Java PooledByteBuffer类代码示例

import io.undertow.connector.PooledByteBuffer; //导入依赖的package包/类
@Test
public void test() throws Exception {
	ByteBufferPool byteBufferPool = new DefaultByteBufferPool(true, 2, -1, 4);
	PooledByteBufferOutputStream output = new PooledByteBufferOutputStream(byteBufferPool);

	String hello = "hello, 世界！";
	output.write(hello);
	output.flip();

	PooledByteBuffer[] buffers = output.getPooledByteBuffers();

	try (PooledByteBufferInputStream input = new PooledByteBufferInputStream(buffers);) {
		byte[] bytes = new byte[input.available()];
		input.read(bytes);
		String str = new String(bytes, "UTF-8");

		assertEquals(hello, str);
	}

	output.release();
	output.close();
}
 

import io.undertow.connector.PooledByteBuffer; //导入依赖的package包/类
@Test
public void sendNoIoThread2Chunks() throws Exception {
  new MockUnit(ReadableByteChannel.class, HttpServerExchange.class, IoCallback.class,
      Sender.class, PooledByteBuffer.class)
      .expect(exchange)
      .expect(noIoThread)
      .expect(pooled)
      .expect(readLargeChunk)
      .expect(transferEncoding)
      .expect(sendChunk)
      .expect(noIoThread)
      .expect(pooled)
      .expect(readChunk)
      .expect(sendChunk)
      .run(unit -> {
        ChunkedStream chunkedStream = new ChunkedStream();
        chunkedStream.send(unit.get(ReadableByteChannel.class),
            unit.get(HttpServerExchange.class), unit.get(IoCallback.class));
        chunkedStream.onComplete(unit.get(HttpServerExchange.class), unit.get(Sender.class));
      });
}
 

import io.undertow.connector.PooledByteBuffer; //导入依赖的package包/类
@Test
public void sendNoIoThread2ChunksWithLen() throws Exception {
  new MockUnit(ReadableByteChannel.class, HttpServerExchange.class, IoCallback.class,
      Sender.class, PooledByteBuffer.class)
      .expect(exchange)
      .expect(noIoThread)
      .expect(pooled)
      .expect(readLargeChunk)
      .expect(len)
      .expect(sendChunk)
      .expect(noIoThread)
      .expect(pooled)
      .expect(readChunk)
      .expect(sendChunk)
      .run(unit -> {
        ChunkedStream chunkedStream = new ChunkedStream();
        chunkedStream.send(unit.get(ReadableByteChannel.class),
            unit.get(HttpServerExchange.class), unit.get(IoCallback.class));
        chunkedStream.onComplete(unit.get(HttpServerExchange.class), unit.get(Sender.class));
      });
}
 

import io.undertow.connector.PooledByteBuffer; //导入依赖的package包/类
@Test
public void sendIoThread() throws Exception {
  new MockUnit(ReadableByteChannel.class, HttpServerExchange.class, IoCallback.class,
      Sender.class, PooledByteBuffer.class)
      .expect(exchange)
      .expect(ioThread)
      .expect(pooled)
      .expect(readChunk)
      .expect(nolen)
      .expect(sendChunk)
      .run(unit -> {
        ChunkedStream chunkedStream = new ChunkedStream();
        chunkedStream.send(unit.get(ReadableByteChannel.class),
            unit.get(HttpServerExchange.class), unit.get(IoCallback.class));
        chunkedStream.run();
      });
}
 

import io.undertow.connector.PooledByteBuffer; //导入依赖的package包/类
private void internalAsyncRequest(final HttpServerExchange exchange, ArrayList<PooledByteBuffer> bufferList)
		throws Exception {
	// ensure exchange not end
	getResponseChannel(exchange).resumeWrites();

	PooledByteBuffer[] buffers = EMPTY_BUFFERS;

	if (bufferList != null && bufferList.size() > 0) {
		buffers = new PooledByteBuffer[bufferList.size()];
		buffers = bufferList.toArray(buffers);
	}

	handleAsyncRequest(exchange, new PooledByteBufferInputStream(buffers));
}
 

import io.undertow.connector.PooledByteBuffer; //导入依赖的package包/类
/**
 * return the buffer to the buffer pool
 *
 * @param bufferList
 */
private void release(ArrayList<PooledByteBuffer> bufferList) {
	if (bufferList == null || bufferList.size() == 0) {
		return;
	}

	for (int i = 0; i < bufferList.size(); ++i) {
		IoUtils.safeClose(bufferList.get(i));
	}
}
 

import io.undertow.connector.PooledByteBuffer; //导入依赖的package包/类
/**
 * just for async release
 * 
 * @param sender
 * @param pooledBuffers
 *            will be released
 */
private void setPooledBuffers(Sender sender, PooledByteBuffer[] pooledBuffers) {
	if (!(sender instanceof AsyncSenderImpl)) {
		throw new RuntimeException("only support AsyncSenderImpl");
	}

	unsafe().getAndSetObject(sender, asyncSenderImplPooledBuffersFieldOffset, pooledBuffers);
}
 

import io.undertow.connector.PooledByteBuffer; //导入依赖的package包/类
public PooledByteBufferInputStream(PooledByteBuffer[] buffers) {
	Objects.requireNonNull(buffers);

	for (int i = 0; i < buffers.length; i++) {
		if (!buffers[i].isOpen()) {
			throw new IllegalAccessError("buffers must all open");
		}
	}

	this.buffers = buffers;
	next();
}
 

import io.undertow.connector.PooledByteBuffer; //导入依赖的package包/类
public void clear() {
	for (int i = 0; i < pooledList.size(); i++) {
		PooledByteBuffer pooled = pooledList.get(i);
		pooled.getBuffer().clear();
	}

	current = null;
	index = -1;
}
 

import io.undertow.connector.PooledByteBuffer; //导入依赖的package包/类
public void release() {
	for (int i = 0; i < pooledList.size(); i++) {
		PooledByteBuffer pooled = pooledList.get(i);
		IoUtils.safeClose(pooled);
	}

	pooledList.clear();
}
 

import io.undertow.connector.PooledByteBuffer; //导入依赖的package包/类
private void alloc() {
	index++;

	if (pooledList.size() - 1 > index) {
		current = pooledList.get(index).getBuffer();
		return;
	}

	PooledByteBuffer pooled = byteBufferPool.allocate();
	current = pooled.getBuffer();
	pooledList.add(pooled);
}
 

import io.undertow.connector.PooledByteBuffer; //导入依赖的package包/类
public void read(StreamSourceChannel channel) {
    try (PooledByteBuffer poolItem = exchange.getConnection().getByteBufferPool().allocate()) {
        ByteBuffer buffer = poolItem.getBuffer();
        int bytesRead;
        while (true) {
            buffer.clear();
            bytesRead = channel.read(buffer);
            if (bytesRead <= 0) break;
            buffer.flip();
            ensureCapacity(bytesRead);
            buffer.get(body, position, bytesRead);
            position += bytesRead;
        }
        if (bytesRead == -1) {
            if (contentLength >= 0 && position < body.length) {
                throw Exceptions.error("body ends prematurely, expected={}, actual={}", contentLength, position);
            } else if (body == null) {
                body = new byte[0]; // without content length and has no body
            }
            complete = true;
            exchange.putAttachment(REQUEST_BODY, new RequestBody(body, null));
        }
    } catch (Throwable e) { // catch all errors during IO, to pass error to action log
        IoUtils.safeClose(channel);
        complete = true;
        exchange.putAttachment(REQUEST_BODY, new RequestBody(null, e));
    }
}
 

import io.undertow.connector.PooledByteBuffer; //导入依赖的package包/类
@Test
public void sendNoIoThread() throws Exception {
  new MockUnit(ReadableByteChannel.class, HttpServerExchange.class, IoCallback.class,
      Sender.class, PooledByteBuffer.class)
      .expect(exchange)
      .expect(noIoThread)
      .expect(pooled)
      .expect(readChunk)
      .expect(nolen)
      .expect(sendChunk)
      .run(unit -> {
        new ChunkedStream().send(unit.get(ReadableByteChannel.class),
            unit.get(HttpServerExchange.class), unit.get(IoCallback.class));
      });
}
 

import io.undertow.connector.PooledByteBuffer; //导入依赖的package包/类
public PooledByteBuffer[] getPooledByteBuffers() {
	PooledByteBuffer[] buffers = new PooledByteBuffer[pooledList.size()];
	return pooledList.toArray(buffers);
}
 

import io.undertow.connector.PooledByteBuffer; //导入依赖的package包/类
public void flip() {
	for (int i = 0; i < pooledList.size(); i++) {
		PooledByteBuffer pooled = pooledList.get(i);
		pooled.getBuffer().flip();
	}
}