Examples of com.alibaba.dubbo.remoting.buffer.ChannelBuffer

Package com.alibaba.dubbo.remoting.buffer

Examples of com.alibaba.dubbo.remoting.buffer.ChannelBuffer

com.alibaba.dubbo.remoting.buffer.ChannelBuffer
kipedia.org/wiki/Index_(information_technology)#Array_element_identifier">zero-based indexing. It means the index of the first byte is always {@code 0} andthe index of the last byte is always {@link #capacity() capacity - 1}. For example, to iterate all bytes of a buffer, you can do the following, regardless of its internal implementation:
```
 {@link ChannelBuffer} buffer = ...;for (int i = 0; i < buffer.capacity(); i ++) { byte b = buffer.getByte(i); System.out.println((char) b); } 
```
Sequential Access Indexing

{@link ChannelBuffer} provides two pointer variables to support sequentialread and write operations - {@link #readerIndex() readerIndex} for a readoperation and {@link #writerIndex() writerIndex} for a write operationrespectively. The following diagram shows how a buffer is segmented into three areas by the two pointers:
```
 +-------------------+------------------+------------------+ | discardable bytes |  readable bytes  |  writable bytes  | |                   |     (CONTENT)    |                  | +-------------------+------------------+------------------+ |                   |                  |                  | 0      <=      readerIndex   <=   writerIndex    <=    capacity 
```
Readable bytes (the actual content)

This segment is where the actual data is stored. Any operation whose name starts with {@code read} or {@code skip} will get or skip the data at thecurrent {@link #readerIndex() readerIndex} and increase it by the number ofread bytes. If the argument of the read operation is also a {@link ChannelBuffer} and no destination index is specified, the specified buffer's{@link #readerIndex() readerIndex} is increased together.
If there's not enough content left, {@link IndexOutOfBoundsException} israised. The default value of newly allocated, wrapped or copied buffer's {@link #readerIndex() readerIndex} is {@code 0}.
```
 // Iterates the readable bytes of a buffer. {@link ChannelBuffer} buffer = ...;while (buffer.readable()) { System.out.println(buffer.readByte()); } 
```
Writable bytes

This segment is a undefined space which needs to be filled. Any operation whose name ends with {@code write} will write the data at the current {@link #writerIndex() writerIndex} and increase it by the number of written bytes.If the argument of the write operation is also a {@link ChannelBuffer}, and no source index is specified, the specified buffer's {@link #readerIndex() readerIndex} is increased together.
If there's not enough writable bytes left, {@link IndexOutOfBoundsException}is raised. The default value of newly allocated buffer's {@link #writerIndex() writerIndex} is {@code 0}. The default value of wrapped or copied buffer's {@link #writerIndex() writerIndex} is the {@link #capacity() capacity} of the buffer.
```
 // Fills the writable bytes of a buffer with random integers. {@link ChannelBuffer} buffer = ...;while (buffer.writableBytes() >= 4) { buffer.writeInt(random.nextInt()); } 
```
Discardable bytes

This segment contains the bytes which were read already by a read operation. Initially, the size of this segment is {@code 0}, but its size increases up to the {@link #writerIndex() writerIndex} as read operations are executed.The read bytes can be discarded by calling {@link #discardReadBytes()} toreclaim unused area as depicted by the following diagram:
```
 BEFORE discardReadBytes() +-------------------+------------------+------------------+ | discardable bytes |  readable bytes  |  writable bytes  | +-------------------+------------------+------------------+ |                   |                  |                  | 0      <=      readerIndex   <=   writerIndex    <=    capacity AFTER discardReadBytes() +------------------+--------------------------------------+ |  readable bytes  |    writable bytes (got more space)   | +------------------+--------------------------------------+ |                  |                                      | readerIndex (0) <= writerIndex (decreased)        <=        capacity 
```
Please note that there is no guarantee about the content of writable bytes after calling {@link #discardReadBytes()}. The writable bytes will not be moved in most cases and could even be filled with completely different data depending on the underlying buffer implementation.

Clearing the buffer indexes

You can set both {@link #readerIndex() readerIndex} and {@link #writerIndex() writerIndex} to {@code 0} by calling {@link #clear()}. It does not clear the buffer content (e.g. filling with {@code 0}) but just clears the two pointers. Please also note that the semantic of this operation is different from {@link ByteBuffer#clear()}.
```
 BEFORE clear() +-------------------+------------------+------------------+ | discardable bytes |  readable bytes  |  writable bytes  | +-------------------+------------------+------------------+ |                   |                  |                  | 0      <=      readerIndex   <=   writerIndex    <=    capacity AFTER clear() +---------------------------------------------------------+ |             writable bytes (got more space)             | +---------------------------------------------------------+ |                                                         | 0 = readerIndex = writerIndex            <=            capacity 
```
Mark and reset

There are two marker indexes in every buffer. One is for storing {@link #readerIndex() readerIndex} and the other is for storing {@link #writerIndex() writerIndex}. You can always reposition one of the two indexes by calling a reset method. It works in a similar fashion to the mark and reset methods in {@link InputStream} except that there's no {@code readlimit}.

Conversion to existing JDK types

Byte array

If a {@link ChannelBuffer} is backed by a byte array (i.e. {@code byte[]}), you can access it directly via the {@link #array()} method. To determine ifa buffer is backed by a byte array, {@link #hasArray()} should be used.

NIO Buffers

Various {@link #toByteBuffer()} methods convert a {@link ChannelBuffer} intoone or more NIO buffers. These methods avoid buffer allocation and memory copy whenever possible, but there's no guarantee that memory copy will not be involved.

I/O Streams

Please refer to {@link ChannelBufferInputStream} and {@link ChannelBufferOutputStream}. @author kimi

    @Override
    public NextAction handleWrite(FilterChainContext context) throws IOException {
        Connection<?> connection = context.getConnection();
        GrizzlyChannel channel = GrizzlyChannel.getOrAddChannel(connection, url, handler);
        try {
            ChannelBuffer channelBuffer = ChannelBuffers.dynamicBuffer(1024); // 不需要关闭
            
            Object msg = context.getMessage();
            codec.encode(channel, channelBuffer, msg);
            
            GrizzlyChannel.removeChannelIfDisconnectd(connection);
            Buffer buffer = connection.getTransport().getMemoryManager().allocate(channelBuffer.readableBytes());
            buffer.put(channelBuffer.toByteBuffer());
            buffer.flip();
            buffer.allowBufferDispose(true);
            context.setMessage(buffer);
        } finally {
            GrizzlyChannel.removeChannelIfDisconnectd(connection);

View Full Code Here

        Channel channel = GrizzlyChannel.getOrAddChannel(connection, url, handler);
        try {
            if (message instanceof Buffer) { // 收到新的数据包
                Buffer grizzlyBuffer = (Buffer) message; // 缓存


                ChannelBuffer frame;


                if (previousData.readable()) {
                    if (previousData instanceof DynamicChannelBuffer) {
                        previousData.writeBytes(grizzlyBuffer.toByteBuffer());
                        frame = previousData;
                    } else {
                        int size = previousData.readableBytes() + grizzlyBuffer.remaining();
                        frame = ChannelBuffers.dynamicBuffer(size > bufferSize ? size : bufferSize);
                        frame.writeBytes(previousData, previousData.readableBytes());
                        frame.writeBytes(grizzlyBuffer.toByteBuffer());
                    }
                } else {
                    frame = ChannelBuffers.wrappedBuffer(grizzlyBuffer.toByteBuffer());
                }


                Object msg;
                int savedReadIndex;


                do {
                    savedReadIndex = frame.readerIndex();
                    try {
                        msg = codec.decode(channel, frame);
                    } catch (Exception e) {
                        previousData = ChannelBuffers.EMPTY_BUFFER;
                        throw new IOException(e.getMessage(), e);
                    }
                    if (msg == Codec2.DecodeResult.NEED_MORE_INPUT) {
                        frame.readerIndex(savedReadIndex);
                        return context.getStopAction();
                    } else {
                        if (savedReadIndex == frame.readerIndex()) {
                            previousData = ChannelBuffers.EMPTY_BUFFER;
                            throw new IOException("Decode without read data.");
                        }
                        if (msg != null) {
                            context.setMessage(msg);
                            return context.getInvokeAction();
                        } else {
                            return context.getInvokeAction();
                        }
                    }
                } while (frame.readable());
            } else { // 其它事件直接往下传
                return context.getInvokeAction();
            }
        } finally {
            GrizzlyChannel.removeChannelIfDisconnectd(connection);

View Full Code Here


        public void dispose(IoSession session) throws Exception {
        }


        public void encode(IoSession session, Object msg, ProtocolEncoderOutput out) throws Exception {
            ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(1024);
            MinaChannel channel = MinaChannel.getOrAddChannel(session, url, handler);
            try {
              codec.encode(channel, buffer, msg);
            } finally {
                MinaChannel.removeChannelIfDisconnectd(session);
            }
            out.write(ByteBuffer.wrap(buffer.toByteBuffer()));
            out.flush();
        }

View Full Code Here


        public void decode(IoSession session, ByteBuffer in, ProtocolDecoderOutput out) throws Exception {
            int readable = in.limit();
            if (readable <= 0) return;


            ChannelBuffer frame;


            if (buffer.readable()) {
                if (buffer instanceof DynamicChannelBuffer) {
                    buffer.writeBytes(in.buf());
                    frame = buffer;
                } else {
                    int size = buffer.readableBytes() + in.remaining();
                    frame = ChannelBuffers.dynamicBuffer(size > bufferSize ? size : bufferSize);
                    frame.writeBytes(buffer, buffer.readableBytes());
                    frame.writeBytes(in.buf());
                }
            } else {
                frame = ChannelBuffers.wrappedBuffer(in.buf());
            }


            Channel channel = MinaChannel.getOrAddChannel(session, url, handler);
            Object msg;
            int savedReadIndex;


            try {
                do {
                    savedReadIndex = frame.readerIndex();
                    try {
                        msg = codec.decode(channel, frame);
                    } catch (Exception e) {
                        buffer = ChannelBuffers.EMPTY_BUFFER;
                        throw e;
                    }
                    if (msg == Codec2.DecodeResult.NEED_MORE_INPUT) {
                        frame.readerIndex(savedReadIndex);
                        break;
                    } else {
                        if (savedReadIndex == frame.readerIndex()) {
                            buffer = ChannelBuffers.EMPTY_BUFFER;
                            throw new Exception("Decode without read data.");
                        }
                        if (msg != null) {
                            out.write(msg);
                        }
                    }
                } while (frame.readable());
            } finally {
                if (frame.readable()) {
                    frame.discardReadBytes();
                    buffer = frame;
                } else {
                    buffer = ChannelBuffers.EMPTY_BUFFER;
                }
                MinaChannel.removeChannelIfDisconnectd(session);

View Full Code Here

    
    protected void testDecode_assertEquals(byte[] request,Object ret, boolean isServerside) throws IOException{
        //init channel
        Channel channel = isServerside? getServerSideChannel(url) : getCliendSideChannel(url);
        //init request string
        ChannelBuffer buffer = ChannelBuffers.wrappedBuffer(request);


        //decode
        Object obj = codec.decode(channel, buffer);
        Assert.assertEquals(ret, obj);
    }

View Full Code Here

    
    protected void testEecode_assertEquals(Object request,byte[] ret, boolean isServerside) throws IOException{
        //init channel
        Channel channel = isServerside? getServerSideChannel(url) : getCliendSideChannel(url);


        ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(1024);


        codec.encode(channel, buffer, request);
        byte[] data = new byte[buffer.readableBytes()];
        buffer.readBytes(data);


        Assert.assertEquals(ret.length, data.length);
        for(int i=0;i<ret.length;i++){
            if (ret[i] != data[i]){
                Assert.fail();

View Full Code Here

        if (channel == null){
            channel = getServerSideChannel(url);
        }
        
        byte[] buf = objectToByte(request);
        ChannelBuffer buffer = ChannelBuffers.wrappedBuffer(buf);


        //decode
        Object obj = codec.decode(channel, buffer);
        Assert.assertEquals(expectret, obj);
        Assert.assertEquals(channelReceive, channel.getReceivedMessage());

View Full Code Here

        //init channel
        Channel channel = getServerSideChannel(url);
        //init request string
        Person request = new Person();
        byte[] newbuf = join(objectToByte(request), enterbytes);
        ChannelBuffer buffer = ChannelBuffers.wrappedBuffer(newbuf);


        //decode
        Object obj = codec.decode(channel, buffer);
        if (isNeedmore){
            Assert.assertEquals(Codec2.DecodeResult.NEED_MORE_INPUT , obj);

View Full Code Here

    Serialization serialization = getSerialization(Constants.DEFAULT_REMOTING_SERIALIZATION);
    
    


    private Object decode(byte[] request) throws IOException{
        ChannelBuffer buffer = ChannelBuffers.wrappedBuffer(request);
        AbstractMockChannel channel = getServerSideChannel(url);
        //decode
        Object obj = codec.decode(channel, buffer);
        return obj;
    }

View Full Code Here

        Person person = new Person();
        byte[] request = getRequestBytes(person, header);
        
        Channel channel = getServerSideChannel(url);
        byte[] baddata = new byte[]{1,2};
        ChannelBuffer buffer = ChannelBuffers.wrappedBuffer(join(request, baddata));
        Response obj = (Response)codec.decode(channel, buffer);
        Assert.assertEquals(person, obj.getResult());
        //only decode necessary bytes
        Assert.assertEquals(request.length, buffer.readerIndex());
    }

View Full Code Here

0 1 2

TOP

Related Classes of com.alibaba.dubbo.remoting.buffer.ChannelBuffer

com.alibaba.dubbo.remoting.codec.ExchangeCodecTest

com.alibaba.dubbo.remoting.codec.TelnetCodecTest

com.alibaba.dubbo.remoting.transport.grizzly.GrizzlyCodecAdapter

com.alibaba.dubbo.remoting.transport.mina.MinaCodecAdapter$InternalDecoder

com.alibaba.dubbo.remoting.transport.mina.MinaCodecAdapter$InternalEncoder

com.alibaba.dubbo.rpc.protocol.thrift.ThriftCodecTest

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.

Examples of com.alibaba.dubbo.remoting.buffer.ChannelBuffer

Sequential Access Indexing

Readable bytes (the actual content)

Writable bytes

Discardable bytes

Clearing the buffer indexes

Mark and reset

Conversion to existing JDK types

Byte array

NIO Buffers

I/O Streams

Related Classes of com.alibaba.dubbo.remoting.buffer.ChannelBuffer