死磕Netty源码之Netty编解码源码解析

前言

Netty的底层是基于TCP实现的，TCP协议在传输数据的过程中一个完整的业务可能会被TCP拆分成多个包进行发送，也有可能把多个小的包封装成一个大的数据包发送，因此我们需要考虑Netty的粘包拆包问题

消息解码器

Netty提供了拆包的基类ByteToMessageDecoder，如果我们为引用程序添加了解码器每次从TCP缓冲区读到数据都会调用到ByteToMessageDecoder的channelRead方法，它是Netty解码的入口

public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
    if (msg instanceof ByteBuf) {
        CodecOutputList out = CodecOutputList.newInstance();
        try {
            ByteBuf data = (ByteBuf) msg;
            first = cumulation == null;
            if (first) {
                cumulation = data;
            } else {
                cumulation = cumulator.cumulate(ctx.alloc(), cumulation, data);
            }
            callDecode(ctx, cumulation, out);
        } 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) {
                numReads = 0;
                discardSomeReadBytes();
            }

            int size = out.size();
            decodeWasNull = !out.insertSinceRecycled();
            fireChannelRead(ctx, out, size);
            out.recycle();
        }
    } else {
        ctx.fireChannelRead(msg);
    }
}

从上诉代码可以看出Netty拆包的过程主要分为一下四个流程

1.累加数据
2.将累加到的数据传递给业务进行业务拆包
3.清理字节容器
4.传递业务数据包给业务解码器处理

累加数据

ByteBuf data = (ByteBuf) msg;
first = cumulation == null;
if (first) {
    cumulation = data;
} else {
    cumulation = cumulator.cumulate(ctx.alloc(), cumulation, data);
}

累加数据是通过如上代码实现的，主要功能就是将读取到的数据塞到ButeBuf中去。上面涉及到一个累加器cumulator(实现的功能就是往ByteBuf追加数据)，在该类中定义了如下两个累加器(默认情况下会使用MERGE_CUMULATOR)

public static final Cumulator MERGE_CUMULATOR
public static final Cumulator COMPOSITE_CUMULATOR

下面我们看一下MERGE_CUMULATOR是如何将新读取到的数据累加到字节容器里的

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());
        } else {
            buffer = cumulation;
        }
        buffer.writeBytes(in);
        in.release();
        return buffer;
    }
};

Netty中ByteBuf的抽象使得累加非常简单，通过一个简单的API调用buffer.writeBytes(in)便将新数据累加到字节容器中，为了防止字节容器大小不够在累加之前还进行了扩容处理，扩容也是一个内存拷贝操作新增的大小即是新读取数据的大小

static ByteBuf expandCumulation(ByteBufAllocator alloc, ByteBuf cumulation, int readable) {
        ByteBuf oldCumulation = cumulation;
        cumulation = alloc.buffer(oldCumulation.readableBytes() + readable);
        cumulation.writeBytes(oldCumulation);
        oldCumulation.release();
        return cumulation;
}

将累加到的数据传递给业务进行拆包

到这一步字节容器里的数据已是目前未拆包部分的所有的数据了

CodecOutputList out = CodecOutputList.newInstance();
callDecode(ctx, cumulation, out);

callDecode将尝试将字节容器的数据拆分成业务数据包塞到业务数据容器out中

protected void callDecode(ChannelHandlerContext ctx, ByteBuf in, List