前言

我們之前在介紹NIO的三個組件的時候，總結過NIO中的ByteBuffer，針對NIO中的ByteBuffer，我們在讀寫的時候，需要調用flip等方法做一個顯示的讀寫模式的切換。在使用上有些許的不方便。Netty為了更好的讀取和寫入數據，單獨封裝了一個ByteBuf。

ByteBuf

ByteBuf數據結構

ByteBuf內部是一個字節的容器，內部其實就是一個字節數組，但整體也可分為四個部分

第一個部分：已用字節，已被廢棄的無效字節。

第二個部分：可讀字節，從ByteBuf中讀取的字節都來自這個部分。

第三個部分：可寫字節，寫入都ByteBuf的直接都會寫到這個部分。

第四個部分：可擴容字節，最多還能擴容的大小。

ByteBuf的重要屬性

前面提到過，ByteBuf的在讀寫的時候不需要進行讀寫模式的切換，主要是因為ByteBuf通過三個屬性有效的區分可讀數據和可寫數據。

readerIndex 讀指針，每次讀取一個字節，readerIndex自動增加，當readerIndex等于writerIndex的時候，表示ByteBuf不可讀了。并不需要我們切換。

writerIndex寫指針，表示寫入的起始位置，每寫一個自己，writerIndex自動增加一位，一旦writerIndex與capacity()容量相等，表示ByteBuf已經不可寫了。

maxCapacity最大容量，表示ByteBuf可以擴容的最大容量，如果超過maxCapacity則會報錯。

直接看圖吧

ByteBuf的引用計數

Netty中的ByteBuf的內存回收工作是通過引用計數的管理方式（就是JVM中使用的“計數器”）來標記對象是否"不可達"，如果不可達，則會進行內存回收。默認情況下創建完一個ByteBuf的時候，這個ByteBuf的引用為1，每次調用retain方法，這個ByteBuf的計數就增加1，每次調用release方法，則ByteBuf的引用計數就會減一。如果引用計數減為0，則再次訪問這個ByteBuf對象就會拋出異常，因為這個ByteBuf就會被回收。

ByteBuf的分配器

Netty通過ByteBufAllocator分配器來創建和分配緩沖內存空間。其中有池化的分配器——PoolByteBufAllocator和非池化的分配器——UnpooledByteBufAllocator 前者將分配的ByteBuf放入池中，后者每次產生新的ByteBuf，通過Java的垃圾回收機制回收。總體來看ByteBuf的分配有以下幾種方式

//使用默認的分配方式分配ByteBuf
buffer = ByteBufAllocator.DEFAULT.buffer(9, 100);

//利用非池化分配方式，分配ByteBuf
buffer = UnpooledByteBufAllocator.DEFAULT.buffer();

//利用池化分配方式，分配堆外ByteBuf
buffer = PooledByteBufAllocator.DEFAULT.directBuffer();

//利用池化分配方式，分配堆ByteBuf
buffer = PooledByteBufAllocator.DEFAULT.heapBuffer();

如果沒有特別要求，其實第一種分配方式就可以了。

ByteBuf的類型

ByteBuf的類型其實不止一個，主要有以下三個。

類型	說明
Heap ByteBuf	存儲在Java堆中，通過hasArray來判斷是不是堆緩沖區
Direct ByteBuf	直接緩沖區，直接在操作系統的物理內存中分配
CompositeBuffer	多個緩沖區的組合表示

上述的三種，都可以通過池化和非池化的方式來進行分配。這里重點說一下Heap ByteBuf和Direct ByteBuf，后者并不分配于Java堆內存，前者是分配于Java堆上。兩者在讀取數據時是還是有區別的。

HeapByteBuf ：特點是內存的分配和回收速度快。可以被jvm自動回收。缺點就是在進行socket的I/O讀寫時，需要將堆內存的緩沖區拷貝到內核中，有一定拷貝的代價。
DirectByteBuf：特點是分配在堆內存外，相比于堆內存分配速度會慢一點，并需要手動管理其引用計數，清理不使用的內存。但是其直接用native方法，不需要拷貝。

ByteBuf的釋放

除了我們顯示調用ByteBuf的分配，通過查看Netty源碼，會發現Netty的相關線程，會在底層的NIO通道讀取數據的時候，調用ByteBufAllocator方法，創建ByteBuf實例，然后調用pipeline.fireChannelRead(byteBuf)方法將讀取到的數據包送入到入站處理流水線中。

針對ByteBuf的釋放，Netty有幾種方式

如果我們的處理器繼承至ChannelInboundHandlerAdapter則除了手動釋放ByteBuf之外，在調用父類的read方法時，會自動完成ByteBuf的釋放。

如果繼承至SimpleChannelInboundContext除了手動釋放ByteBuf之外，會自動釋放ByteBuf。從源碼中可以看出

@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
    boolean release = true;
    try {
        if (acceptInboundMessage(msg)) {
            @SuppressWarnings("unchecked")
            I imsg = (I) msg;
            channelRead0(ctx, imsg);//子類的channelRead方法
        } else {
            release = false;
            ctx.fireChannelRead(msg);
        }
    } finally {
        if (autoRelease && release) {
            ReferenceCountUtil.release(msg);//這里會自動釋放
        }
    }
}

實例

基本的簡單讀寫

/**
 * autor:liman
 * createtime:2020/9/19
 * comment:基本的ByteBuf讀寫
 */
@Slf4j
public class BaseReadAndWriteBuf {

    public static void main(String[] args) {
        ByteBuf buffer = ByteBufAllocator.DEFAULT.buffer(9,100);
        log.info("分配初始化9，最大空間100的buffer，{}",buffer);
        byte[] data = new byte[]{1,2,3,4};
        log.info("開始寫入數據");
        writeData(buffer,data);
        log.info("讀數據");
        readDataFromBuffer(buffer);
        log.info("取數據");
        getByteFromBuffer(buffer);
        log.info("all done!");
    }

    public static void writeData(ByteBuf buffer,byte[] dataByte){
        buffer.writeBytes(dataByte);
    }

    public static void readDataFromBuffer(ByteBuf buffer){
        while(buffer.isReadable()){
            log.info("讀一個字節:{}",buffer.readByte());
        }
    }

    public static void getByteFromBuffer(ByteBuf buffer){
        for(int i=0;i<buffer.readableBytes();i++){
            log.info("獲取一個字節：{}",buffer.getByte(i));
        }
    }
}

三種ByteBuf實例

直接上實例代碼

/**
 * autor:liman
 * createtime:2020/9/19
 * comment:三種ByteBuf的種類介紹
 */
@Slf4j
public class ByteBufTypeDemo {

    private static final Charset UTF8_CharSet = Charset.forName("UTF-8");

    public static void main(String[] args) {
        testHeapByteBuf();
        testDirectByteBuf();
        testCompositeBuffer();
    }

    /**
     * 測試Heaper Buffer
     */
    public static void testHeapByteBuf() {
        ByteBuf heapBuf = ByteBufAllocator.DEFAULT.heapBuffer();
        heapBuf.writeBytes("Heap Buf的簡單實例".getBytes(UTF8_CharSet));
        if (heapBuf.hasArray()) {
            byte[] array = heapBuf.array();
            int offset = heapBuf.arrayOffset() + heapBuf.readerIndex();
            int length = heapBuf.readableBytes();
            String s = new String(array, offset, length, UTF8_CharSet);
            log.info("Heap Buf 讀取結果為:{}", s);
        }
        heapBuf.release();
    }

    /**
     * 測試的directBuffer
     */
    public static void testDirectByteBuf() {
        ByteBuf directBuf = ByteBufAllocator.DEFAULT.directBuffer();
        directBuf.writeBytes("direct Buf的簡單實例".getBytes(UTF8_CharSet));
        if (!directBuf.hasArray()) {
            int length = directBuf.readableBytes();
            byte[] array = new byte[length];
            directBuf.getBytes(directBuf.readerIndex(), array);
            String content = new String(array, UTF8_CharSet);
            log.info("direct buf 讀取的數據為:{}", content);
        }
        directBuf.release();
    }

    /**
     * 測試組合緩沖區
     */
    public static void testCompositeBuffer() {
        CompositeByteBuf compositeByteBuf = ByteBufAllocator.DEFAULT.compositeBuffer();
        //這個底層會調用并分配一個堆緩沖區
        ByteBuf headerBuf = Unpooled.copiedBuffer("組合緩沖區的header內容", UTF8_CharSet);
        ByteBuf bodyBuf = Unpooled.copiedBuffer("組合緩沖區的body部分", UTF8_CharSet);
        compositeByteBuf.addComponents(headerBuf, bodyBuf);
        readCompositeBufferInfo(compositeByteBuf);
    }

    /**
     * 讀取compositeBuffer中的內容
     *
     * @param compositeByteBuf
     */
    public static void readCompositeBufferInfo(CompositeByteBuf compositeByteBuf) {
        String result = "";
        for (ByteBuf byteBuf : compositeByteBuf) {
            int length = byteBuf.readableBytes();
            byte[] array = new byte[length];
            byteBuf.getBytes(byteBuf.readerIndex(), array);
            result = new String(array, UTF8_CharSet);
            log.info("composite buffer讀取結果：{}", result);
        }
    }
}

總結

簡單總結了ByteBuf中的內容，后續總結Netty的相關解碼器