1. import java.io.BufferedReader;
  2. import java.io.IOException;
  3. import java.io.InputStream;
  4. import java.io.InputStreamReader;
  5. import java.util.ArrayList;
  6. import java.util.List;
  8. public class HttpResponseBuffer {
  10. private final InputStream inputStream;
  11. private final BufferedReader reader;
  12. private final List<String> bufferedLines = new ArrayList<>();
  13. private final int bufferSize;
  15. /**
  16. * Constructor for the HttpResponseBuffer.
  17. * @param inputStream The input stream from the HTTP response.
  18. * @param bufferSize The maximum number of lines to buffer.
  19. */
  20. public HttpResponseBuffer(InputStream inputStream, int bufferSize) {
  21. this.inputStream = inputStream;
  22. this.reader = new BufferedReader(new InputStreamReader(inputStream));
  23. this.bufferSize = bufferSize;
  24. }
  26. /**
  27. * Reads and buffers lines from the input stream.
  28. * @return The next line from the input stream, or null if the stream is closed.
  29. */
  30. public String readLine() {
  31. try {
  32. if (bufferedLines.isEmpty()) {
  33. String line = reader.readLine();
  34. if (line == null) {
  35. return null; // End of stream
  36. }
  37. bufferedLines.add(line);
  38. //If buffer is full, remove the first line
  39. if (bufferedLines.size() > bufferSize) {
  40. bufferedLines.remove(0);
  41. }
  42. return line;
  44. } else {
  45. String line = bufferedLines.remove(0); // Get the oldest line in the buffer
  46. bufferedLines.add(line); // Add the line to the end of the buffer
  47. return line;
  48. }
  49. } catch (IOException e) {
  50. // Handle IO exceptions (e.g., stream closed)
  51. return null; // Or re-throw if appropriate
  52. }
  53. }
  55. /**
  56. * Returns a list of all buffered lines.
  57. * @return A list of strings, each representing a buffered line.
  58. */
  59. public List<String> getBufferedLines() {
  60. return new ArrayList<>(bufferedLines); // Return a copy to prevent external modification
  61. }
  63. /**
  64. * Closes the input stream.
  65. */
  66. public void close() {
  67. try {
  68. reader.close();
  69. inputStream.close();
  70. } catch (IOException e) {
  71. // Handle IO exceptions during closing
  72. e.printStackTrace();
  73. }
  74. }
  76. public static void main(String[] args) throws IOException {
  77. //Example Usage
  78. try (InputStream inputStream = System.in) {
  79. HttpResponseBuffer buffer = new HttpResponseBuffer(inputStream, 5); //Buffer size of 5 lines
  80. for (int i = 0; i < 10; i++) {
  81. String line = buffer.readLine();
  82. if (line != null) {
  83. System.out.println("Read: " + line);
  84. } else {
  85. System.out.println("End of stream");
  86. break;
  87. }
  88. }
  89. buffer.close();
  90. }
  91. }
  92. }

Add your comment