Java Pooled.getResource方法代码示例

import org.xnio.Pooled; //导入方法依赖的package包/类
public long transferFrom(final FileChannel src, final long position, final long count) throws IOException {
    try {
        if (state != 0) {
            final Pooled<ByteBuffer> pooled = exchange.getConnection().getBufferPool().allocate();
            ByteBuffer buffer = pooled.getResource();
            try {
                int res = src.read(buffer);
                if (res <= 0) {
                    return res;
                }
                buffer.flip();
                return write(buffer);
            } finally {
                pooled.free();
            }
        } else {
            return next.transferFrom(src, position, count);
        }
    } catch (IOException | RuntimeException e) {
        IoUtils.safeClose(exchange.getConnection());
        throw e;
    }
}
 

import org.xnio.Pooled; //导入方法依赖的package包/类
@Override
public int write(final ByteBuffer src) throws IOException {
    if(toWrite >= 0 && src.remaining() > toWrite) {
        throw WebSocketMessages.MESSAGES.messageOverflow();
    }
    if(masker == null) {
        return super.write(src);
    } else {
        final Pooled<ByteBuffer> buffer = getChannel().getBufferPool().allocate();
        try {
            ByteBuffer copy = src.duplicate();
            Buffers.copy(buffer.getResource(), copy);
            buffer.getResource().flip();
            masker.beforeWrite(buffer.getResource(), 0, buffer.getResource().remaining());
            int written = super.write(buffer.getResource());
            src.position(src.position() + written);
            toWrite -= written;
            return written;
        } finally {
            buffer.free();
        }
    }
}
 

import org.xnio.Pooled; //导入方法依赖的package包/类
@Override
public void handle(final PartHandler handler, final ByteBuffer rawData) throws IOException {
    Pooled<ByteBuffer> resource = bufferPool.allocate();
    ByteBuffer buf = resource.getResource();
    try {
        do {
            buf.clear();
            try {
                decoder.decode(rawData, buf);
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
            buf.flip();
            handler.data(buf);
        } while (rawData.hasRemaining());
    } finally {
        resource.free();
    }
}
 

import org.xnio.Pooled; //导入方法依赖的package包/类
public void setup(final StreamSourceChannel channel) {
    Pooled<ByteBuffer> resource = bufferPool.allocate();
    ByteBuffer buffer = resource.getResource();
    try {
        int r = 0;
        do {
            r = channel.read(buffer);
            if (r == 0) {
                channel.getReadSetter().set(this);
                channel.resumeReads();
            } else if (r == -1) {
                stringDone(string.extract());
                IoUtils.safeClose(channel);
            } else {
                buffer.flip();
                string.write(buffer);
            }
        } while (r > 0);
    } catch (IOException e) {
        error(e);
    } finally {
        resource.free();
    }
}
 

import org.xnio.Pooled; //导入方法依赖的package包/类
@Override
public void handleEvent(final StreamSourceChannel channel) {
    Pooled<ByteBuffer> resource = bufferPool.allocate();
    ByteBuffer buffer = resource.getResource();
    try {
        int r = 0;
        do {
            r = channel.read(buffer);
            if (r == 0) {
                return;
            } else if (r == -1) {
                stringDone(string.extract());
                IoUtils.safeClose(channel);
            } else {
                buffer.flip();
                string.write(buffer);
            }
        } while (r > 0);
    } catch (IOException e) {
        error(e);
    } finally {
        resource.free();
    }
}
 

import org.xnio.Pooled; //导入方法依赖的package包/类
@Override
public void send(final String data, final Charset charset, final IoCallback callback) {
    ByteBuffer bytes = ByteBuffer.wrap(data.getBytes(charset));
    if (bytes.remaining() == 0) {
        callback.onComplete(exchange, this);
    } else {
        int i = 0;
        ByteBuffer[] bufs = null;
        while (bytes.hasRemaining()) {
            Pooled<ByteBuffer> pooled = exchange.getConnection().getBufferPool().allocate();
            if (bufs == null) {
                int noBufs = (bytes.remaining() + pooled.getResource().remaining() - 1) / pooled.getResource().remaining(); //round up division trick
                pooledBuffers = new Pooled[noBufs];
                bufs = new ByteBuffer[noBufs];
            }
            pooledBuffers[i] = pooled;
            bufs[i] = pooled.getResource();
            Buffers.copy(pooled.getResource(), bytes);
            pooled.getResource().flip();
            ++i;
        }
        send(bufs, callback);
    }
}
 

import org.xnio.Pooled; //导入方法依赖的package包/类
private void registerWebSocketChannelListener(WebSocketChannel webSocketChannel) {
    ChannelListener<WebSocketChannel> listener = new AbstractReceiveListener() {

        @Override
        protected void onFullBinaryMessage(WebSocketChannel channel, BufferedBinaryMessage message) throws IOException {
            log.log(Level.FINE, "Server received full binary message");
            Pooled<ByteBuffer[]> pulledData = message.getData();
            try {
                ByteBuffer[] resource = pulledData.getResource();
                ByteBuffer byteBuffer = WebSockets.mergeBuffers(resource);
                String msg = new String(byteBuffer.array());
                log.log(Level.FINE, "Sending message to decoder: "+ msg);
                writeToDecoder(msg);
            }
            finally {
                pulledData.discard();
            }
        }
    };
    webSocketChannel.getReceiveSetter().set(listener);
}
 

import org.xnio.Pooled; //导入方法依赖的package包/类
void startWriting() {
    Iterator<Pooled<ByteBuffer>> iterator = allocated.iterator();
    while (iterator.hasNext()) {
        Pooled<ByteBuffer> pooledBuffer = iterator.next();
        ByteBuffer byteBuffer = pooledBuffer.getResource();
        if (!byteBuffer.hasRemaining()) {
            byteBuffer.clear();
            pooledBuffer.free();
            iterator.remove();
        } else {
            break;
        }
    }
    Pooled<ByteBuffer> lastPooledBuffer = allocated.peekLast();
    if (lastPooledBuffer != null) {
        ByteBuffer lastBuffer = lastPooledBuffer.getResource();
        if (lastBuffer.limit() < lastBuffer.capacity()) {
            currentWriteBuffer = lastBuffer.compact();
        }
    }
}
 

import org.xnio.Pooled; //导入方法依赖的package包/类
private void registerWebSocketChannelListener(WebSocketChannel webSocketChannel) {
  ChannelListener<WebSocketChannel> listener = new AbstractReceiveListener() {

    @Override
    protected void onFullBinaryMessage(WebSocketChannel channel, BufferedBinaryMessage message) throws IOException {
      log.trace("Server received full binary message");
      Pooled<ByteBuffer[]> pulledData = message.getData();
      try {
        ByteBuffer[] resource = pulledData.getResource();
        ByteBuffer byteBuffer = WebSockets.mergeBuffers(resource);
        String msg = new String(byteBuffer.array());
        log.trace("Sending message to decoder: {}", msg);
        writeToDecoder(msg);
      } finally {
        pulledData.discard();
      }
    }
  };
  webSocketChannel.getReceiveSetter().set(listener);
}
 

import org.xnio.Pooled; //导入方法依赖的package包/类
/**
 * Pushes back the given data. This should only be used by transfer coding handlers that have read past
 * the end of the request when handling pipelined requests
 *
 * @param unget The buffer to push back
 */
public void ungetRequestBytes(final Pooled<ByteBuffer> unget) {
    if (getExtraBytes() == null) {
        setExtraBytes(unget);
    } else {
        Pooled<ByteBuffer> eb = getExtraBytes();
        ByteBuffer buf = eb.getResource();
        final ByteBuffer ugBuffer = unget.getResource();

        if (ugBuffer.limit() - ugBuffer.remaining() > buf.remaining()) {
            //stuff the existing data after the data we are ungetting
            ugBuffer.compact();
            ugBuffer.put(buf);
            ugBuffer.flip();
            eb.free();
            setExtraBytes(unget);
        } else {
            //TODO: this is horrible, but should not happen often
            final byte[] data = new byte[ugBuffer.remaining() + buf.remaining()];
            int first = ugBuffer.remaining();
            ugBuffer.get(data, 0, ugBuffer.remaining());
            buf.get(data, first, buf.remaining());
            eb.free();
            unget.free();
            final ByteBuffer newBuffer = ByteBuffer.wrap(data);
            setExtraBytes(new ImmediatePooled<>(newBuffer));
        }
    }
}
 

import org.xnio.Pooled; //导入方法依赖的package包/类
@Override
public long transferTo(long count, ByteBuffer throughBuffer, StreamSinkChannel target) throws IOException {
    Pooled<ByteBuffer>[] buffered = getAttachment(BUFFERED_REQUEST_DATA);
    if (buffered == null) {
        return super.transferTo(count, throughBuffer, target);
    }
    //make sure there is no garbage in throughBuffer
    throughBuffer.position(0);
    throughBuffer.limit(0);
    long copied = 0;
    for (int i = 0; i < buffered.length; ++i) {
        Pooled<ByteBuffer> pooled = buffered[i];
        if (pooled != null) {
            final ByteBuffer buf = pooled.getResource();
            if (buf.hasRemaining()) {
                int res = target.write(buf);

                if (!buf.hasRemaining()) {
                    pooled.free();
                    buffered[i] = null;
                }
                if (res == 0) {
                    return copied;
                } else {
                    copied += res;
                }
            } else {
                pooled.free();
                buffered[i] = null;
            }
        }
    }
    removeAttachment(BUFFERED_REQUEST_DATA);
    if (copied == 0) {
        return super.transferTo(count, throughBuffer, target);
    } else {
        return copied;
    }
}
 

import org.xnio.Pooled; //导入方法依赖的package包/类
@Override
public long read(ByteBuffer[] dsts, int offset, int length) throws IOException {
    Pooled<ByteBuffer>[] buffered = getAttachment(BUFFERED_REQUEST_DATA);
    if (buffered == null) {
        return super.read(dsts, offset, length);
    }
    long copied = 0;
    for (int i = 0; i < buffered.length; ++i) {
        Pooled<ByteBuffer> pooled = buffered[i];
        if (pooled != null) {
            final ByteBuffer buf = pooled.getResource();
            if (buf.hasRemaining()) {
                copied += Buffers.copy(dsts, offset, length, buf);
                if (!buf.hasRemaining()) {
                    pooled.free();
                    buffered[i] = null;
                }
                if (!Buffers.hasRemaining(dsts, offset, length)) {
                    return copied;
                }
            } else {
                pooled.free();
                buffered[i] = null;
            }
        }
    }
    removeAttachment(BUFFERED_REQUEST_DATA);
    if (copied == 0) {
        return super.read(dsts, offset, length);
    } else {
        return copied;
    }
}
 

import org.xnio.Pooled; //导入方法依赖的package包/类
private void createLastChunk(final boolean writeFinal) throws UnsupportedEncodingException {
    Pooled<ByteBuffer> lastChunkBufferPooled =  bufferPool.allocate();
    ByteBuffer lastChunkBuffer = lastChunkBufferPooled.getResource();
    if (writeFinal) {
        lastChunkBuffer.put(CRLF);
    } else if(chunkingSepBuffer.hasRemaining()) {
        //the end of chunk /r/n has not been written yet
        //just add it to this buffer to make managing state easier
        lastChunkBuffer.put(chunkingSepBuffer);
    }
    lastChunkBuffer.put(LAST_CHUNK);
    //we just assume it will fit
    HeaderMap trailers = attachable.getAttachment(HttpAttachments.RESPONSE_TRAILERS);
    if (trailers != null && trailers.size() != 0) {
        for (HeaderValues trailer : trailers) {
            for (String val : trailer) {
                trailer.getHeaderName().appendTo(lastChunkBuffer);
                lastChunkBuffer.put((byte) ':');
                lastChunkBuffer.put((byte) ' ');
                lastChunkBuffer.put(val.getBytes("US-ASCII"));
                lastChunkBuffer.put(CRLF);
            }
        }
        lastChunkBuffer.put(CRLF);
    } else {
        lastChunkBuffer.put(CRLF);
    }
    //horrible hack
    //there is a situation where we can get a buffer leak here if the connection is terminated abnormaly
    //this should be fixed once this channel has its lifecycle tied to the connection, same as fixed length
    lastChunkBuffer.flip();
    ByteBuffer data = ByteBuffer.allocate(lastChunkBuffer.remaining());
    data.put(lastChunkBuffer);
    data.flip();
    this.lastChunkBuffer = new ImmediatePooled<>(data);

    lastChunkBufferPooled.free();
}
 

import org.xnio.Pooled; //导入方法依赖的package包/类
@Override
public int read(final ByteBuffer dst) throws IOException {
    Pooled<ByteBuffer> eb = connection.getExtraBytes();
    if (eb != null) {
        final ByteBuffer buffer = eb.getResource();
        int result = Buffers.copy(dst, buffer);
        if (!buffer.hasRemaining()) {
            eb.free();
            connection.setExtraBytes(null);
        }
        return result;
    } else {
        return super.read(dst);
    }
}
 

import org.xnio.Pooled; //导入方法依赖的package包/类
protected void onFullCloseMessage(final WebSocketChannel channel, BufferedBinaryMessage message) throws IOException {
    Pooled<ByteBuffer[]> data = message.getData();
    try {
        CloseMessage cm = new CloseMessage(data.getResource());
        onCloseMessage(cm, channel);
        if (!channel.isCloseFrameSent()) {
            WebSockets.sendClose(cm, channel, null);
        }
    } finally {
        data.free();
    }
}