Netty编解码器

概述

网络中数据是以二进制字节流进行传输，编码器的作用是将数据编码为二进制字节流，而解码器的作用是将二进制字节流解码为程序能处理的数据格式，本章节将对Netty编解码器实现原理进行分析。

编码器

Netty编码器有两个抽象基类：MessageToByteEncoder与MessageToMessageEncoder，MessageToByteEncoder会将消息编码为字节，MessageToMessageEncode会将消息编码为另一种消息。通过继承这两个基类可以实现自定义编码器，如Netty内置的编码器：StringEncoder、ObjectEncoder、ProtobufEncoder等。

从类图可以看出MessageToByteEncoder与MessageToMessageEncoder均实现了ChannelOutboundHandler接口，也就是说编码器是一个出站事件处理器，其会处理并传播出站事件。以MessageToByteEncoder为例，分析下其实现原理：

public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception {
    ByteBuf buf = null;
    try {
        // 判断编码器是否能处理该消息
        if (acceptOutboundMessage(msg)) {
            @SuppressWarnings("unchecked")
            // 将Object消息类型转换为实际类型
            I cast = (I) msg;
            // 分配内存
            buf = allocateBuffer(ctx, cast, preferDirect);
            try {
                // 调用子类方法进行编码
                encode(ctx, cast, buf);
            } finally {
                // 如果消息是ByteBuf类型则释放内存
                ReferenceCountUtil.release(cast);
            }

            if (buf.isReadable()) {
                // 传播写事件
                ctx.write(buf, promise);
            } else {
                buf.release();
                ctx.write(Unpooled.EMPTY_BUFFER, promise);
            }
            buf = null;
        } else {
            ctx.write(msg, promise);
        }
    } catch (EncoderException e) {
        throw e;
    } catch (Throwable e) {
        throw new EncoderException(e);
    } finally {
        if (buf != null) {
            buf.release();
        }
    }
}

write方法首先会调用acceptOutboundMessage方法判断是否能处理传入的消息，如果不能处理则将该事件向下传播。acceptOutboundMessage通过TypeParameterMatcher#match方法来进行判断。其中TypeParameterMatcher是在实例化编码器时初始化的，具体判断方法在其内部类ReflectiveMatcher中，其中type为编码器中的泛型：

private static final class ReflectiveMatcher extends TypeParameterMatcher {
    private final Class type;

    ReflectiveMatcher(Class type) {
        this.type = type;
    }

    @Override
    public boolean match(Object msg) {
        return type.isInstance(msg);
    }
}

编码器的核心方法为encode，该方法会将消息编码为ByteBuf。基类MessageToMessageEncode中的encode方法为抽象方法，这里使用了模版方法设计模式，需要由子类实现具体的编码逻辑：

protected abstract void encode(ChannelHandlerContext ctx, I msg, ByteBuf out) throws Exception;

以ObjectEncoder为例，看下ObjectEncoder这个编码器是怎么编码的：

protected void encode(ChannelHandlerContext ctx, Serializable msg, ByteBuf out) throws Exception {
  // 获取ByteBuf对象写指针索引位置  
  int startIdx = out.writerIndex();

    // 创建输出流
    ByteBufOutputStream bout = new ByteBufOutputStream(out);
    // 写入4个字节进行占位
    bout.write(LENGTH_PLACEHOLDER);
    ObjectOutputStream oout = new CompactObjectOutputStream(bout);
    // 将消息写入到输出流
    oout.writeObject(msg);
    oout.flush();
    oout.close();

    int endIdx = out.writerIndex();
        // 在输入流开始位置写入int类型的消息长度，即前四个字节
    out.setInt(startIdx, endIdx - startIdx - 4);
}

解码器

Netty解码器同样有两个抽象基类：MessageToByteDecoder与MessageToMessageDecoder，MessageToByteDecoder会将字节解码为消息，MessageToMessageDecoder会将消息解码为另一种消息。以MessageToByteDecoder为例，看下具体实现：

public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
    if (msg instanceof ByteBuf) {
        // 获取CodecOutputList，用于存放解码后的消息
        CodecOutputList out = CodecOutputList.newInstance();
        try {
            ByteBuf data = (ByteBuf) msg;
            first = cumulation == null;
            if (first) {
                // 第一次解码将数据赋值给cumulation
                cumulation = data;
            } else {
                // 不是第一次解码则将数据进行累加到cumulation
                cumulation = cumulator.cumulate(ctx.alloc(), cumulation, data);
            }
            // 解码
            callDecode(ctx, cumulation, out);
        } catch (DecoderException e) {
            throw e;
        } catch (Throwable t) {
            throw new DecoderException(t);
        } finally {
            // 如果cumulation不可读则，则释放cumulation
            if (cumulation != null && !cumulation.isReadable()) {
                numReads = 0;
                cumulation.release();
                cumulation = null;
            } else if (++ numReads >= discardAfterReads) {
                // 如果读次数超过16，则尝试丢弃一些字节
                // 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 {
        ctx.fireChannelRead(msg);
    }
}

CodecOutputList是一个可复用的List，内部维护了一个长度为16的对象数组，用来缓存解码后的消息。CodecOutputList#newInstance方法首先会从对象池中获取，如果获取不到会进行创建。

读取到消息后，首先会将其放入到cumulation这个ByteBuf中，然后尝试解码，每次解码成功就会传播channelRead事件，将消息向下传播。如果消息不能解码，比如出现半包，或者出现粘包（一些字节不足以解码为一条消息），则会被累加到cumulation中等待下次接收到消息后处理。

解码的核心逻辑在callDecode中，该方法会将cumulation中累加的消息进行解码：

protected void callDecode(ChannelHandlerContext ctx, ByteBuf in, List