@Override public InputStream asInputStream() { return this.dataBuffer.asInputStream(); }
@Override public InputStream asInputStream(boolean releaseOnClose) { return this.dataBuffer.asInputStream(releaseOnClose); }
@Override public InputStream asInputStream() { return this.dataBuffer.asInputStream(); }
@Override public InputStream asInputStream(boolean releaseOnClose) { return this.dataBuffer.asInputStream(releaseOnClose); }
@Override public InputStream asInputStream(boolean releaseOnClose) { return this.delegate.asInputStream(releaseOnClose); }
@Override public InputStream asInputStream() { return this.delegate.asInputStream(); }
/** * Write the DataBuffer to the response body OutputStream. * Invoked only when {@link ServletOutputStream#isReady()} returns "true" * and the readable bytes in the DataBuffer is greater than 0. * @return the number of bytes written */ protected int writeToOutputStream(DataBuffer dataBuffer) throws IOException { ServletOutputStream outputStream = this.outputStream; InputStream input = dataBuffer.asInputStream(); int bytesWritten = 0; byte[] buffer = new byte[this.bufferSize]; int bytesRead; while (outputStream.isReady() && (bytesRead = input.read(buffer)) != -1) { outputStream.write(buffer, 0, bytesRead); bytesWritten += bytesRead; } return bytesWritten; }
/** * Write the DataBuffer to the response body OutputStream. * Invoked only when {@link ServletOutputStream#isReady()} returns "true" * and the readable bytes in the DataBuffer is greater than 0. * @return the number of bytes written */ protected int writeToOutputStream(DataBuffer dataBuffer) throws IOException { ServletOutputStream outputStream = this.outputStream; InputStream input = dataBuffer.asInputStream(); int bytesWritten = 0; byte[] buffer = new byte[this.bufferSize]; int bytesRead; while (outputStream.isReady() && (bytesRead = input.read(buffer)) != -1) { outputStream.write(buffer, 0, bytesRead); bytesWritten += bytesRead; } return bytesWritten; }
private <T> Consumer<DataBuffer> expect(T expected, Class<T> expectedType) { return dataBuffer -> { try { Object actual = this.mapper.reader().forType(expectedType) .readValue(dataBuffer.asInputStream()); assertEquals(expected, actual); } catch (IOException e) { throw new UncheckedIOException(e); } finally { release(dataBuffer); } }; }
protected final Consumer<DataBuffer> expect(Msg msg) { return dataBuffer -> { try { assertEquals(msg, Msg.parseDelimitedFrom(dataBuffer.asInputStream())); } catch (IOException ex) { throw new UncheckedIOException(ex); } finally { DataBufferUtils.release(dataBuffer); } }; } }
@Override @SuppressWarnings({"rawtypes", "unchecked"}) // on JDK 9 where XMLEventReader is Iterator<Object> public Flux<XMLEvent> decode(Publisher<DataBuffer> inputStream, ResolvableType elementType, @Nullable MimeType mimeType, @Nullable Map<String, Object> hints) { Flux<DataBuffer> flux = Flux.from(inputStream); if (this.useAalto) { AaltoDataBufferToXmlEvent aaltoMapper = new AaltoDataBufferToXmlEvent(); return flux.flatMap(aaltoMapper) .doFinally(signalType -> aaltoMapper.endOfInput()); } else { Mono<DataBuffer> singleBuffer = DataBufferUtils.join(flux); return singleBuffer. flatMapMany(dataBuffer -> { try { InputStream is = dataBuffer.asInputStream(); Iterator eventReader = inputFactory.createXMLEventReader(is); return Flux.fromIterable((Iterable<XMLEvent>) () -> eventReader) .doFinally(t -> DataBufferUtils.release(dataBuffer)); } catch (XMLStreamException ex) { return Mono.error(ex); } }); } }
@Test public void inputStreamReleaseOnClose() throws IOException { DataBuffer buffer = createDataBuffer(3); byte[] bytes = {'a', 'b', 'c'}; buffer.write(bytes); InputStream inputStream = buffer.asInputStream(true); try { byte[] result = new byte[3]; int len = inputStream.read(result); assertEquals(3, len); assertArrayEquals(bytes, result); } finally { inputStream.close(); } // AbstractDataBufferAllocatingTestCase.LeakDetector will verify the buffer's release }
@Override @Test public void encode() { Mono<Message> input = Mono.just(this.msg1); testEncodeAll(input, Msg.class, step -> step .consumeNextWith(dataBuffer -> { try { assertEquals(this.msg1, Msg.parseFrom(dataBuffer.asInputStream())); } catch (IOException ex) { throw new UncheckedIOException(ex); } finally { DataBufferUtils.release(dataBuffer); } }) .verifyComplete()); }
@Override @SuppressWarnings({"rawtypes", "unchecked"}) // on JDK 9 where XMLEventReader is Iterator<Object> public Flux<XMLEvent> decode(Publisher<DataBuffer> inputStream, ResolvableType elementType, @Nullable MimeType mimeType, @Nullable Map<String, Object> hints) { Flux<DataBuffer> flux = Flux.from(inputStream); if (this.useAalto) { AaltoDataBufferToXmlEvent aaltoMapper = new AaltoDataBufferToXmlEvent(); return flux.flatMap(aaltoMapper) .doFinally(signalType -> aaltoMapper.endOfInput()); } else { Mono<DataBuffer> singleBuffer = DataBufferUtils.join(flux); return singleBuffer. flatMapMany(dataBuffer -> { try { InputStream is = dataBuffer.asInputStream(); Iterator eventReader = inputFactory.createXMLEventReader(is); return Flux.fromIterable((Iterable<XMLEvent>) () -> eventReader) .doFinally(t -> DataBufferUtils.release(dataBuffer)); } catch (XMLStreamException ex) { return Mono.error(ex); } }); } }
@Test public void inputStream() throws IOException { DataBuffer buffer = createDataBuffer(4); buffer.write(new byte[]{'a', 'b', 'c', 'd', 'e'}); buffer.readPosition(1); InputStream inputStream = buffer.asInputStream(); assertEquals(4, inputStream.available()); int result = inputStream.read(); assertEquals('b', result); assertEquals(3, inputStream.available()); byte[] bytes = new byte[2]; int len = inputStream.read(bytes); assertEquals(2, len); assertArrayEquals(new byte[]{'c', 'd'}, bytes); assertEquals(1, inputStream.available()); Arrays.fill(bytes, (byte) 0); len = inputStream.read(bytes); assertEquals(1, len); assertArrayEquals(new byte[]{'e', (byte) 0}, bytes); assertEquals(0, inputStream.available()); assertEquals(-1, inputStream.read()); assertEquals(-1, inputStream.read(bytes)); release(buffer); }
@Override public InputStream asInputStream() { return this.dataBuffer.asInputStream(); }
@Override public InputStream asInputStream(boolean releaseOnClose) { return this.dataBuffer.asInputStream(releaseOnClose); }
private void save(DataBuffer t) { try { body = IOUtils.toString(t.asInputStream()); } catch (IOException e) { e.printStackTrace(); } }
@Override public Mono<InputStream> asInputStream() { final InputStream initial = new InputStream() { @Override public int read() { return -1; } }; return response.body(BodyExtractors.toDataBuffers()).reduce(initial, (s, d) -> new SequenceInputStream(s, d.asInputStream())); }
@Override public Mono<JsonDocument> decodeToMono(Publisher<DataBuffer> inputStream, ResolvableType elementType, MimeType mimeType, Map<String, Object> hints) { return Flux.from(inputStream) .flatMap(buffer -> { try { return Flux.just(IOUtils.toString(buffer.asInputStream(), UTF_8)); } catch (IOException e) { return Flux.error(e); } }) .collect(StringBuilder::new, StringBuilder::append) .map(StringBuilder::toString) .map(message -> new JsonDocument(jsonProvider.parse(message))); }