Netty 解决粘包半包 解码器ByteToMessageDecoder

本文主要分析 ByteToMessageDecoder，它是用来解决粘包半包处理主要处理类。

ByteToMessageDecoder

什么是粘包半包？
tcp是基于报文的协议，当使用netty传输数据时，可能一次读数据不是一个完整的数据，可能读取的是一半或者多余具体应用层数据的数据。

如何解决这样的问题呢？
可以用一个全局缓存池，每次解码器进行解码时，只能解码一个完整数据，不够或者多余则放到下次解码。
ByteToMessageDecoder 就是这样解决这样的问题的。

解码器原理

在netty读取数据时，会尝试一次性最多进行16次IO读取，每次读取都会调用 pipeline.fireChannelRead(byteBuf) 方法：
AbstractNioByteChannel$NioByteUnsafe的read 方法：

                do {
                    byteBuf = allocHandle.allocate(allocator);
                    allocHandle.lastBytesRead(doReadBytes(byteBuf));
                    if (allocHandle.lastBytesRead() <= 0) {
                        // nothing was read. release the buffer.
                        byteBuf.release();
                        byteBuf = null;
                        close = allocHandle.lastBytesRead() < 0;
                        if (close) {
                            // There is nothing left to read as we received an EOF.
                            readPending = false;
                        }
                        break;
                    }

                    allocHandle.incMessagesRead(1);
                    readPending = false;
                    pipeline.fireChannelRead(byteBuf);
                    byteBuf = null;
                } while (allocHandle.continueReading());

这样，经过pipeline传递，如果有配置 ByteToMessageDecoder 的子类作为handler处理器，则会进入到ByteToMessageDecoder 的 channelRead：方法：

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        if (msg instanceof ByteBuf) {
            CodecOutputList out = CodecOutputList.newInstance();
            try {
                first = cumulation == null;
                cumulation = cumulator.cumulate(ctx.alloc(),
                        first ? Unpooled.EMPTY_BUFFER : cumulation, (ByteBuf) msg);
                callDecode(ctx, cumulation, out);
            } 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();
                firedChannelRead |= out.insertSinceRecycled();
                fireChannelRead(ctx, out, size);
                out.recycle();
            }
        } else {
            ctx.fireChannelRead(msg);
        }
    }

1. 只有msg 类型为ByteBuf，才会进行处理。
2. 构造一个 CodecOutputList，CodecOutputList是一个Netty自定义的 List，继承自 AbstractList，每次解码后，如果满足要求，会将解码后数据放入CodecOutputList 中。。
3. Cumulator是其内部定义的字节合并容器，对于字节数据合并，有两种实现，一种是使用字节拷贝方式，将一个里面所有数据，拷贝到另一个ByteBuf中，另一种是通过CompositeByteBuf 这种特殊的ByteBuf进行逻辑上的合并。

                cumulation = cumulator.cumulate(ctx.alloc(),
                        first ? Unpooled.EMPTY_BUFFER : cumulation, (ByteBuf) msg);

当 是第一次解析，则使用空ByteBuf和msg进行合并，否则就使用上一次没有用完的cumulation进行合并。
4. 调用 callDecode 对cumulation进行解码。
5. 接完码后，会在finally块中，调用fireChannelRead 进行数据传递。

callDecode方法

ByteToMessageDecoder 的 callDecode 方法：

    protected void callDecode(ChannelHandlerContext ctx, ByteBuf in, List