Java Code Examples for org.springframework.core.io.buffer.DataBufferUtils#release()

private DataBuffer encodeValue(Message message, DataBufferFactory bufferFactory, boolean delimited) {

		DataBuffer buffer = bufferFactory.allocateBuffer();
		boolean release = true;
		try {
			if (delimited) {
				message.writeDelimitedTo(buffer.asOutputStream());
			}
			else {
				message.writeTo(buffer.asOutputStream());
			}
			release = false;
			return buffer;
		}
		catch (IOException ex) {
			throw new IllegalStateException("Unexpected I/O error while writing to data buffer", ex);
		}
		finally {
			if (release) {
				DataBufferUtils.release(buffer);
			}
		}
	}
 

@Override
protected DataBuffer readFromInputStream() throws IOException {
	boolean release = true;
	int capacity = this.bufferSize;
	DataBuffer dataBuffer = this.factory.allocateBuffer(capacity);
	try {
		ByteBuffer byteBuffer = dataBuffer.asByteBuffer(0, capacity);
		ServletRequest request = getNativeRequest();
		int read = ((CoyoteInputStream) request.getInputStream()).read(byteBuffer);
		logBytesRead(read);
		if (read > 0) {
			dataBuffer.writePosition(read);
			release = false;
			return dataBuffer;
		}
		else if (read == -1) {
			return EOF_BUFFER;
		}
		else {
			return null;
		}
	}
	finally {
		if (release) {
			DataBufferUtils.release(dataBuffer);
		}
	}
}
 

@Override
protected DataBuffer readFromInputStream() throws IOException {
	boolean release = true;
	int capacity = this.bufferSize;
	DataBuffer dataBuffer = this.factory.allocateBuffer(capacity);
	try {
		ByteBuffer byteBuffer = dataBuffer.asByteBuffer(0, capacity);
		ServletRequest request = getNativeRequest();
		int read = ((CoyoteInputStream) request.getInputStream()).read(byteBuffer);
		logBytesRead(read);
		if (read > 0) {
			dataBuffer.writePosition(read);
			release = false;
			return dataBuffer;
		}
		else if (read == -1) {
			return EOF_BUFFER;
		}
		else {
			return null;
		}
	}
	finally {
		if (release) {
			DataBufferUtils.release(dataBuffer);
		}
	}
}
 

@Override
protected boolean write(DataBuffer dataBuffer) throws IOException {
	ByteBuffer buffer = this.byteBuffer;
	if (buffer == null) {
		return false;
	}

	// Track write listener calls from here on..
	this.writePossible = false;

	// In case of IOException, onError handling should call discardData(DataBuffer)..
	int total = buffer.remaining();
	int written = writeByteBuffer(buffer);

	if (logger.isTraceEnabled()) {
		logger.trace(getLogPrefix() + "Wrote " + written + " of " + total + " bytes");
	}
	else if (rsWriteLogger.isTraceEnabled()) {
		rsWriteLogger.trace(getLogPrefix() + "Wrote " + written + " of " + total + " bytes");
	}
	if (written != total) {
		return false;
	}

	// We wrote all, so can still write more..
	this.writePossible = true;

	DataBufferUtils.release(dataBuffer);
	this.byteBuffer = null;
	return true;
}
 

@Override
protected boolean write(DataBuffer dataBuffer) throws IOException {
	if (ServletServerHttpResponse.this.flushOnNext) {
		if (rsWriteLogger.isTraceEnabled()) {
			rsWriteLogger.trace(getLogPrefix() + "Flush attempt");
		}
		flush();
	}

	boolean ready = ServletServerHttpResponse.this.isWritePossible();
	int remaining = dataBuffer.readableByteCount();
	if (ready && remaining > 0) {
		// In case of IOException, onError handling should call discardData(DataBuffer)..
		int written = writeToOutputStream(dataBuffer);
		if (logger.isTraceEnabled()) {
			logger.trace(getLogPrefix() + "Wrote " + written + " of " + remaining + " bytes");
		}
		else if (rsWriteLogger.isTraceEnabled()) {
			rsWriteLogger.trace(getLogPrefix() + "Wrote " + written + " of " + remaining + " bytes");
		}
		if (written == remaining) {
			DataBufferUtils.release(dataBuffer);
			return true;
		}
	}
	else {
		if (rsWriteLogger.isTraceEnabled()) {
			rsWriteLogger.trace(getLogPrefix() + "ready: " + ready + ", remaining: " + remaining);
		}
	}

	return false;
}
 

@Override
protected Resource decodeDataBuffer(DataBuffer dataBuffer, ResolvableType elementType,
		@Nullable MimeType mimeType, @Nullable Map<String, Object> hints) {

	byte[] bytes = new byte[dataBuffer.readableByteCount()];
	dataBuffer.read(bytes);
	DataBufferUtils.release(dataBuffer);

	if (logger.isDebugEnabled()) {
		logger.debug(Hints.getLogPrefix(hints) + "Read " + bytes.length + " bytes");
	}

	Class<?> clazz = elementType.toClass();
	if (clazz == InputStreamResource.class) {
		return new InputStreamResource(new ByteArrayInputStream(bytes));
	}
	else if (Resource.class.isAssignableFrom(clazz)) {
		return new ByteArrayResource(bytes);
	}
	else {
		throw new IllegalStateException("Unsupported resource class: " + clazz);
	}
}
 

private void releaseCachedItem() {
	synchronized (this) {
		Object item = this.item;
		if (item instanceof DataBuffer) {
			DataBufferUtils.release((DataBuffer) item);
		}
		this.item = null;
	}
}
 

private ContentChunk toContentChunk(DataBuffer buffer) {
	return new ContentChunk(buffer.asByteBuffer(), new Callback() {
		@Override
		public void succeeded() {
			DataBufferUtils.release(buffer);
		}

		@Override
		public void failed(Throwable x) {
			DataBufferUtils.release(buffer);
			throw Exceptions.propagate(x);
		}
	});
}
 

private Consumer<DataBuffer> expectDataBuffer(byte[] expected) {
	return actual -> {
		byte[] actualBytes = new byte[actual.readableByteCount()];
		actual.read(actualBytes);
		assertArrayEquals(expected, actualBytes);

		DataBufferUtils.release(actual);
	};
}
 

@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;
}
 

/**
 * Indicates whether the given data buffer is not the last boundary, i.e. it does not start
 * with two hyphens.
 */
private static boolean notLastBoundary(DataBuffer dataBuffer) {
	if (dataBuffer.readableByteCount() >= 2) {
		int readPosition = dataBuffer.readPosition();
		if (dataBuffer.getByte(readPosition) == HYPHEN && dataBuffer.getByte(readPosition + 1) == HYPHEN) {
			DataBufferUtils.release(dataBuffer);
			return false;
		}
	}
	return true;
}
 

@Override
public String decode(DataBuffer dataBuffer, ResolvableType elementType,
		@Nullable MimeType mimeType, @Nullable Map<String, Object> hints) {

	Charset charset = getCharset(mimeType);
	CharBuffer charBuffer = charset.decode(dataBuffer.asByteBuffer());
	DataBufferUtils.release(dataBuffer);
	String value = charBuffer.toString();
	LogFormatUtils.traceDebug(logger, traceOn -> {
		String formatted = LogFormatUtils.formatValue(value, !traceOn);
		return Hints.getLogPrefix(hints) + "Decoded " + formatted;
	});
	return value;
}
 

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);
		}
	};
}
 

/**
 * Split the given data buffer on delimiter boundaries.
 * The returned Flux contains an {@link #END_FRAME} buffer after each delimiter.
 */
private List<DataBuffer> splitOnDelimiter(DataBuffer dataBuffer, List<byte[]> delimiterBytes) {
	List<DataBuffer> frames = new ArrayList<>();
	do {
		int length = Integer.MAX_VALUE;
		byte[] matchingDelimiter = null;
		for (byte[] delimiter : delimiterBytes) {
			int index = indexOf(dataBuffer, delimiter);
			if (index >= 0 && index < length) {
				length = index;
				matchingDelimiter = delimiter;
			}
		}
		DataBuffer frame;
		int readPosition = dataBuffer.readPosition();
		if (matchingDelimiter != null) {
			if (this.stripDelimiter) {
				frame = dataBuffer.slice(readPosition, length);
			}
			else {
				frame = dataBuffer.slice(readPosition, length + matchingDelimiter.length);
			}
			dataBuffer.readPosition(readPosition + length + matchingDelimiter.length);

			frames.add(DataBufferUtils.retain(frame));
			frames.add(END_FRAME);
		}
		else {
			frame = dataBuffer.slice(readPosition, dataBuffer.readableByteCount());
			dataBuffer.readPosition(readPosition + dataBuffer.readableByteCount());
			frames.add(DataBufferUtils.retain(frame));
		}
	}
	while (dataBuffer.readableByteCount() > 0);

	DataBufferUtils.release(dataBuffer);
	return frames;
}
 

@Override
public boolean release() {
	boolean result;
	try {
		result = DataBufferUtils.release(this.dataBuffer);
	}
	finally {
		this.pooledByteBuffer.close();
	}
	return result && this.pooledByteBuffer.isOpen();
}
 

@Override
public List<? extends XMLEvent> apply(DataBuffer dataBuffer) {
	try {
		this.streamReader.getInputFeeder().feedInput(dataBuffer.asByteBuffer());
		List<XMLEvent> events = new ArrayList<>();
		while (true) {
			if (this.streamReader.next() == AsyncXMLStreamReader.EVENT_INCOMPLETE) {
				// no more events with what currently has been fed to the reader
				break;
			}
			else {
				XMLEvent event = this.eventAllocator.allocate(this.streamReader);
				events.add(event);
				if (event.isEndDocument()) {
					break;
				}
			}
		}
		return events;
	}
	catch (XMLStreamException ex) {
		throw Exceptions.propagate(ex);
	}
	finally {
		DataBufferUtils.release(dataBuffer);
	}
}
 

private String string(DataBuffer buffer) {
	String value = DataBufferTestUtils.dumpString(buffer, StandardCharsets.UTF_8);
	DataBufferUtils.release(buffer);
	return value;
}
 

@Override
protected void discardData(DataBuffer dataBuffer) {
	DataBufferUtils.release(dataBuffer);
}
 

public void discard() {
	if (this.output != null) {
		DataBufferUtils.release(this.output);
	}
}
 

@Override
protected void discardData(DataBuffer dataBuffer) {
	DataBufferUtils.release(dataBuffer);
}