康康不遛猫
康康不遛猫

Netty解码

Netty解码_第1张图片
图片.png

Netty解码_第2张图片
图片.png

Q

  • 解码器抽象解码过程?
  • netty提供哪些拆箱即用的解码器?解码器基类与常见解码器解析

一、ByteToMessageDecoder解码步骤

  • **累加字节流
    设置first为cumulation是否为空,累加器为空表赋值为读进来的ByteBuf对象,累加器非空调用cumulator的cumulate()方法通过ByteBuffer的writeBytes()方法把当前累加器里面的数据和读进来的数据进行累加
  • 调用子类的decode方法进行解析
    调用callDecode()方法将累加器数据解析到的对象放到CodecOutputList向下进行传播,循环判断累加器里面是否有数据,通过调用fireChannelRead()方法向下进行事件传播,调用decode()方法ByteBuf解码根据不同协议子类的解码器把当前读到的所有数据即累加器里面的数据取出二进制数据流解析放进CodecOutputList
  • 将解析到的ByteBuf向下传播
    调用fireChannelRead()方法循环遍历CodecOutputList通过事件传播机制ctx.fireChannelRead()调用CodecOutputList的getUnsafe()方法获取ByteBuf把解析到的ByteBuf对象向下进行传播

ByteToMessageDecoder.channelRead

public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        if (msg instanceof ByteBuf) {//基于ByteBuf解码
            CodecOutputList out = CodecOutputList.newInstance();
            try {
                ByteBuf data = (ByteBuf) msg;
                first = cumulation == null;
                if (first) {
                    cumulation = data;//初始化cumulation 
                } else {
                    cumulation = cumulator.cumulate(ctx.alloc(), cumulation, data);//累加
                }
                callDecode(ctx, cumulation, out);//解析cumulation中ByteBuf到OutputList
            } 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) {
                    // We did enough reads already try to discard some bytes so we not risk to see a OOME.
                    // See https://github.com/netty/netty/issues/4275
                    numReads = 0;
                    discardSomeReadBytes();
                }

                int size = out.size();
                decodeWasNull = !out.insertSinceRecycled();
                fireChannelRead(ctx, out, size);//解析出的数据outlist，向后传播
                out.recycle();//outlist回收
            }
        } else {
            ctx.fireChannelRead(msg);
        }
    }

cumulator.cumulate

public static final Cumulator MERGE_CUMULATOR = new Cumulator() {
        @Override
        public ByteBuf cumulate(ByteBufAllocator alloc, ByteBuf cumulation, ByteBuf in) {
            final ByteBuf buffer;
            if (cumulation.writerIndex() > cumulation.maxCapacity() - in.readableBytes()
                    || cumulation.refCnt() > 1 || cumulation.isReadOnly()) {
                buffer = expandCumulation(alloc, cumulation, in.readableBytes());//cumulation扩容
            } else {
                buffer = cumulation;
            }
            buffer.writeBytes(in);
            in.release();
            return buffer;
        }
    };

callDecode

protected void callDecode(ChannelHandlerContext ctx, ByteBuf in, List out) {
        try {
            while (in.isReadable()) {//如果累加器还有数据
                int outSize = out.size();

                if (outSize > 0) {//如果outputlist有数据，则向后传播，并清空
                    fireChannelRead(ctx, out, outSize);
                    out.clear();

                    if (ctx.isRemoved()) {
                        break;
                    }
                    outSize = 0;
                }

                int oldInputLength = in.readableBytes();
                decodeRemovalReentryProtection(ctx, in, out);

                if (ctx.isRemoved()) {
                    break;
                }

                if (outSize == out.size()) {//说明size没变化，没解析到数据
                    if (oldInputLength == in.readableBytes()) {
                        break;
                    } else {
                        continue;
                    }
                }
                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);
        }
    }

final void decodeRemovalReentryProtection(ChannelHandlerContext ctx, ByteBuf in, List out)
            throws Exception {
        decodeState = STATE_CALLING_CHILD_DECODE;
        try {
            decode(ctx, in, out);//抽象方法，子类实现，解析后对象放在out里
        } finally {
            boolean removePending = decodeState == STATE_HANDLER_REMOVED_PENDING;
            decodeState = STATE_INIT;
            if (removePending) {
                handlerRemoved(ctx);
            }
        }
    }
 
 
二、基于固定长度解码器分析FixedLengthFrameDecoder
 
 
基于固定长度解码器FixedLengthFrameDecoder成员变量frameLength表示固定长度，解码器以多少长度分割解析,构造方法传参frameLength赋值给frameLength保存。
 调用decode()方法解析累加器数据添加到CodecOutputList,判断累加器可读字节是否小于frameLength,小于返回空表示没有从累加器里面读取数据,反之调用readRetainedSlice()方法从当前累加器里面截取frameLength长度ByteBuf，返回从当前readerIndex开始增加frameLength长度的Buffer子区域新保留切片。
 
 
FixedLengthFrameDecoder
 
 
/**
 * A decoder that splits the received {@link ByteBuf}s by the fixed number
 * of bytes. For example, if you received the following four fragmented packets:
 * 
 * +---+----+------+----+
 * | A | BC | DEFG | HI |
 * +---+----+------+----+
 * 

 * A {@link FixedLengthFrameDecoder}{@code (3)} will decode them into the
 * following three packets with the fixed length:
 * 如果固定长度为3，上面数据包会被解析成如下：
 * 
 * +-----+-----+-----+
 * | ABC | DEF | GHI |
 * +-----+-----+-----+
 * 

 */
public class FixedLengthFrameDecoder extends ByteToMessageDecoder {

    private final int frameLength;

    public FixedLengthFrameDecoder(int frameLength) {
        if (frameLength <= 0) {
            throw new IllegalArgumentException(
                    "frameLength must be a positive integer: " + frameLength);
        }
        this.frameLength = frameLength;
    }

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

protected Object decode(
            @SuppressWarnings("UnusedParameters") ChannelHandlerContext ctx, ByteBuf in) throws Exception {
        if (in.readableBytes() < frameLength) {//当前可读字节小于固定长度，返回null，不添加到outList
            return null;
        } else {
            return in.readRetainedSlice(frameLength);
        }
    }
}
 
 
三、行解码器分析LineBasedFrameDecoder
 
 
基于行解码器LineBasedFrameDecoder
 
 
     
  
  • 成员变量
     maxLength[行解码器解析数据包最大长度],failFast[超越最大长度是否立即抛异常],
     stripDelimiter[解析数据包是否带换行符,换行符支持\n和\r],
     discarding[解码过程是否处于丢弃模式],
     discardedBytes[解码过程丢弃字节],
    •  
  
  • 调用decode()方法解析累加器cumulation数据把数据包添加到CodecOutputList,通过findEndOfLine()方法从累加器ByteBuf里面查找获取行的结尾eol即\n或者\r\n,
    •  
  
  • 非丢弃模式查找到行的结尾eol计算从换行符到可读字节的长度length和分隔符的长度判断length是否大于解析数据包最大长度maxLength,大于maxLength则readerIndex指向行的结尾eol后面的可读字节丢弃数据通过fail()方法传播异常,判断分隔符是否算在完整数据包范畴从buffer分割length长度获取新保留切片并且buffer跳过分隔符readerIndex指向分隔符后面的可读字节,
    •  
  
  • 未查找到行的结尾eol获取可读字节长度length超过解析数据包最大长度maxLength赋值discardedBytes为length读指针readerIndex指向写指针writerIndex赋值discarding为true进入丢弃模式并且根据failFast调用fail()方法立即传播fail异常,
    •  
  
  • 丢弃模式查找到行的结尾eol按照丢弃字节+从换行符到可读字节的长度计算length和换行符长度将readerIndex指向丢弃字节换行符后面的可读字节赋值discardedBytes为0并且discarding为false表示当前属于非丢弃模式,根据failFast调用fail()方法立即传播fail异常,
     未查找到行的结尾eol则discardedBytes增加buffer的可读字节并且读指针readerIndex指向写指针writerIndex
    •  
 
 
 
 
  
 
   
 
    Netty解码_第3张图片 
   
 
  
 
  

    图片.png 
  
 
 
 
 
public class LineBasedFrameDecoder extends ByteToMessageDecoder {

    /** 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;//解析的数据包时候带换行符，false带，true不带

    /** True if we're discarding input because we're already over maxLength.  */
    private boolean discarding;//超过最大长度时候抛弃
    private int discardedBytes;//抛弃的字节数

    /**
     * Creates a new decoder.
     * @param maxLength  the maximum length of the decoded frame.
     *                   A {@link TooLongFrameException} is thrown if
     *                   the length of the frame exceeds this value.
     */
    public LineBasedFrameDecoder(final int maxLength) {
        this(maxLength, true, false);
    }

    /**
     * Creates a new decoder.
     * @param maxLength  the maximum length of the decoded frame.
     *                   A {@link TooLongFrameException} is thrown if
     *                   the length of the frame exceeds this value.
     * @param stripDelimiter  whether the decoded frame should strip out the
     *                        delimiter or not
     * @param failFast  If true, a {@link TooLongFrameException} is
     *                  thrown as soon as the decoder notices the length of the
     *                  frame will exceed maxFrameLength regardless of
     *                  whether the entire frame has been read.
     *                  If false, a {@link TooLongFrameException} is
     *                  thrown after the entire frame that exceeds
     *                  maxFrameLength has been read.
     */
    public LineBasedFrameDecoder(final int maxLength, final boolean stripDelimiter, final boolean failFast) {
        this.maxLength = maxLength;
        this.failFast = failFast;
        this.stripDelimiter = stripDelimiter;
    }

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

    /**
     * Create a frame out of the {@link ByteBuf} and return it.
     *
     * @param   ctx             the {@link ChannelHandlerContext} which this {@link ByteToMessageDecoder} belongs to
     * @param   buffer          the {@link ByteBuf} from which to read data
     * @return  frame           the {@link ByteBuf} which represent the frame or {@code null} if no frame could
     *                          be created.
     */
    protected Object decode(ChannelHandlerContext ctx, ByteBuf buffer) throws Exception {
        final int eol = findEndOfLine(buffer);//寻找行的结尾，\n或者\r\n
        if (!discarding) {//非丢弃模式
            if (eol >= 0) {
                final ByteBuf frame;
                final int length = eol - buffer.readerIndex();//endofline-readerIndex即为可读字节
                final int delimLength = buffer.getByte(eol) == '\r'? 2 : 1;//分隔符长度，2或者1

                if (length > maxLength) {
                    buffer.readerIndex(eol + delimLength);//当可读字节大于行最大长度，则移动readerIndex到下一个可读区域
                    fail(ctx, length);//传播异常
                    return null;//返回null表示当前什么也没有解析
                }

                if (stripDelimiter) {//是否跳过分隔符
                    frame = buffer.readRetainedSlice(length);//解析数据不包含分隔符
                    buffer.skipBytes(delimLength);
                } else {
                    frame = buffer.readRetainedSlice(length + delimLength);//解析数据包含分隔符
                }

                return frame;//返回解析数据包
            } else {//readerIndex和writerIndex没有换行符
                final int length = buffer.readableBytes();
                if (length > maxLength) {//可读长度大于最大行长度
                    discardedBytes = length;//丢弃字节长度
                    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();//丢弃长度=discardedBytes +当前可读长度
                final int delimLength = buffer.getByte(eol) == '\r'? 2 : 1;
                buffer.readerIndex(eol + delimLength);//移动指针到分隔符之后
                discardedBytes = 0;//重置丢弃长度
                discarding = false;//进入非丢弃模式
                if (!failFast) {
                    fail(ctx, length);
                }
            } else {//没有找到分隔符，直接移动readerIndex到writerIndex
                discardedBytes += buffer.readableBytes();
                buffer.readerIndex(buffer.writerIndex());
            }
            return null;
        }
    }

    private void fail(final ChannelHandlerContext ctx, int length) {
        fail(ctx, String.valueOf(length));
    }
 
 
四、分隔符解码器DelimiterBasedFrameDecoder
 
 
 
  
 
   
 
    Netty解码_第4张图片 
   
 
  
 
  

    图片.png 
  
 
 
 
 
public class DelimiterBasedFrameDecoder extends ByteToMessageDecoder {

    private final ByteBuf[] delimiters;
    private final int maxFrameLength;
    private final boolean stripDelimiter;
    private final boolean failFast;
    private boolean discardingTooLongFrame;
    private int tooLongFrameLength;
    /** Set only when decoding with "\n" and "\r\n" as the delimiter.  */
    private final LineBasedFrameDecoder lineBasedDecoder;


    public DelimiterBasedFrameDecoder(int maxFrameLength, ByteBuf delimiter) {
        this(maxFrameLength, true, delimiter);
    }


    public DelimiterBasedFrameDecoder(
            int maxFrameLength, boolean stripDelimiter, ByteBuf delimiter) {
        this(maxFrameLength, stripDelimiter, true, delimiter);
    }


    public DelimiterBasedFrameDecoder(
            int maxFrameLength, boolean stripDelimiter, boolean failFast,
            ByteBuf delimiter) {
        this(maxFrameLength, stripDelimiter, failFast, new ByteBuf[] {
                delimiter.slice(delimiter.readerIndex(), delimiter.readableBytes())});
    }


    public DelimiterBasedFrameDecoder(int maxFrameLength, ByteBuf... delimiters) {
        this(maxFrameLength, true, delimiters);
    }


    public DelimiterBasedFrameDecoder(
            int maxFrameLength, boolean stripDelimiter, ByteBuf... delimiters) {
        this(maxFrameLength, stripDelimiter, true, delimiters);
    }

    //构造方法
    public DelimiterBasedFrameDecoder(
            int maxFrameLength, boolean stripDelimiter, boolean failFast, ByteBuf... delimiters) {
        validateMaxFrameLength(maxFrameLength);
        if (delimiters == null) {
            throw new NullPointerException("delimiters");
        }
        if (delimiters.length == 0) {
            throw new IllegalArgumentException("empty delimiters");
        }

        if (isLineBased(delimiters) && !isSubclass()) {//初始化行解码器
            lineBasedDecoder = new LineBasedFrameDecoder(maxFrameLength, stripDelimiter, failFast);
            this.delimiters = null;
        } else {
            this.delimiters = new ByteBuf[delimiters.length];
            for (int i = 0; i < delimiters.length; i ++) {
                ByteBuf d = delimiters[i];
                validateDelimiter(d);
                this.delimiters[i] = d.slice(d.readerIndex(), d.readableBytes());
            }
            lineBasedDecoder = null;
        }
        this.maxFrameLength = maxFrameLength;
        this.stripDelimiter = stripDelimiter;
        this.failFast = failFast;
    }

    /**判断分隔符是否是 "\n" and "\r\n"，是则为行解码器  */
    private static boolean isLineBased(final ByteBuf[] delimiters) {
        if (delimiters.length != 2) {
            return false;
        }
        ByteBuf a = delimiters[0];
        ByteBuf b = delimiters[1];
        if (a.capacity() < b.capacity()) {
            a = delimiters[1];
            b = delimiters[0];
        }
        return a.capacity() == 2 && b.capacity() == 1
                && a.getByte(0) == '\r' && a.getByte(1) == '\n'
                && b.getByte(0) == '\n';
    }

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


    protected Object decode(ChannelHandlerContext ctx, ByteBuf buffer) throws Exception {
        if (lineBasedDecoder != null) {//行解码器不为空，则使用 行解码器解码
            return lineBasedDecoder.decode(ctx, buffer);
        }
        // Try all delimiters and choose the delimiter which yields the shortest frame.
        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;
            }
        }

        if (minDelim != null) {//找到分隔符
            int minDelimLength = minDelim.capacity();
            ByteBuf frame;

            if (discardingTooLongFrame) {//是否丢弃模式
                discardingTooLongFrame = false;//重置丢弃模式为false
                buffer.skipBytes(minFrameLength + minDelimLength);//跳过

                int tooLongFrameLength = this.tooLongFrameLength;
                this.tooLongFrameLength = 0;
                if (!failFast) {//是否已快速失败
                    fail(tooLongFrameLength);
                }
                return null;
            }

           //最小分隔符分割的数据包仍大于最大数据包
            if (minFrameLength > maxFrameLength) {
                // Discard read frame.
                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;
        } else {//没有找到分隔符时
            if (!discardingTooLongFrame) {//非丢弃状态
                if (buffer.readableBytes() > maxFrameLength) {//可读数据大于允许最大数据包
                    // Discard the content of the buffer until a delimiter is found.
                    tooLongFrameLength = buffer.readableBytes();
                    buffer.skipBytes(buffer.readableBytes());//直接跳过可读数据
                    discardingTooLongFrame = true;//进去丢弃状态
                    if (failFast) {//是否快速失败
                        fail(tooLongFrameLength);
                    }
                }
            } else {//丢弃状态
                // Still discarding the buffer since a delimiter is not found.
                tooLongFrameLength += buffer.readableBytes();//记录丢弃的字节数
                buffer.skipBytes(buffer.readableBytes());//直接跳过可读数据
            }
            return null;
        }
    }

    private void fail(long frameLength) {
        if (frameLength > 0) {
            throw new TooLongFrameException(
                            "frame length exceeds " + maxFrameLength +
                            ": " + frameLength + " - discarded");
        } else {
            throw new TooLongFrameException(
                            "frame length exceeds " + maxFrameLength +
                            " - discarding");
        }
    }

    /**
     * Returns the number of bytes between the readerIndex of the haystack and
     * the first needle found in the haystack.  -1 is returned if no needle is
     * found in the haystack.
     */
    private static int indexOf(ByteBuf haystack, ByteBuf needle) {
        for (int i = haystack.readerIndex(); i < haystack.writerIndex(); i ++) {
            int haystackIndex = i;
            int needleIndex;
            for (needleIndex = 0; needleIndex < needle.capacity(); needleIndex ++) {
                if (haystack.getByte(haystackIndex) != needle.getByte(needleIndex)) {
                    break;
                } else {
                    haystackIndex ++;
                    if (haystackIndex == haystack.writerIndex() &&
                        needleIndex != needle.capacity() - 1) {
                        return -1;
                    }
                }
            }

            if (needleIndex == needle.capacity()) {
                // Found the needle from the haystack!
                return i - haystack.readerIndex();
            }
        }
        return -1;
    }

    private static void validateDelimiter(ByteBuf delimiter) {
        if (delimiter == null) {
            throw new NullPointerException("delimiter");
        }
        if (!delimiter.isReadable()) {
            throw new IllegalArgumentException("empty delimiter");
        }
    }

    private static void validateMaxFrameLength(int maxFrameLength) {
        if (maxFrameLength <= 0) {
            throw new IllegalArgumentException(
                    "maxFrameLength must be a positive integer: " +
                    maxFrameLength);
        }
    }
}
 
 
五、基于长度域解码器LengthFieldBasedFrameDecoder
 
 
1、成员变量解析
 
 
     
  
  • lengthFieldOffset：长度域偏移量即长度域在二进制数据流里面偏移量
    •  
  
  • lengthFieldLength：长度域长度即从长度域开始往后几个字节组合起来表示长度
    •  
  
  • lengthAdjustment：长度域表示长度+额外调整长度=数据包长度，即长度域计算完整数据包长度,长度额外调整
    •  
  
  • initialBytesToStrip：decode出完整数据包之后向下传播的时候是否需要砍掉几个字节即解析数据包前面跳过字节
     构造函数 
    •  
 
 
 
public LengthFieldBasedFrameDecoder(
            ByteOrder byteOrder, int maxFrameLength, int lengthFieldOffset, int lengthFieldLength,
            int lengthAdjustment, int initialBytesToStrip, boolean failFast) {
        if (byteOrder == null) {
            throw new NullPointerException("byteOrder");
        }

        if (maxFrameLength <= 0) {
            throw new IllegalArgumentException(
                    "maxFrameLength must be a positive integer: " +
                    maxFrameLength);
        }

        if (lengthFieldOffset < 0) {
            throw new IllegalArgumentException(
                    "lengthFieldOffset must be a non-negative integer: " +
                    lengthFieldOffset);
        }

        if (initialBytesToStrip < 0) {
            throw new IllegalArgumentException(
                    "initialBytesToStrip must be a non-negative integer: " +
                    initialBytesToStrip);
        }

        if (lengthFieldOffset > maxFrameLength - lengthFieldLength) {
            throw new IllegalArgumentException(
                    "maxFrameLength (" + maxFrameLength + ") " +
                    "must be equal to or greater than " +
                    "lengthFieldOffset (" + lengthFieldOffset + ") + " +
                    "lengthFieldLength (" + lengthFieldLength + ").");
        }

        this.byteOrder = byteOrder;
        this.maxFrameLength = maxFrameLength;
        this.lengthFieldOffset = lengthFieldOffset;
        this.lengthFieldLength = lengthFieldLength;
        this.lengthAdjustment = lengthAdjustment;
        lengthFieldEndOffset = lengthFieldOffset + lengthFieldLength;
        this.initialBytesToStrip = initialBytesToStrip;
        this.failFast = failFast;
    }

 
 
示例1
 
 
 * lengthFieldOffset   = 0
 * lengthFieldLength   = 2
 * lengthAdjustment    = 0
 * initialBytesToStrip = 0 (= do not strip header)
 * BEFORE DECODE (14 bytes)         AFTER DECODE (14 bytes)
 * +--------+----------------+      +--------+----------------+
 * | Length | Actual Content |----->| Length | Actual Content |
 * | 0x000C | "HELLO, WORLD" |      | 0x000C | "HELLO, WORLD" |
 * +--------+----------------+      +--------+----------------+

new LengthFieldBasedFrameDecoder(Integer.MAX, 0, 2);
1.第一个参数是 maxFrameLength 表示的是包的最大长度，超出包的最大长度netty将会做一些特殊处理，后面会讲到
2.第二个参数指的是长度域的偏移量lengthFieldOffset，在这里是0，表示无偏移
3.第三个参数指的是长度域长度lengthFieldLength，这里是2，表示长度域的长度为2

 
 
示例2
 
 
 * lengthFieldOffset   = 0
 * lengthFieldLength   = 2
 * lengthAdjustment    = 0
 * initialBytesToStrip = 2 (= the length of the Length field)
 * BEFORE DECODE (14 bytes)         AFTER DECODE (12 bytes)
 * +--------+----------------+      +----------------+
 * | Length | Actual Content |----->| Actual Content |
 * | 0x000C | "HELLO, WORLD" |      | "HELLO, WORLD" |
 * +--------+----------------+      +----------------+

new LengthFieldBasedFrameDecoder(Integer.MAX, 0, 2, 0, 2);
前面三个参数的含义和上文相同
第四个参数lengthAdjustment，后面再讲
第五个参数就是initialBytesToStrip，这里为2，表示获取完一个完整的数据包之后，忽略前面的2个字节（长度）

 
 
示例3
 
 
 * lengthFieldOffset   =  0
 * lengthFieldLength   =  2
 * lengthAdjustment    = -2 (= the length of the Length field)
 * initialBytesToStrip =  0
 *
 * BEFORE DECODE (14 bytes)         AFTER DECODE (14 bytes)
 * +--------+----------------+      +--------+----------------+
 * | Length | Actual Content |----->| Length | Actual Content |
 * | 0x000E | "HELLO, WORLD" |      | 0x000E | "HELLO, WORLD" |
 * +--------+----------------+      +--------+----------------+

new LengthFieldBasedFrameDecoder(Integer.MAX, 0, 2,-2,0);
lengthFieldLength 是2，lengthAdjustment为-2，表示数据包长度0x000E-2，即为0x000C

 
 
示例4
 
 
 * lengthFieldOffset   = 2 (= the length of Header 1)
 * lengthFieldLength   = 3
 * lengthAdjustment    = 0
 * initialBytesToStrip = 0
 *
 * BEFORE DECODE (17 bytes)                      AFTER DECODE (17 bytes)
 * +----------+----------+----------------+      +----------+----------+----------------+
 * | Header 1 |  Length  | Actual Content |----->| Header 1 |  Length  | Actual Content |
 * |  0xCAFE  | 0x00000C | "HELLO, WORLD" |      |  0xCAFE  | 0x00000C | "HELLO, WORLD" |
 * +----------+----------+----------------+      +----------+----------+----------------+

new LengthFieldBasedFrameDecoder(Integer.MAX, 2, 3, 0, 0);
长度域偏移为2，长度域大小为3，即0x00000C

 
 
示例5
 
 
 * lengthFieldOffset   = 0
 * lengthFieldLength   = 3
 * lengthAdjustment    = 2 (= the length of Header 1)
 * initialBytesToStrip = 0
 *
 * BEFORE DECODE (17 bytes)                      AFTER DECODE (17 bytes)
 * +----------+----------+----------------+      +----------+----------+----------------+
 * |  Length  | Header 1 | Actual Content |----->|  Length  | Header 1 | Actual Content |
 * | 0x00000C |  0xCAFE  | "HELLO, WORLD" |      | 0x00000C |  0xCAFE  | "HELLO, WORLD" |
 * +----------+----------+----------------+      +----------+----------+----------------+

new LengthFieldBasedFrameDecoder(Integer.MAX, 0, 3, 2, 0);
长度域中0x00000C ，Header 占用2字节，所以数据包长度为0x00000C +2（lengthAdjustment）

 
 
示例6
 
 
 * lengthFieldOffset   = 1 (= the length of HDR1)
 * lengthFieldLength   = 2
 * lengthAdjustment    = 1 (= the length of HDR2)
 * initialBytesToStrip = 3 (= the length of HDR1 + LEN)
 *
 * BEFORE DECODE (16 bytes)                       AFTER DECODE (13 bytes)
 * +------+--------+------+----------------+      +------+----------------+
 * | HDR1 | Length | HDR2 | Actual Content |----->| HDR2 | Actual Content |
 * | 0xCA | 0x000C | 0xFE | "HELLO, WORLD" |      | 0xFE | "HELLO, WORLD" |
 * +------+--------+------+----------------+      +------+----------------+
new LengthFieldBasedFrameDecoder(Integer.MAX, 1, 2, 1, 3);
数据包长度为0x000C  +1（lengthAdjustment），截取前面3（initialBytesToStrip）个字节

 
 
示例7
 
 
 * lengthFieldOffset   =  1
 * lengthFieldLength   =  2
 * lengthAdjustment    = -3 (= the length of HDR1 + LEN, negative)
 * initialBytesToStrip =  3
 *
 * BEFORE DECODE (16 bytes)                       AFTER DECODE (13 bytes)
 * +------+--------+------+----------------+      +------+----------------+
 * | HDR1 | Length | HDR2 | Actual Content |----->| HDR2 | Actual Content |
 * | 0xCA | 0x0010 | 0xFE | "HELLO, WORLD" |      | 0xFE | "HELLO, WORLD" |
 * +------+--------+------+----------------+      +------+----------------+

 
 
2、decode方法分析
 
 
     
  
  • 计算需要抽取的数据包长度。
    •  
  
  • 跳过字节逻辑处理。
    •  
  
  • 丢弃模式下的处理。
    •  
 
 
 
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 = getUnadjustedFrameLength(in, actualLengthFieldOffset, lengthFieldLength, byteOrder);//抽取的数据包长度

        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) {//数据包长度大于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);//直接丢弃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;//实际数据包
        ByteBuf frame = extractFrame(ctx, in, readerIndex, actualFrameLength);
        in.readerIndex(readerIndex + actualFrameLength);
        return frame;
    }

//支持1、2、3、4、8的length
protected long getUnadjustedFrameLength(ByteBuf buf, int offset, int length, ByteOrder order) {
        buf = buf.order(order);
        long frameLength;
        switch (length) {
        case 1:
            frameLength = buf.getUnsignedByte(offset);
            break;
        case 2:
            frameLength = buf.getUnsignedShort(offset);
            break;
        case 3:
            frameLength = buf.getUnsignedMedium(offset);
            break;
        case 4:
            frameLength = buf.getUnsignedInt(offset);
            break;
        case 8:
            frameLength = buf.getLong(offset);
            break;
        default:
            throw new DecoderException(
                    "unsupported lengthFieldLength: " + lengthFieldLength + " (expected: 1, 2, 3, 4, or 8)");
        }
        return frameLength;
    }

protected ByteBuf extractFrame(ChannelHandlerContext ctx, ByteBuf buffer, int index, int length) {
        return buffer.retainedSlice(index, length);
}

 

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(Netty解码)

        

            

                
    
                    
  • 王东伟，中原焦点秦皇岛站第五期，每日分享第181天
                        Vivian_c8c7

                        
    《解码青春期》让孩子懂得承担责任，学会道歉。英国诗人亚历山大•蒲柏有句名言：凡人难免犯错宽恕方显神性。学会如何请求对方宽恕对于保持健康的关系至关重要。当青少年把事情搞砸的时候，他们需要从关心他们的成年人那里获得帮助。家长的目标是要培养一个能为自己的行为承担责任的青少年，培养一个敢于诚恳的承认错误，愿意真心悔改的青少年。青少年只关注自己如何委屈，而且会竭尽全力为自己的行为辩解。所以，家长得小心地拆除
    
                    
    • 
                    
  • Windows安装ciphey编码工具，附一道ciscn编码题例
                        im-Miclelson
CTF工具网络安全
                        
    TA是什么一款智能化的编码分析解码工具，对于CTF中复杂性编码类题目可以快速攻破。编码自动分析解码的神器。如何安装Windows环境Python3.864位（最新的版本不兼容，32位的也不行）PIP直接安装pipinstallciphey-ihttps://pypi.mirrors.ustc.edu.cn/simple/安装后若是出现报错请根据错误代码行数找到对应文件，r修改成rb即可。使用标准语
    
                    
    • 
                    
  • CTF-bugku-crypto-[7+1+0]-base64解码之后做偏移
                        沧海一粟日尽其用
算法安全python
                        
    CTF-bugku-crypto-[7+1+0]-base64解码之后做偏移1.题目2.解题思路2.1base64编码原理2.2解题思路2.2.1base64解码找规律2.2.2破解思路3.解题脚本4.flag5.附EASCII码表1.题目提示信息：7+1+0？格式bugku{xxxxx}密文：4nXna/V7t2LpdLI44mn0fQ==要求：破解密文获得flag2.解题思路2.1base64
    
                    
    • 
                    
  • 全自动解密解码神器 — Ciphey
                        K'illCode
python_模块pythonvscode
                        
    Ciphey是一个使用自然语言处理和人工智能的全自动解密/解码/破解工具。简单地来讲，你只需要输入加密文本，它就能给你返回解密文本。就是这么牛逼。有了Ciphey，你根本不需要知道你的密文是哪种类型的加密，你只知道它是加密的，那么Ciphey就能在3秒甚至更短的时间内给你解密，返回你想要的大部分密文的答案。下面就给大家介绍Ciphey的实战使用教程。1.准备开始之前，你要确保Python和pip已
    
                    
    • 
                    
  • netty-简易聊天
                        2401_84046645
程序员java开发语言
                        
    publicvoidsend(Stringtext){channel.writeAndFlush(Unpooled.copiedBuffer(text.getBytes()));}publicvoidcloseConnect(){send(“bye”);channel.close();}}classMyHandlerextendsChannelInboundHandlerAdapter{@Over
    
                    
    • 
                    
  • transformer架构(Transformer Architecture)原理与代码实战案例讲解
                        AI架构设计之禅
大数据AI人工智能Python入门实战计算科学神经计算深度学习神经网络大数据人工智能大型语言模型AIAGILLMJavaPython架构设计AgentRPA
                        
    transformer架构(TransformerArchitecture)原理与代码实战案例讲解关键词：Transformer,自注意力机制,编码器-解码器,预训练,微调,NLP,机器翻译作者：禅与计算机程序设计艺术/ZenandtheArtofComputerProgramming1.背景介绍1.1问题的由来自然语言处理（NLP）领域的发展经历了从规则驱动到统计驱动再到深度学习驱动的三个阶段。
    
                    
    • 
                    
  • Netty权威指南：Netty总结-高性能与可靠性
                        Ty_1106
Nettyjava网络rpc
                        
    第二十二章高性能之道22.1RPC调用性能模型分析22.1.1传统RPC调用性能差三宗罪：网络传输采用同步阻塞I/O导致经常性阻塞序列化性能差线程模型问题22.1.2I/O通信性能三要素传输：BIO、NIO或者AIO协议：HTTP公有协议，内部私有协议线程：数据报如何读取，Reactor线程模型22.2Netty高性能之道22.2.1异步非阻塞通信I/O多路复用技术22.2.2高效的Reactor
    
                    
    • 
                    
  • leetcode--91--解码方法
                        minningl

                        
    题目：一条包含字母A-Z的消息通过以下方式进行了编码：'A'->1'B'->2...'Z'->26给定一个只包含数字的非空字符串，请计算解码方法的总数。示例1:输入:"12"输出:2解释:它可以解码为"AB"（12）或者"L"（12）。示例2:输入:"226"输出:3解释:它可以解码为"BZ"(226),"VF"(226),或者"BBF"(226)。链接：https://leetcode-cn.c
    
                    
    • 
                    
  • netty4源码阅读与分析---netty线程模型
                        红尘之一骑
javaNIOnetty源码阅读与分析
                        
    本文主要说下我自己对netty线程模型的理解，以及这样的线程模型的好处。通俗的来讲，netty的线程模型描述的就是老板和员工的故事。老板(通常情况下是一个老板)负责接活，与客户沟通，协调(netty的accept),谈成后(通道建立)，他需要从员工中选出一位员工来负责处理后续具体的事宜(worker线程，这里我们有16位员工，编号1-16)，员工做事时按照任务的先后顺序进行处理，这样可以避免错乱，
    
                    
    • 
                    
  • python--排错--AttributeError: 'str' object has no attribute 'decode'，关于python3的字符串
                        我不是庸医
python排错记录
                        
    AttributeError:'str'objecthasnoattribute'decode'一般是因为str的类型本身不是bytes，所以不能解码两个概念:普通str：可理解的语义字节流str（bytes）（0101010101，可视化显示）两个语法Encode:把普通字符串转为机器可识别的bytesDecode:把bytes转为字符串两个差异Python3的str默认不是bytes，所以不能
    
                    
    • 
                    
  • GPS信号解释
                        记得往前走
GNSS
                        
    笔者在进行对GPS信号解码的时候，看得头昏脑涨，就整理一下1.频段和频率L1/1575.42MHz:这是GPS的主要频段之一，用于大多数民用和军用信号。L2/1227.60MHz:这是GPS的第二个主要频段，通常用于提高精度，特别是与L1组合使用以消除电离层误差。L5/1176.45MHz:这是最新引入的频段，主要用于航空导航和其他高精度应用。2.信号类型（ChannelorCode）每个频段有多
    
                    
    • 
                    
  • 前端有关文件上传下载操作
                        发呆小天才yy
前端javascript
                        
    文件上传文件上传有两种形式（传给后端的文件形式）变成blob通过formData搭载传输（二进制blob传输）转为base64直接传输(简便，但是后端需要解码，时间长)，通过fileReader搭载相关对象：files（blob的一个子类）：通过input标签读取过来的文件对象（属于前端的方法，没办法直接传给后端）blob:不可变的二进制内容，包含很多操作方法（newBlob([file])直接将
    
                    
    • 
                    
  • freeswitch模块的介绍系列【codecs】【mod_ilbc】
                        黄宝良
freeswitch学习linux视频编解码音视频
                        
    ffreeswitch模块的介绍系列【编解码】【mod_ilbc】mod_ilbc文章目录ffreeswitch模块的介绍系列【编解码】【mod_ilbc】一、mod_ilbc是什么？二、使用步骤1.引入模块环境2.安装mod_ilbc模块2.FS导入模块总结一、mod_ilbc是什么？“mod_ilbc”是freeswitch忠低比特率编解码器（iLBC）模块，通常在电信和互联网协议语音（VoI
    
                    
    • 
                    
  • 解码工业自动化：ArtInChip M6800系列编码器接口协议全解析
                        芯智云
自动化网络运维
                        
    在工业自动化的浪潮中，编码器以其精确的位置和速度反馈是实现精密控制的基础。随着技术的发展，编码器与控制系统之间的通信协议变得尤为关键。本文将聚焦于多摩川、BISS和Endat等主流协议，以ArtInChipM6800系列芯片为例，分析它们如何满足不同工业场景的需求，以及如何推动自动化技术的进步。01-多摩川协议多摩川协议是基于485硬件接口的标准NRZ协议，其通讯波特率常见2.5MHz和5MHz，
    
                    
    • 
                    
  • 百行代码复现扩散模型-基于线性回归
                        李新然
数据统计分析深度学习线性回归算法回归python数据分析
                        
    文章目录引言简化模型原本模型模型改造实现过程数据集文本编码图像编码解码扩散过程训练过程生成过程完整实现结论引言多模态的深度学习模型，通常需要大量的算力去训练和验证。这导致缺乏算力的普通读者，阅读“大模型”论文，只能按论文作者所写来构造自己的认知。可能对很多类似笔者的人来说：纸上得来终觉浅。或许我们可以退而求其次，只选择Follow论文的思路。本文以DiffusionModel为例，说明从核心思想来
    
                    
    • 
                    
  • 2021年行业重点趋势关键词
                        德业生涯规划爽爽

                        
    2021年各行业重点关键词为您把握趋势提供解码线索。德业生涯规划师-爽爽汽车关键词：回暖复苏变革升级、格局重塑趋势一：乘用车销量呈U型反弹，供需提振推动销量复苏趋势二：新能源政策需求双向利好，产业链多元创新发展趋势三：重卡格局纷繁复杂，商用车价值双向延伸趋势四：汽车金融竞争加剧,玩家加速业务与模式重塑趋势五：二手车精准化残值评估与数字化资产管理体系逐步成型趋势六：移动出行行业洗牌，后疫情创新升级探
    
                    
    • 
                    
  • 深度长文解析SpringWebFlux响应式框架15个核心组件源码
                        快乐非自愿
javaspring
                        
    SpringWebFlux介绍SpringWebFlux是SpringFramework5.0版本引入的一个响应式Web框架，它与SpringMVC并存，提供了一种全新的编程范式，支持异步非阻塞的Web应用开发。WebFlux完全基于响应式编程模型，支持ReactiveStreams规范，可以在诸如Netty、Undertow以及Servlet3.1+容器上运行。WebFlux的核心控制器是Dis
    
                    
    • 
                    
  • Java网络编程：IO，NIO与Netty
                        坚持是一种态度
javajava网络编程NettyJavaIONIONIO与Netty
                        
    Java网络编程：IO，NIO与NettyJava网络编程：IO，NIO与NettyJavaI/O相关概念同步与异步阻塞与非阻塞OIONIOAIOreactor模型proactor模型JavaIO应用场景Netty简介NIO与Netty生产使用Java网络编程：IO，NIO与Netty新公司新项目，项目需要在硬件和软件平台进行信息传递，具体来说使用Netty。硬件和软件使用socket连接，硬件作
    
                    
    • 
                    
  • 字符串的编码和解码
                        zhupanos
rubyonrailstherubyway
                        
    rot13编码和解码classStringdefrot13self.tr("A-Ma-mN-Zn-z","N-Zn-zA-Ma-m")endendtest="test"test=test.rot13#"grfg"test=test.rot13#"test"base64字符串的编码和解码str="test"new_string=[str].pack("m")#"dGVzdA==\n"original
    
                    
    • 
                    
  • 【算法】leetcode394. 字符串解码（辅助栈法）
                        岚清子
leetcodepythonleetcodepython字符串辅助栈
                        
    问题来源leetcode394.字符串解码394.字符串解码给定一个经过编码的字符串，返回它解码后的字符串。编码规则为:k[encoded_string]，表示其中方括号内部的encoded_string正好重复k次。注意k保证为正整数。你可以认为输入字符串总是有效的；输入字符串中没有额外的空格，且输入的方括号总是符合格式要求的。此外，你可以认为原始数据不包含数字，所有的数字只表示重复的次数k，例
    
                    
    • 
                    
  • python怎么解码成字符串_python字符串怎么解码？
                        weixin_39619478
python怎么解码成字符串
                        
    python字符串解码的方法：python中可以使用decode()方法对字符串进行解码。python中可以使用encode()方法将字符串转换为bytes类型，此过程称为“编码”。decode()方法用于将bytes类型的二进制数据转换为str类型，这个过程也称为“解码”。decode()方法的语法格式如下：bytes.decode([encoding="utf-8"][,errors="str
    
                    
    • 
                    
  • java reactor模式例子_Netty Reactor模式实现原理详解
                        weixin_39923623
javareactor模式例子
                        
    在前面的文章中(Reactor模型详解)，我们讲解了Reactor模式的各种演变形式，本文主要讲解的则是Netty是如何实现Reactor模式的。这里关于Netty实现的Reactor模式，需要说明的是，其实现的模式如下图所示：对于Netty使用的Reactor模式，其主要特点如下：使用一个线程作为mainReactor，专门用于监听客户端的连接事件，当获取到事件之后就将该事件交由Acceptor
    
                    
    • 
                    
  • 8B10B编解码及FPGA实现
                        weixin_34309435

                        
    概述在使用ALTERA的高速串行接口时，GXB模块里硬件实现了8B10B编码，用户只是“傻瓜”式的使用，笔者也一直没有弄清楚。网上搜索了一些学习资料，结合参考文献希望能够对其进行消化。另外，ALTERA现在已经提供8B10BIP，用户可以直接使用，不过有时候为了代码可移植性需要自己写代码实现8B10B编解码，笔者希望在这方面也做些实践。8B10B编码概念基本概念网上可以轻易找到答案，简单的说就是将
    
                    
    • 
                    
  • Netty实战二-实现UDP的单播和广播(1)
                        2401_84048671
程序员udp网络协议网络
                        
    publicclassAnswerHandlerextendsSimpleChannelInboundHandler{/应答的具体内容从常量字符串数组中取得，由nextQuote方法随机获取/privatestaticfinalString[]DICTIONARY={“一个男生暗恋一个女生很久了。一天自习课上，男生偷偷的传了小纸条给女生，上面写着“其实我注意你很久了”。不一会儿，女生传了另一张纸条
    
                    
    • 
                    
  • 音视频编解码技术（二）：AAC 音频编码技术
                        音视频开发老马
音视频开发流媒体服务器Android音视频开发视频编解码音视频网络协议实时音视频网络
                        
    一、AAC编码概述AAC是高级音频编码（AdvancedAudioCoding）的缩写，出现于1997年，最初是基于MPEG-2的音频编码技术，目的是取代MP3格式。2000年，MPEG-4标准出台，AAC重新集成了其它技术包括SBR或PS特性，目前AAC可以定义为⼀种由MPEG-4标准定义的有损音频压缩格式二、AAC编码规格简述AAC共有9种规格，以适应不同的场合的需要：MPEG-2AACLC低
    
                    
    • 
                    
  • 音视频入门基础：WAV专题（5）——FFmpeg源码中解码WAV Header的实现
                        cuijiecheng2018
FFmpeg源码分析音视频技术音视频ffmpeg
                        
    =================================================================音视频入门基础：WAV专题系列文章：音视频入门基础：WAV专题（1）——使用FFmpeg命令生成WAV音频文件音视频入门基础：WAV专题（2）——WAV格式简介音视频入门基础：WAV专题（3）——FFmpeg源码中，判断某文件是否为WAV音频文件的实现音视频入门基础：W
    
                    
    • 
                    
  • netty源码解读三（NioEventLoop）
                        orcharddd_real
nettyjavanetty
                        
    NioEventLoop初始化EventExecutor类型的数组数组大小默认为cpu数量的两倍，遍历数组，通过newNioEventLoop(xxx)往数组中添加元素，NioEventLoop继承了EventExecutor；每次需要线程时，执行chooser的next方法从数组中取出一个线程；关键代码打开netty源码，找到example包下的EchoService类，追溯创建boss线程组和
    
                    
    • 
                    
  • Netty源码分析:NioEventLoopGroup
                        HelloWorld_EE
netty源码分析源代码nettyEventLoop
                        
    Netty源码分析:NioEventLoopGroup在工作之余，看到自己公司的超哥（俞超）关于Netty的系列博文，讲解的很好，因此，自己在学习之余也跟了下源代码，来了解Netty，也做了相关的笔记，将形成系列博文，这是第一篇。超哥的博文地址在这里：http://www.jianshu.com/p/c5068caab217Netty版本：4.0.23.Final借用超哥的例子，一般服务端的代码如
    
                    
    • 
                    
  • Spring Cloud OpenFeign 自定义结果解码器
                        飞空之羽
springcloud由浅入深spring
                        
    我们在定义微服务接口的时候，通常会使用一个Result类进行封装，将提示信息，返回对象和状态码等内容封装到一起返回给调用方，例如如下的格式：publicclassResult{/***响应码，200为成功*/privateIntegercode;/***失败时的具体失败信息*/privateStringmessage;/***失败信息是否为用户提示，如果是的话框架不会主动拦截该错误*/privat
    
                    
    • 
                    
  • 视频的容器格式和编码格式详解
                        半桶水专家
音视频音视频
                        
    视频的容器格式和编码格式是视频文件的两个核心概念，它们相互关联但具有不同的功能。以下是详细的解释：1.容器格式(ContainerFormat)容器格式，又称封装格式，指的是视频文件的外壳或容器，它用于封装视频、音频、字幕、元数据（如标题、章节信息等）等各种流媒体内容。容器格式本质上决定了文件的扩展名。常见的容器格式：MP4：支持多种编解码器，广泛用于互联网和移动设备。MKV：支持多轨音频、字幕，
    
                    
    • 
                                
  • java Illegal overloaded getter method with ambiguous type for propert的解决
                                    zwllxs
javajdk
                                    
    好久不来iteye,今天又来看看，哈哈,今天碰到在编码时，反射中会抛出 
 Illegal overloaded getter method with ambiguous type for propert这么个东东，从字面意思看，是反射在获取getter时迷惑了，然后回想起java在boolean值在生成getter时，分别有is和getter，也许我们的反射对象中就有is开头的方法迷惑了jdk，
    
                                
    • 
                                
  • IT人应当知道的10个行业小内幕
                                    beijingjava
工作互联网
                                    
    10. 虽然IT业的薪酬比其他很多行业要好，但有公司因此视你为其“佣人”。 
　　尽管IT人士的薪水没有互联网泡沫之前要好，但和其他行业人士比较，IT人的薪资还算好点。在接下的几十年中，科技在商业和社会发展中所占分量会一直增加，所以我们完全有理由相信，IT专业人才的需求量也不会减少。 
　　然而，正因为IT人士的薪水普遍较高，所以有些公司认为给了你这么多钱，就把你看成是公司的“佣人”，拥有你的支配
    
                                
    • 
                                
  • java 实现自定义链表
                                    CrazyMizzz
java数据结构
                                    
    1.链表结构 
 
  链表是链式的结构 
 
 
2.链表的组成 
 
   链表是由头节点，中间节点和尾节点组成 
 
   节点是由两个部分组成： 
 
      1.数据域 
      2.引用域 
 
 
3.链表的实现 
 
&nbs
    
                                
    • 
                                
  • web项目发布到服务器后图片过一会儿消失
                                    麦田的设计者
struts2上传图片永久保存
                                    
      作为一名学习了android和j2ee的程序员，我们必须要意识到，客服端和服务器端的交互是很有必要的，比如你用eclipse写了一个web工程，并且发布到了服务器（tomcat）上，这时你在webapps目录下看到了你发布的web工程，你可以打开电脑的浏览器输入http://localhost:8080/工程/路径访问里面的资源。但是，有时你会突然的发现之前用struts2上传的图片
    
                                
    • 
                                
  • CodeIgniter框架Cart类 name 不能设置中文的解决方法
                                    IT独行者
CodeIgniterCart框架　
                                    
    今天试用了一下CodeIgniter的Cart类时遇到了个小问题，发现当name的值为中文时，就写入不了session。在这里特别提醒一下。 在CI手册里也有说明，如下： 
$data = array(
               'id'      => 'sku_123ABC',
               'qty'     => 1,
               '
    
                                
    • 
                                
  • linux回收站
                                    _wy_
linux回收站
                                    
    今天一不小心在ubuntu下把一个文件移动到了回收站，我并不想删，手误了。我急忙到Nautilus下的回收站中准备恢复它，但是里面居然什么都没有。      后来我发现这是由于我删文件的地方不在HOME所在的分区，而是在另一个独立的Linux分区下，这是我专门用于开发的分区。而我删除的东东在分区根目录下的.Trash-1000/file目录下，相关的删除信息（删除时间和文件所在
    
                                
    • 
                                
  • jquery回到页面顶端
                                    知了ing
htmljquerycss
                                    
    html代码： 
 
<h1 id="anchor">页面标题</h1>
<div id="container">页面内容</div>
<p><a href="#anchor" class="topLink">回到顶端</a><
    
                                
    • 
                                
  • B树、B-树、B+树、B*树
                                    矮蛋蛋
B树
                                    
    原文地址： 
http://www.cnblogs.com/oldhorse/archive/2009/11/16/1604009.html 
B树 
 
       即二叉搜索树： 
 
       1.所有非叶子结点至多拥有两个儿子（Left和Right）； 
 
&nb
    
                                
    • 
                                
  • 数据库连接池
                                    alafqq
数据库连接池
                                    
    http://www.cnblogs.com/xdp-gacl/p/4002804.html 
 
@Anthor:孤傲苍狼 
 
数据库连接池 
 
用MySQLv5版本的数据库驱动没有问题，使用MySQLv6和Oracle的数据库驱动时候报如下错误： 
java.lang.ClassCastException: $Proxy0 cannot be cast to java.sql.Connec
    
                                
    • 
                                
  • java泛型
                                    百合不是茶
java泛型
                                    
    泛型 
在Java SE 1.5之前，没有泛型的情况的下，通过对类型Object的引用来实现参数的“任意化”，任意化的缺点就是要实行强制转换，这种强制转换可能会带来不安全的隐患 
  
泛型的特点：消除强制转换 确保类型安全 向后兼容 
  
简单泛型的定义： 
     泛型：就是在类中将其模糊化，在创建对象的时候再具体定义 
class fan
    
                                
    • 
                                
  • javascript闭包[两个小测试例子]
                                    bijian1013
JavaScriptJavaScript
                                    
    一.程序一 
<script>
var name = "The Window";
var Object_a = {
　　name : "My Object",
　　getNameFunc : function(){
               var that = this;
　　　　return function(){
　　　　
    
                                
    • 
                                
  • 探索JUnit4扩展：假设机制（Assumption）
                                    bijian1013
javaAssumptionJUnit单元测试
                                    
    一.假设机制（Assumption）概述        理想情况下，写测试用例的开发人员可以明确的知道所有导致他们所写的测试用例不通过的地方，但是有的时候，这些导致测试用例不通过的地方并不是很容易的被发现，可能隐藏得很深，从而导致开发人员在写测试用例时很难预测到这些因素，而且往往这些因素并不是开发人员当初设计测试用例时真正目的，
    
                                
    • 
                                
  • 【Gson四】范型POJO的反序列化
                                    bit1129
POJO
                                    
    在下面这个例子中，POJO(Data类)是一个范型类，在Tests中，指定范型类为PieceData，POJO初始化完成后，通过 
String str = new Gson().toJson(data); 
得到范型化的POJO序列化得到的JSON串，然后将这个JSON串反序列化为POJO 
  
import com.google.gson.Gson;

import java.
    
                                
    • 
                                
  • 【Spark八十五】Spark Streaming分析结果落地到MySQL
                                    bit1129
Stream
                                    
    几点总结： 
1. DStream.foreachRDD是一个Output Operation，类似于RDD的action，会触发Job的提交。DStream.foreachRDD是数据落地很常用的方法 
2. 获取MySQL Connection的操作应该放在foreachRDD的参数（是一个RDD[T]=>Unit的函数类型)，这样，当foreachRDD方法在每个Worker上执行时，
    
                                
    • 
                                
  • NGINX + LUA实现复杂的控制
                                    ronin47
nginx lua
                                    
    安装lua_nginx_module 模块 
lua_nginx_module 可以一步步的安装，也可以直接用淘宝的OpenResty 
Centos和debian的安装就简单了。。 
这里说下freebsd的安装： 
fetch http://www.lua.org/ftp/lua-5.1.4.tar.gz
tar zxvf lua-5.1.4.tar.gz
cd lua-5.1.4
ma
    
                                
    • 
                                
  • java-递归判断数组是否升序
                                    bylijinnan
java
                                    
    

public class IsAccendListRecursive {

	/*递归判断数组是否升序
	 * if a Integer array is ascending,return true
	 * use recursion
	 */
	
	public static void main(String[] args){
		IsAccendListRecursiv
    
                                
    • 
                                
  • Netty源码学习-DefaultChannelPipeline2
                                    bylijinnan
javanetty
                                    
    Netty3的API 
 
http://docs.jboss.org/netty/3.2/api/org/jboss/netty/channel/ChannelPipeline.html 
里面提到ChannelPipeline的一个“pitfall”： 
如果ChannelPipeline只有一个handler（假设为handlerA）且希望用另一handler（假设为handlerB） 
来
    
                                
    • 
                                
  • Java工具之JPS
                                    chinrui
java
                                    
    JPS使用 
  
  
熟悉Linux的朋友们都知道，Linux下有一个常用的命令叫做ps（Process Status)，是用来查看Linux环境下进程信息的。同样的，在Java Virtual Machine里面也提供了类似的工具供广大Java开发人员使用，它就是jps（Java Process Status)，它可以用来
    
                                
    • 
                                
  • window.print分页打印
                                    ctrain
window
                                    
    
function init() {
    var tt = document.getElementById("tt");
    var childNodes = tt.childNodes[0].childNodes;
    var level = 0;
    for (var i = 0; i < childNodes.length; i++) {

    
                                
    • 
                                
  • 安装hadoop时 执行jps命令Error occurred during initialization of VM
                                    daizj
jdkhadoopjps
                                    
    在安装hadoop时，执行JPS出现下面错误 
  
[slave16][email protected]:/tmp/hsperfdata_hdfs# jps 
Error occurred during initialization of VM 
java.lang.Error: Properties init: Could not determine current working
    
                                
    • 
                                
  • PHP开发大型项目的一点经验
                                    dcj3sjt126com
PHP重构
                                    
    一、变量 最好是把所有的变量存储在一个数组中，这样在程序的开发中可以带来很多的方便，特别是当程序很大的时候。变量的命名就当适合自己的习惯，不管是用拼音还是英语，至少应当有一定的意义，以便适合记忆。变量的命名尽量规范化，不要与PHP中的关键字相冲突。 二、函数 PHP自带了很多函数，这给我们程序的编写带来了很多的方便。当然，在大型程序中我们往往自己要定义许多个函数，几十
    
                                
    • 
                                
  • android笔记之--向网络发送GET/POST请求参数
                                    dcj3sjt126com
android
                                    
    使用GET方法发送请求 
private static boolean sendGETRequest (String path,

                     Map<String, String> params) throws Exception{

              //发送地http://192.168.100.91:8080/videoServi
    
                                
    • 
                                
  • linux复习笔记 之bash shell (3) 通配符
                                    eksliang
linux 通配符linux通配符
                                    
    转载请出自出处：
http://eksliang.iteye.com/blog/2104387  
在bash的操作环境中有一个非常有用的功能，那就是通配符。 
下面列出一些常用的通配符，如下表所示    符号 意义   * 万用字符，代表0个到无穷个任意字符   ? 万用字符，代表一定有一个任意字符   [] 代表一定有一个在中括号内的字符。例如：[abcd]代表一定有一个字符，可能是a、b、c
    
                                
    • 
                                
  • Android关于短信加密
                                    gqdy365
android
                                    
    关于Android短信加密功能，我初步了解的如下（只在Android应用层试验）： 
    1、因为Android有短信收发接口，可以调用接口完成短信收发； 
        发送过程：APP（基于短信应用修改）接受用户输入号码、内容——>APP对短信内容加密——>调用短信发送方法Sm
    
                                
    • 
                                
  • asp.net在网站根目录下创建文件夹
                                    hvt
.netC#hovertreeasp.netWeb Forms
                                    
    假设要在asp.net网站的根目录下建立文件夹hovertree,C#代码如下： 
string m_keleyiFolderName = Server.MapPath("/hovertree");

if (Directory.Exists(m_keleyiFolderName))
{
//文件夹已经存在
return;
}
else
{
try
{
D
    
                                
    • 
                                
  • 一个合格的程序员应该读过哪些书
                                    justjavac
程序员书籍
                                    
    编者按：2008年8月4日，StackOverflow 网友 Bert F 发帖提问：哪本最具影响力的书，是每个程序员都应该读的？ 
 
 “如果能时光倒流，回到过去，作为一个开发人员，你可以告诉自己在职业生涯初期应该读一本， 你会选择哪本书呢？我希望这个书单列表内容丰富，可以涵盖很多东西。” 
 
很多程序员响应，他们在推荐时也写下自己的评语。 以前就有国内网友介绍这个程序员书单，不过都是推荐数
    
                                
    • 
                                
  • 单实例实践
                                    跑龙套_az
单例
                                    
      
 1、内部类 
public class Singleton {
      private static class SingletonHolder {
             public static Singleton singleton = new Singleton();
      } 
       public Singleton getRes
    
                                
    • 
                                
  • PO VO BEAN 理解
                                    q137681467
VODTOpo
                                    
    PO： 
     全称是 persistant object持久对象 最形象的理解就是一个PO就是数据库中的一条记录。 好处是可以把一条记录作为一个对象处理，可以方便的转为其它对象。 
  
  
BO： 
    全称是 business object:业务对象 主要作用是把业务逻辑封装为一个对象。这个对
    
                                
    • 
                                
  • 战胜惰性，暗自努力
                                    金笛子
努力
                                    
    偶然看到一句很贴近生活的话：“别人都在你看不到的地方暗自努力，在你看得到的地方，他们也和你一样显得吊儿郎当，和你一样会抱怨，而只有你自己相信这些都是真的，最后也只有你一人继续不思进取。”很多句子总在不经意中就会戳中一部分人的软肋，我想我们每个人的周围总是有那么些表现得“吊儿郎当”的存在，是否你就真的相信他们如此不思进取，而开始放松了对自己的要求随波逐流呢？ 
我有个朋友是搞技术的，平时嘻嘻哈哈，以
    
                                
    • 
                                
  • NDK/JNI二维数组多维数组传递
                                    wenzongliang
二维数组jniNDK
                                    
    多维数组和对象数组一样处理，例如二维数组里的每个元素还是一个数组 用jArray表示，直到数组变为一维的，且里面元素为基本类型，去获得一维数组指针。给大家提供个例子。已经测试通过。 
Java_cn_wzl_FiveChessView_checkWin( JNIEnv* env,jobject thiz,jobjectArray qizidata)

{
jint i,j;

int s
    
                                
    •