Netty之ByteBuf

本文内容主要参考<<Netty In Action>>,偏笔记向.

网络编程中,字节缓冲区是一个比较基本的组件.Java NIO提供了ByteBuffer,可是使用过的都知道ByteBuffer对于读写数据操做仍是有些麻烦的,切换读写状态须要flip().Netty框架对字节缓冲区进行了封装,名称是ByteBuf,相较于ByteBuffer更灵活.

1.ByteBuf特色概览

• 用户能够自定义缓冲区类型对其扩展
• 经过内置的符合缓冲区类型实现了透明的零拷贝
• 容量能够按需增加(相似StringBuilder)
• 切换读写模式不用调用flip()方法
• 读写使用各自的索引
• 支持方法的链式调用
• 支持引用计数
• 支持池化

2.ByteBuf类介绍

2.1工做模式

ByteBuf维护了两个指针,一个用于读取(readerIndex),一个用于写入(writerIndex).

使用ByteBuf的API中的read*方法读取数据时,readerIndex会根据读取字节数向后移动,可是get*方法不会移动readerIndex;使用write*数据时,writerIndex会根据字节数移动,可是set*方法不会移动writerIndex.(read*表示read开头的方法,其他意义相同)

读取数据时,若是readerIndex超过了writerIndex会触发IndexOutOfBoundsException.

能够指定ByteBuf容量最大值,capacity(int)或ensureWritable(int),当超出容量时会抛出异常.

2.2使用模式

2.2.1堆缓冲区

将ByteBuf存入JVM的堆空间.可以在没有池化的状况下提供快速的分配和释放.

除此以外,ByteBuf的堆缓冲区还提供了一个后备数组(backing array).后备数组和ByteBuf中的数据是对应的,若是修改了backing array中的数据,ByteBuf中的数据是同步的.

public static void main(String[] args) {
        ByteBuf heapBuf = Unpooled.buffer(1024);
        if(heapBuf.hasArray()){
            heapBuf.writeBytes("Hello,heapBuf".getBytes());
            System.out.println("数组第一个字节在缓冲区中的偏移量:"+heapBuf.arrayOffset());
            System.out.println("缓冲区中的readerIndex:"+heapBuf.readerIndex());
            System.out.println("writerIndex:"+heapBuf.writerIndex());
            System.out.println("缓冲区中的可读字节数:"+heapBuf.readableBytes());//等于writerIndex-readerIndex
            byte[] array = heapBuf.array();
            for(int i = 0;i < heapBuf.readableBytes();i++){
                System.out.print((char) array[i]);
                if(i==5){
                    array[i] = (int)'.';
                }
            }
            //不会修改readerIndex位置
            System.out.println("\n读取数据后的readerIndex:"+heapBuf.readerIndex());
            //读取缓冲区的数据,查看是否将逗号改为了句号
            while (heapBuf.isReadable()){
                System.out.print((char) heapBuf.readByte());
            }
        }

输出:

数组第一个字节在缓冲区中的偏移量:0
缓冲区中的readerIndex:0
writerIndex:13
缓冲区中的可读字节数:13
Hello,heapBuf
读取数据后的readerIndex:0
Hello.heapBuf

若是hasArray()返回false,尝试访问backing array会报错

2.2.2直接缓冲区

直接缓冲区存储于JVM堆外的内存空间.这样作有一个好处,当你想把JVM中的数据写给socket,须要将数据复制到直接缓冲区(JVM堆外内存)再交给socket.若是使用直接缓冲区,将减小复制这一过程.

可是直接缓冲区也是有不足的,与JVM堆的缓冲区相比,他们的分配和释放是比较昂贵的.并且还有一个缺点,面对遗留代码的时候,可能不肯定ByteBuf使用的是直接缓冲区仍是堆缓冲区,你可能须要进行一次额外的复制.如代码示例.

与自带后备数组的堆缓冲区来说,这要多作一些工做.因此,若是肯定容器中的数据会被做为数组来访问,你可能更愿意使用堆内存.

//实际上你不知道从哪得到的引用,这多是一个直接缓冲区的ByteBuf
        //忽略Unpooled.buffer方法,当作不知道从哪得到的directBuf
        ByteBuf directBuf = Unpooled.buffer(1024); 
        //若是想要从数组中访问数据,须要将直接缓冲区中的数据手动复制到数组中
        if (!directBuf.hasArray()) {
            int length = directBuf.readableBytes();
            byte[] array = new byte[length];
            directBuf.getBytes(directBuf.readerIndex(), array);
            handleArray(array, 0, length);
        }

2.2.3符合缓冲区(CompositeByteBuf)

聚合缓冲区是个很是好用的东西,是多个ByteBuf的聚合视图,能够添加或删除ByteBuf实例.

CompositeByteBuf中的ByteBuf实例可能同事包含直接内存分配和非直接内存分配.若是其中只有一个实例,那么调用CompositeByteBuf中的hasArray()方法将返回该组件上的hasArray()方法的值,不然返回false

多个ByteBuf组成一个完整的消息是很常见的,好比header和body组成的HTTP协议传输的消息.消息中的body有时候可能能重用,咱们不想每次都建立重复的body,咱们能够经过CompositeByteBuf来复用body.

对比一下JDK中的ByteBuffer实现复合缓冲区和Netty中的CompositeByteBuf.

//JDK版本实现复合缓冲区
public static void byteBufferComposite(ByteBuffer header, ByteBuffer body) {
        //使用一个数组来保存消息的各个部分
        ByteBuffer[] message =  new ByteBuffer[]{ header, body };

        // 建立一个新的ByteBuffer来复制合并header和body
        ByteBuffer message2 =
                ByteBuffer.allocate(header.remaining() + body.remaining());
        message2.put(header);
        message2.put(body);
        message2.flip();
    }

//Netty中的CompositeByteBuf
 public static void byteBufComposite() {
        CompositeByteBuf messageBuf = Unpooled.compositeBuffer();
        ByteBuf headerBuf = Unpooled.buffer(1024); // 多是直接缓存也多是堆缓存中的
        ByteBuf bodyBuf = Unpooled.buffer(1024);   // 多是直接缓存也多是堆缓存中的
        messageBuf.addComponents(headerBuf, bodyBuf);
        //...
        messageBuf.removeComponent(0); // remove the header
        for (ByteBuf buf : messageBuf) {
            System.out.println(buf.toString());
        }
    }

CompositeByteBuf不支持访问其后备数组,因此访问CompositeByteBuf中的数据相似于访问直接缓冲区

CompositeByteBuf compBuf = Unpooled.compositeBuffer();
int length = compBuf.readableBytes();
byte[] array = new byte[length];
//将CompositeByteBuf中的数据复制到数组中
compBuf.getBytes(compBuf.readerIndex(), array);
//处理一下数组中的数据
handleArray(array, 0, array.length);

Netty使用CompositeByteBuf来优化socket的IO操做,避免了JDK缓冲区实现所致使的性能和内存使用率的缺陷.内存使用率的缺陷是指对可复用对象大量的复制,Netty对其在内部作了优化,虽然没有暴露出来,可是应该知道CompositeByteBuf的优点和JDK自带工具的弊端.

JDK的NIO包中提供了Scatter/Gather I/O技术,字面意思是打散和聚合,能够理解为把单个ByteBuffer切分红多个或者把多个ByteBuffer合并成一个.

3.字节级操做

ByteBuf的索引从0开始,最后一个索引是capacity()-1.

遍历演示

ByteBuf buffer = Unpooled.buffer(1024); 
for (int i = 0; i < buffer.capacity(); i++) {
    byte b = buffer.getByte(i);//这种方法不会移动readerIndex指针
    System.out.println((char) b);
}

3.1readerIndex和writerIndex

JDK中的ByteBuffer只有一个索引,须要经过flip()来切换读写操做,Netty中的ByteBuf既有读索引,也有写索引,经过两个索引把ByteBuf划分了三部分.

能够调用discardReadBytes()方法可丢弃可丢弃字节并回收空间.

调用discardReadBytes()方法以后

使用read*或skip*方法都会增长readerIndex.

移动readerIndex读取可读数据的方式

ByteBuf buffer = ...;
while (buffer.isReadable()) {
    System.out.println(buffer.readByte());
}

write*方法写入ByteBuf时会增长writerIndex,若是超过容量会抛出IndexOutOfBoundException.

writeableBytes()能够返回可写字节数.

ByteBuf buffer = ...;
while (buffer.writableBytes() >= 4) {
    buffer.writeInt(random.nextInt());
}

3.2索引管理

JDK 的InputStream 定义了 mark(int readlimit)和reset()方法，这些方法分别被用来将流中的当前位置标记为指定的值，以及将流重置到该位置。
一样，能够经过调用 markReaderIndex()、markWriterIndex()、 resetWriterIndex()和resetReaderIndex()来标记和重置 ByteBuf的readerIndex和 writerIndex。这些和InputStream上的调用相似，只是没有readlimit 参数来指定标记何时失效。

若是将索引设置到一个无效位置会抛出IndexOutOfBoundsException.

能够经过clear()归零索引,归零索引不会清除数据.

3.3查找

ByteBuf中不少方法能够肯定值的索引,如indexOf().

复杂查找能够经过那些须要一个ByteBufProcessor做为参数的方法完成.这个接口应该可使用lambda表达式(可是我如今使用的Netty4.1.12已经废弃了该接口,应该使用ByteProcessor).

ByteBuf buffer = ...;
int index = buffer.forEachByte(ByteProcessor.FIND_CR);

3.4派生缓冲区

派生缓冲区就是,基于原缓冲区一顿操做生成新缓冲区.好比复制,切分等等.

duplicate()；slice()； slice(int, int);Unpooled.unmodifiableBuffer(…);order(ByteOrder)； readSlice(int).

每一个这些方法都将返回一个新的 ByteBuf 实例，它具备本身的读索引、写索引和标记
索引。 其内部存储和 JDK 的 ByteBuffer 同样也是共享的。这使得派生缓冲区的建立成本
是很低廉的，可是这也意味着，若是你修改了它的内容，也同时修改了其对应的源实例，所
以要当心

//复制
public static void byteBufCopy() {
        Charset utf8 = Charset.forName("UTF-8");
        ByteBuf buf = Unpooled.copiedBuffer("Netty in Action rocks!", utf8);
        ByteBuf copy = buf.copy(0, 15);
        System.out.println(copy.toString(utf8));
        buf.setByte(0, (byte)'J');
        assert buf.getByte(0) != copy.getByte(0);
    }
//切片
 public static void byteBufSlice() {
        Charset utf8 = Charset.forName("UTF-8");
        ByteBuf buf = Unpooled.copiedBuffer("Netty in Action rocks!", utf8);
        ByteBuf sliced = buf.slice(0, 15);
        System.out.println(sliced.toString(utf8));
        buf.setByte(0, (byte)'J');
        assert buf.getByte(0) == sliced.getByte(0);
    }

还有一些读写操做的API,留在文末展现吧.

4.ByteBufHolder接口

咱们常常发现， 除了实际的数据负载以外， 咱们还须要存储各类属性值。 HTTP 响应即是一个很好的例子， 除了表示为字节的内容，还包括状态码、 cookie 等。
为了处理这种常见的用例， Netty 提供了 ByteBufHolder。 ByteBufHolder 也为 Netty 的高级特性提供了支持，如缓冲区池化，其中能够从池中借用 ByteBuf， 而且在须要时自动释放。ByteBufHolder 只有几种用于访问底层数据和引用计数的方法。

5.ByteBuf的分配

咱们能够经过ByteBufAllocator来分配一个ByteBuf实例.ByteBufAllocator接口实现了ByteBuf的池化.

能够经过 Channel（每一个均可以有一个不一样的 ByteBufAllocator实例）或者绑定到ChannelHandler 的 ChannelHandlerContext获取一个到ByteBufAllocator的引用。

//从Channel获取一个ByteBufAllocator的引用
Channel channel = ...;
ByteBufAllocator allocator = channel.alloc();
....
//从ChannelHandlerContext获取ByteBufAllocator 的引用
ChannelHandlerContext ctx = ...;
ByteBufAllocator allocator2 = ctx.alloc();

Netty提供了两种ByteBufAllocator的实现： PooledByteBufAllocator和UnpooledByteBufAllocator。前者池化了ByteBuf的实例以提升性能并最大限度地减小内存碎片。 后者的实现不 池化ByteBuf实例， 而且在每次它被调用时都会返回一个新的实例。

默认使用的是PooledByteBufAllocator,能够经过ChannelConfig修改.

Unpooled缓冲区

可能有时候拿不到ByteBufAllocator引用的话,可使用Unpooled工具类来建立未持化ByteBuf实例.

ByteBufUtil类

ByteBufUtil 提供了用于操做 ByteBuf 的静态的辅助方法。由于这个 API 是通用的， 而且和池化无关，因此这些方法已然在分配类的外部实现。
这些静态方法中最有价值的可能就是 hexdump()方法， 它以十六进制的表示形式打印ByteBuf 的内容。这在各类状况下都颇有用，例如， 出于调试的目的记录 ByteBuf 的内容。十六进制的表示一般会提供一个比字节值的直接表示形式更加有用的日志条目，此外，十六进制的版本还能够很容易地转换回实际的字节表示。
另外一个有用的方法是 boolean equals(ByteBuf, ByteBuf)， 它被用来判断两个 ByteBuf实例的相等性。若是你实现本身的 ByteBuf 子类，你可能会发现 ByteBufUtil 的其余有用方法。

6.引用计数

引用计数是一种经过在某个对象所持有的资源再也不被其余对象引用时释放该对象所持有的资源来优化内存使用和性能的技术。 它们都实现了 interface ReferenceCounted。 引用计数背后的想法并非特别的复杂；它主要涉及跟踪到某个特定对象的活动引用的数量。一个 ReferenceCounted 实现的实例将一般以活动的引用计数为 1 做为开始。只要引用计数大于 0， 就能保证对象不会被释放。当活动引用的数量减小到 0 时，该实例就会被释放。注意，虽然释放的确切语义多是特定于实现的，可是至少已经释放的对象应该不可再用了。

//从Channel获取ByteBufAllocator
Channel channel = ...;
ByteBufAllocator allocator = channel.alloc();
....
//从ByteBufAllocator分配一个ByteBuf
ByteBuf buffer = allocator.directBuffer();
assert buffer.refCnt() == 1;//引用计数是否为1

7.API

ByteBuf

ByteBufAllocator

Unpooled