Netty源码—8.编解码原理一

大纲

1.读数据入口

2.拆包原理

3.ByteToMessageDecoder解码步骤

4.解码器抽象的解码过程总结

5.Netty里常见的开箱即用的解码器

6.writeAndFlush()方法的大体步骤

7.MessageToByteEncoder的编码步骤

8.unsafe.write()写队列

9.unsafe.flush()刷新写队列

10.如何把对象变成字节流写到unsafe底层

1.读数据入口

当客户端Channel的Reactor线程NioEventLoop检测到有读事件时，会执行NioByteUnsafe的read()方法。该方法会调用doReadBytes()方法将TCP缓冲区的数据读到由ByteBufAllocator分配的一个ByteBuf对象中，然后通过pipeline.fireChannelRead()方法带上这个ByteBuf对象向下传播ChannelRead事件。

在传播的过程中，首先会来到pipeline的head结点的channelRead()方法。该方法会继续带着那个ByteBuf对象向下传播ChannelRead事件，比如会来到ByteToMessageDecoder结点的channelRead()方法。

注意：服务端Channel的unsafe变量是一个NioMessageUnsafe对象，客户端Channel的unsafe变量是一个NioByteUnsafe对象。

//SingleThreadEventLoop implementation which register the Channel's to a Selector and so does the multi-plexing of these in the event loop.
public final class NioEventLoop extends SingleThreadEventLoop {
    Selector selector;
    private SelectedSelectionKeySet selectedKeys;
    private boolean needsToSelectAgain;
    private int cancelledKeys;
    ...
    @Override
    protected void run() {
        for (;;) {
            ...
            //1.调用select()方法执行一次事件轮询
            select(wakenUp.getAndSet(false));
            if (wakenUp.get()) {
                selector.wakeup();
            }
            ...
            //2.处理产生IO事件的Channel
            needsToSelectAgain = false;
            processSelectedKeys();
            ...
            //3.执行外部线程放入TaskQueue的任务
            runAllTasks(ioTime * (100 - ioRatio) / ioRatio);
        }
    }
    
    private void processSelectedKeys() {
        if (selectedKeys != null) {
            //selectedKeys.flip()会返回一个数组
            processSelectedKeysOptimized(selectedKeys.flip());
        } else {
            processSelectedKeysPlain(selector.selectedKeys());
        }
    }
    
    private void processSelectedKeysOptimized(SelectionKey[] selectedKeys) {
        for (int i = 0;; i ++) {
            //1.首先取出IO事件
            final SelectionKey k = selectedKeys[i];
            if (k == null) {
                break;
            }
            selectedKeys[i] = null;//Help GC
            //2.然后获取对应的Channel和处理该Channel
            //默认情况下，这个a就是NioChannel，也就是服务端启动时经过Netty封装的Channel
            final Object a = k.attachment();
            if (a instanceof AbstractNioChannel) {
                //网络事件的处理
                processSelectedKey(k, (AbstractNioChannel) a);
            } else {
                //NioTask主要用于当一个SelectableChannel注册到Selector时，执行的一些任务
                NioTask task = (NioTask) a;
                processSelectedKey(k, task);
            }
            //3.最后判断是否应该再进行一次轮询
            if (needsToSelectAgain) {
                for (;;) {
                    i++;
                    if (selectedKeys[i] == null) {
                        break;
                    }
                    selectedKeys[i] = null;
                }
                selectAgain();
                //selectedKeys.flip()会返回一个数组
                selectedKeys = this.selectedKeys.flip();
                i = -1;
            }
        }
    }
    
    private void processSelectedKey(SelectionKey k, AbstractNioChannel ch) {
        final AbstractNioChannel.NioUnsafe unsafe = ch.unsafe();
        ...
        try {
            int readyOps = k.readyOps();
            ...
            //新连接已准备接入或者已经存在的连接有数据可读
            if ((readyOps & (SelectionKey.OP_READ | SelectionKey.OP_ACCEPT)) != 0 || readyOps == 0) {
                //如果是新连接已准备接入，则调用NioMessageUnsafe的read()方法
                //如果是已经存在的连接有数据可读，执行的是NioByteUnsafe的read()方法
                unsafe.read();
                if (!ch.isOpen()) {
                    return;
                }
            }
        } catch (CancelledKeyException ignored) {
            unsafe.close(unsafe.voidPromise());
        }
    }
    ...
}

public abstract class AbstractNioByteChannel extends AbstractNioChannel {
    ...
    protected class NioByteUnsafe extends AbstractNioUnsafe {
        ...
        @Override
        public final void read() {
            final ChannelConfig config = config();
            final ChannelPipeline pipeline = pipeline();
            //创建ByteBuf分配器
            final ByteBufAllocator allocator = config.getAllocator();
            final RecvByteBufAllocator.Handle allocHandle = recvBufAllocHandle();
            allocHandle.reset(config);

            ByteBuf byteBuf = null;
            do {
                //1.分配一个ByteBuf
                byteBuf = allocHandle.allocate(allocator);
                //2.将数据读取到分配的ByteBuf中
                allocHandle.lastBytesRead(doReadBytes(byteBuf));
                if (allocHandle.lastBytesRead() <= 0) {
                    byteBuf.release();
                    byteBuf = null;
                    close = allocHandle.lastBytesRead() < 0;
                    break;
                }
                ...
                //3.调用DefaultChannelPipeline的fireChannelRead()方法从Head结点开始传播事件
                pipeline.fireChannelRead(byteBuf);
                byteBuf = null;
            } while (allocHandle.continueReading());

            allocHandle.readComplete();
            //4.调用DefaultChannelPipeline的fireChannelReadComplete()方法从Head结点开始传播事件
            pipeline.fireChannelReadComplete();
            ...
        }
    }
}

NioByteUnsafe主要会进行如下处理：

一.通过客户端Channel的ChannelConfig获取内存分配器ByteBufAllocator，然后用内存分配器来分配一个ByteBuf对象

二.将客户端Channel中的TCP缓冲区的数据读取到ByteBuf对象

三.读取完数据后便调用DefaultChannelPipeline的fireChannelReadComplete()方法，从HeadContext结点开始在整个ChannelPipeline中传播ChannelRead事件

2.拆包原理

一.不用Netty的拆包原理

不断地从TCP缓冲区中读取数据，每次读完都判断是否为一个完整的数据包。如果当前读取的数据不足以拼接成一个完整的数据包，就保留数据，继续从TCP缓冲区中读。如果当前读取的数据加上已读取的数据足够拼成完整的数据包，就将拼好的数据包往业务传递，而多余的数据则保留。

二.Netty的拆包原理

Netty拆包基类内部会有一个字节容器，每次读取到数据就添加到字节容器中。然后尝试对累加的字节数据进行拆包，拆成一个完整的业务数据包，这个拆包基类叫ByteToMessageDecoder。

3.ByteToMessageDecoder解码步骤

(1)解码的整体步骤

(2)首先累加字节流

(3)然后调用子类的decode()方法进行解析

(4)接着清理累加字节容器

(5)最后将解析到的ByteBuf向下传播

(1)解码的整体介绍

一.累加字节流

Netty会通过一个ByteBuf字节容器cumulation，把所有读取到的字节流累加到该字节容器。

二.调用子类的decode()方法进行解析

把累加字节容器里的字节流通过子类的decode()方法进行解析。

三.将解析到的ByteBuf向下传播

如果调用子类的decode()方法可以解析到一个ByteBuf对象，则将这个ByteBuf对象向下传播。

public abstract class ByteToMessageDecoder extends ChannelInboundHandlerAdapter {
    ...
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        //只基于ByteBuf对象进行解码
        if (msg instanceof ByteBuf) {
            //1.累加字节流
            //2.调用子类的decode()方法进行解析
            //3.清理累加字节容器
            //4.将解析到的ByteBuf向下传播
        } else {
            ctx.fireChannelRead(msg);
        }
    }
    ...
}

(2)首先累加字节流

如果当前字节容器中没有数据，那么就将字节容器的指针指向新读取的数据。如果当前字节容器中有数据，那么就调用累加器的cumulate()方法将数据累加到字节容器。

public abstract class ByteToMessageDecoder extends ChannelInboundHandlerAdapter {
    ByteBuf cumulation;//字节容器
    private Cumulator cumulator = MERGE_CUMULATOR;//默认的累加器
    private boolean decodeWasNull;
    private boolean first;
    private int discardAfterReads = 16;
    private int numReads;
    ...
    //Cumulate ByteBufs by merge them into one ByteBuf's, using memory copies.
    public static final Cumulator MERGE_CUMULATOR = new Cumulator() {
        //累加器的累加方法，会传入一个字节容器cumulation
        @Override
        public ByteBuf cumulate(ByteBufAllocator alloc, ByteBuf cumulation, ByteBuf in) {
            ByteBuf buffer;//一个大的字节容器，用来copy传入的字节容器
            if (cumulation.writerIndex() > cumulation.maxCapacity() - in.readableBytes() || cumulation.refCnt() > 1) {
                buffer = expandCumulation(alloc, cumulation, in.readableBytes());
            } else {
                buffer = cumulation;
            }
            buffer.writeBytes(in);//将当前数据累加到copy的字节容器中
            in.release();
            return buffer;//返回copy的字节容器
        }
    };

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        if (msg instanceof ByteBuf) {
            CodecOutputList out = CodecOutputList.newInstance();
            try {
                //1.累加字节流
                ByteBuf data = (ByteBuf) msg;
                first = cumulation == null;
                if (first) {//如果当前字节容器中没有数据
                    //就将字节容器的指针指向新读取的数据
                    cumulation = data;
                } else {//如果当前字节容器中有数据
                    //则调用累加器的cumulate()方法将数据累加到字节容器
                    cumulation = cumulator.cumulate(ctx.alloc(), cumulation, data);
                }
             
                //2.将字节容器里的数据传递给业务拆包器进行拆包
                //调用callDecode()方法对数据进行拆包
                callDecode(ctx, cumulation, out);
            } catch (DecoderException e) {
                throw e;
            } catch (Throwable t) {
                throw new DecoderException(t);
            } finally {
                //3.清理字节容器
                if (cumulation != null && !cumulation.isReadable()) {
                    numReads = 0;
                    cumulation.release();
                    cumulation = null;
                } else if (++ numReads >= discardAfterReads) {
                    numReads = 0;
                    discardSomeReadBytes();
                }
          
                //4.将解析到的ByteBuf向下传播
                int size = out.size();
                decodeWasNull = !out.insertSinceRecycled();
                fireChannelRead(ctx, out, size);
                out.recycle();
            }
        } else {
            ctx.fireChannelRead(msg);
        }
    }
    
    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;
    }
    ...
}

(3)然后调用子类的decode()方法进行解析

将数据累加到字节容器之后，就会调用callDecode()方法，这个方法会尝试将字节容器的数据拆分成业务数据包并将业务数据包放入业务数据容器out中。

Netty对各种用户协议的支持就体现在ByteToMessageDecoder的抽象方法decode()中，decode()方法的入参是当前读取到的未被处理的所有数据in和业务数据包容器out，所有拆包器都需要实现ByteToMessageDecoder的decoed()方法。

拆包器完成一次拆包后：如果没有拆到一个完整的数据包，此时若拆包器未读取任何数据则跳出循环，否则继续拆包。如果已经拆到一个完整的数据包，但此时拆包器未读取任何数据，则抛出一个异常DecodeException。

public abstract class ByteToMessageDecoder extends ChannelInboundHandlerAdapter {
    ...
    //Called once data should be decoded from the given ByteBuf. 
    //This method will call #decode(ChannelHandlerContext, ByteBuf, List) as long as decoding should take place.
    //@param ctx，the ChannelHandlerContext which this ByteToMessageDecoder belongs to
    //@param in，the ByteBuf from which to read data
    //@param out，the List to which decoded messages should be added
    protected void callDecode(ChannelHandlerContext ctx, ByteBuf in, List