//數(shù)據(jù)包的最大長(zhǎng)度, 超過(guò)該長(zhǎng)度會(huì)進(jìn)行丟棄模式
private final int maxLength;
//超出最大長(zhǎng)度是否要拋出異常
private final boolean failFast;
//最終解析的數(shù)據(jù)包是否帶有換行符
private final boolean stripDelimiter;
//為true說(shuō)明當(dāng)前解碼過(guò)程為丟棄模式
private boolean discarding;
//丟棄了多少字節(jié)
private int discardedBytes;

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 {
    //找這行的結(jié)尾
    final int eol = findEndOfLine(buffer);
    if (!discarding) {
        if (eol >= 0) {
            final ByteBuf frame;
            //計(jì)算從換行符到可讀字節(jié)之間的長(zhǎng)度
            final int length = eol - buffer.readerIndex();
            //拿到分隔符長(zhǎng)度, 如果是\r\n結(jié)尾, 分隔符長(zhǎng)度為2
            final int delimLength = buffer.getByte(eol) == '\r'? 2 : 1;
            //如果長(zhǎng)度大于最大長(zhǎng)度
            if (length > maxLength) {
                //指向換行符之后的可讀字節(jié)(這段數(shù)據(jù)完全丟棄)
                buffer.readerIndex(eol + delimLength);
                //傳播異常事件
                fail(ctx, length);
                return null;
            }
            //如果這次解析的數(shù)據(jù)是有效的
            //分隔符是否算在完整數(shù)據(jù)包里
            //true為丟棄分隔符
            if (stripDelimiter) {
                //截取有效長(zhǎng)度
                frame = buffer.readRetainedSlice(length);
                //跳過(guò)分隔符的字節(jié)
                buffer.skipBytes(delimLength);
            } else {
                //包含分隔符
                frame = buffer.readRetainedSlice(length + delimLength);
            }

            return frame;
        } else {
            //如果沒(méi)找到分隔符(非丟棄模式)
            //可讀字節(jié)長(zhǎng)度
            final int length = buffer.readableBytes();
            //如果朝超過(guò)能解析的最大長(zhǎng)度
            if (length > maxLength) {
                //將當(dāng)前長(zhǎng)度標(biāo)記為可丟棄的
                discardedBytes = length;
                //直接將讀指針移動(dòng)到寫(xiě)指針
                buffer.readerIndex(buffer.writerIndex());
                //標(biāo)記為丟棄模式
                discarding = true;
                //超過(guò)最大長(zhǎng)度拋出異常
                if (failFast) {
                    fail(ctx, "over " + discardedBytes);
                }
            }
            //沒(méi)有超過(guò), 則直接返回
            return null;
        }
    } else {
        //丟棄模式
        if (eol >= 0) {
            //找到分隔符
            //當(dāng)前丟棄的字節(jié)(前面已經(jīng)丟棄的+現(xiàn)在丟棄的位置-寫(xiě)指針)
            final int length = discardedBytes + eol - buffer.readerIndex();
            //當(dāng)前換行符長(zhǎng)度為多少
            final int delimLength = buffer.getByte(eol) == '\r'? 2 : 1;
            //讀指針直接移到換行符+換行符的長(zhǎng)度
            buffer.readerIndex(eol + delimLength);
            //當(dāng)前丟棄的字節(jié)為0
            discardedBytes = 0;
            //設(shè)置為未丟棄模式
            discarding = false;
            //丟棄完字節(jié)之后觸發(fā)異常
            if (!failFast) {
                fail(ctx, length);
            }
        } else {
            //累計(jì)已丟棄的字節(jié)個(gè)數(shù)+當(dāng)前可讀的長(zhǎng)度
            discardedBytes += buffer.readableBytes();
            //移動(dòng)
            buffer.readerIndex(buffer.writerIndex());
        }
        return null;
    }
}

private static int findEndOfLine(final ByteBuf buffer) {
    //找到/n這個(gè)字節(jié)
    int i = buffer.forEachByte(ByteProcessor.FIND_LF);
    //如果找到了, 并且前面的字符是-r, 則指向/r字節(jié)
    if (i > 0 && buffer.getByte(i - 1) == '\r') {
        i--;
    }
    return i;
}

final ByteBuf frame; 
final int length = eol - buffer.readerIndex();
final int delimLength = buffer.getByte(eol) == '\r'? 2 : 1; 
if (length > maxLength) {
    buffer.readerIndex(eol + delimLength);
    fail(ctx, length);
    return null;
} 
if (stripDelimiter) { 
    frame = buffer.readRetainedSlice(length); 
    buffer.skipBytes(delimLength);
} else { 
    frame = buffer.readRetainedSlice(length + delimLength);
}
return frame;

final int length = buffer.readableBytes();
if (length > maxLength) { 
    discardedBytes = length; 
    buffer.readerIndex(buffer.writerIndex());
    discarding = true; 
    if (failFast) {
        fail(ctx, "over " + discardedBytes);
    }
} 
return null;

final int length = discardedBytes + eol - buffer.readerIndex();
final int delimLength = buffer.getByte(eol) == '\r'? 2 : 1;
buffer.readerIndex(eol + delimLength);
discardedBytes = 0;
discarding = false;
if (!failFast) {
    fail(ctx, length);
}

discardedBytes += buffer.readableBytes();
buffer.readerIndex(buffer.writerIndex());