@Override public int readableByteCount() { return this.dataBuffer.readableByteCount(); }
private static String bufferToString(DataBuffer buffer, Charset charset) { Assert.notNull(charset, "'charset' must not be null"); byte[] bytes = new byte[buffer.readableByteCount()]; buffer.read(bytes); return new String(bytes, charset); }
/** * A shortcut for decoding the raw content of the message to text with the * given character encoding. This is useful for text WebSocket messages, or * otherwise when the payload is expected to contain text. * @param charset the character encoding * @since 5.0.5 */ public String getPayloadAsText(Charset charset) { byte[] bytes = new byte[this.payload.readableByteCount()]; this.payload.read(bytes); return new String(bytes, charset); }
private static String dumpString(DataBuffer buffer, Charset charset) { Assert.notNull(charset, "'charset' must not be null"); byte[] bytes = new byte[buffer.readableByteCount()]; buffer.read(bytes); return new String(bytes, charset); }
private static String bufferToString(DataBuffer buffer, Charset charset) { byte[] bytes = new byte[buffer.readableByteCount()]; buffer.read(bytes); return new String(bytes, charset); }
@Override protected DataBuffer decodeDataBuffer(DataBuffer buffer, ResolvableType elementType, @Nullable MimeType mimeType, @Nullable Map<String, Object> hints) { if (logger.isDebugEnabled()) { logger.debug(Hints.getLogPrefix(hints) + "Read " + buffer.readableByteCount() + " bytes"); } return buffer; }
@Override protected ByteBuffer decodeDataBuffer(DataBuffer dataBuffer, ResolvableType elementType, @Nullable MimeType mimeType, @Nullable Map<String, Object> hints) { int byteCount = dataBuffer.readableByteCount(); ByteBuffer copy = ByteBuffer.allocate(byteCount); copy.put(dataBuffer.asByteBuffer()); copy.flip(); DataBufferUtils.release(dataBuffer); if (logger.isDebugEnabled()) { logger.debug(Hints.getLogPrefix(hints) + "Read " + byteCount + " bytes"); } return copy; }
@Override protected byte[] decodeDataBuffer(DataBuffer dataBuffer, ResolvableType elementType, @Nullable MimeType mimeType, @Nullable Map<String, Object> hints) { byte[] result = new byte[dataBuffer.readableByteCount()]; dataBuffer.read(result); DataBufferUtils.release(dataBuffer); if (logger.isDebugEnabled()) { logger.debug(Hints.getLogPrefix(hints) + "Read " + result.length + " bytes"); } return result; }
private void handleOnComplete() { if (!this.content.isTerminated()) { byte[] bytes = new byte[this.buffer.readableByteCount()]; this.buffer.read(bytes); this.content.onNext(bytes); } } }
private static String dumpString(DataBuffer buffer, Charset charset) { Assert.notNull(charset, "'charset' must not be null"); byte[] bytes = new byte[buffer.readableByteCount()]; buffer.read(bytes); return new String(bytes, charset); }
private static String bufferToString(DataBuffer buffer, Charset charset) { Assert.notNull(charset, "'charset' must not be null"); byte[] bytes = new byte[buffer.readableByteCount()]; buffer.read(bytes); return new String(bytes, charset); }
private static String bufferToString(DataBuffer buffer, Charset charset) { Assert.notNull(charset, "'charset' must not be null"); byte[] bytes = new byte[buffer.readableByteCount()]; buffer.read(bytes); return new String(bytes, charset); }
/** * Dump all the bytes in the given data buffer, and returns them as a byte array. * <p>Note that this method reads the entire buffer into the heap, which might * consume a lot of memory. * @param buffer the data buffer to dump the bytes of * @return the bytes in the given data buffer */ public static byte[] dumpBytes(DataBuffer buffer) { Assert.notNull(buffer, "'buffer' must not be null"); byte[] bytes = new byte[buffer.readableByteCount()]; buffer.read(bytes); return bytes; }
@Override public Mono<String> getResourceVersion(Resource resource) { Flux<DataBuffer> flux = DataBufferUtils.read(resource, dataBufferFactory, StreamUtils.BUFFER_SIZE); return DataBufferUtils.join(flux) .map(buffer -> { byte[] result = new byte[buffer.readableByteCount()]; buffer.read(result); DataBufferUtils.release(buffer); return DigestUtils.md5DigestAsHex(result); }); }
protected Consumer<DataBuffer> expectXml(String expected) { return dataBuffer -> { byte[] resultBytes = new byte[dataBuffer.readableByteCount()]; dataBuffer.read(resultBytes); release(dataBuffer); String actual = new String(resultBytes, UTF_8); assertThat(actual, isSimilarTo(expected)); }; }
private Consumer<DataBuffer> expectDataBuffer(byte[] expected) { return actual -> { byte[] actualBytes = new byte[actual.readableByteCount()]; actual.read(actualBytes); assertArrayEquals(expected, actualBytes); DataBufferUtils.release(actual); }; } }
/** * Create a result consumer that expects the given bytes. * @param expected the expected bytes * @return a consumer that expects the given data buffer to be equal to {@code expected} */ protected final Consumer<DataBuffer> expectBytes(byte[] expected) { return dataBuffer -> { byte[] resultBytes = new byte[dataBuffer.readableByteCount()]; dataBuffer.read(resultBytes); release(dataBuffer); assertArrayEquals(expected, resultBytes); }; }
@Test public void writeEmptyString() { DataBuffer buffer = createDataBuffer(1); buffer.write("", StandardCharsets.UTF_8); assertEquals(0, buffer.readableByteCount()); release(buffer); }
@Test public void join() { DataBuffer composite = this.bufferFactory.join(Arrays.asList(stringBuffer("a"), stringBuffer("b"), stringBuffer("c"))); assertEquals(3, composite.readableByteCount()); byte[] bytes = new byte[3]; composite.read(bytes); assertArrayEquals(new byte[] {'a','b','c'}, bytes); release(composite); }
@Override public Mono<Void> handle(ServerHttpRequest request, ServerHttpResponse response) { Mono<Integer> requestSizeMono = request.getBody(). reduce(0, (integer, dataBuffer) -> integer + dataBuffer.readableByteCount()). doOnSuccessOrError((size, throwable) -> { assertNull(throwable); assertEquals(REQUEST_SIZE, (long) size); }); response.getHeaders().setContentLength(RESPONSE_SIZE); return requestSizeMono.then(response.writeWith(multipleChunks())); }