Lire flux deux fois

Selon l'endroit où l'InputStream est à venir à partir de, vous pourriez ne pas être en mesure de le réinitialiser. Vous pouvez vérifier si mark() et reset() sont pris en charge à l'aide de markSupported().

Si elle l'est, vous pouvez appeler reset() sur l'InputStream pour revenir au début. Si non, vous devez lire l'InputStream à partir de la source de nouveau.

Vous pouvez envelopper les flux d'entrée avec PushbackInputStream. PushbackInputStream permet de non lus ("écrire de nouveau") octets qui ont déjà lu, de sorte que vous pouvez le faire comme ceci:

public class StreamTest {
public static void main(String[] args) throws IOException {
byte[] bytes = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
InputStream originalStream = new ByteArrayInputStream(bytes);
byte[] readBytes = getBytes(originalStream, 3);
printBytes(readBytes); //prints: 1 2 3
readBytes = getBytes(originalStream, 3);
printBytes(readBytes); //prints: 4 5 6
//now let's wrap it with PushBackInputStream
originalStream = new ByteArrayInputStream(bytes);
InputStream wrappedStream = new PushbackInputStream(originalStream, 10); //10 means that maximnum 10 characters can be "written back" to the stream
readBytes = getBytes(wrappedStream, 3);
printBytes(readBytes); //prints 1 2 3
((PushbackInputStream) wrappedStream).unread(readBytes, 0, readBytes.length);
readBytes = getBytes(wrappedStream, 3);
printBytes(readBytes); //prints 1 2 3
}
private static byte[] getBytes(InputStream is, int howManyBytes) throws IOException {
System.out.print("Reading stream: ");
byte[] buf = new byte[howManyBytes];
int next = 0;
for (int i = 0; i < howManyBytes; i++) {
next = is.read();
if (next > 0) {
buf[i] = (byte) next;
}
}
return buf;
}
private static void printBytes(byte[] buffer) throws IOException {
System.out.print("Reading stream: ");
for (int i = 0; i < buffer.length; i++) {
System.out.print(buffer[i] + " ");
}
System.out.println();
}
}

Veuillez noter que PushbackInputStream magasins interne de la mémoire tampon d'octets de sorte qu'il crée vraiment une mémoire tampon qui est titulaire d'octets "écrit".

Sachant que cette approche nous permet d'aller plus loin et de le combiner avec FilterInputStream. FilterInputStream magasins d'entrée original stream en tant que délégué. Cela permet de créer de nouveaux définition de la classe qui permet de "non lus" origine des données automatiquement. La définition de cette classe est la suivante:

public class TryReadInputStream extends FilterInputStream {
private final int maxPushbackBufferSize;
/**
* Creates a <code>FilterInputStream</code>
* by assigning the  argument <code>in</code>
* to the field <code>this.in</code> so as
* to remember it for later use.
*
* @param in the underlying input stream, or <code>null</code> if
*           this instance is to be created without an underlying stream.
*/
public TryReadInputStream(InputStream in, int maxPushbackBufferSize) {
super(new PushbackInputStream(in, maxPushbackBufferSize));
this.maxPushbackBufferSize = maxPushbackBufferSize;
}
/**
* Reads from input stream the <code>length</code> of bytes to given buffer. The read bytes are still avilable
* in the stream
*
* @param buffer the destination buffer to which read the data
* @param offset  the start offset in the destination <code>buffer</code>
* @aram length how many bytes to read from the stream to buff. Length needs to be less than
*        <code>maxPushbackBufferSize</code> or IOException will be thrown
*
* @return number of bytes read
* @throws java.io.IOException in case length is
*/
public int tryRead(byte[] buffer, int offset, int length) throws IOException {
validateMaxLength(length);
//NOTE: below reading byte by byte instead of "int bytesRead = is.read(firstBytes, 0, maxBytesOfResponseToLog);"
//because read() guarantees to read a byte
int bytesRead = 0;
int nextByte = 0;
for (int i = 0; (i < length) && (nextByte >= 0); i++) {
nextByte = read();
if (nextByte >= 0) {
buffer[offset + bytesRead++] = (byte) nextByte;
}
}
if (bytesRead > 0) {
((PushbackInputStream) in).unread(buffer, offset, bytesRead);
}
return bytesRead;
}
public byte[] tryRead(int maxBytesToRead) throws IOException {
validateMaxLength(maxBytesToRead);
ByteArrayOutputStream baos = new ByteArrayOutputStream(); //as ByteArrayOutputStream to dynamically allocate internal bytes array instead of allocating possibly large buffer (if maxBytesToRead is large)
//NOTE: below reading byte by byte instead of "int bytesRead = is.read(firstBytes, 0, maxBytesOfResponseToLog);"
//because read() guarantees to read a byte
int nextByte = 0;
for (int i = 0; (i < maxBytesToRead) && (nextByte >= 0); i++) {
nextByte = read();
if (nextByte >= 0) {
baos.write((byte) nextByte);
}
}
byte[] buffer = baos.toByteArray();
if (buffer.length > 0) {
((PushbackInputStream) in).unread(buffer, 0, buffer.length);
}
return buffer;
}
private void validateMaxLength(int length) throws IOException {
if (length > maxPushbackBufferSize) {
throw new IOException(
"Trying to read more bytes than maxBytesToRead. Max bytes: " + maxPushbackBufferSize + ". Trying to read: " +
length);
}
}
}

Cette classe a deux méthodes. Un pour la lecture en mémoire tampon existante (définition est analogue à l'appel de public int read(byte b[], int off, int len) de la classe InputStream). Deuxième qui retourne un nouveau tampon (cela peut être plus efficace si la taille de la mémoire tampon de lecture est inconnu).

Maintenant, nous allons voir notre classe en action:

public class StreamTest2 {
public static void main(String[] args) throws IOException {
byte[] bytes = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
InputStream originalStream = new ByteArrayInputStream(bytes);
byte[] readBytes = getBytes(originalStream, 3);
printBytes(readBytes); //prints: 1 2 3
readBytes = getBytes(originalStream, 3);
printBytes(readBytes); //prints: 4 5 6
//now let's use our TryReadInputStream
originalStream = new ByteArrayInputStream(bytes);
InputStream wrappedStream = new TryReadInputStream(originalStream, 10);
readBytes = ((TryReadInputStream) wrappedStream).tryRead(3); //NOTE: no manual call to "unread"(!) because TryReadInputStream handles this internally
printBytes(readBytes); //prints 1 2 3
readBytes = ((TryReadInputStream) wrappedStream).tryRead(3); 
printBytes(readBytes); //prints 1 2 3
readBytes = ((TryReadInputStream) wrappedStream).tryRead(3);
printBytes(readBytes); //prints 1 2 3
//we can also call normal read which will actually read the bytes without "writing them back"
readBytes = getBytes(wrappedStream, 3);
printBytes(readBytes); //prints 1 2 3
readBytes = getBytes(wrappedStream, 3);
printBytes(readBytes); //prints 4 5 6
readBytes = ((TryReadInputStream) wrappedStream).tryRead(3); //now we can try read next bytes
printBytes(readBytes); //prints 7 8 9
readBytes = ((TryReadInputStream) wrappedStream).tryRead(3); 
printBytes(readBytes); //prints 7 8 9
}
}

Comment sur:

if (stream.markSupported() == false) {
//lets replace the stream object
ByteArrayOutputStream baos = new ByteArrayOutputStream();
IOUtils.copy(stream, baos);
stream.close();
stream = new ByteArrayInputStream(baos.toByteArray());
//now the stream should support 'mark' and 'reset'
}

Au cas où quelqu'un est en cours d'exécution, au Printemps de Démarrage de l'app, et vous voulez lire le corps de la réponse d'un RestTemplate (c'est pourquoi je veux lire un flux à deux reprises), il est propre(re) manière de faire.

Tout d'abord, vous devez utiliser le Printemps StreamUtils de copier le flux d'une Chaîne de caractères:

String text = StreamUtils.copyToString(response.getBody(), Charset.defaultCharset()))

Mais ce n'est pas tout. Vous devez également utiliser une demande d'usine qui peuvent tampon du flux pour vous, comme:

ClientHttpRequestFactory factory = new BufferingClientHttpRequestFactory(new SimpleClientHttpRequestFactory());
RestTemplate restTemplate = new RestTemplate(factory);

Ou, si vous êtes à l'aide de l'usine, de haricots, puis (c'est Kotlin, mais quand même):

@Bean
@Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
fun createRestTemplate(): RestTemplate = RestTemplateBuilder()
.requestFactory { BufferingClientHttpRequestFactory(SimpleClientHttpRequestFactory()) }
.additionalInterceptors(loggingInterceptor)
.build()

Source: https://objectpartners.com/2018/03/01/log-your-resttemplate-request-and-response-without-destroying-the-body/