Netty（9）粘包与半包问题和解决

最新推荐文章于 2024-05-26 22:32:25 发布
最新推荐文章于 2024-05-26 22:32:25 发布
阅读量301 收藏
点赞数 1
分类专栏： # netty 文章标签： java netty 网络协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yyuggjggg/article/details/126476923
版权

粘包现象

服务端代码

public class HelloWorldServer {
    static final Logger log = LoggerFactory.getLogger(HelloWorldServer.class);
    void start() {
        NioEventLoopGroup boss = new NioEventLoopGroup(1);
        NioEventLoopGroup worker = new NioEventLoopGroup();
        try {
            ServerBootstrap serverBootstrap = new ServerBootstrap();
            serverBootstrap.channel(NioServerSocketChannel.class);
            serverBootstrap.group(boss, worker);
            serverBootstrap.childHandler(new ChannelInitializer<SocketChannel>() {
                @Override
                protected void initChannel(SocketChannel ch) throws Exception {
                    //调试打印出服务器端收到的数据
                    ch.pipeline().addLast(new LoggingHandler(LogLevel.DEBUG));
                }
            });
            ChannelFuture channelFuture = serverBootstrap.bind(8080);
            channelFuture.sync();
            channelFuture.channel().closeFuture().sync();
        } catch (InterruptedException e) {
            log.error("server error", e);
        } finally {
            boss.shutdownGracefully();
            worker.shutdownGracefully();
            log.debug("stoped");
        }
    }

    public static void main(String[] args) {
        new HelloWorldServer().start();
    }
}

客户端代码

客户端代码希望发送 10 个消息，每个消息是 16 字节

public class HelloWorldClient {
    static final Logger log = LoggerFactory.getLogger(HelloWorldClient.class);
    public static void main(String[] args) {
        NioEventLoopGroup worker = new NioEventLoopGroup();
        try {
            Bootstrap bootstrap = new Bootstrap();
            bootstrap.channel(NioSocketChannel.class);
            bootstrap.group(worker);
            bootstrap.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 buffer = ctx.alloc().buffer(16);
                            for (int i = 0; i < 10; i++) {
                                buffer.writeBytes(new byte[]{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15});
                                ctx.writeAndFlush(buffer);
                            }
                        }
                    });
                }
            });
            ChannelFuture channelFuture = bootstrap.connect("127.0.0.1", 8080).sync();
            channelFuture.channel().closeFuture().sync();

        } catch (InterruptedException e) {
            log.error("client error", e);
        } finally {
            worker.shutdownGracefully();
        }
    }
}

运行结果

一次就接收了 160 个字节，而非分 10 次接收
在这里插入图片描述

半包现象

服务端修改一下接收缓冲区，其它代码不变

serverBootstrap.option(ChannelOption.SO_RCVBUF, 10);

serverBootstrap.option(ChannelOption.SO_RCVBUF, 10) 影响的底层接收缓冲区（即滑动窗口）大小，仅决定了 netty 读取的最小单位，netty 实际每次读取的一般是它的整数倍
在这里插入图片描述

运行结果

在这里插入图片描述

现象分析

本质是因为 TCP 是流式协议，消息无边界

只要是使用TCP/IP协议进行编程，就会出现黏包和半包想象

UDP协议没有

滑动窗口

TCP 以一个段（segment）为单位，每发送一个段就需要进行一次确认应答（ack）处理，但如果这么做，缺点是包的往返时间越长性能就越差
在这里插入图片描述
为了解决此问题，引入了窗口概念，窗口大小即决定了无需等待应答而可以继续发送的数据最大值
在这里插入图片描述
窗口实际就起到一个缓冲区的作用，同时也能起到 流量控制的作用

  • 图中深色的部分即要发送的数据，高亮的部分即窗口
  • 窗口内的数据才允许被发送，当应答未到达前，窗口必须停止滑动
  • 如果 1001~2000 这个段的数据 ack 回来了，窗口就可以向前滑动
  • 接收方也会维护一个窗口，只有落在窗口内的数据才能允许接收

TCP层面分析（滑动窗口）

  • 如果网络比较繁忙，接收方的窗口使用完了，不能继续向下滑动，其接收到的数据势必会容易发生半包现象（到一半窗口使用完了，如果这时候去读缓冲区，读到的就是半包的数据）

  • 如果滑动窗口比较空闲，里面还有许多的空间没有使用，这时候客户端发送的许多条数据过来，滑动窗口将这多条数据都接收到了，那就发生了黏包现象

MSS 限制

  • 链路层对一次能够发送的最大数据有限制，这个限制称之为 MTU（maximum transmission unit），不同的链路设备的 MTU 值也有所不同，例如

  • 以太网的 MTU 是 1500

  • FDDI（光纤分布式数据接口）的 MTU 是 4352

  • 本地回环地址的 MTU 是 65535 - 本地测试不走网卡

  • MSS 是最大段长度（maximum segment size），它是 MTU 刨去 tcp 头和 ip 头后剩余能够作为数据传输的字节数

  • ipv4 tcp 头占用 20 bytes，ip 头占用 20 bytes，因此以太网 MSS 的值为 1500 - 40 = 1460

  • TCP 在传递大量数据时，会按照 MSS 大小将数据进行分割发送

  • MSS 的值在三次握手时通知对方自己 MSS 的值，然后在两者之间选择一个小值作为 MSS
    在这里插入图片描述

Nagle 算法

  • 即使发送一个字节，也需要加入 tcp 头和 ip 头，也就是总字节数会使用 41 bytes，非常不经济。因此为了提高网络利用率，tcp 希望尽可能发送足够大的数据，这就是 Nagle 算法产生的缘由
  • 该算法是指发送端即使还有应该发送的数据，但如果这部分数据很少的话，则进行延迟发送
    • 如果 SO_SNDBUF 的数据达到 MSS，则需要发送
    • 如果 SO_SNDBUF 中含有 FIN（表示需要连接关闭）这时将剩余数据发送，再关闭
    • 如果 TCP_NODELAY = true，则需要发送
    • 已发送的数据都收到 ack 时，则需要发送
    • 上述条件不满足，但发生超时（一般为 200ms）则需要发送
    • 除上述情况，延迟发送

粘包

  • 现象，发送 abc def，接收 abcdef
  • 原因
    • 应用层：接收方 ByteBuf 设置太大（Netty 默认 1024）（如果发送很小的ByteBuf便会出现粘包）
    • 滑动窗口（TCP层面）：假设发送方 256 bytes 表示一个完整报文，但由于接收方处理不及时且窗口大小足够大，这 256 bytes 字节就会缓冲在接收方的滑动窗口中，当滑动窗口中缓冲了多个报文就会粘包
    • Nagle 算法（TCP层面）：会造成粘包

半包

  • 现象，发送 abcdef，接收 abc def
  • 原因
    • 应用层：接收方 ByteBuf 小于实际发送数据量
    • 滑动窗口（TCP层面）：假设接收方的窗口只剩了 128 bytes，发送方的报文大小是 256 bytes，这时放不下了，只能先发送前 128 bytes，等待 ack 后才能发送剩余部分，这就造成了半包
    • MSS 限制（链路层）：当发送的数据超过 MSS 限制后，会将数据切分发送，就会造成半包

解决方法

短链接

短链接，发一个包建立一次连接，这样连接建立到连接断开之间就是消息的边界，缺点效率太低

粘包解决

服务器代码

public class HelloWorldClient {
    static final Logger log = LoggerFactory.getLogger(HelloWorldClient.class);

    public static void main(String[] args) {
        // 分 10 次发送
        for (int i = 0; i < 10; i++) {
            send();
        }
        System.out.println("finish");
    }

    private static void send() {
        NioEventLoopGroup worker = new NioEventLoopGroup();
        try {
            Bootstrap bootstrap = new Bootstrap();
            bootstrap.channel(NioSocketChannel.class);
            bootstrap.group(worker);
            bootstrap.handler(new ChannelInitializer<SocketChannel>() {
                @Override
                protected void initChannel(SocketChannel ch) throws Exception {
                    ch.pipeline().addLast(new ChannelInboundHandlerAdapter() {
                        @Override
                        public void channelActive(ChannelHandlerContext ctx) throws Exception {
                            ByteBuf buffer = ctx.alloc().buffer();
                            buffer.writeBytes(new byte[]{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15});
                            ctx.writeAndFlush(buffer);
                            // 发完即关
                            ctx.channel().close();
                        }
                    });
                }
            });
            ChannelFuture channelFuture = bootstrap.connect("localhost", 8080).sync();
            channelFuture.channel().closeFuture().sync();

        } catch (InterruptedException e) {
            log.error("client error", e);
        } finally {
            worker.shutdownGracefully();
        }
    }
}
客户端代码

客户端代码只是需要将之前设置滑动窗口的代码注释掉即可

如果不设置滑动窗口的话，现在的操作系统可以自行调整滑动窗口的大小

ByteBuf默认是1024，足够大了

运行结果

在这里插入图片描述

半包

半包用这种办法还是不好解决，因为接收方的缓冲区大小是有限的

定长解码器

让所有数据包长度固定（假设长度为 8 字节），服务器端加入


ch.pipeline().addLast(new FixedLengthFrameDecoder(8));

缺点是，数据包的大小不好把握

  • 长度定的太大，浪费
  • 长度定的太小，对某些数据包又显得不够

服务器代码

@Slf4j
public class Server2 {
    void start() {
        NioEventLoopGroup boss = new NioEventLoopGroup();
        NioEventLoopGroup worker = new NioEventLoopGroup();
        try {
            ServerBootstrap serverBootstrap = new ServerBootstrap();
            serverBootstrap.channel(NioServerSocketChannel.class);
            // 调整系统的接收缓冲区（滑动窗口）
//            serverBootstrap.option(ChannelOption.SO_RCVBUF, 10);
            // 调整 netty 的接收缓冲区（byteBuf）
            serverBootstrap.childOption(ChannelOption.RCVBUF_ALLOCATOR, new AdaptiveRecvByteBufAllocator(16, 16, 16));
            serverBootstrap.group(boss, worker);
            serverBootstrap.childHandler(new ChannelInitializer<SocketChannel>() {
                @Override
                protected void initChannel(SocketChannel ch) throws Exception {
                    ch.pipeline().addLast(new FixedLengthFrameDecoder(10));
                    ch.pipeline().addLast(new LoggingHandler(LogLevel.DEBUG));
                }
            });
            ChannelFuture channelFuture = serverBootstrap.bind(8080).sync();
            channelFuture.channel().closeFuture().sync();
        } catch (InterruptedException e) {
            log.error("server error", e);
        } finally {
            boss.shutdownGracefully();
            worker.shutdownGracefully();
        }
    }

    public static void main(String[] args) {
        new Server2().start();
    }
}

客户端代码

public class Client2 {
    static final Logger log = LoggerFactory.getLogger(Client1.class);

    public static void main(String[] args) {
        send();
        System.out.println("finish");
    }

    /*
        产生定长的消息
            产生一个内容为c的消息，消息的长度是len，不足len的长度使用下划线补全
     */
    public static byte[] fill10Bytes(char c, int len) {
        byte[] bytes = new byte[10];
        Arrays.fill(bytes, (byte) '_');
        for (int i = 0; i < len; i++) {
            bytes[i] = (byte) c;
        }
        System.out.println(new String(bytes));
        return bytes;
    }

    private static void send() {
        NioEventLoopGroup worker = new NioEventLoopGroup();
        try {
            Bootstrap bootstrap = new Bootstrap();
            bootstrap.channel(NioSocketChannel.class);
            bootstrap.group(worker);
            bootstrap.handler(new ChannelInitializer<SocketChannel>() {
                @Override
                protected void initChannel(SocketChannel ch) {
                    ch.pipeline().addLast(new LoggingHandler(LogLevel.DEBUG));
                    ch.pipeline().addLast(new ChannelInboundHandlerAdapter() {
                        // 会在连接 channel 建立成功后，会触发 active 事件
                        @Override
                        public void channelActive(ChannelHandlerContext ctx) {
                            ByteBuf buf = ctx.alloc().buffer();
                            char c = '0';
                            Random r = new Random();
                            for (int i = 0; i < 10; i++) {
                                //内容长度随机：1到10之间
                                byte[] bytes = fill10Bytes(c, r.nextInt(10) + 1);
                                c++;
                                //将bytes数组里面的内容写入到buf中
                                buf.writeBytes(bytes);
                            }
                            //向服务器端发送消息
                            ctx.writeAndFlush(buf);
                        }
                    });
                }
            });
            ChannelFuture channelFuture = bootstrap.connect("127.0.0.1", 8080).sync();
            channelFuture.channel().closeFuture().sync();
        } catch (InterruptedException e) {
            log.error("client error", e);
        } finally {
            worker.shutdownGracefully();
        }
    }
}

运行结果

客户端输出

可以发现，在这里保证了每一条消息的长度都是10

客户端将10*10=100个字节的消息一起发出去了


23:39:02 [DEBUG] [nioEventLoopGroup-2-1] i.n.h.l.LoggingHandler - [id: 0x7a473d9c] REGISTERED
23:39:02 [DEBUG] [nioEventLoopGroup-2-1] i.n.h.l.LoggingHandler - [id: 0x7a473d9c] CONNECT: /127.0.0.1:8080
23:39:02 [DEBUG] [nioEventLoopGroup-2-1] i.n.h.l.LoggingHandler - [id: 0x7a473d9c, L:/127.0.0.1:10305 - R:/127.0.0.1:8080] ACTIVE
000_______
11111_____
222222____
33333_____
44444444__
555_______
6666666___
77777_____
8888______
99________
23:39:02 [DEBUG] [nioEventLoopGroup-2-1] i.n.h.l.LoggingHandler - [id: 0x7a473d9c, L:/127.0.0.1:10305 - R:/127.0.0.1:8080] WRITE: 100B
         +-------------------------------------------------+
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 30 30 30 5f 5f 5f 5f 5f 5f 5f 31 31 31 31 31 5f |000_______11111_|
|00000010| 5f 5f 5f 5f 32 32 32 32 32 32 5f 5f 5f 5f 33 33 |____222222____33|
|00000020| 33 33 33 5f 5f 5f 5f 5f 34 34 34 34 34 34 34 34 |333_____44444444|
|00000030| 5f 5f 35 35 35 5f 5f 5f 5f 5f 5f 5f 36 36 36 36 |__555_______6666|
|00000040| 36 36 36 5f 5f 5f 37 37 37 37 37 5f 5f 5f 5f 5f |666___77777_____|
|00000050| 38 38 38 38 5f 5f 5f 5f 5f 5f 39 39 5f 5f 5f 5f |8888______99____|
|00000060| 5f 5f 5f 5f                                     |____            |
+--------+-------------------------------------------------+----------------+
23:39:02 [DEBUG] [nioEventLoopGroup-2-1] i.n.h.l.LoggingHandler - [id: 0x7a473d9c, L:/127.0.0.1:10305 - R:/127.0.0.1:8080] FLUSH
服务器输出

服务器将消息进行解码，虽然之前发出来的时候是黏包了，都是现在输出的是没有黏包的

23:39:02 [DEBUG] [nioEventLoopGroup-3-1] i.n.h.l.LoggingHandler - [id: 0xc0d7cca8, L:/127.0.0.1:8080 - R:/127.0.0.1:10305] REGISTERED
23:39:02 [DEBUG] [nioEventLoopGroup-3-1] i.n.h.l.LoggingHandler - [id: 0xc0d7cca8, L:/127.0.0.1:8080 - R:/127.0.0.1:10305] ACTIVE
23:39:02 [DEBUG] [nioEventLoopGroup-3-1] i.n.h.l.LoggingHandler - [id: 0xc0d7cca8, L:/127.0.0.1:8080 - R:/127.0.0.1:10305] READ: 10B
         +-------------------------------------------------+
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 30 30 30 5f 5f 5f 5f 5f 5f 5f                   |000_______      |
+--------+-------------------------------------------------+----------------+
23:39:02 [DEBUG] [nioEventLoopGroup-3-1] i.n.h.l.LoggingHandler - [id: 0xc0d7cca8, L:/127.0.0.1:8080 - R:/127.0.0.1:10305] READ COMPLETE
23:39:02 [DEBUG] [nioEventLoopGroup-3-1] i.n.h.l.LoggingHandler - [id: 0xc0d7cca8, L:/127.0.0.1:8080 - R:/127.0.0.1:10305] READ: 10B
         +-------------------------------------------------+
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 31 31 31 31 31 5f 5f 5f 5f 5f                   |11111_____      |
+--------+-------------------------------------------------+----------------+
23:39:02 [DEBUG] [nioEventLoopGroup-3-1] i.n.h.l.LoggingHandler - [id: 0xc0d7cca8, L:/127.0.0.1:8080 - R:/127.0.0.1:10305] READ: 10B
         +-------------------------------------------------+
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 32 32 32 32 32 32 5f 5f 5f 5f                   |222222____      |
+--------+-------------------------------------------------+----------------+
23:39:02 [DEBUG] [nioEventLoopGroup-3-1] i.n.h.l.LoggingHandler - [id: 0xc0d7cca8, L:/127.0.0.1:8080 - R:/127.0.0.1:10305] READ COMPLETE
23:39:02 [DEBUG] [nioEventLoopGroup-3-1] i.n.h.l.LoggingHandler - [id: 0xc0d7cca8, L:/127.0.0.1:8080 - R:/127.0.0.1:10305] READ: 10B
         +-------------------------------------------------+
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 33 33 33 33 33 5f 5f 5f 5f 5f                   |33333_____      |
+--------+-------------------------------------------------+----------------+
23:39:02 [DEBUG] [nioEventLoopGroup-3-1] i.n.h.l.LoggingHandler - [id: 0xc0d7cca8, L:/127.0.0.1:8080 - R:/127.0.0.1:10305] READ COMPLETE
23:39:02 [DEBUG] [nioEventLoopGroup-3-1] i.n.h.l.LoggingHandler - [id: 0xc0d7cca8, L:/127.0.0.1:8080 - R:/127.0.0.1:10305] READ: 10B
         +-------------------------------------------------+
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 34 34 34 34 34 34 34 34 5f 5f                   |44444444__      |
+--------+-------------------------------------------------+----------------+
23:39:02 [DEBUG] [nioEventLoopGroup-3-1] i.n.h.l.LoggingHandler - [id: 0xc0d7cca8, L:/127.0.0.1:8080 - R:/127.0.0.1:10305] READ: 10B
         +-------------------------------------------------+
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 35 35 35 5f 5f 5f 5f 5f 5f 5f                   |555_______      |
+--------+-------------------------------------------------+----------------+
23:39:02 [DEBUG] [nioEventLoopGroup-3-1] i.n.h.l.LoggingHandler - [id: 0xc0d7cca8, L:/127.0.0.1:8080 - R:/127.0.0.1:10305] READ COMPLETE
23:39:02 [DEBUG] [nioEventLoopGroup-3-1] i.n.h.l.LoggingHandler - [id: 0xc0d7cca8, L:/127.0.0.1:8080 - R:/127.0.0.1:10305] READ: 10B
         +-------------------------------------------------+
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 36 36 36 36 36 36 36 5f 5f 5f                   |6666666___      |
+--------+-------------------------------------------------+----------------+
23:39:02 [DEBUG] [nioEventLoopGroup-3-1] i.n.h.l.LoggingHandler - [id: 0xc0d7cca8, L:/127.0.0.1:8080 - R:/127.0.0.1:10305] READ: 10B
         +-------------------------------------------------+
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 37 37 37 37 37 5f 5f 5f 5f 5f                   |77777_____      |
+--------+-------------------------------------------------+----------------+
23:39:02 [DEBUG] [nioEventLoopGroup-3-1] i.n.h.l.LoggingHandler - [id: 0xc0d7cca8, L:/127.0.0.1:8080 - R:/127.0.0.1:10305] READ COMPLETE
23:39:02 [DEBUG] [nioEventLoopGroup-3-1] i.n.h.l.LoggingHandler - [id: 0xc0d7cca8, L:/127.0.0.1:8080 - R:/127.0.0.1:10305] READ: 10B
         +-------------------------------------------------+
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 38 38 38 38 5f 5f 5f 5f 5f 5f                   |8888______      |
+--------+-------------------------------------------------+----------------+
23:39:02 [DEBUG] [nioEventLoopGroup-3-1] i.n.h.l.LoggingHandler - [id: 0xc0d7cca8, L:/127.0.0.1:8080 - R:/127.0.0.1:10305] READ COMPLETE
23:39:02 [DEBUG] [nioEventLoopGroup-3-1] i.n.h.l.LoggingHandler - [id: 0xc0d7cca8, L:/127.0.0.1:8080 - R:/127.0.0.1:10305] READ: 10B
         +-------------------------------------------------+
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 39 39 5f 5f 5f 5f 5f 5f 5f 5f                   |99________      |
+--------+-------------------------------------------------+----------------+
23:39:02 [DEBUG] [nioEventLoopGroup-3-1] i.n.h.l.LoggingHandler - [id: 0xc0d7cca8, L:/127.0.0.1:8080 - R:/127.0.0.1:10305] READ COMPLETE

固定分隔符

第一种方法：

  • 服务端加入，默认以 \n 或 \r\n 作为分隔符，如果超出指定长度仍未出现分隔符，则抛出异常

    //以换行符作为分隔符 （Linux: \n 和 Windows: \r\n）
ch.pipeline().addLast(new LineBasedFrameDecoder(1024));

  • 客户端在每条消息之后，加入 \n 分隔符

第二种方法定义分隔符

/*
maxFrameLength: 最大长度
delimiter: 字节定义的ByteBuf类型的分隔符
*/
ch.pipeline().addLast(new DelimiterBasedFrameDecoder(int maxFrameLength, ByteBuf delimiter));

客户端代码

循环十次，发送10条消息，只不过这些消息都会以\n结结束

public class Client3 {
    static final Logger log = LoggerFactory.getLogger(Client1.class);

    public static void main(String[] args) {
        send();
        System.out.println("finish");
    }

    public static StringBuilder makeString(char c, int len) {
        StringBuilder sb = new StringBuilder(len + 2);
        for (int i = 0; i < len; i++) {
            sb.append(c);
        }
        sb.append("\n");
        return sb;
    }

    private static void send() {
        NioEventLoopGroup worker = new NioEventLoopGroup();
        try {
            Bootstrap bootstrap = new Bootstrap();
            bootstrap.channel(NioSocketChannel.class);
            bootstrap.group(worker);
            bootstrap.handler(new ChannelInitializer<SocketChannel>() {
                @Override
                protected void initChannel(SocketChannel ch) {
                    ch.pipeline().addLast(new LoggingHandler(LogLevel.DEBUG));
                    ch.pipeline().addLast(new ChannelInboundHandlerAdapter() {
                        // 会在连接 channel 建立成功后，会触发 active 事件
                        @Override
                        public void channelActive(ChannelHandlerContext ctx) {
                            ByteBuf buf = ctx.alloc().buffer();
                            char c = '0';
                            Random r = new Random();
                            for (int i = 0; i < 10; i++) {
                                StringBuilder sb = makeString(c, r.nextInt(256) + 1);
                                c++;
                                buf.writeBytes(sb.toString().getBytes());
                            }
                            ctx.writeAndFlush(buf);
                        }
                    });
                }
            });
            ChannelFuture channelFuture = bootstrap.connect("127.0.0.1", 8080).sync();
            channelFuture.channel().closeFuture().sync();
        } catch (InterruptedException e) {
            log.error("client error", e);
        } finally {
            worker.shutdownGracefully();
        }
    }
}

服务器代码

@Slf4j
public class Server3 {
    void start() {
        NioEventLoopGroup boss = new NioEventLoopGroup();
        NioEventLoopGroup worker = new NioEventLoopGroup();
        try {
            ServerBootstrap serverBootstrap = new ServerBootstrap();
            serverBootstrap.channel(NioServerSocketChannel.class);
            // 调整系统的接收缓冲区（滑动窗口）
//            serverBootstrap.option(ChannelOption.SO_RCVBUF, 10);
            // 调整 netty 的接收缓冲区（byteBuf）
            serverBootstrap.childOption(ChannelOption.RCVBUF_ALLOCATOR, new AdaptiveRecvByteBufAllocator(16, 16, 16));
            serverBootstrap.group(boss, worker);
            serverBootstrap.childHandler(new ChannelInitializer<SocketChannel>() {
                @Override
                protected void initChannel(SocketChannel ch) throws Exception {
                    ch.pipeline().addLast(new LineBasedFrameDecoder(1024));
                    ch.pipeline().addLast(new LoggingHandler(LogLevel.DEBUG));
                }
            });
            ChannelFuture channelFuture = serverBootstrap.bind(8080).sync();
            channelFuture.channel().closeFuture().sync();
        } catch (InterruptedException e) {
            log.error("server error", e);
        } finally {
            boss.shutdownGracefully();
            worker.shutdownGracefully();
        }
    }

    public static void main(String[] args) {
        new Server3().start();
    }
}

预设长度

在发送消息前，先约定用定长字节表示接下来数据的长度

// 最大长度，长度偏移，长度占用字节，长度调整，剥离字节数
/*
maxFrameLength： 		最大长度
lengthFieldoffset : 	长度字段偏移量
lengthFieldLength : 	消息长度占用字节
lengthAdjustment : 		长度字段为基准，还有几个字节(过后)才是内容
initialBytesToStrip : 	从头剥离几个字节, 不需要的字节内容
*/
ch.pipeline().addLast(new LengthFieldBasedFrameDecoder(1024, 0, 1, 0, 1));

具体的使用，可以看源码中的文档说明
在这里插入图片描述

代码


public class TestLengthFieldDecoder {
    public static void main(String[] args) {
    	//使用的是writeInt, int占四个字节
    	//将版本进行了保留
        EmbeddedChannel channel = new EmbeddedChannel(
                new LengthFieldBasedFrameDecoder(
                        1024, 0, 4, 1, 4),
                new LoggingHandler(LogLevel.DEBUG)
        );

        //  4 个字节的内容长度， 实际内容
        ByteBuf buffer = ByteBufAllocator.DEFAULT.buffer();
        //想buf中加入内容：Hello, world
        send(buffer, "Hello, world");
        send(buffer, "Hi!");
        //将消息写入channel
        channel.writeInbound(buffer);
    }

    private static void send(ByteBuf buffer, String content) {
        byte[] bytes = content.getBytes(); // 实际内容
        int length = bytes.length; // 实际内容长度
        buffer.writeInt(length);
        buffer.writeByte(1);//使用一个字节表示版本号为：1 
        buffer.writeBytes(bytes);
    }
}

运行结果

00:02:23 [DEBUG] [main] i.n.h.l.LoggingHandler - [id: 0xembedded, L:embedded - R:embedded] REGISTERED
00:02:23 [DEBUG] [main] i.n.h.l.LoggingHandler - [id: 0xembedded, L:embedded - R:embedded] ACTIVE
00:02:23 [DEBUG] [main] i.n.h.l.LoggingHandler - [id: 0xembedded, L:embedded - R:embedded] READ: 13B
         +-------------------------------------------------+
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 01 48 65 6c 6c 6f 2c 20 77 6f 72 6c 64          |.Hello, world   |
+--------+-------------------------------------------------+----------------+
00:02:23 [DEBUG] [main] i.n.h.l.LoggingHandler - [id: 0xembedded, L:embedded - R:embedded] READ: 4B
         +-------------------------------------------------+
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 01 48 69 21                                     |.Hi!            |
+--------+-------------------------------------------------+----------------+
00:02:23 [DEBUG] [main] i.n.h.l.LoggingHandler - [id: 0xembedded, L:embedded - R:embedded] READ COMPLETE

Process finished with exit code 0
?abc!
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Netty 粘包/半包原理与拆包实战 【源代码 新】
11-11
- 本实例是《Netty 粘包/半包原理与拆包实战》 一文的源代码工程。 大家好，我是作者尼恩。 在前面的文章中，完成了一个高性能的 Java 聊天程序，尼恩已经再一次的进行了通讯协议的选择。放弃了大家非常熟悉的json 格式，选择了性能更佳的 Protobuf协议。 本实例，解决粘包和半包问题
Netty 粘包/半包原理与拆包实战 源码
11-11
本实例是《Netty 粘包/半包原理与拆包实战》 一文的源代码工程。 大家好，我是作者尼恩。 在前面的文章中，完成了一个高性能的 Java 聊天程序，尼恩已经再一次的进行了通讯协议的选择。放弃了大家非常熟悉的json 格式，选择了性能更佳的 Protobuf协议。 在上一篇文章中，并且完成了Netty 和 Protobuf协议整合实战。具体的文章为： Netty+Protobuf 整合一：实战案例，带源码 并且，专门开出一篇文章，介绍了通讯消息数据包的几条设计准则。具体的文章为： Netty +Protobuf 整合二：protobuf 消息通讯协议设计的几个准则 在开始聊天器实战开发之前，还有一个非常基础的问题，需要解决：这就是通讯的粘包和半包问题。
netty解析http协议异常Connection closed before received headers 分析
lixia0417mul2的博客
06-15 476
netty解析http协议 http协议解析错误 netty解析http协议错误 http协议不完整导致的解析异常
Netty源码，详解Http协议的数据包解码过程
吴就业
12-29 2021
Http全称为超文本传输协议，是一种无状态协议。即不会记录你上一次访问了什么。一应一答，一个请求一个响应，无需保持连接。在不保持长连接的情况下，一次ht...
Netty使用篇：半包&粘包
热门推荐
七叔的博客
11-13 2万+
Netty使用篇：半包&粘包
netty对http协议解析原理解析
月夜楓
03-12 812
1. http协议 1.1 描述 标示 ASCII 描述 字符 CR 13 Carriage return LF 10 Line feed SP 32 Horizontal space(空 COLON 58 COLON(冒号) : http协议主要使用CRLF进行分 1.2 请求包 主要包含三部分：请求行(line)，请求头(header)，请求正文(body) ...
Netty进阶——粘包/半包
weixin_52315708的博客
06-29 847
TCP（Transmission Control Protocol）是一种面向连接的可靠传输协议，广泛应用于网络通信领域。在TCP协议中，数据被分割成一个一个的报文段进行传输。然而，由于网络传输的不可靠性，TCP协议会面临一些数据传输问题，如粘包和半包问题。在网络通信中，当发送方连续发送多个小数据包时，接收方可能会将它们合并成一个大的数据包，这就是粘包问题；而当发送方发送的数据包长度大于接收方的缓冲区长度时，接收方无法完整接收数据包，导致数据的接收不完整，这就是半包问题。
关于netty配置的理解serverBootstrap.option和serverBootstrap.childOption
zuixiaoyao_001的博客
05-13 5853
关于netty配置的理解serverBootstrap.option和serverBootstrap.childOption The parameters that we set using ServerBootStrap.option apply to the ChannelConfig of a newly created ServerChan...
java socket直接访问netty服务器中数据接收不全的问题
WarrenMihail的博客
06-03 6297
在项目中，通过netty框架搭建的服务器。但是在Android端我想直接采用Socket与服务器通信。但是在这个过程中遇到两个问题。1.服务器接收不到数据解决方法：我发送的形式是直接将字符串转成字节流，按照tcp协议进行发送的。一开始服务器能看到客户端接入了，但是就是收不到消息。后来在字符串的末尾加上了'\n'换行符就行了。2.服务器发送数据时，客户端接收的数据是一串奇怪的字符串。例如：[@Bd3...
解决粘包半包问题--分隔符和消息定长
11-05
组的， 这个问题只能通过上层的应用协议栈设计来解决， 根据业界的主流协议的解决方案， 可以归纳如下。 （1） 在包尾增加分割符， 比如回车换行符进行分割， 例如 FTP 协议； （2） 消息定长， 例如每个报文的大小...
netty websocket通讯接收数据不完整问题
09-23
这是一个java web项目集成了netty websocket的完整代码。java web项目作为服务器端和客户端进行数据通信。但是常常存在提示Max frame length of 65536 has been exceeded问题。初始化握手对象时指定了maxFramePayloadLength 的长度、以及通过配置netty内置解码器处理数据半包等方法，均无效。以下是终极解决办法，供大家参考和解决这样的问题。
netty案例，netty4.1基础入门篇八《NettyClient半包粘包处理、编码解码处理、收发数据方式》源码
10-11
netty案例，netty4.1基础入门篇八《NettyClient半包粘包处理、编码解码处理、收发数据方式》源码 ...
netty案例，netty4.1基础入门篇九《自定义编码解码器，处理半包、粘包数据》源码
10-11
netty案例，netty4.1基础入门篇九《自定义编码解码器，处理半包、粘包数据》源码 ...
Netty粘包/半包问题解析
AN_ERA的博客
02-10 1466
目录 一、什么是粘包/半包问题 二、TCP粘包/半包发生的原因 三、粘包/半包解决办法 四、Netty中粘包/半包解决示例 1. 采用固定长度数据包编解码方式 2. 采用特殊字符作为边界字符编解码方式 3. 基于长度解码器 一、什么是粘包/半包问题 在客户端发送数据时，实际是把数据写入到了TCP发送缓存里面的; 如图: 1. 如果发送的包的大小比TCP发送缓存的容量大，那么...
Netty 从netty角度分析http协议解析（一）HttpServerCodec
anLA_的专栏
12-18 2700
从netty角度分析http协议解析
Netty黏包半包解决方案
前者已逝，后者未至。
03-24 1507
了解黏包半包发生的原因，了解各个解决方案适用的场景。
Netty学习16-如何让Netty应用容易进行问题定位和排查
Pasto的博客
12-29 241
学习第40节 从以下3个方面使Netty应用更容易进行问题定位和排查： • 完善“线程名” • 完善 “Handler ”名称 • 使用好 Netty 的日志 1、完善“线程名” 2、完善 “Handler 名称” 3、使用好Netty日志 Netty 日志的原理及使用 • Netty 日志框架原理 • 修改 JDK logger 级别 • 使用 slf4j + log4j 示例 • 衡量好 logging handler 的位置和级别 注:内容参考极客时间相关课程 ...
【STM32学习】HAL库点灯学习
最新发布
2301_78895982的博客
05-26 950
STM32基于HAL库流水灯实验_hel库安装教程中文版-CSDN博客t=N7T8。
Netty半包和粘包问题如何解决
03-24
Netty半包和粘包问题通常可以通过以下几种方法来解决： 1. 定长方法：通过指定消息的长度来解决，比如在消息头中添加消息长度字段，服务器接收到消息后先判断消息长度是否足够，不够则继续等待，够了则读取数据。 2. 分隔符方法：通过在消息末尾添加一个特殊的分隔符来解决，服务器接收到消息后根据分隔符来判断消息是否读取完整。 3. 消息压缩方法：通过对消息进行压缩来减小消息的长度，比如使用Gzip压缩算法。 需要注意的是，不同的场景需要采用不同的方法，选择正确的方法需要根据具体情况进行判断。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

?abc!

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值