netty5源代码探索(一)----ByteBuf初探

Netty的各种简单介绍，总体架构就不介绍了，假设大家感觉的确须要，给我留言我再追加。

这里再推广一个自己做得netty+spring的集成方案，优化netty配置启动，并提供基础server搭建的配置+极少代码的实现方案。

http://download.csdn.net/detail/jackieliyido/9497093

回归正事：咱们直接从从Netty的核心类ByteBuf開始看起。

先看抽象类定义，后面的方法我们详细看核心实现AbstractByteBuf

先看ByteBuf源代码。

@SuppressWarnings("ClassMayBeInterface")
public abstract class ByteBuf implements ReferenceCounted, Comparable<ByteBuf> 

先告诉编译器忽略ClassMayBeInterface警告。

然后看到ByteBuf类本身实现了一个netty的引用计数器，以及compareble接口。为什么要写这里，由于看类名的时候第一反应是这个类继承自ByteBuffer.

然后再看凝视，凝视非常重要，作为netty刚開始学习的人是最重要的guide line。

 * <h3>Creation of a buffer</h3>
 *
 * It is recommended to create a new buffer using the helper methods in
 * {@link Unpooled} rather than calling an individual implementation's
 * constructor.

推荐使用helper 的方法去创建一块新的buffer，不推荐使用实现类自己的构造器。

下一段：

 * <h3>Random Access Indexing</h3>
 *
 * Just like an ordinary primitive byte array, {@link ByteBuf} uses
 * <a href="http://en.wikipedia.org/wiki/Zero-based_numbering">zero-based indexing</a>.
 * It means the index of the first byte is always {@code 0} and the index of the last byte is
 * always {@link #capacity() capacity - 1}.  For example, to iterate all bytes of a buffer, you
 * can do the following, regardless of its internal implementation:
 *
 * <pre>
 * {@link ByteBuf} buffer = ...;
 * for (int i = 0; i < buffer.capacity(); i ++) {
 *     byte b = buffer.getByte(i);
 *     System.out.println((char) b);
 * }
 * </pre>

这一段比較水。事实上说的bytebuf是遵循以0为第一位的计数方式。第一眼看到zero-based indexing 没反应过来。后来一看就是说从0開始计数。

嗯。作者非常负责。同一时候学了一个装逼的词 zero-based indexing...

同一时候咱不漏过上面的一句话，buffer.capacity(),这种方法是获取buffer的容量。

buffer.getByte(i),获取指定位置的字节数据

重头戏開始来来了，来看以下一段：

* <h3>Sequential Access Indexing</h3>
 *
 * {@link ByteBuf} provides two pointer variables to support sequential
 * read and write operations - {@link #readerIndex() readerIndex} for a read
 * operation and {@link #writerIndex() writerIndex} for a write operation
 * respectively.  The following diagram shows how a buffer is segmented into
 * three areas by the two pointers:
 *
 * <pre>
 *      +-------------------+------------------+------------------+
 *      | discardable bytes |  readable bytes  |  writable bytes  |
 *      |                   |     (CONTENT)    |                  |
 *      +-------------------+------------------+------------------+
 *      |                   |                  |                  |
 *      0      <=      readerIndex   <=   writerIndex    <=    capacity
 * </pre>

顺序訪问索引。ByteBuf提供两个指针标量来支持读写操作。嗯，这个有点像曾经有面试官问的问题。怎样用循环数组实现队列。

看图上第一段，是被丢弃的字节，这个和我们的电脑磁盘操作一样，删除文件时仅仅是将文件的描写叙述指针从当前位置挪开(好吧。事实上我也不知道叫啥指针甚至于是不是指针)，将这块区域置为新空间标识，嗯。大概就是这么个意思。

第一段以下有个readerIndex,也就是在0到readIndex之间都是被丢弃的字节(已读完)。readerIndex 到writerIndex之间为可读内容，writeable到容量之间的区域为可写区域。

这里easy误解的地方在于。什么是write，read.这里的读写不是指我们写数据发出去，读数据进来两个动作同一时候发生。而是指单个业务行为比方读数据进来的时候实际发生的底层动作。有点绕。写的好像有点多余。

通过几个图应该就能够看出来了（这部分參考的《netty权威指南》）：

初始化ByteBuf的时候：

 *      +---------------------------------------------------------+
 *      |                    writable bytes                       |
 *      |                                                         |
 *      +---------------------------------------------------------+
 *      |                                                         |
 *      0 =readerIndex =writerIndex                           capacity

写入N个字节后的ByteBuf:

 *      +--------------------------------------+------------------+
 *      |                readable bytes        |  writable bytes  |
<pre name="code" class="java"> *      |                                      |                  |

* +--------------------------------------+------------------+ * | | * 0 =readerIndex N=writerIndex capacity

读取M(M<N)个字节以后:

 *      +-------------------+------------------+------------------+
 *      | discardable bytes |  readable bytes  |  writable bytes  |
 *      |                   |                  |                  |
 *      +-------------------+------------------+------------------+
 *      |                   |                  |                  |
 *      0            M=readerIndex      N=writerIndex          capacity

调用discardReadBytes操作后的ByteBuf:

 *      +-------------------+-------------------------------------+
 *      | readable bytes    |           writable bytes            |
 *      |                   |                                     |
 *      +-------------------+-------------------------------------+
 *      |                   |                                     |
 *      0=readerIndex      N-M=writerIndex                    capacity

调用clear方法后：

 *      +---------------------------------------------------------+
 *      |                    writable bytes                       |
 *      |                                                         |
 *      +---------------------------------------------------------+
 *      |                                                         |
 *      0 =readerIndex =writerIndex                           capacity

认真看完以上几个图后，能够知道readerIndex和writerIndex的工作方式了。

继续回到凝视上，我们掠过代码中关于两个指针的描写叙述后，来到例如以下内容：

 * <h3>Search operations</h3>
 *
 * For simple single-byte searches, use {@link #indexOf(int, int, byte)} and {@link #bytesBefore(int, int, byte)}.
 * {@link #bytesBefore(byte)} is especially useful when you deal with a {@code NUL}-terminated string.
 * For complicated searches, use {@link #forEachByte(int, int, ByteBufProcessor)} with a {@link ByteBufProcessor}
 * implementation.

这个是关于检索/搜索的描写叙述，对于简单的单子接搜索，推荐使用 ByteBuf.indexOf(int fromIndex,
int toIndex, byte value)、bytesBefore(int index,int length,byte value)以及bytesBefore(byte
value)进行检索，粗粗看了下关于这几个方法的描写叙述。均是指在可读区域(即readerIndex与writerIndex之间部分)内的指定长度范围检索特定值。返回为找到的第一个值的index值，否则返回-1.

关于重置和标记：

 * <h3>Mark and reset</h3>
 *
 * There are two marker indexes in every buffer. One is for storing
 * {@link #readerIndex() readerIndex} and the other is for storing
 * {@link #writerIndex() writerIndex}.  You can always reposition one of the
 * two indexes by calling a reset method.  It works in a similar fashion to
 * the mark and reset methods in {@link InputStream} except that there's no
 * {@code readlimit}.

这里说的rederIndex和writerIndex能够觉得是两个marker,并且能够像使用InputStream一样进行reset，差别在于InputStream有readlimit參数。

补充下InputStream.mark(int readlimit)其中readlimit的作用：在inputStream中。mark的作用是在你mark完一个数据点时，当你继续往下读的时候能够通过调用reset方法回到mark的地点。

可是，这个mark须要有个限制。当你在读readlimit的数据长度内，都会保留mark。超出则不再保留mark

关于衍生缓冲区：

 * <h3>Derived buffers</h3>
 *
 * You can create a view of an existing buffer by calling either
 * {@link #duplicate()}, {@link #slice()} or {@link #slice(int, int)}.
 * A derived buffer will have an independent {@link #readerIndex() readerIndex},
 * {@link #writerIndex() writerIndex} and marker indexes, while it shares
 * other internal data representation, just like a NIO buffer does.
 * <p>
 * In case a completely fresh copy of an existing buffer is required, please
 * call {@link #copy()} method instead.

调用duplicate()、slice()、slice(int index, int length)会创建一个现有缓冲区的视图。衍生的缓冲区有独立的readerIndex、writerIndex和标注索引。共享内部数据。假设须要现有缓冲区的全新副本，能够使用copy()获得。

这里须要说明：duplicate。slice方法均持有独立的读写索引，可是共享内容指针引用。即改动副本的内容将影响原本中的内容。

最后一段。关于转换成JDK已存在的类

 * <h3>Conversion to existing JDK types</h3>
 *
 * <h4>Byte array</h4>
 *
 * If a {@link ByteBuf} is backed by a byte array (i.e. {@code byte[]}),
 * you can access it directly via the {@link #array()} method.  To determine
 * if a buffer is backed by a byte array, {@link #hasArray()} should be used.
 *
 * <h4>NIO Buffers</h4>
 *
 * If a {@link ByteBuf} can be converted into an NIO {@link ByteBuffer} which shares its
 * content (i.e. view buffer), you can get it via the {@link #nioBuffer()} method.  To determine
 * if a buffer can be converted into an NIO buffer, use {@link #nioBufferCount()}.
 *
 * <h4>Strings</h4>
 *
 * Various {@link #toString(Charset)} methods convert a {@link ByteBuf}
 * into a {@link String}.  Please note that {@link #toString()} is not a
 * conversion method.
 *
 * <h4>I/O Streams</h4>
 *
 * Please refer to {@link ByteBufInputStream} and
 * {@link ByteBufOutputStream}.

数组：假设一个bytebuf是一个数组类型。能够使用array()方法。推断是否为数组的方法为：hasArray()

NIO Buffer:能够通过使用nioBuffer()方法使ByteBuf转换为java.nio.ByteBuffer。

推断能否转换的方法为：nioBufferCount(). nioBufferCount()返回NIO buffer的个数。假设没有则返回-1.

转String：toString(Charset)将可读区域的bytes依照指定编码转换成String，转换不改动readerIndex和writerIndex. toString()打印内存地址，并不转换成String

IO stream:參看日后分析的ByteBufInputStream和ByteBufOutputStream

第一篇先写到这，接下来我们主要分析AbstractByteBuf、HeapByteBuf、DirectByteBuf等几个核心实现。