netty粘包拆包之FixedLengthFrameDecoder解码器

​目录

          一、背景简介

          二、应用

          三、源码

---

一、背景简介

FixedLengthFrameDecoder 固定长度解码器，他能够按照我们指定的固定长度(frameLength)对接收到的消息进行解码，如果我们接收到的消息字节数等于frameLength，则认为是一次完整的消息传输，如果我们接收到的消息字节数小于frameLength，则服务端在decode()处理的时候会返回null，所以客户端在传输数据的时候如果消息字节数小于frameLength需要补全空白部分(达到frameLength长度)，否则会造成消息丢失(只是没有解析出来，其实还是在缓冲区中)，如果我们接收到的消息字节数大于frameLength，除了从接收到的消息字节数截取frameLength长度的数据外，其余数据会放到缓冲区，等到下次再次接收到消息进行判断是否达到一个完整的frameLength。

二、应用

下面是FixedLengthFrameDecoder 的一个简单应用，模拟发送不同长度的信息服务端使用FixedLengthFrameDecoder 解码出来的信息是什么样的。

服务端：

    public class FixedLengthFrameDecoderTestServer {
​
    public static void main(String[] args) throws Exception {
        EventLoopGroup bossGroup = new NioEventLoopGroup();
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        try {
            ServerBootstrap b = new ServerBootstrap();
            b.group(bossGroup, workerGroup)
                    .channel(NioServerSocketChannel.class)
                    .childHandler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        public void initChannel(SocketChannel ch) {
                            ch.pipeline()
                                    .addLast(new FixedLengthFrameDecoder(4))
                                    .addLast(new ChannelInboundHandlerAdapter() {
                                        @Override
                                        public void channelRead(ChannelHandlerContext ctx, Object msg) {
                                            if (msg instanceof ByteBuf) {
                                                ByteBuf packet = (ByteBuf) msg;
                                                System.out.println(packet.toString(Charset.defaultCharset()));
                                            }
                                        }
                                    });
                        }
                    });
            ChannelFuture f = b.bind(9000).sync();
            System.out.println("Started FixedLengthFrameDecoderTestServer...");
            f.channel().closeFuture().sync();
        } finally {
            workerGroup.shutdownGracefully();
            bossGroup.shutdownGracefully();
        }
    }
}

客户端：

public class FixedLengthFrameDecoderTestClient {
​
    public static void main(String[] args) throws Exception {
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        try {
            Bootstrap b = new Bootstrap();
            b.group(workerGroup)
                    .channel(NioSocketChannel.class)
                    .option(ChannelOption.SO_KEEPALIVE, true)
                    .handler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        public void initChannel(SocketChannel ch) throws Exception {
                            ch.pipeline()
                                    .addLast(new ChannelInboundHandlerAdapter() {
                                        public void channelActive(ChannelHandlerContext ctx) {
                                            ByteBuf byteBuf = Unpooled.buffer().writeBytes("ABCDEFGHI1234   ".getBytes());
                                            ctx.writeAndFlush(byteBuf);
                                        }
                                    });
                        }
                    });
            ChannelFuture f = b.connect("127.0.0.1", 9000).sync();
            System.out.println("Started FixedLengthFrameDecoderTestClient...");
            f.channel().closeFuture().sync();
        } finally {
            workerGroup.shutdownGracefully();
        }
    }
}

这里使用FixedLengthFrameDecoder设置的固定解码长度frameLength为4，首先客户端发送ABCDEFG测试服务端输出结果。

然后客户端发送ABCDEFG后补全空白后测试服务端输出结果。

此时，所有数据信息都能完整解码获取到。

三、源码

netty提供的各种解码器统一都继承了ByteToMessageDecoder，ByteToMessageDecoder负责读取字节流并转换成其他消息的功能，而ByteToMessageDecoder又继承了ChannelInboundHandlerAdapter，而ChannelInboundHandlerAdapter正是我们刚才在测试数据的时候在客户端重写了他的方法channelActive(),使管道生效并且数据写入缓冲区并发送。

在客户端代码流程原理并不复杂，我们主要看服务端是怎么解码、获取到数据的。

当客户端通过Channel发送数据的时候，服务端会在ByteToMessageDecoder的channelRead方法接收到。我们以channelRead方法为入口看服务端是怎么进行消息解码的。

在channelRead方法中首先会判断消息msg是不是ByteBuf类型的：

①、如果msg不是ByteBuf类型的，直接调用ctx.fireChannelRead(msg)方法，fireChannelRead方法实际上是调用pipeline管道的下一个Handler去继续处理消息其他的逻辑去了，我们进入到AbstractChannelHandlerContext的fireChannelRead方法，发现只有一个方法invokeChannelRead，寻找下一个绑定的Handler并且调用ChannelRead方法。

    @Override
    public ChannelHandlerContext fireChannelRead(final Object msg) {
        //寻找下一个绑定的Handler并且调用ChannelRead方法
        invokeChannelRead(findContextInbound(), msg);
        return this;
    }

继续进入到invokeChannelRead。

    static void invokeChannelRead(final AbstractChannelHandlerContext next, Object msg) {
        final Object m = next.pipeline.touch(ObjectUtil.checkNotNull(msg, "msg"), next);
        EventExecutor executor = next.executor();
        if (executor.inEventLoop()) {
            next.invokeChannelRead(m);
        } else {
            executor.execute(() -> next.invokeChannelRead(m));
        }
    }

最终都会调用invokeChannelRead，而invokeChannelRead就是将Handler转换成ChannelInboundHandler类型去执行具体的channelRead方法，去进一步的读取消息并处理相关Handler逻辑。

 private void invokeChannelRead(Object msg) {
        if (invokeHandler()) {
            try {
                ((ChannelInboundHandler) handler()).channelRead(this, msg);
            } catch (Throwable t) {
                notifyHandlerException(t);
            }
        } else {
            fireChannelRead(msg);
        }
    }

②、如果msg是ByteBuf类型的，去调用解码逻辑callDecode方法去解析数据。

     protected void callDecode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) {
        try {
            while (in.isReadable()) {
                int outSize = out.size();
                //将out里的事件执行并且清空out
                if (outSize > 0) {
                    fireChannelRead(ctx, out, outSize);
                    out.clear();
                    // 在继续解码之前，请检查是否已删除此处理程序
                    // 如果已将其删除，则继续在缓冲区上操作是不安全的。
                    if (ctx.isRemoved()) {
                        break;
                    }
                    outSize = 0;
                }
                int oldInputLength = in.readableBytes();
                // 开始解析数据，如果解析出来数据，那么out的长度一定会改变
                decode(ctx, in, out);
​
                // 在继续循环之前，请检查是否已删除此处理程序。
                // 如果已将其删除，则继续在缓冲区上操作是不安全的。
                if (ctx.isRemoved()) {
                    break;
                }
                // 如果没有解析出来数据
                if (outSize == out.size()) {
                    if (oldInputLength == in.readableBytes()) {
                        break;
                    } else {
                        continue;
                    }
                }
​
                if (oldInputLength == in.readableBytes()) {
                    throw new DecoderException(
                            StringUtil.simpleClassName(getClass()) +
                            ".decode() did not read anything but decoded a message.");
                }
                if (isSingleDecode()) {
                    break;
                }
            }
        } catch (DecoderException e) {
            throw e;
        } catch (Throwable cause) {
            throw new DecoderException(cause);
        }
    }

在callDecode方法中，使用while循环去解析数据，这是因为一次发送的数据有可能大于定长frameLength，对于循环中的每次解析，首先判断缓冲区中是否还有可读空间，有可读空间执行while循环体，第一次执行循环体的时候out肯定是没有数据的，也就是out的size为0，下面会调用解码逻辑decode(ctx, in, out)去进行数据的第一次解析，我们先不看decode(ctx, in, out)到底执行了什么逻辑，现在假设已经执行了一次decode(ctx, in, out)逻辑，也就是out里面有数据了，就是第一次解析出来的数据，现在out的size为1，现在进入outSize > 0逻辑判断中，可以看到这个if判断逻辑核心就是fireChannelRead(ctx, out, outSize)，然后将out清空，size置位0，关于fireChannelRead方法，其实在上面刚才我们也说过了，就是调用下一个Handler处理器去执行下一步处理逻辑，我们再次跟进去。

    static void fireChannelRead(ChannelHandlerContext ctx, List<Object> msgs, int numElements) {
        if (msgs instanceof CodecOutputList) {
            fireChannelRead(ctx, (CodecOutputList) msgs, numElements);
        } else {
            for (int i = 0; i < numElements; i++) {
                ctx.fireChannelRead(msgs.get(i));
            }
        }
    }

继续进入到fireChannelRead，来到AbstractChannelHandlerContext的fireChannelRead。

    @Override
    public ChannelHandlerContext fireChannelRead(final Object msg) {
        //寻找下一个绑定的Handler并且调用ChannelRead方法
        invokeChannelRead(findContextInbound(), msg);
        return this;
    }

继续往里走。

static void invokeChannelRead(final AbstractChannelHandlerContext next, Object msg) {
        final Object m = next.pipeline.touch(ObjectUtil.checkNotNull(msg, "msg"), next);
        EventExecutor executor = next.executor();
        if (executor.inEventLoop()) {
            next.invokeChannelRead(m);
        } else {
            executor.execute(() -> next.invokeChannelRead(m));
        }
    }
​
    private void invokeChannelRead(Object msg) {
        if (invokeHandler()) {
            try {
                ((ChannelInboundHandler) handler()).channelRead(this, msg);
            } catch (Throwable t) {
                notifyHandlerException(t);
            }
        } else {
            fireChannelRead(msg);
        }
    }

重点看((ChannelInboundHandler) handler()).channelRead(this, msg)，这里将handler转成ChannelInboundHandler类型，执行他的channelRead方法，其实就是我们刚才服务端的重写的channelRead方法。

也就是说解析完一次数据时候立刻就去执行我们自定义的处理逻辑去了。当然在这里只是一个测试代码，如果真正我们自定义的处理逻辑比较复杂，比如涉及到操作数据库、磁盘IO等，可以考虑放入线程池中进行业务处理，避免造成解析数据缓慢，网络迟钝。

回到我们刚才while循环解析数据的逻辑，进入到decode(ctx, in, out)中。进入到其实现类FixedLengthFrameDecoder 中。

    @Override
    protected final void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) throws Exception {
        Object decoded = decode(ctx, in);
        if (decoded != null) {
            out.add(decoded);
        }
    }

decoded就是解析完的对象，如果这个对象不为空，就放到out中去，再看decode方法。

protected Object decode(@SuppressWarnings("UnusedParameters") ChannelHandlerContext ctx, ByteBuf in) throws Exception {
        if (in.readableBytes() < frameLength) {
            return null;
        } else {
            return in.readRetainedSlice(frameLength);
        }
    }

如果缓冲区中可读字节数小于了定长frameLength，那就认为是一次不完整的消息，不会去处理，直接返回null，反之，去解析剩下的可读字节数据。解析剩下的可读字节数据就是操作内存读取缓冲区中字节数据，读索引readerIndex增加length，设置引用计数加1，详细的代码执行逻辑不再细看。

循环体执行完成后，根据固定长度frameLength获取到的一个或者多个数据都已经获取到了，而且在每次循环中也通过服务端的重写的channelRead方法执行了我们自定义的业务处理逻辑，如果还有剩余的数据没有读取完(in.readableBytes() < frameLength)，那么数据就还在缓冲区中了,所以客户端在发送数据的时候需要根据定长达成一致协议发送数据量是定长的整数倍的数据(包括填充数据)。

至此，服务端利用FixedLengthFrameDecoder解码器解析数据的流程也就分析完了。

个人才疏学浅、信手涂鸦，netty框架更多模块解读相关源码持续更新中，感兴趣的朋友请移步至个人公众号，谢谢支持😜😜......

公众号：wenyixicodedog