1.ByteBuf类 - Netty的数据容器

ByteBuf维护了两个不同的索引：

• readerIndex：用于读取
• writerIndex：用于写入

起始位置都从0开始：

名称以read或者write开头的方法会更新ByteBuf对应的索引，而名称以set或者get开头的操作不会。 AbstractByteBuf#readByte 代码如下：

public byte readByte() {    checkReadableBytes0(1);    int i = readerIndex;    byte b = _getByte(i);    readerIndex = i + 1;// 这里更新了索引    return b;}

AbstractByteBuf#getByte 代码如下：

public byte getByte(int index) {    checkIndex(index);    return _getByte(index);// 直接返回，没有更新索引}

---

2.ByteBuf的使用模式

(1)堆缓冲区

将数据存储在JVM的堆空间。

• 好处：提供快速分配和释放4
• 场景：遗留数据处理

public static void heapBuffer() {    ByteBuf heapBuf = BYTE_BUF_FROM_SOMEWHERE; //get reference form somewhere    if (heapBuf.hasArray()) { //检查 ByteBuf 是否有一个支撑数组        byte[] array = heapBuf.array();//如果有，则获取对该数组的引用        int offset = heapBuf.arrayOffset() + heapBuf.readerIndex();//计算第一个字节的偏移量        int length = heapBuf.readableBytes();//获得可读字节数        handleArray(array, offset, length);//使用数组、偏移量和长度作为参数调用你的方法    }}

如果hasArray()返回false，仍然去访问array()会抛出UnsupportedOperationException。

(2)直接缓冲区

NIO在JDK1.4中引入的ByteBuffer类允许JVM实现通过本地调用来分配内存。直接缓冲区的内容将驻留在常规的会被垃圾回收的堆之外。 如果数据包含在一个在堆上分配的缓冲区中，在通过套接字发送它之前，JVM会在内部把缓冲区复制到一个直接缓冲区中。

• 目的：避免在每次调用本地I/O操作之前(后)将缓冲区的内容复制到一个中间缓冲区(或者从中间缓冲区把内容复制到缓冲区)
• 缺点：直接缓冲区的分配和释放较堆缓冲区昂贵

public static void directBuffer() {    ByteBuf directBuf = BYTE_BUF_FROM_SOMEWHERE; //get reference form somewhere    if (!directBuf.hasArray()) {//检查 ByteBuf 是否由数组支撑。如果不是，则这是一个直接缓冲区        int length = directBuf.readableBytes();//获取可读字节数        byte[] array = new byte[length];//分配一个新的数组来保存具有该长度的字节数据        directBuf.getBytes(directBuf.readerIndex(), array);//将字节复制到该数组        handleArray(array, 0, length);//使用数组、偏移量和长度作为参数调用你的方法    }}

(3)复合缓冲区

为多个ByteBuf提供一个聚合视图，可以根据需要添加或者删除ByteBuf实例。 CompositeByteBuf ByteBuf的子类，提供一个将多个缓冲区表示为单个合并缓冲区的虚拟表示。CompositeByteBuf中的ByteBuf实例可能同时包含直接内存分配和非直接内存分配。

• 通过JDK的ByteBuffer实现：创建一个包含两个ByteBuffer的数组来保存消息组件

public static void byteBufferComposite(ByteBuffer header, ByteBuffer body) {    // Use an array to hold the message parts    ByteBuffer[] message =  new ByteBuffer[]{ header, body };    // Create a new ByteBuffer and use copy to merge the header and body    ByteBuffer message2 =            ByteBuffer.allocate(header.remaining() + body.remaining());    message2.put(header);    message2.put(body);    message2.flip();}

• 使用CompositeByteBuf实现的复合缓冲区模式：

public static void byteBufComposite() {    CompositeByteBuf messageBuf = Unpooled.compositeBuffer();    ByteBuf headerBuf = BYTE_BUF_FROM_SOMEWHERE; // can be backing or direct    ByteBuf bodyBuf = BYTE_BUF_FROM_SOMEWHERE;   // can be backing or direct    messageBuf.addComponents(headerBuf, bodyBuf);//将 ByteBuf 实例追加到 CompositeByteBuf    //...    //删除位于索引位置为 0（第一个组件）的 ByteBuf    messageBuf.removeComponent(0); // remove the header    //循环遍历所有的 ByteBuf 实例    for (ByteBuf buf : messageBuf) {        System.out.println(buf.toString());    }}

• 因为CompositeByteBuf可能不支持访问其支撑数组，访问CompositeByteBuf中的数据类似于直接缓冲区的模式：

public static void byteBufCompositeArray() {    CompositeByteBuf compBuf = Unpooled.compositeBuffer();    int length = compBuf.readableBytes();//获得可读字节数    byte[] array = new byte[length];//分配一个具有可读字节数长度的新数组    compBuf.getBytes(compBuf.readerIndex(), array);//将字节读到该数组中    handleArray(array, 0, array.length);//使用偏移量和长度作为参数使用该数组}

---

3.ByteBuf字节级操作

ByteBuf提供了许多超出基本读/写操作的方法用于修改数据。

(1)随机访问索引

第一个字节的索引：0, 最后一个字节的索引：capacity() - 1

public static void byteBufRelativeAccess() {    ByteBuf buffer = BYTE_BUF_FROM_SOMEWHERE; //get reference form somewhere    for (int i = 0; i < buffer.capacity(); i++) {        byte b = buffer.getByte(i);        System.out.println((char) b);    }}

(2)顺序访问索引

首先看下ByteBuf的内部分段：

+-------------------+------------------+------------------+      | discardable bytes |  readable bytes  |  writable bytes  |      |                   |     (CONTENT)    |                  |      +-------------------+------------------+------------------+      |                   |                  |                  |      0      <=      readerIndex   <=   writerIndex    <=    capacity

After discardReadBytes()：对可写分段的内容并没有任何保证，因为只是移动了可以读取的字节以及writerIndex，并没有对所有可写入的字节进行擦除写。

+------------------+--------------------------------------+      |  readable bytes  |    writable bytes (got more space)   |      +------------------+--------------------------------------+      |                  |                                      | readerIndex (0) <= writerIndex (decreased)        <=        capacity

可以看出，ByteBuf被读索引和写索引划分成了3个区域：

• 可丢弃字节：已经被读过的字节，调用discardReadBytes()丢弃并回收空间(丢弃字节部分变为可写)。初始大小是0,存储在readerIndex中，随着read操作的执行而增加。
• 可读字节：可读字节分段存储了实际数据。新分配的/包装的/复制的缓冲区的默认的readerIndex值为0。任何read或者skip开头的操作都将检索或者跳过位于当前readerIndex的数据，并且将它增加已读字节数。如果被调用的方法需要一个ByteBuf参数作为写入的目标，并且没有指定目标索引参数，那么该目标缓冲区的writerIndex也将被增加。如果尝试在缓冲区的可读字节数已经耗尽时从中读取数据，将抛出-IndexOutOfBoundsException 见下面代码
• 可写字节：可写字节分段指一个未定义内容/写入就绪的内存区域。新分配的缓冲区的writerIndex的默认值是0。任何write开头的操作都将从当前的writerIndex处开始写数据，并将它增加已经写入的字节数。

readBytes(ByteBuf dst) 代码

public ByteBuf readBytes(ByteBuf dst) {    readBytes(dst, dst.writableBytes());    return this;}public ByteBuf readBytes(ByteBuf dst, int length) {    if (checkBounds) {        if (length > dst.writableBytes()) {            throw new IndexOutOfBoundsException(String.format(                    "length(%d) exceeds dst.writableBytes(%d) where dst is: %s", length, dst.writableBytes(), dst));        }    }    readBytes(dst, dst.writerIndex(), length);    dst.writerIndex(dst.writerIndex() + length);    return this;}

如何读取所有可读字节：

public static void readAllData() {    ByteBuf buffer = BYTE_BUF_FROM_SOMEWHERE; //get reference form somewhere    while (buffer.isReadable()) {        System.out.println(buffer.readByte());    }}

如何往可写字节分段写数据：

public static void write() {    // Fills the writable bytes of a buffer with random integers.    ByteBuf buffer = BYTE_BUF_FROM_SOMEWHERE; //get reference form somewhere    while (buffer.writableBytes() >= 4) {        buffer.writeInt(random.nextInt());    }}