您的位置：首页 > Web前端

netty io.netty.buffer简介

2015-08-11 00:00 901 查看

摘要: 主要介绍netty buffer包io.netty.util.ReferenceCounted 此接口代表一个引用计数的对象，此对象需要显示的释放.当一个

ReferenceCounted

对象被实例化的时候，该对象的引用数量就是1，调用

retain()

方法会增加引用数量，调用

release()

方法会减少引用数量，如果引用数量减少到0，该对象就需要显示释放掉。访问释放掉的对象通常会导致访问冲突。如果实现

ReferenceCounted

接口的对象是一个包含同样实现

ReferenceCounted

接口的对象的容器。当容器的引用数量变为0的时候，容器中的对象也要通过

release()

方法来释放掉。主要方法：

int refCnt(); //返回当前对象的引用数量，如果返回零，说明当前对象已经被释放掉了

ReferenceCounted retain();//引用数量增加1

ReferenceCounted retain(int increment);//引用计数增加给定值increment

ReferenceCounted touch();\\此方法记录对象的当前访问位置，主要用来调试。如果确定当前对象内存泄露，通过此操作记
\\录的信息将通过ResourceLeakDetector提供给你

ReferenceCounted touch(Object hint);\\此方法记录对象的当前访问位置并附加一个hint对象，主要用来调试。如果
\\确定当前对象内存泄露，通过此操作记录的信息将通过ResourceLeakDetector提供给你

boolean release();\\引用计数减1，如果引用计数变为0了，则显示的释放掉该对象，当且仅当引用计数变为0且该对象已
\\被释放掉才返回ture，否则返回false

boolean release(int decrement);\\引用计数减少给定值decrement，如果引用计数变为0了，则显示的释放掉该对象，
当且仅当引用计数变为0且该对象已被释放掉才返回ture，否则返回false

io.netty.buffer.ByteBuf这是一个随机和顺序访问的序列其包含0或者多个字节，此接口为一个或者多字节数组和NIO buffers提供了一个抽象试图创建buffer 建议使用辅助方法创建一个新的缓冲区不要调用具体实现的构造函数。随进访问索引 就像普通的byte数组一样，ByteBuf使用基于0的索引，也就是第一个的索引是0最后一个元素的索引是capacity-1，下面举例迭代访问buffer中的所有字节，做如下操作的时候你可以忽略其内部实现：

ByteBuf buffer = ...;
for (int i = 0; i < buffer.capacity(); i ++) {
byte b = buffer.getByte(i);
System.out.println((char) b);
}

顺序访问索引

ByteBuf

提供了两个指针变量来分别支持读和写操作，

readerIndex

用于读操作

，

writerIndex

用于写操作. 下面的图展示了一个buffer使如何被两个指针分割成三个区域的:

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

discardable bytes代表可废弃的区域，readable bytes代码可读区域，writable bytes代表可写区域 readerIndex代表读的起点，writerIndex代表写的起点，capacity代表容量可读区域（实际内容）这个区域存储的是实际的数据或者叫有效的数据. 任何以read或者skip开头的操作（任何是指本类中的任何方法）都会得到或者跳过当前readerIndex指示的数据，并且readerIndex会根据读取或者跳过的字节数自增。如果读取操作的参数也是一个Byte并且没有指定目标ByteBuf的起始index，则该参数ByteBuf的writerIndex也要跟着一起增长。如果没有足够的数据供读取则报

IndexOutOfBoundsException。新分配、wrapped或者拷贝的buffer，其readerIndex是0.相关读取操作如下：

// Iterates the readable bytes of a buffer. ByteBuf buffer = ...;
while (buffer.readable()) {
System.out.println(buffer.readByte());
}

可写数据区域此区域是未定义的区域也就是需要往里面写数据的区域。任何以write开始的操作（任何是指本类中的任何方法）将会从writerIndex开始写数据，并且writerIndex会根据写入的数量增加。如果write操作的参数也是一个ByteBuf并且没有制定源Buff的开始index, 那么该参数ByteBuf的readerInx也要跟着一起增长.如果没有足够的空间供写入报

IndexOutOfBoundsException

，新分配的buffer的writerIndex是0. wrapped 或者copy的 buffer

writerIndex 等于capacity。写入操作代码：

// Fills the writable bytes of a buffer with random integers. ByteBuf buffer = ...;
while (buffer.maxWritableBytes() >= 4) {
buffer.writeInt(random.nextInt());
}

可废弃区域这个区域包含的是通过读操作读完的数据区域.初始状态这个区域的大小是

, 随着读操作的调用这个区域会增长到writerIndex的大小. 读过的数据可以通过

调用discardReadBytes()方法回收该区域，该方法的功能如下

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

需要注意的是，不能保证可写区域的数据内容，可写区域的内容多数情况下不会跟着移动，甚至有可能被不同的数据填充，这依赖于具体的buffer实现。清空缓冲索引你可以通过调用

clear()方法来将

readerIndex

和

writerIndex

设置为

. 但是不会清除内容，而只是重置了两个指针. 注意这里的clear()方法语义和java.nio.Buffer.clear()语义是不一样的。

BEFORE clear()

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

AFTER clear()

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

search相关操作对于简单的字节搜索，使用

indexOf(int, int, byte)

和

bytesBefore(int, int, byte)

bytesBefore(byte)

. 对于复杂的搜索使用

forEachByte(int, int, ByteBufProcessor)

方法，该方法需要一个

ByteBufProcessor

的实现类.标记和充值（mark reset）每个buffer有两个marker indexes. 一个用来存储

readerIndex

另一个用来存储

writerIndex

. 可以通过调用reset方法重置，其工作方式类似于InputStream中的mark和reset方法，不同的是其没有readlimit参数.派生缓冲区（Derived buffers）你可以通过调用方法

duplicate()

slice()

slice(int, int)

来根据现有buffer创建一个试图（view） . 一个派生的buffer会有一个独立的

readerIndex

writerIndex

和 marker indexes，同时会共享内部数据，这和Java NIO一样.如果要完整拷贝一个buffer，需要调用

copy()

方法.转换成现有的JAVA类型

Byte array

如果ByteBuf内部实现是一个byte[], 可以通过调用

array()

方法来访问数组. 判断是否是byte[]可以调用

hasArray()

方法.

NIO Buffers

通过调用

nioBuffer()

方法可以得到一个NIO buffer，判断能否进行转换可以调用

nioBufferCount()

方法.

Strings

可以调用提供的多个

toString(Charset)

方法将

ByteBuf

转换为

String

. 需要注意的是，

toString()

不是转换方法，而是继承Object的toString()方法

I/O Streams

参考

ByteBufInputStream

和

ByteBufOutputStream

io.netty.buffer.ByteBufAllocator该接口的实现类负责创建buffer，接口实现类必须是线程安全的。

io.netty.buffer.ByteBufHolder

发送接收的数据包

io.netty.buffer.AbstractByteBuf

实现bytebuf的一个骨架

io.netty.buffer.AbstractByteBufAllocator

ByteBufAllocator

的骨架

io.netty.buffer.AbstractDerivedByteBuf

Bytebuf的一个抽象基类，其主要功能是实现了能够封装另一个Bytebuf

io.netty.buffer.AbstractReferenceCountedByteBuf

ByteBuf的一个抽象基类，主要功能是实现了引用计数的功能，即ReferenceCounted借口的功能（retain和release、touch方法）

io.netty.buffer.ByteBufInputStream

继承了InputStream类，该类可以从ByteBuf中读取数据，对该对象进行读操作的时候内部buffer的readerIndex也会增加，需要注意的是读取的字节数量在初始化该对象的时候已经确定了（构造函数内部，初始化的时候已经和设置了长度），后面在对该buffer写数据，对该对象来讲，不会读到。改流还是

DataInput

借口，字节的序列并不总是大端序列（big endian），这取决于内部buffer实现

io.netty.buffer.ByteBufOutputStream

继承了OutputStream类，该类可以向ByteBuf中写数据，对该对象进行写操作的时候内部buffer的writerindex也会增加，改流还是

DataOutput

借口，字节的序列并不总是大端序列（big endian），这取决于内部buffer实现

io.netty.buffer.ByteBufUtil

这是一个处理ByteBuf对象的一些方法的工具类.

io.netty.buffer.CompositeByteBuf

这是一个虚拟bufer，实际上是一个组合buffer，其内部封装了多个buffer，其功能就是将多个buffer组合成一个buffer，推荐使用

ByteBufAllocator.compositeBuffer()

或者

Unpooled.wrappedBuffer(ByteBuf...)来创建CompositeByteBuf对象，不要直接调用构造函数来创建对象

io.netty.buffer.DefaultByteBufHolder

ByteBufHolder

的默认实现，期功能就是把数据存储在bytebuf中

io.netty.buffer.DuplicatedByteBuf

一个派生buffer，简单的把所有的数据访问请求发送给内部的buffer。简易通过

ByteBuf.duplicate()

方法来创建该对象。该对象与其内部bufer共享数据，只不过二者的readerindex和writerindex是独立的。

io.netty.buffer.EmptyByteBuf

这是一个空的ByteBuf，容量是0

io.netty.buffer.PooledByteBufAllocator

带缓冲的

ByteBufAllocator

io.netty.buffer.ReadOnlyByteBuf

这个一个派生buffer，他禁止写操作发送给内部buffer，简易通过

Unpooled.unmodifiableBuffer(ByteBuf)

方法来创建对象io.netty.buffer.SliceByteBuf一个派生buffer，他的功能是仅仅暴露内部buffer的一个自区域，就是切片，推荐通过

ByteBuf.slice()

and

ByteBuf.slice(int, int)

方法来创建对象

io.netty.buffer.SwappedByteBuf

一个包装buffer，其功能是交换bytebuf的字节序列，即大端序列和小端序列的转换io.netty.buffer. Unpooled

io.netty.buffer.UnpooledByteBufAllocator

带缓冲的

ByteBufAllocator

io.netty.buffer.UnpooledDirectByteBuf

基于NIO

ByteBuffer

的ByteBuf，推

荐通过调用Unpooled.directBuffer(int)或者

Unpooled.wrappedBuffer(ByteBuffer)方法来创建对象

io.netty.buffer.UnpooledHeapByteBuf

大端序列的java堆buffer实现

io.netty.buffer.Unpooled

相当于一个工具类，可以创建Bytebuf

内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理

标签： nettty buffer ByteBuf CompositeByteBuf ByteBufAllocator

相关文章推荐

新的分享

章节导航