netty 编/解码处理

    1.LineBasedFrameDecoder

        1.先找到结束符索引

        private static int findEndOfLine(final ByteBuf buffer) {

            final int n = buffer.writerIndex();

            for (int i = buffer.readerIndex(); i < n; i ++) {

                final byte b = buffer.getByte(i);

                if (b == '\n') {

                    return i;

                } else if (b == '\r' && i < n - 1 && buffer.getByte(i + 1) == '\n') {

                    return i;  // \r\n

                }

            }

            return -1;  // Not found.

        }

        2.然后读取数据bytes 转换成对象返回,容错处理暂时不分析 核心代码

        

             if (eol >= 0) {

                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) {//是否连结束符返回 true 不返回

                    frame = buffer.readBytes(length);

                    buffer.skipBytes(delimLength);//跳过结束符数据

                } else {

                    frame = buffer.readBytes(length + delimLength);

                }



                return frame;

            }

    2.StringDecoder 分析 比较简单，ByteBuf 转换 string

        @Override

        protected void decode(ChannelHandlerContext ctx, ByteBuf msg, List<Object> out) throws Exception {

            out.add(msg.toString(charset));

        }

    3.DelimiterBasedFrameDecoder 自定义结束符解码分析，原理基本跟 LineBasedFrameDecoder 相同

        1.找到结束符 ByteBuf 对象，可支持多个

            int minFrameLength = Integer.MAX_VALUE;

            ByteBuf minDelim = null;

            for (ByteBuf delim: delimiters) {

                int frameLength = indexOf(buffer, delim);

                if (frameLength >= 0 && frameLength < minFrameLength) {

                    minFrameLength = frameLength;

                    minDelim = delim;

                }

            }

        2.然后读取数据bytes 转换成对象返回,容错处理暂时不分析 核心代码

            if (stripDelimiter) {//是否连结束符返回 true 不返回

                frame = buffer.readBytes(minFrameLength);

                buffer.skipBytes(minDelimLength);//跳过结束符数据

            } else {

                frame = buffer.readBytes(minFrameLength + minDelimLength);

            }



            return frame;

    4.FixedLengthFrameDecoder 比较简单

        protected Object decode(@SuppressWarnings("UnusedParameters") ChannelHandlerContext ctx, ByteBuf in) throws Exception {

            if (in.readableBytes() < frameLength) {

                return null;

            } else {

                return in.readBytes(frameLength);

            }

        }

    5.LengthFieldBasedFrameDecoder 在 FixedLengthFrameDecoder 基础上指定偏移读取长度,动态帧长度

        1.先看构造方法

        

            /**

     * Creates a new instance.

     *

     * @param byteOrder

     *        the {@link ByteOrder} of the length field

     * @param maxFrameLength

     *        the maximum length of the frame.  If the length of the frame is

     *        greater than this value, {@link TooLongFrameException} will be

     *        thrown.

     * @param lengthFieldOffset

     *        the offset of the length field

     * @param lengthFieldLength

     *        the length of the length field

     * @param lengthAdjustment

     *        the compensation value to add to the value of the length field

     * @param initialBytesToStrip

     *        the number of first bytes to strip out from the decoded frame

     * @param failFast

     *        If <tt>true</tt>, a {@link TooLongFrameException} is thrown as

     *        soon as the decoder notices the length of the frame will exceed

     *        <tt>maxFrameLength</tt> regardless of whether the entire frame

     *        has been read.  If <tt>false</tt>, a {@link TooLongFrameException}

     *        is thrown after the entire frame that exceeds <tt>maxFrameLength</tt>

     *        has been read.

     */

    public LengthFieldBasedFrameDecoder(  

        ByteOrder byteOrder, //传输方式，默认ByteOrder.BIG_ENDIAN

        int maxFrameLength, //帧最大长度

        int lengthFieldOffset,//数据长度偏移，忽略包头信息

        int lengthFieldLength,//数据长度大小

        int lengthAdjustment, //附加数据长度 默认0

        int initialBytesToStrip, 

        boolean failFast    //true 超过 maxFrameLength 长度会抛异常，看处理写得不清晰

    ) {

 



        this.byteOrder = byteOrder;

        this.maxFrameLength = maxFrameLength;

        this.lengthFieldOffset = lengthFieldOffset;

        this.lengthFieldLength = lengthFieldLength;

        this.lengthAdjustment = lengthAdjustment;

        lengthFieldEndOffset = lengthFieldOffset + lengthFieldLength;

        this.initialBytesToStrip = initialBytesToStrip;

        this.failFast = failFast;

    }

        2.核心分析    

      protected Object decode(ChannelHandlerContext ctx, ByteBuf in) throws Exception {

        if (discardingTooLongFrame) { //是否丢弃处理

            long bytesToDiscard = this.bytesToDiscard;

            int localBytesToDiscard = (int) Math.min(bytesToDiscard, in.readableBytes());

            in.skipBytes(localBytesToDiscard);//跳过丢弃数据

            bytesToDiscard -= localBytesToDiscard;

            this.bytesToDiscard = bytesToDiscard;//记录索引



            failIfNecessary(false);

        }

        //少于头信息忽略

        if (in.readableBytes() < lengthFieldEndOffset) {

            return null;

        }

        //计算实际数据读取索引

        int actualLengthFieldOffset = in.readerIndex() + lengthFieldOffset;

        //获取数据长度

        long frameLength = getFrameLength(in, actualLengthFieldOffset);



        if (frameLength < 0) {

            in.skipBytes(lengthFieldEndOffset);

            throw new CorruptedFrameException(

                    "negative pre-adjustment length field: " + frameLength);

        }

        // 帧总长度 = 数据长度+附加数据长度+ 偏移总长度

        frameLength += lengthAdjustment + lengthFieldEndOffset;



        if (frameLength < lengthFieldEndOffset) {

            in.skipBytes(lengthFieldEndOffset);

            throw new CorruptedFrameException(

                    "Adjusted frame length (" + frameLength + ") is less " +

                    "than lengthFieldEndOffset: " + lengthFieldEndOffset);

        }



        if (frameLength > maxFrameLength) {

            long discard = frameLength - in.readableBytes();

            tooLongFrameLength = frameLength;



            if (discard < 0) {

                // buffer contains more bytes then the frameLength so we can discard all now

                in.skipBytes((int) frameLength);

            } else {

                // Enter the discard mode and discard everything received so far.

                discardingTooLongFrame = true;

                bytesToDiscard = discard;

                in.skipBytes(in.readableBytes());

            }

            failIfNecessary(true);

            return null;

        }



        // never overflows because it's less than maxFrameLength

        int frameLengthInt = (int) frameLength;

        if (in.readableBytes() < frameLengthInt) {

            return null;

        }



        if (initialBytesToStrip > frameLengthInt) {

            in.skipBytes(frameLengthInt);

            throw new CorruptedFrameException(

                    "Adjusted frame length (" + frameLength + ") is less " +

                    "than initialBytesToStrip: " + initialBytesToStrip);

        }

        in.skipBytes(initialBytesToStrip);



        // extract frame

        int readerIndex = in.readerIndex();//当前读索引

        int actualFrameLength = frameLengthInt - initialBytesToStrip;//不清楚为什么-initialBytesToStrip

        ByteBuf frame = extractFrame(ctx, in, readerIndex, actualFrameLength); //拷贝数据

        in.readerIndex(readerIndex + actualFrameLength);//修改读索引

        return frame;

    }

    

    

        private long getFrameLength(ByteBuf in, int actualLengthFieldOffset) {

            in = in.order(byteOrder);

            long frameLength;

            switch (lengthFieldLength) {

            case 1:

                frameLength = in.getUnsignedByte(actualLengthFieldOffset);

                break;

            case 2:

                frameLength = in.getUnsignedShort(actualLengthFieldOffset);

                break;

            case 3:

                frameLength = in.getUnsignedMedium(actualLengthFieldOffset);

                break;

            case 4:

                frameLength = in.getUnsignedInt(actualLengthFieldOffset);

                break;

            case 8:

                frameLength = in.getLong(actualLengthFieldOffset);

                break;

            default:

                throw new Error("should not reach here");

            }

            return frameLength;

        }