概要

顾名思义, 基于换行符的解码器.

关键属性

/** Maximum length of a frame we're willing to decode.  */
private final int maxLength;
/** Whether or not to throw an exception as soon as we exceed maxLength. */
private final boolean failFast;
private final boolean stripDelimiter;

/** True if we're discarding input because we're already over maxLength.  */
private boolean discarding;
private int discardedBytes;

解码

protected Object decode(ChannelHandlerContext ctx, ByteBuf buffer) throws Exception {
    // 查找buffer中的换行符
    final int eol = findEndOfLine(buffer);
    // 如果是非丢弃模式,说明一切正常
    if (!discarding) {
        // 如果有换行符
        if (eol >= 0) {
            final ByteBuf frame;
            // 那么readerindex-eol之间是可读的范围
            final int length = eol - buffer.readerIndex();
            final int delimLength = buffer.getByte(eol) == '\r'? 2 : 1;

            // 如果可读的范围超过了最大阈值,那么跳过这段
            if (length > maxLength) {
                // 直接跳到该换行符之后           
                buffer.readerIndex(eol + delimLength);
                // 而且还要传递异常TooLongFrameException
                fail(ctx, length);
                return null;
            }
            
            // 最终读取的数据中是否要包含换行符
            if (stripDelimiter) {
                frame = buffer.readRetainedSlice(length);
                buffer.skipBytes(delimLength);
            } else {
                frame = buffer.readRetainedSlice(length + delimLength);
            }

            return frame;
        // 如果没有找到换行符
        } else {
            final int length = buffer.readableBytes();
            // 且可读的范围超过了最大阈值,那么直接跳过这段
            if (length > maxLength) {
                discardedBytes = length;
                // 将readerindex移动到writerindex,表示这一段数据全部丢弃
                buffer.readerIndex(buffer.writerIndex());
                // 进入丢弃模式
                discarding = true;
                if (failFast) {
                    fail(ctx, "over " + discardedBytes);
                }
            }
            return null;
        }
    // 如果是丢弃模式
    } else {
        // 如果发现换行符, 那么这一段直接丢弃
        if (eol >= 0) {
            // 计算总共丢弃了多少长度
            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);
            }
        // 如果还没有找到换行符, 那么这次的全部丢弃, 继续读取
        } else {
            discardedBytes += buffer.readableBytes();
            buffer.readerIndex(buffer.writerIndex());
        }
        return null;
    }
}

总体很简单, 主要是maxLength在里面作祟, 理解为数据通过换行符切分, 每一段都必须在maxLength范围内, 否则整段丢弃.