Netty源码八 Netty解码

1. 概述

所谓解码就是将一串二进制数据流解析成一个个自定义协议的数据包，也就是ByteBuf。后续业务就可以直接基于ByteBuf进行处理。

两个问题

• 解码器抽象的解码过程
• netty里面有哪些拆箱即用的解码器

主要内容

• 解码器基类
• netty中常见的解码器

2. 抽象解码器ByteToMessageDecoder

ByteToMessageDecoder解码步骤

• 累加字节流
• 调用子类的decode方法进行解析
• 将解析到的ByteBuf向下传播

具体分析

1. 累加字节流
   ByteToMessageDecoder是基于ByteBuf进行解码的，ByteToMessageDecoder的channelRead方法：

    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        if (msg instanceof ByteBuf) { // 先判断是不是ByteBuf，如果是ByteBuf进行解码器的处理
            CodecOutputList out = CodecOutputList.newInstance(); // 存放解析完之后的对象
            try {
                ByteBuf data = (ByteBuf) msg;
                first = cumulation == null; // 如果cumulation == null 说明累加器中没数据
                if (first) {
                    cumulation = data; // 累加器为null， 将ByteBuf对象赋值给累加器
                } else { // 将累加器中的数据和读进来的数据累加，然后赋值给累加器
                    cumulation = cumulator.cumulate(ctx.alloc(), cumulation, data);
                }
                callDecode(ctx, cumulation, out); // 调用子类decode方法进行解析
            } catch (DecoderException e) {
                throw e;
            } catch (Exception e) {
                throw new DecoderException(e);
            } 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);
                out.recycle();
            }
        } else {// 如果不是ByteBuf类型，直接将其向下传播
            ctx.fireChannelRead(msg);
        }
    }

我们来看cumulator是什么：

    public static final Cumulator MERGE_CUMULATOR = new Cumulator() {
        @Override
        public ByteBuf cumulate(ByteBufAllocator alloc, ByteBuf cumulation, ByteBuf in) {
            try {
                final ByteBuf buffer;
                if (cumulation.writerIndex() > cumulation.maxCapacity() - in.readableBytes()
                    || cumulation.refCnt() > 1 || cumulation.isReadOnly()) {
                    // Expand cumulation (by replace it) when either there is not more room in the buffer
                    // or if the refCnt is greater then 1 which may happen when the user use slice().retain() or
                    // duplicate().retain() or if its read-only.
                    //
                    // See:
                    // - https://github.com/netty/netty/issues/2327
                    // - https://github.com/netty/netty/issues/1764
                    buffer = expandCumulation(alloc, cumulation, in.readableBytes());
                } else {
                    buffer = cumulation;
                }
                buffer.writeBytes(in); // 把当前数据写入累加器 
                return buffer;
            } finally {
                // We must release in in all cases as otherwise it may produce a leak if writeBytes(...) throw
                // for whatever release (for example because of OutOfMemoryError)
                in.release(); // 读进来的数据进行释放
            }
        }
    };

cumulation.writerIndex() > cumulation.maxCapacity() - in.readableBytes() 判断当前累加器是否有足够的空间，如果空间不够就进行扩容。

2. 调用子类decode
   接下来看 allDecode(ctx, cumulation, out); 方法:

    protected void callDecode(ChannelHandlerContext ctx, ByteBuf in, List