Netty进阶——粘包/半包

前言：

TCP（Transmission Control Protocol）是一种面向连接的可靠传输协议，广泛应用于网络通信领域。在TCP协议中，数据被分割成一个一个的报文段进行传输。然而，由于网络传输的不可靠性，TCP协议会面临一些数据传输问题，如粘包和半包问题。在网络通信中，当发送方连续发送多个小数据包时，接收方可能会将它们合并成一个大的数据包，这就是粘包问题；而当发送方发送的数据包长度大于接收方的缓冲区长度时，接收方无法完整接收数据包，导致数据的接收不完整，这就是半包问题。本文将深入探讨TCP协议中的粘包和半包问题，分析他们出现的根本原因，并提供一些解决方案，以便更好地应对这些问题。

粘包和半包产生原因

粘包就是多个数据混淆在一起了，而且多个数据包之间没有明确的分隔，导致无法对这些数据包进行正确的读取。

半包就是一个大的数据包被拆分成了多个数据包发送，读取的时候没有把多个包合成一个原本的大包，导致读取的数据不完整。

这种问题产生的原因可能有多种因素，从应用层到链路层中都有可能引起这个问题。

1.TCP协议中的滑动窗口

TCP协议是一种可靠性传输协议，所以在传输数据的时候必须要等到对方的应答之后才能发送下一条数据，这种显然效率不高。

TCP协议为了解决这个传输效率的问题，引入了滑动窗口。滑动窗口就是在发送方和接收方都有一个缓冲区，这个缓冲区就是"窗口"，假设发送方的窗口大小是 0~100KB,那么发送数据的时候前100KB的数据不需要等到对方ACK应答即可全部发送。

如果发送的过程中收到了对方返回某个数据包的ACK，那么这个窗口会对应的向后滑动。比如刚开始的窗口大小是0~100KB，收到前20KB数据包的ACK之后，这个窗口就会滑动到20~120KB的位置，以此类推。这里还有一个小问题，如果发送方一直未接收到前20KB的ACK消息，那么在发送完0~100KB的数据之后，窗口就会卡在那里，这就是经典的队头阻塞问题，后续会讲解，本文重点不是这个，先有个印象。

接收方那里也有这么一个窗口，只会读取窗口内的数据并返回ACK，返回ACK后，接收窗口往后滑动。

对于TCP的滑动窗口，发送方的窗口起到了优化传输效率的作用，接收方的窗口起到了流量控制的作用。
 

Netty中具体实现

1、设置滑动窗口大小

• .option(ChannelOption.SO_RCVBUF,10) 调整系统的接收缓冲区（TCP滑动窗口）
• .childOption(ChannelOption.RCVBUF_ALLOCATOR,new AdaptiveRecvByteBufAllocator(16,16,16)) 调整netty的接收缓冲区

2、使用解码器，设置消息发送的长度，按指定长度进行发送

• ch.pipeline().addLast(new FixedLengthFrameDecoder(16));

📢 将接收到的bytebuf按固定字节数拆分的解码器。

例如，如果收到以下4个分片报文:

+---+----+------+----+

| a | BC | defg | hi |

+---+----+------+----+

FixedLengthFrameDecoder(3)将它们解码成以下三个固定长度的数据包:

+-----+-----+-----+

| ABC | def | ghi |

+-----+-----+-----+

3、按指定字符进行拆分发送

• LineBasedFrameDecoder 使用换行符进行分割，“\n”和“\r\n
• DelimiterBasedFrameDecoder 使用指定字符作为分隔符。

 🔔 代码示例

        服务器

public static void main(String[] args) {
        NioEventLoopGroup boss = new NioEventLoopGroup();
        NioEventLoopGroup worker = new NioEventLoopGroup();
        try {
            ServerBootstrap serverBootstrap = new ServerBootstrap();
            serverBootstrap
                    .group(boss, worker)
                    .channel(NioServerSocketChannel.class)
//                    1、调整系统的接收缓冲区（TCP滑动窗口）
//                    .option(ChannelOption.SO_RCVBUF,10)
//                    调整netty的接收缓冲区（byteBuf）
//                    .childOption(ChannelOption.RCVBUF_ALLOCATOR,new AdaptiveRecvByteBufAllocator(16,16,16))
                    .childHandler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {
//                            2、解码器，把消息按指定长度进行发送（）
//                            ch.pipeline().addLast(new FixedLengthFrameDecoder(16));
//                            3、通过指定换行符进行拆分接收
//                            ch.pipeline().addLast(new LineBasedFrameDecoder(1024));
//                            ch.pipeline().addLast(new DelimiterBasedFrameDecoder(1024));
//                            4、使用动态解码器
                            ch.pipeline().addLast(new LengthFieldBasedFrameDecoder(1024,0,0,0,0));
                            ch.pipeline().addLast(new LoggingHandler(LogLevel.DEBUG));
                        }
                    });
            ChannelFuture channelFuture = serverBootstrap.bind(8080).sync();
            channelFuture.channel().closeFuture().sync();

        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            boss.shutdownGracefully();
            worker.shutdownGracefully();
        }
    }

        客户端

public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            start();
        }
    }
    private static void start() {
        NioEventLoopGroup group = new NioEventLoopGroup();
        try {
            Bootstrap bootstrap = new Bootstrap();
            bootstrap
                    .group(group)
                    .channel(NioSocketChannel.class)
//                    .option(ChannelOption.SO_RCVBUF,10)
                    .handler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {
                            ch.pipeline().addLast(new ChannelInboundHandlerAdapter(){
    //                            会在连接Channel 建立成功后，会触发active事件
                                @Override
                                public void channelActive(ChannelHandlerContext ctx) throws Exception {
                                        ByteBuf buf = ctx.alloc().buffer(16);
                                    for (int i = 0; i < 10; i++) {
                                        buf.writeBytes(new byte[]{0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18});
                                    }
                                    ctx.writeAndFlush(buf);
                                }
                            });
                        }
                    });
            ChannelFuture channelFuture = bootstrap.connect("127.0.0.1", 8080).sync();
            channelFuture.channel().closeFuture().sync();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            group.shutdownGracefully();
        }
    }

4、使用LengthFieldBasedFrameDecoder 使用动态解码器进行

 

测试代码

public static void main(String[] args) {
        EmbeddedChannel channel = new EmbeddedChannel(
                new LengthFieldBasedFrameDecoder(1024,0,4,1,4),
                new LoggingHandler(LogLevel.DEBUG)
        );
        ByteBuf buffer = ByteBufAllocator.DEFAULT.buffer();
        send(buffer,"Hello,world");
        send(buffer,"Hi");
        send(buffer,"zhangsan");
        channel.writeOneInbound(buffer);
    }

    private static void send(ByteBuf buffer, String content) {
        byte[] bytes = content.getBytes();
        int length = bytes.length;
        buffer.writeInt(length);
        buffer.writeByte(1);
        buffer.writeBytes(bytes);
    }