public abstract class ByteToMessageDecoder extends ChannelInboundHandlerAdapter{
    //類體省略
}

ByteBuf cumulation;

public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
    //如果message是byteBuf類型
    if (msg instanceof ByteBuf) {
        //簡(jiǎn)單當(dāng)成一個(gè)arrayList, 用于盛放解析到的對(duì)象
        CodecOutputList out = CodecOutputList.newInstance();
        try {
            ByteBuf data = (ByteBuf) msg;
            //當(dāng)前累加器為空, 說明這是第一次從io流里面讀取數(shù)據(jù)
            first = cumulation == null;
            if (first) {
                //如果是第一次, 則將累加器賦值為剛讀進(jìn)來的對(duì)象
                cumulation = data;
            } else {
                //如果不是第一次, 則把當(dāng)前累加的數(shù)據(jù)和讀進(jìn)來的數(shù)據(jù)進(jìn)行累加
                cumulation = cumulator.cumulate(ctx.alloc(), cumulation, data);
            }
            //調(diào)用子類的方法進(jìn)行解析
            callDecode(ctx, cumulation, out);
        } catch (DecoderException e) {
            throw e;
        } catch (Throwable t) {
            throw new DecoderException(t);
        } finally {
            if (cumulation != null && !cumulation.isReadable()) {
                numReads = 0;
                cumulation.release();
                cumulation = null;
            } else if (++ numReads >= discardAfterReads) {
                numReads = 0;
                discardSomeReadBytes();
            }
            //記錄list長(zhǎng)度
            int size = out.size();
            decodeWasNull = !out.insertSinceRecycled();
            //向下傳播
            fireChannelRead(ctx, out, size);
            out.recycle();
        }
    } else {
        //不是byteBuf類型則向下傳播
        ctx.fireChannelRead(msg);
    }
}

private Cumulator cumulator = MERGE_CUMULATOR;

public static final Cumulator MERGE_CUMULATOR = new Cumulator() {
    @Override
    public ByteBuf cumulate(ByteBufAllocator alloc, ByteBuf cumulation, ByteBuf in) {
        ByteBuf buffer;
        //不能到過最大內(nèi)存
        if (cumulation.writerIndex() > cumulation.maxCapacity() - in.readableBytes()
                || cumulation.refCnt() > 1) {
            buffer = expandCumulation(alloc, cumulation, in.readableBytes());
        } else {
            buffer = cumulation;
        }
        //將當(dāng)前數(shù)據(jù)buffer
        buffer.writeBytes(in);
        in.release();
        return buffer;
    }
};

protected void callDecode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) {
    try {
        //只要累加器里面有數(shù)據(jù)
        while (in.isReadable()) {
            int outSize = out.size();
            //判斷當(dāng)前List是否有對(duì)象
            if (outSize > 0) {
                //如果有對(duì)象, 則向下傳播事件
                fireChannelRead(ctx, out, outSize);
                //清空當(dāng)前l(fā)ist
                out.clear();
                //解碼過程中如ctx被removed掉就break
                if (ctx.isRemoved()) {
                    break;
                }
                outSize = 0;
            }
            //當(dāng)前可讀數(shù)據(jù)長(zhǎng)度
            int oldInputLength = in.readableBytes();
            //子類實(shí)現(xiàn)
            //子類解析, 解析玩對(duì)象放到out里面
            decode(ctx, in, out);
            if (ctx.isRemoved()) {
                break;
            }
            //List解析前大小 和解析后長(zhǎng)度一樣(什么沒有解析出來)
            if (outSize == out.size()) {
                //原來可讀的長(zhǎng)度==解析后可讀長(zhǎng)度
                //說明沒有讀取數(shù)據(jù)(當(dāng)前累加的數(shù)據(jù)并沒有拼成一個(gè)完整的數(shù)據(jù)包)
                if (oldInputLength == in.readableBytes()) {
                    //跳出循環(huán)(下次在讀取數(shù)據(jù)才能進(jìn)行后續(xù)的解析)
                    break;
                } else {
                    //沒有解析到數(shù)據(jù), 但是進(jìn)行讀取了
                    continue;
                }
            }
            //out里面有數(shù)據(jù), 但是沒有從累加器讀取數(shù)據(jù)
            if (oldInputLength == in.readableBytes()) {
                throw new DecoderException(
                        StringUtil.simpleClassName(getClass()) +
                        ".decode() did not read anything but decoded a message.");
            }

            if (isSingleDecode()) {
                break;
            }
        }
    } catch (DecoderException e) {
        throw e;
    } catch (Throwable cause) {
        throw new DecoderException(cause);
    }
}

finally {
    if (cumulation != null && !cumulation.isReadable()) {
        numReads = 0;
        cumulation.release();
        cumulation = null;
    } else if (++ numReads >= discardAfterReads) {
        numReads = 0;
        discardSomeReadBytes();
    }
    //記錄list長(zhǎng)度
    int size = out.size();
    decodeWasNull = !out.insertSinceRecycled();
    //向下傳播
    fireChannelRead(ctx, out, size);
    out.recycle();
}

static void fireChannelRead(ChannelHandlerContext ctx, CodecOutputList msgs, int numElements) {
    //遍歷List
    for (int i = 0; i < numElements; i ++) {
        //逐個(gè)向下傳遞
        ctx.fireChannelRead(msgs.getUnsafe(i));
    }
}