Netty(三)---黏包半包，滑动窗口

最新推荐文章于 2024-06-25 17:50:43 发布
最新推荐文章于 2024-06-25 17:50:43 发布
阅读量363 收藏
点赞数 1
分类专栏： netty 文章标签： java c# 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_45699541/article/details/126386054
版权
本文详细探讨了TCP协议中出现的黏包和半包问题，通过实例代码展示了如何在服务器和客户端设置接收缓冲区大小来触发这些问题。同时，提到了滑动窗口、固定分隔符、预设长度等解决策略，并介绍了协议解析和设计的重要性，特别是HTTP协议在处理这类问题上的应用。最后，文章强调了协议解析和设计在确保数据正确传输中的关键作用。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

黏包半包

黏包现象

#客户端向 服务器发送10*16个字节 (分十次发送)

#服务器端 , 
 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));
                    ch.pipeline().addLast(new ChannelInboundHandlerAdapter() {
                        @Override
                        public void channelActive(ChannelHandlerContext ctx) throws Exception {
                            log.debug("connected {}", ctx.channel());
                            super.channelActive(ctx);
                        }

                        @Override
                        public void channelInactive(ChannelHandlerContext ctx) throws Exception {
                            log.debug("disconnect {}", ctx.channel());
                            super.channelInactive(ctx);
                        }
                    });
                }
            });
            ChannelFuture channelFuture = serverBootstrap.bind(8080);
            log.debug("{} binding...", channelFuture.channel());
            channelFuture.sync();
            log.debug("{} bound...", channelFuture.channel());
            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();
    }
}

#客户端
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 {
                    log.debug("connetted...");
                    ch.pipeline().addLast(new ChannelInboundHandlerAdapter() {
                        @Override
                        public void channelActive(ChannelHandlerContext ctx) throws Exception {
                            log.debug("sending...");
                            Random r = new Random();
                            char c = 'a';
                            for (int i = 0; i < 10; i++) {
                                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);
                            }
                        }
                    });
                }
            });
            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();
        }
    }
}

在这里插入图片描述

出现半包现象

 // 出现半包现象 《---设置接收缓冲区的大小
            serverBootstrap.option(ChannelOption.SO_RCVBUF,9) ;

在这里插入图片描述

滑动窗口

在这里插入图片描述

在这里插入图片描述

利用短链接设置半包

建立十次连接
虽然能解决黏包问题,但是还是不能避免半包问题

#服务器端
 //设置每个连接的channel最大缓冲区 这样会出现半包现象
 serverBootstrap.childOption(ChannelOption.RCVBUF_ALLOCATOR,new AdaptiveRecvByteBufAllocator(10,10,10)) ;



#客户端
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.option(ChannelOption.SO_RCVBUF,300) ;

            //设置每个连接的channel最大缓冲区 这样会出现半包现象
            serverBootstrap.childOption(ChannelOption.RCVBUF_ALLOCATOR,new AdaptiveRecvByteBufAllocator(10,10,10)) ;

            serverBootstrap.childHandler(new ChannelInitializer<SocketChannel>() {
                @Override
                protected void initChannel(SocketChannel ch) throws Exception {
                    //****
                    ch.pipeline().addLast(new LoggingHandler(LogLevel.DEBUG));
                    //
                    ch.pipeline().addLast(new ChannelInboundHandlerAdapter() {
                        @Override
                        public void channelActive(ChannelHandlerContext ctx) throws Exception {
                            log.debug("获得连接管道 connected {}", ctx.channel());
                            super.channelActive(ctx);
                        }

                        @Override
                        public void channelInactive(ChannelHandlerContext ctx) throws Exception {
                            log.debug("管道关闭disconnect {}", ctx.channel());
                            super.channelInactive(ctx);
                        }
                    }

                    //*****
                    );
                }
            });
            ChannelFuture channelFuture = serverBootstrap.bind(8080);
            log.debug("{} binding...", channelFuture.channel());
            channelFuture.sync();
            log.debug("{} bound...", channelFuture.channel());
            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();
    }
}

在这里插入图片描述

固定分隔符

不常用

固定长度

这种并不好 设定接收长度为十 ,每次空余的也会被填满

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 {
                    log.debug("connetted...");
                    ch.pipeline().addLast(new LoggingHandler(LogLevel.DEBUG));
                    ch.pipeline().addLast(new ChannelInboundHandlerAdapter() {
                        @Override
                        public void channelActive(ChannelHandlerContext ctx) throws Exception {
                            log.debug("sending...");
                            // 发送内容随机的数据包
                            Random r = new Random();
                            char c = 'a';
                            ByteBuf buffer = ctx.alloc().buffer();
                            for (int i = 0; i < 10; i++) {
                                byte[] bytes = new byte[8];
                                for (int j = 0; j < r.nextInt(8); j++) {
                                    bytes[j] = (byte) c;
                                }
                                c++;
                                buffer.writeBytes(bytes);
                            }
                            ctx.writeAndFlush(buffer);
                        }
                    });
                }
            });
            ChannelFuture channelFuture = bootstrap.connect("192.168.0.103", 9090).sync();
            channelFuture.channel().closeFuture().sync();

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

预设长度

 public static void main(String[] args) {
        EmbeddedChannel channel = new EmbeddedChannel(
                new LengthFieldBasedFrameDecoder(
                        //   lengthFieldOffset长度偏移量,  lengthFieldLength 长度所占字节, initialBytesToStrip： 过滤四个字节，因为长度占四个
                        1024,0,4,0,4),
                new LoggingHandler(LogLevel.DEBUG)
        );

        ByteBuf buffer = ByteBufAllocator.DEFAULT.buffer();

         send(buffer,"w=wwww");
         send(buffer,"w=wwwaaaw");
         send(buffer,"w=wwasdwww");
          // 写入channel
        channel.writeInbound(buffer) ;

    }

  public static void send(ByteBuf buf,String content){
      byte[] bytes = content.getBytes(StandardCharsets.UTF_8);
      //先写入长度
      buf.writeInt(bytes.length);
      //再写入内容
      buf.writeBytes(bytes);
  }

协议解析和设计


public class HelloWorldServer {
    static final Logger log = LoggerFactory.getLogger(HelloWorldServer.class);
    final byte[] LINE = {13,10};
    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));
                    //
                  ch.pipeline().addLast(new HttpServerCodec()) ;
                  //
                  /*  ch.pipeline().addLast(new ChannelInboundHandlerAdapter(){
                        @Override
                        public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
                            log.info("{}",msg.getClass());
                            if (msg instanceof HttpRequest){

                            }else if (msg instanceof HttpContent){

                            }

                        }
                    });
*/
                    // 入站处理器 对某一种类型的 请求关心
                   ch.pipeline().addLast(new SimpleChannelInboundHandler<HttpRequest>() {
                       @Override
                       protected void channelRead0(ChannelHandlerContext ctx,
                                                   HttpRequest httpRequest) throws Exception {
                           System.out.println(httpRequest.getUri());
                           //返回响应
                           DefaultFullHttpResponse response =
                                   new DefaultFullHttpResponse(httpRequest.getProtocolVersion(),
                                           HttpResponseStatus.OK
                                           ) ;

                           byte[] bytes = "<h1>hll 你个 sb<h1>".getBytes(StandardCharsets.UTF_8);
                           // 告诉浏览器响应长度

                           response.headers().setInt(CONTENT_LENGTH,bytes.length);
                           response.content().writeBytes(bytes) ;
                         //写回响应
                           ctx.writeAndFlush(response);
                       }
                   });

                    //*****
                }
            });
            ChannelFuture channelFuture = serverBootstrap.bind(8080);
            log.debug("{} binding...", channelFuture.channel());
            channelFuture.sync();
            log.debug("{} bound...", channelFuture.channel());
            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();
    }

浏览器访问8080端口
在这里插入图片描述

30.Netty进阶-黏包&半包解决方案-短链接
卷土的博客
06-22 339
/调整netty的接收缓冲区ByteBuf, AdaptiveRecvByteBufAllocator设置最小值就是16，所以在调小是不行的。从滑动窗口看，在服务端保证有足够的缓冲区。默认服务端的滑动窗口足够大。所以不要再设置SO_RCVBUF的值，使用默认的就可以了。如果在服务端调整netty的接收缓冲区ByteBuf为16字节，客户端发送数据位18个字节。客户端发送一次完整的消息，然后就把与服务端的链接断开。服务端读到的结果就是-1。服务器就知道 从链接建立到断开，发送的数据是一条完整的数据。
29.Netty进阶-黏包&半包
卷土的博客
06-21 401
服务端代码客户端代码从日志信息看出：服务端收到了160个字节这是一个黏包的现象，客户端发了十次，每次发送16个字节。但是服务端一次性接受了160个字节。
netty——黏包半包的解决方案、滑动窗口的概念
qq_44027353的博客
11-16 1057
黏包半包 滑动窗口 在深入理解黏包半包问题之前，先了解TCP的一个知识点——滑动窗口 我们都指定tcp是一种可靠的传输协议，这主要是因为在tcp中客户端给服务器端发送一条消息，要等待服务器端的应答，如果很长时间都没有应答那就需要重发这条消息。 既然引入了应答机制，那势必会影响到吞吐量，需要等到第一条消息的应答回来后才能发送第二条消息，这样就会导致吞吐量比较低，解决方法就是引入了滑动窗口的概念。 在发送方可以设置一个窗口的大小，其实就是一个有大小的缓冲区，还能有一个流量监控的功能。在这个窗口大小范围内的请
Netty-网络协议与滑动窗口
dhylanyu1的博客
07-29 475
Netty-网络协议与滑动窗口TCP三次握手漏洞：四次挥手心跳TCP通信原理Socket套接字TCP缓冲区窗口机制滑动窗口目的Http过程 TCP 三次握手 三次握手原因： TCP是面向连接的，需要双方都确认连接的建立。 第一次握手：客户端请求建立连接 第二次握手：服务器应答，并请求建立连接 第三次握手：客户端针对服务器请求的确认应答 漏洞： SYN洪泛攻击 网络服务所在的端口发送大量伪造原地址的攻击报文，发送到服务端，造成服务端上的半开连接队列被占满，从而阻止其他用户进行访问 解决方案： 无效连接
Netty进阶——粘包与半包（滑动窗口)
小志的博客
11-29 411
Netty进阶——粘包与半包（滑动窗口)
Netty 应用
weixin_44025076的博客
07-06 427
Netty 应用 粘包和半包 分析 粘包 现象 发送 abc def，接收 abcdef 原因 应用层 接收方 ByteBuf 设置太大（Netty 默认 1024） 传输层-网络层 滑动窗口：假设发送方 256 bytes 表示一个完整报文，但由于接收方处理不及时且**窗口大小足够大（大于256 bytes），这 256 bytes 字节就会缓冲在接收方的滑动窗口中，**当滑动窗口中缓冲了多个报文就会粘包 Nagle 算法：会造成粘包 半包 现象 发送 abcdef，接收
Netty学习（二）——黏包半包、协议设计解析、聊天室
最新发布
weixin_44630656的博客
06-25 1141
TCP 以一个段（segment）为单位，每发送一个段就需要进行一次确认应答（ack）处理，但如果这么做，缺点是包的往返时间越长性能就越差为了解决此问题，引入了窗口概念，窗口大小即决定了无需等待应答而可以继续发送的数据最大值窗口实际就起到一个缓冲区的作用，同时也能起到流量控制的作用图中深色的部分即要发送的数据，高亮的部分即窗口窗口内的数据才允许被发送，当应答未到达前，窗口必须停止滑动如果 1001~2000 这个段的数据 ack 回来了，窗口就可以向前滑动。
netty框架图及netty面试知识点解析
11-13
4. 流量控制：理解TCP的滑动窗口机制及其在Netty中的应用。 5. Netty的内存管理：比如ByteBuf的使用和池化策略。 6. 高级特性：例如零拷贝技术、心跳检测、通道管道的自定义等。 7. Netty在实际项目中的应用案例：如...
TCP滑动窗口和SO_RCVBUF之间的实际关系
wfziyou的专栏
06-18 848
上次转载了一篇文章http://blog.youkuaiyun.com/jwybobo2007/archive/2010/12/30/6107419.aspx, 上面提到了TCP窗口大小与SO_RCVBUF选项之间的关系.但其实这篇文章描述的是有问题的.   　　在以Unix为核心的一些操作系统中(不一定都是),SO_RCVBUF选项确实决定了TCP窗口的大小.你设置为多少窗口就为多少.但在Windows
（四）Netty之Buffer缓冲区
qq_38949960的博客
11-26 1810
基本介绍 缓冲区（Buffer）：缓冲区本质上是一个可以读写数据的内存块，可以理解成是一个容器对象（含数组），该对象提供了一组方法，可以更轻松地使用内存块，缓冲区对象内置了一些机智，能够跟踪和记录缓冲区的状态变化情况。Channel提供从文件、网络读取数据的渠道，但是读取或写入的数据都必须经由Buffer Buffer类及其子类 1.在NIO中，Buffer是一个顶层父类，它是一个抽象类，类的层级关系图： 常用Buffer子类一览 ByteBuffer，存储字节数据到缓冲区 ShortBuffer，存
NETTY option参数
ddz777751的博客
02-23 524
Channel配置参数 (1).通用参数 CONNECT_TIMEOUT_MILLIS :   Netty参数，连接超时毫秒数，默认值30000毫秒即30秒。 MAX_MESSAGES_PER_READ   Netty参数，一次Loop读取的最大消息数，对于ServerChannel或者NioByteChannel，默认值为16，其他Channel默认值为1。默认值这样...
netty-接收缓冲区大小适配及类型选择
godme
03-14 9527
Channel创建 再次回顾一下Channel的流程吧。 doBind public ChannelFuture bind(int inetPort) { return bind(new InetSocketAddress(inetPort)); } bind2 public ChannelFuture bind(SocketAddress localAddress) { val...
Netty进阶-Netty篇
原名又逢乱世。不要放下学习的脚步，毕竟比天天打牌、钓鱼、打游戏更能从内在充实自己。
01-21 3298
Netty处理粘包、半包、 粘包、半包现象分析、 什么是滑动窗口、 什么是MSS限制、 什么是Nagle算法、 协议设计与解析、 http 协议、 自定义协议、 @Sharable 注解、 空闲检测-连接假死、 Netty常用参数配置
Netty遇到TCP发送缓冲区满了 写半包操作该如何处理
Java技术攻略的博客
03-13 1023
主要负责处理写半包：环形发送数组不停地从ChannelOutboundBuffer读取数据，看是否有可以发送的数据如果有，并且是ByteBuf类型的，可以选择发送数据如果一次发送没有发送完，则采取一定次数的循环发送（写半包）数据最后还是没有发送完，则会开一条新线程专门进行剩余数据的发送在最后会去同步数据写入进度对于接收方来说，来自发送方的数据压力太大了，因此不得不采取的一种降保护措施可以在发送方进行解决、也可以在接收方进行解决。
Java简单实现滑动窗口
热门推荐
tianyaleixiaowu的专栏
11-01 1万+
由于最近有一个统计单位时间内某key的访问次数的需求，譬如每5秒访问了redis的某key超过100次，就取出该key单独处理。 这样的单位时间统计，很明显我们都知道有个边界问题，譬如5秒内100次的限制。刚好前4.99秒访问都是0，最后0.01秒来了100次，5.01秒又来了100次。也就是访问有明显的毛刺情况出现，为了弱化这个毛刺情况，我们可以采用滑动窗口。 滑动窗口 滑动窗口的主要原理...
Netty 笔记整理
u012662731的博客
12-15 2953
Netty是一个高性能、异步事件驱动的NIO框架，它提供了对TCP、UDP和文件传输的支持，作为一个异步NIO框架，Netty的所有IO操作都是异步非阻塞的，通过Future-Listener机制，用户可以方便的主动获取或者通过通知机制获得IO操作结果。  作为当前最流行的NIO框架，Netty在互联网领域、大数据分布式计算领域、游戏行业、通信行业等获得了广泛的应用，一些业界著名的开
滑动窗口
leifei2012的博客
07-08 745
如果采用同步的数据传送方式即发送一个数据包就等待接收方一个ack确认信息的话，传输效率太低。 采用滑动窗口： 发送方的发送缓存内的数据都可以被分为4类: 已发送，已收到ACK 已发送，未收到ACK 未发送，但允许发送 未发送，但不允许发送 其中类型2和3都属于发送窗口。 接收方的缓存数据分为3类： 已接收 未接收但准备接收 未接收而且不准备接收 数据传输过程： 首先发送端发送A,B,...
深入解析Netty框架及其面试核心知识点
### 三、Netty底层TCP协议的滑动窗口解析 Netty内部通过ChannelHandlerContext、ChannelInboundHandler和ChannelOutboundHandler等组件对TCP的滑动窗口机制进行了抽象和封装，使得开发者能够更加专注于应用逻辑的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值