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

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();

}

@1CodecOutputList out = CodecOutputList.newInstance();
@2static CodecOutputList newInstance() {    return CODEC_OUTPUT_LISTS_POOL.get().getOrCreate();
}
@3private static final FastThreadLocal<CodecOutputLists> CODEC_OUTPUT_LISTS_POOL =        new FastThreadLocal<CodecOutputLists>() {            @Override
            protected CodecOutputLists initialValue() throws Exception {                // 16 CodecOutputList per Thread are cached.
                return new CodecOutputLists(16);
            }
        };
@4CodecOutputLists(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;
}
@5private CodecOutputList(CodecOutputListRecycler recycler, int size) {    this.recycler = recycler;
    array = new Object[size];
}

@6public 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;
}

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

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;
    }
};

@ 1callDecode(ctx, cumulation, out);

@2
 protected void callDecode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) {    // 如果累计区还有可读字节
    while (in.isReadable()) {        int outSize = out.size();        // 上次循环成功解码
        if (outSize > 0) {            // 调用后面的业务 handler 的  ChannelRead 方法
            fireChannelRead(ctx, out, outSize);            // 将 size 置为0
            out.clear();//
            if (ctx.isRemoved()) {                break;
            }
            outSize = 0;
        }        // 得到可读字节数
        int oldInputLength = in.readableBytes();        // 调用 decode 方法，将成功解码后的数据放入道 out 数组中，可能会删除当前节点，删除之前会将数据发送到最后的 handler
        decodeRemovalReentryProtection(ctx, in, out);// decode()
        if (ctx.isRemoved()) {            break;
        }        if (outSize == out.size()) {            if (oldInputLength == in.readableBytes()) {                break;
            } else {                continue;
            }
        }        if (isSingleDecode()) {            break;
        }
    }
}