Netty-4 TCP粘包拆包问题

最新推荐文章于 2024-09-03 14:42:05 发布
最新推荐文章于 2024-09-03 14:42:05 发布
阅读量705 收藏 1
点赞数
分类专栏： # Netty
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mail_liuxing/article/details/90609205
版权

完整代码：https://gitee.com/firewolf/java-io/tree/master/java-io/netty-02-tcppacket

一、TCP粘包/拆包问题

TCP是一个“流”协议，所谓流，也就是一串没界限的数字，在TCP底层是连接成一片的，没有界限，因为不知道业务层含义，所以只会根据TCP缓冲区的实际情况进行划分，导致在业务层来看，一个完整的包可能会被TCP拆分成多个包，也可能把多个小的包封装起来，形成一个大的包。
粘包和拆包可能会出现如下情况：
在这里插入图片描述
假设客户端发送两个数据包D1和D2给服务端，由于服务端一次读到的字节数是不固定的，所以可能出现如下几种情况：

  1. 服务端分两次读取到了两个完整的数据包，分别是D1和D2，没有发生粘包和拆包；
  2. 服务端一次读取到了两个数据包，D1和D2粘在了一起，发生了粘包；
  3. 服务端分两次读了两个数据包，第一次读取了完整的D1包和D2包的一部分内容D2_1，第二次读取了D2包的另外一部分D2_2。发生了拆包和粘包；
  4. 服务端分两次读了两个数据包，第一次读取了D1包的部分D1_1，第二次读取了D1包的另一部分D1_2和D2完整包，发生了粘包和拆包；
  5. 除此之外，还可能发生多次拆包和粘包；

二、TCP粘包/拆包问题产生的原因

问题产生的原因主要有三个：

  1. 应用程序write写入的字节大小大于套接口发送缓冲区的大小；
  2. 进行MSS大小的TCP分段
  3. 以太网的payload大于MTU进行IP分片
    在这里插入图片描述

三、TCP粘包/拆包问题的解决策略

  1. 消息定长，例如每个报文的长度为200，不够的时候，使用空格补齐；
  2. 在尾部增加回车换行符进行分割，如TCP协议；
  3. 在尾部增加特殊的字符进行分割，回车换行就是一种特殊的情况；
  4. 将消息分为消息头和消息体，消息头包含表示消息总长度字段；
  5. 使用更复杂的应用层协议；

四、TCP粘包/拆包问题演示

这里简单的写一个程序，功能是客户端连接服务端之后，向服务端发送20个字符串，服务端收到后进行显示：

（一）服务端

package com.firewolf.java.io.netty.packagee.paste.origin;

import io.netty.bootstrap.ServerBootstrap;
import io.netty.buffer.ByteBuf;
import io.netty.channel.Channel;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelHandlerAdapter;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelOption;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import java.util.HashMap;
import java.util.Map;

/**
 * 作者：刘兴 时间:2019/5/15
 **/
public class HelloServer {


  public HelloServer(int port) {

    EventLoopGroup bossGroup = new NioEventLoopGroup();
    EventLoopGroup workGroup = new NioEventLoopGroup();
    try {
      ServerBootstrap bootstrap = new ServerBootstrap();
      bootstrap.group(bossGroup, workGroup)
          .channel(NioServerSocketChannel.class)
          .option(ChannelOption.SO_BACKLOG, 1024)
          .childHandler(new ChannelInitializer<SocketChannel>() {
            @Override
            protected void initChannel(SocketChannel socketChannel) throws Exception {
              socketChannel.pipeline()
                  .addLast(new MessageServerHandler());
            }
          });
      ChannelFuture future = bootstrap.bind(port).sync();
      System.out.println("启动服务端监听端口：" + port);
      future.channel().closeFuture().sync();

    } catch (InterruptedException e) {
      e.printStackTrace();
    } finally {
      bossGroup.shutdownGracefully();
      workGroup.shutdownGracefully();
    }

  }

  class MessageServerHandler extends ChannelInboundHandlerAdapter {

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
      ByteBuf buf = (ByteBuf) msg;
      byte[] bytes = new byte[buf.readableBytes()];
      buf.readBytes(bytes);
      String message = new String(bytes);
      System.out.println("有客户端消息：" + message);
      buf.release();
    }
  }


  public static void main(String[] args) {
    new HelloServer(9999);
  }

}

（二）客户端

package com.firewolf.java.io.netty.packagee.paste.origin;

import io.netty.bootstrap.Bootstrap;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelHandlerAdapter;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelOption;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioSocketChannel;
import java.net.InetSocketAddress;

/**
 * 作者：刘兴 时间:2019/5/15
 **/
public class HelloClient {


  public HelloClient(String host, int port) {
    NioEventLoopGroup group = new NioEventLoopGroup();
    try {
      Bootstrap bootstrap = new Bootstrap();
      bootstrap.group(group)
          .channel(NioSocketChannel.class)
          .option(ChannelOption.TCP_NODELAY, true)
          .handler(new ChannelInitializer<SocketChannel>() {
            @Override
            protected void initChannel(SocketChannel socketChannel) throws Exception {
              socketChannel.pipeline()
                  .addLast(new MessageClientHandler());
            }
          });

      ChannelFuture f = bootstrap.connect(new InetSocketAddress(host, port)).sync();
      System.out.println("连接服务器成功-----");
      f.channel().closeFuture().sync();
    } catch (InterruptedException e) {
      e.printStackTrace();
    } finally {
      group.shutdownGracefully();
    }
  }


  class MessageClientHandler extends ChannelInboundHandlerAdapter {

    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {

      //遍历写出100个字符串
      for (int i = 0; i < 20; i++) {
        String message = "helllo," + i + System.getProperty("line.separator");
        ByteBuf buf = Unpooled.buffer(message.getBytes().length);
        buf.writeBytes(message.getBytes());
        ctx.writeAndFlush(buf);
      }
    }
  }


  public static void main(String[] args) {
    new HelloClient("127.0.0.1", 9999);
  }
}

启动服务端，再启动客户端，服务端打印信息如下：

有客户端消息：helllo,0
helllo,1
helllo,2
helllo,3
helllo,4
helllo,5
helllo,6
helllo,7
helllo,8
helllo,9
helllo,10
helllo,11
helllo,12
helllo,13
helllo,14
helllo,15
helllo,16
helllo,17
helllo,18
helllo,19

我们会发现，实际上， 服务端一次接受了全部字符串，也就是说，这些包并没有正常的接受到，而是发生了粘包。

五、Netty对粘包/拆包问题解决

为了解决TCP拆包/粘包导致的半读包问题，Netty默认提供了很多编码解码器用于处理半包。

（一）LineBasedFrameDecoder

LineBasedFrameDecoder会对包进行识别，根据包里面的回车(13)换行(10)符进行切割。

1. 服务端代码

package com.firewolf.java.io.netty.packagee.paste.solve;

import io.netty.bootstrap.ServerBootstrap;
import io.netty.buffer.ByteBuf;
import io.netty.channel.Channel;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelHandlerAdapter;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelOption;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.handler.codec.LineBasedFrameDecoder;
import io.netty.handler.codec.string.StringDecoder;
import java.util.HashMap;
import java.util.Map;

/**
 * 作者：刘兴 时间:2019/5/15
 **/
public class HelloServerSolve {


  public HelloServerSolve(int port) {

    EventLoopGroup bossGroup = new NioEventLoopGroup();
    EventLoopGroup workGroup = new NioEventLoopGroup();
    try {
      ServerBootstrap bootstrap = new ServerBootstrap();
      bootstrap.group(bossGroup, workGroup)
          .channel(NioServerSocketChannel.class)
          .option(ChannelOption.SO_BACKLOG, 1024)
          .childHandler(new ChannelInitializer<SocketChannel>() {
            @Override
            protected void initChannel(SocketChannel socketChannel) throws Exception {
              socketChannel.pipeline()
                  //添加编码器
                  .addLast(new LineBasedFrameDecoder(1024))
                  .addLast(new StringDecoder())
                  .addLast(new MessageServerHandler());
            }
          });
      ChannelFuture future = bootstrap.bind(port).sync();
      System.out.println("启动服务端监听端口：" + port);
      future.channel().closeFuture().sync();

    } catch (InterruptedException e) {
      e.printStackTrace();
    } finally {
      bossGroup.shutdownGracefully();
      workGroup.shutdownGracefully();
    }

  }

  class MessageServerHandler extends ChannelInboundHandlerAdapter {


    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
      //由于StringDecoder的功劳，接受消息的时候，我们可以直接转成String
      String message = (String) msg;
      System.out.println("有客户端消息：" + message);
    }
  }


  public static void main(String[] args) {
    new HelloServerSolve(9999);
  }

}

服务端有两处改动

  • 给启动类BootStrap添加了消息解码器；
  • 接受消息的时候直接使用String接受，这个是由于添加了StringDecoder具有的功能。

2.客户端代码

package com.firewolf.java.io.netty.packagee.paste.solve;

import io.netty.bootstrap.Bootstrap;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelHandlerAdapter;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelOption;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioSocketChannel;
import io.netty.handler.codec.LineBasedFrameDecoder;
import io.netty.handler.codec.string.StringDecoder;
import java.net.InetSocketAddress;

/**
 * 作者：刘兴 时间:2019/5/15
 **/
public class HelloClientSolve {


  public HelloClientSolve(String host, int port) {
    NioEventLoopGroup group = new NioEventLoopGroup();
    try {
      Bootstrap bootstrap = new Bootstrap();
      bootstrap.group(group)
          .channel(NioSocketChannel.class)
          .option(ChannelOption.TCP_NODELAY, true)
          .handler(new ChannelInitializer<SocketChannel>() {
            @Override
            protected void initChannel(SocketChannel socketChannel) throws Exception {
              socketChannel.pipeline()
                  .addLast(new MessageClientHandler());
            }
          });

      ChannelFuture f = bootstrap.connect(new InetSocketAddress(host, port)).sync();
      System.out.println("连接服务器成功-----");
      f.channel().closeFuture().sync();
    } catch (InterruptedException e) {
      e.printStackTrace();
    } finally {
      group.shutdownGracefully();
    }
  }


  class MessageClientHandler extends ChannelInboundHandlerAdapter {

    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {

      //遍历写出100个字符串
      for (int i = 0; i < 20; i++) {
        String message = "helllo," + i + System.getProperty("line.separator");
        ByteBuf buf = Unpooled.buffer(message.getBytes().length);
        buf.writeBytes(message.getBytes());
        ctx.writeAndFlush(buf);
      }
    }
  }


  public static void main(String[] args) {
    new HelloClientSolve("127.0.0.1", 9999);
  }
}

我们可以看到，客户端没有任何变化。

3.查看效果

再次启动后，打印内容如下：

有客户端消息：helllo,0
有客户端消息：helllo,1
有客户端消息：helllo,2
有客户端消息：helllo,3
有客户端消息：helllo,4
有客户端消息：helllo,5
有客户端消息：helllo,6
有客户端消息：helllo,7
有客户端消息：helllo,8
有客户端消息：helllo,9
有客户端消息：helllo,10
有客户端消息：helllo,11
有客户端消息：helllo,12
有客户端消息：helllo,13
有客户端消息：helllo,14
有客户端消息：helllo,15
有客户端消息：helllo,16
有客户端消息：helllo,17
有客户端消息：helllo,18
有客户端消息：helllo,19

可以看到，这些消息是分开了的，没有了粘包和拆包问题。
LineBasedFrameDecoder：以回车换行符作为对包进行切割；
StringDecoder：把ByteBuf转换成字符串
一般情况下，StringDecoder和LineBasedFrameDecoder会配合使用。

（二）DelimiterBasedFrameDecoder

其实DelimiterBasedFrameDecoder的功能和LineBasedFrameDecoder类似，只不过会比LineBasedFrameDecoder更加强大，支持我们自己指定用来切割的字符（串），使用方法和LineBasedFrameDecoder几乎是一模一样，这里只是简单的贴出部分代码：

1.服务端添加解码器

这里使用_$进行分割：

 socketChannel.pipeline()
                  //添加编码器
                  .addLast(new DelimiterBasedFrameDecoder(1024, Unpooled.copiedBuffer("_$".getBytes())))

2.发送消息的时候，带上_$结尾

    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {

      //遍历写出100个字符串
      for (int i = 0; i < 20; i++) {
        String message = "helllo," + i + "_$";
        ByteBuf buf = Unpooled.buffer(message.getBytes().length);
        buf.writeBytes(message.getBytes());
        ctx.writeAndFlush(buf);
      }
    }

（三）FixedLengthFrameDecoder

FixedLengthFrameDecoder是固定长度解码器，它能够按照指定的长度对消息进行解码。
同样，这里只是简单的贴出发生变化的代码（相对于DelimiterBasedFrameDecoder）。

1. 服务端添加解码器

              socketChannel.pipeline()
                  //添加编码器
                  .addLast(new FixedLengthFrameDecoder(20))

这里设置长度为20

2. 客户端

没有任何变化，就不再贴出

效果如下：

有客户端消息：helllo,0_$helllo,1_$
有客户端消息：helllo,2_$helllo,3_$
有客户端消息：helllo,4_$helllo,5_$
有客户端消息：helllo,6_$helllo,7_$
有客户端消息：helllo,8_$helllo,9_$
有客户端消息：helllo,10_$helllo,11
有客户端消息：_$helllo,12_$helllo,
有客户端消息：13_$helllo,14_$helll
有客户端消息：o,15_$helllo,16_$hel
有客户端消息：llo,17_$helllo,18_$h

可以看到，得到的字符串长度都是20，而且，最后一个由于长度不足20，就没有显示出来。

六、总结

自行阅读上面几个解码器的原代码我们可以看到，这些解码器都是继承了ByteToMessageDecoder，对原始获取到的ByteBuf进行了处理，也就是说，我们也可以通过继承ByteToMessageDecoder来实现自己的解码器。

遮不住的殇
关注
专栏目录
Netty4实战 - TCP粘包&拆包解决方案
Ricky
03-15 1万+
Netty4实战 - TCP粘包&拆包解决方案
Netty解决TCP粘包拆包问题
is_Javaer的博客
08-19 501
什么是TCP粘包/拆包 TCP是一种面向连接的、可靠的、基于字节流的传输层通信协议。TCP是基于字节流传输的，就像河流一样，数据“流”式传输，数据中间没有分界。 TCP底层并不了解上层业务数据的具体含义，它会根据TCP缓冲区的实际情况进行包的划分，所以一个完整的数据包可能会拆分成多个包传输，或者多个数据包可能会合并成一个包传输，这就是所谓的TCP的粘包/拆包问题。如下图所示： 正常业务逻辑上，Client需要向Server发送D1和D2两个数据包（如上图第一种情况）；但实际在TCP传输的过程中，可能会将D
Netty精粹之TCP粘包拆包问题
09-27
什么是粘包拆包，为什么发生拆包粘包问题，如何处理拆包粘包问题
Netty 之 TCP粘包拆包场景
z69183787的专栏
09-20 1185
TCP编程底层都有粘包和拆包机制，因为我们在C/S这种传输模型下，以TCP协议传输的时候，在网络中的byte其实就像是河水，TCP就像一个搬运工,将这流水从一端转送到另一端，这时又分两种情况： 1）如果客户端的每次制造的水比较多，也就是我们常说的客户端给的包比较大，TCP这个搬运工就会分多次去搬运。 2）如果客户端每次制造的水比较少的话，TCP可能会等客户端多次生产之后，把所有的水一起
【netty系列-09】深入理解和解决tcp的粘包拆包
最新发布
zhenghuishengq的博客
09-03 1318
深入理解和解决tcp的粘包拆包问题
Netty解决粘包和拆包问题的四种方案
weixin_34239169的博客
03-21 1014
在RPC框架中，粘包和拆包问题是必须解决一个问题，因为RPC框架中，各个微服务相互之间都是维系了一个TCP长连接，比如dubbo就是一个全双工的长连接。由于微服务往对方发送信息的时候，所有的请求都是使用的同一个连接，这样就会产生粘包和拆包的问题。本文首先会对粘包和拆包问题进行描述，然后介绍其常用的解决方案，最后会对Netty提供的几种解决方案进行讲解。这里说明一下，由于oschina将“jie m...
Netty 粘包 拆包
weixin_36995355的博客
11-10 143
什么是粘包和半包？ 先从数据包的发送和接收开始讲起。 我们知道， Netty 发送和读取数据的单位，可以形象的使用 ByteBuf 来充当。 每一次发送，就是向Channel 写入一个 ByteBuf ；每一次读取，就是从 Channel 读到一个 ByteBuf 。 发送一次数据，举例如下： channel.writeAndFlush(buffer); 读取一次数据，举例如下： public void channelRead(ChannelHandlerContext ctx, O.
使用Netty解决TCP粘包和拆包问题过程详解
08-25
使用Netty解决TCP粘包和拆包问题过程详解 Netty是一个流行的Java网络编程框架，提供了简洁、灵活的API来处理网络编程的各种问题。其中，解决TCP粘包和拆包问题是Netty的一个重要应用场景。本文将详细介绍使用Netty...
netty解决tcp粘包和拆包问题
远方的少年
01-20 2937
tcp为了提高效率会将多个数据包批量发送过来，所以就会存在粘包和拆包的问题。使用Netty,可以通过自定义协议+编解码器来解决粘包和拆包的问题。 1.定义协议 public class MessageProtocol { private int len; private byte[] content; public int getLen() { return len; } public void setLen(int len) {
Netty粘包拆包问题解决方案
08-18
Netty 粘包拆包问题解决方案 Netty 是一个基于 Java 的网络编程框架，它提供了一个便捷的方式来处理网络数据的读写操作。然而，在使用 Netty 进行网络编程时，经常会遇到粘包和拆包的问题。所谓粘包和拆包，就是指...
Netty粘包拆包
qq_41931364的博客
01-03 461
Netty粘包拆包1、什么是粘包拆包？2、解决方案3、代码示例3.1、MyClient3.2、MyClientHandler3.3、MyServer3.4、MyServerHandler3.5、MyMessageDecoder3.6、MyMessageEncoder3.7、MyMessageProtocol 1、什么是粘包拆包？ 粘包拆包一般是发生在TCP协议层的，TCP作为传输层一般不知道上层（这里指的是我们的代码业务层）数据的具体含义，它会根据TCP缓冲区 的实际情况进行数据包的划分，所以在业务上认为
Netty 粘包/拆包
www1234的博客
01-15 411
  Netty 粘包/拆包 TCP是个“流”协议，所谓流，就是没有界限的一串数据。大家可以想想河里的流水，是连成一片的，其间并没有分界线。TCP底层并不了解上层业务数据的具体含义，它会根据TCP缓冲区的实际情况进行包的划分，所以在业务上认为，一个完整的包可能会被TCP拆分成多个包进行发送，也有可能把多个小的包封装成一个大的数据包发送，这就是所谓的TCP粘包和拆包问题。 ​​ 假设客户端分别...
Netty是如何解决TCP的粘包和拆包问题的？
热门推荐
LMR的博客
05-21 1万+
TCP是个“流协议”，所谓流，就是没有界限的一连串数据，没有界限。TCP底层不了解业务数据的含义，它会根据TCP缓冲区的实际情况进行包的划分，所以业务上认为，一个完整的包可能被TCP拆分为多个包进行发送，也可能把多个小包封装成一个大的数据包进行发送，这就是所谓的TCP粘包和拆包问题。
Netty中粘包和拆包的解决方案
一个无限死循环的博客
10-10 739
粘包和拆包是TCP网络编程中不可避免的，无论是服务端还是客户端，当我们读取或者发送消息的时候，都需要考虑TCP底层的粘包/拆包机制。 TCP粘包和拆包 TCP是个“流”协议，所谓流，就是没有界限的一串数据。TCP底层并不了解上层业务数据的具体含义，它会根据TCP缓冲区的实际情况进行包的划分，所以在业务上认为，一个完整的包可能会被TCP拆分成多个包进行发送，也有可能把多个小的包封装成一个大的数据包发...
netty4源码阅读与分析---netty4如何处理tcp的粘包，拆包
红尘之一骑的专栏
06-27 521
粘包，拆包
Netty解决TCP粘包/拆包导致的半包读写问题
ForeverLove的博客
07-12 5162
一.TCP粘包/拆包问题说明   TCP是个“流”协议，就是没有界限的一串数据。TCP底层并不了解上层业务数据的具体含义，它会根据TCP缓冲区的实际情况进行包拆分，所以在业务上认为，一个完整的包可能会被TCP拆分成多个包进行发送，也有可能把多个小的包封装成一个大的数据包发送，这就是所谓的TCP粘包和拆包问题。 二.利用LinedBasedFrameDecoder解决TCP粘包问题    为了
Netty框架之粘包、拆包
蜗牛的高铁
09-30 492
netty实战1. 概述2. TCP粘包/拆包2.1 出现原因2.2 解决办法3. Netty拆包方案 1. 概述 在网络编程中，数据总是以字节的形式在流动，我们在实际开发中，总是要知道一段消息从哪开始从哪结束。解决好这个问题实际上就解决了TCP的粘包和拆包问题。 2. TCP粘包/拆包 TCP协议的字节流是有序而无实际意义的二进制，我们实际开发中给数据限定的业务意义对字节流来说是透明的，对底层TCP协议来说我们所谓的业务数据可能是一个块，也可能是分多个块传输，所以出现了粘包和拆包的问题，即粘包和拆包是依据
Netty 笔记之粘包拆包问题
Wu_yongtao的博客
02-14 1211
在 TCP 的通信过程中，发送数据流的时候，有可能出现一份完整的数据，被 TCP 拆分为多个数据包进行发送，当然也有可能将多个数据包合并为一个数据包进行发送。从而产生了粘包以及拆包的问题。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值