Netty 缓存buffer介绍及使用

每当你需要传输数据时，它必须包含一个缓冲区。Java NIO API 自带的缓冲区类是相当有限的，没有经过优化，使用 JDK 的
ByteBuffer 操作更复杂。缓冲区是一个重要的组建，它是 API
的一部分。Netty提供了一个强大的缓冲区实现用于表示一个字节序列，并帮助你操作原始字节或自定义的 POJO。Netty 的 ByteBuf
相当于 JDK 的ByteBuffer，ByteBuf的作用是在 Netty 中通过 Channel 传输数据。它被重新设计以解决 JDK
的 ByteBuffer 中的一些问题， 从而使开发人员开发网络应用程序显得更有效率。

Netty 的缓冲 API 有两个接口

一： ByteBuf
当需要与远程进行交互时，需要以字节码发送/接收数据。由于各种原因，一个高效、方便、易用的数据接口是必须的，而 Netty 的 ByteBuf 满足这些需求，ByteBuf 是一个很好的经过优化的数据容器， 我们可以将字节数据有效的添加到 ByteBuf 中或从 ByteBuf 中获取数据。ByteBuf 有 2 部分：一个用于读，一个用于写。我们可以按顺序的读取数据，并且可以跳到开始重新读一遍。 所有的数据操作， 我们只需要做的是调整读取数据索引和再次开始读操作。
写入数据到 ByteBuf 后， 写入索引是增加的字节数量。 开始读字节后， 读取索引增加。你可以读取字节，直到写入索引和读取索引处理相同的位置，次数若继续读取，则会抛出IndexOutOfBoundsException。调用 ByteBuf 的任何方法开始读/写都会单独维护读索引和写索引。ByteBuf 的默认最大容量限制是 Integer.MAX_VALUE，写入时若超出这个值将会导致一个异常。
ByteBuf 类似于一个字节数组，最大的区别是读和写的索引可以用来控制对缓冲区数据的访问。
使用 Netty 时会遇到 3 种不同类型的 ByteBuf：

• Heap Buffer( 堆缓冲区)
  最常用的类型是 ByteBuf 将数据存储在 JVM 的堆空间，这是通过将数据存储在数组的实现。堆缓冲区可以快速分配，当不使用时也可以快速释放。它还提供了直接访问数组的方法，通过ByteBuf.array()来获取 byte[]数据。 访问非堆缓冲区 ByteBuf 的数组会导致 UnsupportedOperationException， 可以使用ByteBuf.hasArray()来检查是否支持访问数组。
• Direct Buffer( 直接缓冲区)
  直接缓冲区，在堆之外直接分配内存。直接缓冲区不会占用堆空间容量，使用时应该考虑到应用程序要使用的最大内存容量以及如何限制它。直接缓冲区在使用 Socket 传递数据时性能很好，因为若使用间接缓冲区，JVM 会先将数据复制到直接缓冲区再进行传递；但是直接缓冲区的缺点是在分配内存空间和释放内存时比堆缓冲区更复杂， 而 Netty使用内存池来解决这样的问题，这也是 Netty 使用内存池的原因之一。直接缓冲区不支持数组访问数据，但是我们可以间接的访问数据数组，如下面代码：

    ByteBuf directBuf =  Unpooled.directBuffer(16);
    if(!directBuf.hasArray()){
       int len =  directBuf.readableBytes();
       byte[] arr = new byte[len];
       directBuf.getBytes(0, arr);
    }

• Composite Buffer(复合缓冲区)
  复合缓冲区，我们可以创建多个不同的 ByteBuf，然后提供一个这些 ByteBuf
  组合的视图。复合缓冲区就像一个列表，我们可以动态的添加和删除其中的 ByteBuf，JDK 的ByteBuffer 没有这样的功能。Netty 提供了 CompositeByteBuf 类来处理复合缓冲区，CompositeByteBuf只是一个视图，CompositeByteBuf.hasArray()总是返回 false，因为它 可能包含一些直接或间接的不同类型的 ByteBuf。下面是使用 CompositeByteBuf 的例子：

 CompositeByteBuf compBuf =Unpooled.compositeBuffer();
 ByteBuf heapBuf = Unpooled.buffer(8);
 ByteBuf directBuf = Unpooled.directBuffer(16);//添加ByteBuf到
 CompositeByteBuf  
 compBuf.addComponents(heapBuf,directBuf);//删除第一个ByteBuf    compBuf.removeComponent(0);
 Iterator iter = compBuf.iterator();
 while(iter.hasNext()){
   System.out.println(iter.next().toString());  
 }
   //使用数组访问数据
   if(!compBuf.hasArray()){
      int len = compBuf.readableBytes();
      byte[] arr = new byte[len];
      compBuf.getBytes(0, arr);
   }

CompositeByteBuf是ByteBuf的子类， 我们可以像操作BytBuf一样操作CompositeByteBuf。并且 Netty 优化套接字读写的操作是尽可能的使用 CompositeByteBuf 来做的，使用CompositeByteBuf不会操作内存泄露问题。

ByteBuf 字节操作API：

• 随机访问索引
  ByteBuf 使用 zero-based-indexing(从 0 开始的索引)，第一个字节的索引是 0，最后一个字节的索引是 ByteBuf 的 capacity - 1，下面代码是遍历 ByteBuf 的所有字节：

//create   a ByteBuf of capacity is 16 
   ByteBuf buf = Unpooled.buffer(16);
   //write data to buf
   for(int i=0;i<16;i++){
         buf.writeByte(i+1); 
   } 
   //read data from buf
   for(int i=0;i

注意通过索引访问时不会推进读索引和写索引，我们可以通过 ByteBuf 的
readerIndex()或writerIndex()来分别推进读索引或写索引。

• 顺序访问索引
  ByteBuf 提供两个指针变量支付读和写操作，读操作是使用 readerIndex()，写操作时使用 writerIndex()。这和 JDK 的 ByteBuffer 不同，ByteBuffer 只有一个方法来设置索引，所以需要使用 flip()方法来切换读和写模式。 ByteBuf 一定符合：
  0 <= readerIndex <= writerIndex <= capacity。

• Discardable bytes废弃字节
  我们可以调用 ByteBuf.discardReadBytes()来回收已经读取过的字节， discardReadBytes()将丢弃从索引 0 到 readerIndex 之间的字节。
  ByteBuf.discardReadBytes()可以用来清空 ByteBuf 中已读取的数据， 从而使ByteBuf有多余的空间容纳新的数据， 但是 discardReadBytes()可能会涉及内存复制， 因为它需要移动 ByteBuf 中可读的字节到开始位置， 这样的操作会影响性能， 一般在需要马上释放内存的时候使用收益会比较大。

• 可读字节( 实际内容)
  任何读操作会增加 readerIndex，如果读取操作的参数也是一个 ByteBuf
  而没有指定目的索引，指定的目的缓冲区的 writerIndex 会一起增加，没有足够的内容时会抛出IndexOutOfBoundException。 新分配、 包装、 复制的缓冲区的 readerIndex 的默认值都是 0。下面代码显示了获取所有可读数据：

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

• 可写字节
  Writable bytes 任何写的操作会增加 writerIndex。 若写操作的参数也是一个 ByteBuf 并且没有指定数据源索引，那么指定缓冲区的 readerIndex也会一起增加。若没有足够的可写字节会抛出IndexOutOfBoundException。新分配的缓冲区 writerIndex的默认值是 0。下面代码显示了随机一个 int 数字来填充缓冲区，直到缓冲区空间耗尽：

      Random random = new Random();
      ByteBuf buf = Unpooled.buffer(16);
      while(buf.writableBytes() >= 4){
         buf.writeInt(random.nextInt());
      }

• 清除缓冲区索引
  Clearing the buffer indexs 调用 ByteBuf.clear()可以设置 readerIndex 和 writerIndex 为 0，clear()不会清除缓冲区的内容， 只是将两个索引值设置为 0。 请注意 ByteBuf.clear()与 JDK 的 ByteBuffer.clear()的语义不同。 和 discardReadBytes()相比，clear()是便宜的，因为 clear()不会复制任何内存。
• 搜索操作
  Search operations 各种 indexOf()方法帮助你定位一个值的索引是否符合，我们可以用ByteBufProcessor 复杂动态顺序搜索实现简单的静态单字节搜索。如果你想解码可变长度的数据，如 null 结尾的字符串，你会发现 bytesBefore(byte value)方法有用。例如我们写一个集成的 flash sockets 的应用程序，这个应用程序使用 NULL 结束的内容，使用bytesBefore(byte value)方法可以很容易的检查数据中的空字节。没有 ByteBufProcessor的话，我们需要自己做这些事情，使用 ByteBufProcessor 效率更好。
• 标准和重置 Mark and reset 每个 ByteBuf 有两个标注索引，一个存储 readerIndex，一个存储 writerIndex。你可以通过调用一个重置方法重新定位两个索引之一， 它类似于 InputStream 的标注和重置方法，没有读限制。 我们可以通过调用 readerIndex(int readerIndex)和 writerIndex(int writerIndex) 移动读索引和写索引到指定位置，调用这两个方法设置指定索引位置时可能抛出IndexOutOfBoundException。 衍生的缓冲区Derived buffers 调用 duplicate()、slice()、slice(int index, int length)、order(ByteOrder endianness)会创建一个现有缓冲区的视图。衍生的缓冲区有独立的 readerIndex、writerIndex 和标注索引。如果需要现有缓冲区的全新副本，可以使用 copy()或 copy(int index, int length)获得。

 // get a Charset of UTF-8
 Charset utf8 = Charset.forName("UTF-8");
 // get a ByteBuf
 ByteBuf buf = Unpooled.copiedBuffer("Netty in Action rocks!", utf8);
 // slice  
 ByteBuf sliced = buf.slice(0, 14); 
 // copy
 ByteBuf copy = buf.copy(0, 14);
 // print "“Netty in Action   rocks!“" 
 System.out.println(buf.toString(utf8));
// print "“ Netty  in Act"
System.out.println(sliced.toString(utf8));
// print "“ Netty in Act"
System.out.println(copy.toString(utf8));

• 读/ 写操作以及其他一些操作 有两种主要类型的读写操作：

  2. get/set 操作以索引为基础，在给定的索引设置或获取字节
  3. 从当前索引开始读写，递增当前的写索引或读索引

二： ByteBufHolder

ByteBufHolder 是一个辅助类，是一个接口，其实现类是DefaultByteBufHolder，还有一些实现了ByteBufHolder 接口的其他接口类。ByteBufHolder 的作用就是帮助更方便的访问 ByteBuf 中的数据， 当缓冲区没用了后， 可以使用这个辅助类释放资源。 ByteBufHolder很简单，提供的可供访问的方法也很少。如果你想实现一个“消息对象”有效负载存储在ByteBuf，使用ByteBufHolder 是一个好主意。

尽管 Netty 提供的各种缓冲区实现类已经很容易使用，但 Netty 依然提供了一些使用的工具类， 使得创建和使用各种缓冲区更加方便。 下面会介绍一些 Netty 中的缓冲区工具类。

• ByteBufAllocator Netty 支持各种 ByteBuf 的池实现，来使 Netty 提供一种称为ByteBufAllocator 成为可能。ByteBufAllocator 负责分配 ByteBuf 实例，ByteBufAllocator 提供了各种分配不同ByteBuf 的方法，如需要一个堆缓冲区可以使用 ByteBufAllocator.heapBuffer()，需要一个直接缓冲区可以使用ByteBufAllocator.directBuffer()，需要一个复合缓冲区可以使用 ByteBufAllocator.compositeBuffer()。 其他方法的使用可以看ByteBufAllocator 源码及注释。 获取 ByteBufAllocator 对象很容易，可以从 Channel 的 alloc()获取，也可以从ChannelHandlerContext 的 alloc()获取。看下面代码：

 ServerBootstrap b = new ServerBootstrap();
 new InetSocketAddress(port)).childHandler(
    new ChannelInitializer() {
  @Override
  protected void initChannel(SocketChannel ch) throws Exception {
  // get  ByteBufAllocator instance by Channel.alloc()
  ByteBufAllocator alloc0 = ch.alloc();
  ch.pipeline().addLast(new ChannelInboundHandlerAdapter(){
   @Override
   public void channelActive(ChannelHandlerContext ctx)
   throws Exception{
   //get ByteBufAllocator instance by ChannelHandlerContext.alloc()
   ctx.writeAndFlush(buf.duplicate()).addListener(
       ChannelFutureListener.CLOSE);
    }
   });
  }
});

Netty 有两种不同的 ByteBufAllocator 实现，一个实现 ByteBuf实例池将分配和回收成本以及内存使用降到最低；另一种实现是每次使用都创建一个新的 ByteBuf 实例。Netty默认使用PooledByteBufAllocator， 我们可以通过 ChannelConfig 或通过引导设置一个不同的实现来改变。更多细节在后面讲述。

1. Unpooled
   Unpooled也是用来创建缓冲区的工具类，Unpooled 的使用也很容易。Unpooled 提供了很多方法，详细方法及使用可以看 API 文档或 Netty 源码。看下面代码：

  //创建复合缓冲区 
  CompositeByteBuf compBuf = Unpooled.compositeBuffer();
  //创建堆缓冲区
  ByteBuf heapBuf = Unpooled.buffer(8);
  //创建直接缓冲区
  ByteBuf directBuf = Unpooled.directBuffer(16);

2. ByteBufUtil
   ByteBufUtil 提供了一些静态的方法，在操作 ByteBuf 时非常有用。ByteBufUtil 提供了 Unpooled 之外的一些方法，也许最有价值的是 hexDump(ByteBuf buffer)方法，这个方法返回指定 ByteBuf 中可读字节的十六进制字符串， 可以用于调试程序时打印 ByteBuf 的内容，十六进制字符串相比字节而言对用户更友好。

Netty 缓冲 API 提供了几个优势

3. 可以自定义缓冲类型

4. 通过一个内置的复合缓冲类型实现零拷贝

5. 扩展性好，比如 StringBuffer

6. 不需要调用 flip()来切换读/写模式

7. 读取和写入索引分开

8. 方法链

9. 引用计数

10. Pooling(池)

无意中发现了一个巨牛的人工智能教程，忍不住分享一下给大家。教程不仅是零基础，通俗易懂，而且非常风趣幽默，像看小说一样！觉得太牛了，所以分享给大家。点这里可以跳转到教程。