protected final void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) throws Exception {
    Object decoded = decode(ctx, in);
    if (decoded != null) {
        out.add(decoded);
    }
}

protected Object decode(ChannelHandlerContext ctx, ByteBuf buffer) throws Exception {
    //行處理器(1)
    if (lineBasedDecoder != null) { 
        return lineBasedDecoder.decode(ctx, buffer);
    }
    int minFrameLength = Integer.MAX_VALUE;
    ByteBuf minDelim = null; 
    //找到最小長(zhǎng)度的分隔符(2)
    for (ByteBuf delim: delimiters) {
        //每個(gè)分隔符分隔的數(shù)據(jù)包長(zhǎng)度
        int frameLength = indexOf(buffer, delim);
        if (frameLength >= 0 && frameLength < minFrameLength) {
            minFrameLength = frameLength;
            minDelim = delim;
        }
    }
    //解碼(3)
    //已經(jīng)找到分隔符
    if (minDelim != null) {
        int minDelimLength = minDelim.capacity();
        ByteBuf frame;
        //當(dāng)前分隔符否處于丟棄模式
        if (discardingTooLongFrame) { 
            //首先設(shè)置為非丟棄模式
            discardingTooLongFrame = false;
            //丟棄
            buffer.skipBytes(minFrameLength + minDelimLength);

            int tooLongFrameLength = this.tooLongFrameLength;
            this.tooLongFrameLength = 0;
            if (!failFast) {
                fail(tooLongFrameLength);
            }
            return null;
        }
        //處于非丟棄模式
        //當(dāng)前找到的數(shù)據(jù)包, 大于允許的數(shù)據(jù)包
        if (minFrameLength > maxFrameLength) {
            //當(dāng)前數(shù)據(jù)包+最小分隔符長(zhǎng)度 全部丟棄
            buffer.skipBytes(minFrameLength + minDelimLength);
            //傳遞異常事件
            fail(minFrameLength);
            return null;
        }
        //如果是正常的長(zhǎng)度
        //解析出來(lái)的數(shù)據(jù)包是否忽略分隔符
        if (stripDelimiter) {
            //如果不包含分隔符
            //截取
            frame = buffer.readRetainedSlice(minFrameLength);
            //跳過(guò)分隔符
            buffer.skipBytes(minDelimLength);
        } else {
            //截取包含分隔符的長(zhǎng)度
            frame = buffer.readRetainedSlice(minFrameLength + minDelimLength);
        }
        return frame;
    } else {
        //如果沒(méi)有找到分隔符
        //非丟棄模式
        if (!discardingTooLongFrame) {
            //可讀字節(jié)大于允許的解析出來(lái)的長(zhǎng)度
            if (buffer.readableBytes() > maxFrameLength) {
                //將這個(gè)長(zhǎng)度記錄下
                tooLongFrameLength = buffer.readableBytes();
                //跳過(guò)這段長(zhǎng)度
                buffer.skipBytes(buffer.readableBytes());
                //標(biāo)記當(dāng)前處于丟棄狀態(tài)
                discardingTooLongFrame = true;
                if (failFast) {
                    fail(tooLongFrameLength);
                }
            }
        } else {
            tooLongFrameLength += buffer.readableBytes();
            buffer.skipBytes(buffer.readableBytes());
        }
        return null;
    }
}

public DelimiterBasedFrameDecoder(
        int maxFrameLength, boolean stripDelimiter, boolean failFast, ByteBuf... delimiters) {
    //代碼省略
    //如果是基于行的分隔
    if (isLineBased(delimiters) && !isSubclass()) {
        //初始化行處理器
        lineBasedDecoder = new LineBasedFrameDecoder(maxFrameLength, stripDelimiter, failFast);
        this.delimiters = null;
    } else {
        //代碼省略
    }
    //代碼省略
}

private static boolean isLineBased(final ByteBuf[] delimiters) {
    //分隔符長(zhǎng)度不為2
    if (delimiters.length != 2) {
        return false;
    }
    //拿到第一個(gè)分隔符
    ByteBuf a = delimiters[0];
    //拿到第二個(gè)分隔符
    ByteBuf b = delimiters[1];
    if (a.capacity() < b.capacity()) {
        a = delimiters[1];
        b = delimiters[0];
    }
    //確保a是/r/n分隔符, 確保b是/n分隔符
    return a.capacity() == 2 && b.capacity() == 1
            && a.getByte(0) == '\r' && a.getByte(1) == '\n'
            && b.getByte(0) == '\n';
}

for (ByteBuf delim: delimiters) {
    //每個(gè)分隔符分隔的數(shù)據(jù)包長(zhǎng)度
    int frameLength = indexOf(buffer, delim);
    if (frameLength >= 0 && frameLength < minFrameLength) {
        minFrameLength = frameLength;
        minDelim = delim;
    }
}

int minDelimLength = minDelim.capacity();
ByteBuf frame; 
if (discardingTooLongFrame) { 
    discardingTooLongFrame = false; 
    buffer.skipBytes(minFrameLength + minDelimLength); 
    int tooLongFrameLength = this.tooLongFrameLength;
    this.tooLongFrameLength = 0;
    if (!failFast) {
        fail(tooLongFrameLength);
    }
    return null;
} 
if (minFrameLength > maxFrameLength) { 
    buffer.skipBytes(minFrameLength + minDelimLength); 
    fail(minFrameLength);
    return null;
} 
if (stripDelimiter) { 
    frame = buffer.readRetainedSlice(minFrameLength); 
    buffer.skipBytes(minDelimLength);
} else { 
    frame = buffer.readRetainedSlice(minFrameLength + minDelimLength);
}
return frame;

if (!discardingTooLongFrame) { 
    if (buffer.readableBytes() > maxFrameLength) { 
        tooLongFrameLength = buffer.readableBytes();
        buffer.skipBytes(buffer.readableBytes());
        discardingTooLongFrame = true;
        if (failFast) {
            fail(tooLongFrameLength);
        }
    }
} else {
    tooLongFrameLength += buffer.readableBytes();
    buffer.skipBytes(buffer.readableBytes());
}
return null;