Netty 解码器抽象父类 ByteToMessageDecoder 源码解析

前言

Netty 的解码器有很多种，比如基于长度的，基于分割符的，私有协议的。但是，总体的思路都是一致的。

拆包思路：当数据满足了 解码条件时，将其拆开。放到数组。然后发送到业务 handler 处理。

半包思路： 当读取的数据不够时，先存起来，直到满足解码条件后，放进数组。送到业务 handler 处理。

而实现这个逻辑的就是我们今天的主角：ByteToMessageDecoder。

看名字的意思是：将字节转换成消息的解码器。人如其名。而他本身也是一个入站 handler，所以，我们还是从他的 channelRead 方法入手。

1. channelRead 方法

精简过的代码如下：

public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
    // 从对象池中取出一个List
    CodecOutputList out = CodecOutputList.newInstance();
    ByteBuf data = (ByteBuf) msg;
    first = cumulation == null;
    if (first) {
        // 第一次解码
        cumulation = data;// 累计
    } else {
        // 第二次解码，就将 data 向 cumulation 追加，并释放 data
        cumulation = cumulator.cumulate(ctx.alloc(), cumulation, data);
    }
    // 得到追加后的 cumulation 后，调用 decode 方法进行解码
    // 解码过程中，调用 fireChannelRead 方法，主要目的是将累积区的内容 decode 到 数组中
    callDecode(ctx, cumulation, out);

    // 如果累计区没有可读字节了
    if (cumulation != null && !cumulation.isReadable()) {
        // 将次数归零
        numReads = 0;
        // 释放累计区
        cumulation.release();
        // 等待 gc
        cumulation = null;

    } // 如果超过了 16 次，就压缩累计区，主要是将已经读过的数据丢弃，将 readIndex 归零。
    else if (++ numReads >= discardAfterReads) {
        numReads = 0;
        discardSomeReadBytes();
    }

    int size = out.size();
    // 如果没有向数组插入过任何数据
    decodeWasNull = !out.insertSinceRecycled();
    // 循环数组，向后面的 handler 发送数据，如果数组是空，那不会调用
    fireChannelRead(ctx, out, size);
    // 将数组中的内容清空，将数组的数组的下标恢复至原来
    out.recycle();

}

楼主已经在方法中写了注释，但还是说说主要的步骤：

1. 从对象池中取出一个空的数组。
2. 判断成员变量是否是第一次使用，（注意，既然使用了成员变量，所以这个 handler 不能是 handler 的。）将 unsafe 中传递来的数据写入到这个 cumulation 累积区中。
3. 写到累积区后，调用子类的 decode 方法，尝试将累积区的内容解码，每成功解码一个，就调用后面节点的 channelRead 方法。若没有解码成功，什么都不做。
4. 如果累积区没有未读数据了，就释放累积区。
5. 如果还有未读数据，且解码超过了 16 次（默认），就对累积区进行压缩。将读取过的数据清空，也就是将 readIndex 设置为0.
6. 设置 decodeWasNull 的值，如果上一次没有插入任何数据，这个值就是 ture。该值在 调用 channelReadComplete 方法的时候，会触发 read 方法（不是自动读取的话），尝试从 JDK 的通道中读取数据，并将之前的逻辑重来。主要应该是怕如果什么数据都没有插入，就执行 channelReadComplete 会遗漏数据。
7. 调用 fireChannelRead 方法，将数组中的元素发送到后面的 handler 中。
8. 将数组清空。并还给对象池。

下面来说说详细的步骤。

2. 从对象池中取出一个空的数组

代码：

@1
CodecOutputList out = CodecOutputList.newInstance();
@2
static CodecOutputList newInstance() {
    return CODEC_OUTPUT_LISTS_POOL.get().getOrCreate();
}
@3
private static final FastThreadLocal CODEC_OUTPUT_LISTS_POOL =
        new FastThreadLocal() {
            @Override
            protected CodecOutputLists initialValue() throws Exception {
                // 16 CodecOutputList per Thread are cached.
                return new CodecOutputLists(16);
            }
        };
@4
CodecOutputLists(int numElements) {
    elements = new CodecOutputList[MathUtil.safeFindNextPositivePowerOfTwo(numElements)];
    for (int i = 0; i < elements.length; ++i) {
        // Size of 16 should be good enough for the majority of all users as an initial capacity.
        elements[i] = new CodecOutputList(this, 16);
    }
    count = elements.length;
    currentIdx = elements.length;
    mask = elements.length - 1;
}
@5
private CodecOutputList(CodecOutputListRecycler recycler, int size) {
    this.recycler = recycler;
    array = new Object[size];
}

@6
public CodecOutputList getOrCreate() {
    if (count == 0) {
        // Return a new CodecOutputList which will not be cached. We use a size of 4 to keep the overhead
        // low.
        return new CodecOutputList(NOOP_RECYCLER, 4);
    }
    --count;

    int idx = (currentIdx - 1) & mask;
    CodecOutputList list = elements[idx];
    currentIdx = idx;
    return list;
}

代码分为 1，2，3，4，5， 6 步骤。

1. 静态方法调用。
2. 从 FastThreadLocal 中取出一个 CodecOutputLists 对象，并从这个集合中再取出一个 List。也就是 List 中有 List。可以理解为双重数组。
3. 调用 FastThreadLocal 的 initialValue 方法返回一个 CodecOutputLists 对象。
4. 创建数组。数组大小默认16，循环填充 CodecOutputList 元素。设置 count，currentIdx ，mask 属性。
5. 创建 CodecOutputList 对象，这个 recycler 就是他的父 CodecOutputLists，并创建一个默认 16 的空数组。
6. 首次进入 count 不是0，应该是 16，随后将 count -1，并与运算出 Lists 中的下标，获取到下标的内容。也就是一个 List。在调用 recycle 方法还给对象池的时候，会将所有参数恢复。

由于这个 getOrCreate 方法会被一个线程的多个地方使用，因此 16 是个统计值。当 16 不够的时候，就会创建一个新的 List。也就是 count == 0 的逻辑。而 & mask 的操作就是一个取模的操作。

3. 写入累积区

代码如下：

cumulation = cumulator.cumulate(ctx.alloc(), cumulation, data);

这个 cumulator 默认是个 Cumulator 类型的 MERGE_CUMULATOR，该实例最主要的是从重写了 cumulate 方法：

public static final Cumulator MERGE_CUMULATOR = new Cumulator() {
    @Override
    public ByteBuf cumulate(ByteBufAllocator alloc, ByteBuf cumulation, ByteBuf in) {
        final ByteBuf buffer;
        if (cumulation.writerIndex() > cumulation.maxCapacity() - in.readableBytes()
                || cumulation.refCnt() > 1 || cumulation.isReadOnly()) {
            buffer = expandCumulation(alloc, cumulation, in.readableBytes());
        } else {
            buffer = cumulation;
        }
        buffer.writeBytes(in);
        in.release();
        return buffer;
    }
};

可以看到该方法，主要是将 unsafe.read 传递过来的 ByteBuf 的内容写入到 cumulation 累积区中，然后释放掉旧的内容，由于这个变量是成员变量，因此可以多次调用 channelRead 方法写入。

同时这个方法也考虑到了扩容的问题，总的来说就是 copy。

当然，ByteToMessageDecoder 中还有一个 Cumulator 实例，称之为 COMPOSITE_CUMULATOR，混合累积。由于上个实例的 cumulate 方法是使用内存拷贝的，因此，这里提供了使用混合内存。相较于拷贝，性能会更好点，但同时也会更复杂。

4. decode 方法的作用

当数据追击到累积区之后，需要调用 decode 方法进行解码，代码如下：

@ 1
callDecode(ctx, cumulation, out);

@2
 protected void callDecode(ChannelHandlerContext ctx, ByteBuf in, List