• 面试突击：什么是粘包和半包？怎么解决？

    粘包和半包问题是数据传输中比较常见的问题，所谓的粘包问题是指数据在传输时，在一条消息中读取到了另一条消息的部分数据，这种现象就叫做粘包。比如发送了两条消息，分别为“ABC”和“DEF”，那么正常情况下接收端也应该收到两条消息“ABC”和“DEF”，但接收端却收到的是“ABCD”，像这种情况就叫做粘包，如下图所示：

    半包问题是指接收端只收到了部分数据，而非完整的数据的情况就叫做半包。比如发送了一条消息是“ABC”，而接收端却收到的是“AB”和“C”两条信息，这种情况就叫做半包，如下图所示：

    PS：大部分情况下我们都把粘包问题和半包问题看成同一个问题，所以下文就用“粘包”问题来替代“粘包”和“半包”问题。

    1.为什么会有粘包问题？

    粘包问题发生在 TCP/IP 协议中，因为 TCP 是面向连接的传输协议，它是以“流”的形式传输数据的，而“流”数据是没有明确的开始和结尾边界的，所以就会出现粘包问题。

    2.粘包问题代码演示

    接下来我们用代码来演示一下粘包和半包问题，为了演示的直观性，我会设置两个角色：

    • 服务器端用来接收消息；

    • 客户端用来发送一段固定的消息。

    然后通过打印服务器端接收到的信息来观察粘包问题。服务器端代码实现如下：

    1. /**
    2.  * 服务器端（只负责接收消息）
    3.  */
    4. class ServSocket {
    5.     // 字节数组的长度
    6.     private static final int BYTE_LENGTH = 20;  
    7.     public static void main(String[] args) throws IOException {
    8.         // 创建 Socket 服务器
    9.         ServerSocket serverSocket = new ServerSocket(8888);
    10.         // 获取客户端连接
    11.         Socket clientSocket = serverSocket.accept();
    12.         // 得到客户端发送的流对象
    13.         try (InputStream inputStream = clientSocket.getInputStream()) {
    14.             while (true) {
    15.                 // 循环获取客户端发送的信息
    16.                 byte[] bytes = new byte[BYTE_LENGTH];
    17.                 // 读取客户端发送的信息
    18.                 int count = inputStream.read(bytes, 0, BYTE_LENGTH);
    19.                 if (count > 0) {
    20.                     // 成功接收到有效消息并打印
    21.                     System.out.println("接收到客户端的信息是:" + new String(bytes));
    22.                 }
    23.                 count = 0;
    24.             }
    25.         }
    26.     }
    27. }

    客户端实现代码如下：

    1. /**
    2.  * 客户端（只负责发送消息）
    3.  */
    4. static class ClientSocket {
    5.     public static void main(String[] args) throws IOException {
    6.         // 创建 Socket 客户端并尝试连接服务器端
    7.         Socket socket = new Socket("127.0.0.1", 8888);
    8.         // 发送的消息内容
    9.         final String message = "Hi,Java."; 
    10.         // 使用输出流发送消息
    11.         try (OutputStream outputStream = socket.getOutputStream()) {
    12.             // 给服务器端发送 10 次消息
    13.             for (int i = 0; i < 10; i++) {
    14.                 // 发送消息
    15.                 outputStream.write(message.getBytes());
    16.             }
    17.         }
    18.     }
    19. }

    以上程序的执行结果如下图所示：

    通过上述结果我们可以看出，服务器端发生了粘包问题，因为客户端发送了 10 次固定的“Hi,Java.”的消息，正确的结果应该是服务器端也接收到了 10 次固定消息“Hi,Java.”才对，但实际执行结果并非如此。

    3.解决方案

    粘包问题的常见解决方案有以下 3 种：

    1. 发送方和接收方固定发送数据的大小，当字符长度不够时用空字符弥补，有了固定大小之后就知道每条消息的具体边界了，这样就没有粘包的问题了；

    2. 在 TCP 协议的基础上封装一层自定义数据协议，在自定义数据协议中，包含数据头（存储数据的大小）和 数据的具体内容，这样服务端得到数据之后，通过解析数据头就可以知道数据的具体长度了，也就没有粘包的问题了；

    3. 以特殊的字符结尾，比如以“\n”结尾，这样我们就知道数据的具体边界了，从而避免了粘包问题（推荐方案）。

      解决方案1：固定数据大小

      收、发固定大小的数据，服务器端的实现代码如下：

      1. /**
      2. * 服务器端，改进版本一（只负责接收消息）
      3. */
      4. static class ServSocketV1 {
      5.  private static final int BYTE_LENGTH = 1024;  // 字节数组长度（收消息用）
      6.  public static void main(String[] args) throws IOException {
      7.      ServerSocket serverSocket = new ServerSocket(9091);
      8.      // 获取到连接
      9.      Socket clientSocket = serverSocket.accept();
      10.      try (InputStream inputStream = clientSocket.getInputStream()) {
      11.          while (true) {
      12.              byte[] bytes = new byte[BYTE_LENGTH];
      13.              // 读取客户端发送的信息
      14.              int count = inputStream.read(bytes, 0, BYTE_LENGTH);
      15.              if (count > 0) {
      16.                  // 接收到消息打印
      17.                  System.out.println("接收到客户端的信息是:" + new String(bytes).trim());
      18.              }
      19.              count = 0;
      20.          }
      21.      }
      22.  }
      23. }

      客户端的实现代码如下：

      1. /**
      2. * 客户端，改进版一（只负责接收消息）
      3. */
      4. static class ClientSocketV1 {
      5.  private static final int BYTE_LENGTH = 1024;  // 字节长度
      6.  public static void main(String[] args) throws IOException {
      7.      Socket socket = new Socket("127.0.0.1", 9091);
      8.      final String message = "Hi,Java."; // 发送消息
      9.      try (OutputStream outputStream = socket.getOutputStream()) {
      10.          // 将数据组装成定长字节数组
      11.          byte[] bytes = new byte[BYTE_LENGTH];
      12.          int idx = 0;
      13.          for (byte b : message.getBytes()) {
      14.              bytes[idx] = b;
      15.              idx++;
      16.          }
      17.          // 给服务器端发送 10 次消息
      18.          for (int i = 0; i < 10; i++) {
      19.              outputStream.write(bytes, 0, BYTE_LENGTH);
      20.          }
      21.      }
      22.  }
      23. }

      以上代码的执行结果如下图所示：

      优缺点分析

      从以上代码可以看出，虽然这种方式可以解决粘包问题，但这种固定数据大小的传输方式，当数据量比较小时会使用空字符来填充，所以会额外的增加网络传输的负担，因此不是理想的解决方案。

      解决方案2：自定义请求协议

      这种解决方案的实现思路是将请求的数据封装为两部分：消息头（发送的数据大小）+消息体（发送的具体数据），它的格式如下图所示：

      此解决方案的实现分为以下 3 部分：

    4. 编写一个消息封装类

    5. 编写客户端

    6. 编写服务器端

    接下来我们一一来实现。

    ① 消息封装类

    消息的封装类中提供了两个方法：一个是将消息转换成消息头 + 消息体的方法，另一个是读取消息头的方法，具体实现代码如下：

    1. /**
    2.  * 消息封装类
    3.  */
    4. class SocketPacket {
    5.     // 消息头存储的长度(占 8 字节)
    6.     static final int HEAD_SIZE = 8;
    7.  
    8.     /**
    9.      * 将协议封装为:协议头 + 协议体
    10.      * @param context 消息体(String 类型)
    11.      * @return byte[]
    12.      */
    13.     public byte[] toBytes(String context) {
    14.         // 协议体 byte 数组
    15.         byte[] bodyByte = context.getBytes();
    16.         int bodyByteLength = bodyByte.length;
    17.         // 最终封装对象
    18.         byte[] result = new byte[HEAD_SIZE + bodyByteLength];
    19.         // 借助 NumberFormat 将 int 转换为 byte[]
    20.         NumberFormat numberFormat = NumberFormat.getNumberInstance();
    21.         numberFormat.setMinimumIntegerDigits(HEAD_SIZE);
    22.         numberFormat.setGroupingUsed(false);
    23.         // 协议头 byte 数组
    24.         byte[] headByte = numberFormat.format(bodyByteLength).getBytes();
    25.         // 封装协议头
    26.         System.arraycopy(headByte, 0, result, 0, HEAD_SIZE);
    27.         // 封装协议体
    28.         System.arraycopy(bodyByte, 0, result, HEAD_SIZE, bodyByteLength);
    29.         return result;
    30.     }
    31.  
    32.     /**
    33.      * 获取消息头的内容(也就是消息体的长度)
    34.      * @param inputStream
    35.      * @return
    36.      */
    37.     public int getHeader(InputStream inputStream) throws IOException {
    38.         int result = 0;
    39.         byte[] bytes = new byte[HEAD_SIZE];
    40.         inputStream.read(bytes, 0, HEAD_SIZE);
    41.         // 得到消息体的字节长度
    42.         result = Integer.valueOf(new String(bytes));
    43.         return result;
    44.     }
    45. }

    ② 客户端

    客户端中我们添加一组待发送的消息，随机给服务器端发送一个消息，实现代码如下：

    1. /**
    2.  * 客户端
    3.  */
    4. class MySocketClient {
    5.     public static void main(String[] args) throws IOException {
    6.         // 启动 Socket 并尝试连接服务器
    7.         Socket socket = new Socket("127.0.0.1", 9093);
    8.         // 发送消息合集（随机发送一条消息）
    9.         final String[] message = {"Hi,Java.", "Hi,SQL~", "关注公众号|Java中文社群."};
    10.         // 创建协议封装对象
    11.         SocketPacket socketPacket = new SocketPacket();
    12.         try (OutputStream outputStream = socket.getOutputStream()) {
    13.             // 给服务器端发送 10 次消息
    14.             for (int i = 0; i < 10; i++) {
    15.                 // 随机发送一条消息
    16.                 String msg = message[new Random().nextInt(message.length)];
    17.                 // 将内容封装为:协议头+协议体
    18.                 byte[] bytes = socketPacket.toBytes(msg);
    19.                 // 发送消息
    20.                 outputStream.write(bytes, 0, bytes.length);
    21.                 outputStream.flush();
    22.             }
    23.         }
    24.     }
    25. }

    ③ 服务器端

    服务器端使用线程池来处理每个客户端的业务请求，实现代码如下：

    1. /**
    2.  * 服务器端
    3.  */
    4. class MySocketServer {
    5.     public static void main(String[] args) throws IOException {
    6.         // 创建 Socket 服务器端
    7.         ServerSocket serverSocket = new ServerSocket(9093);
    8.         // 获取客户端连接
    9.         Socket clientSocket = serverSocket.accept();
    10.         // 使用线程池处理更多的客户端
    11.         ThreadPoolExecutor threadPool = new ThreadPoolExecutor(100, 150, 100,
    12.                 TimeUnit.SECONDS, new LinkedBlockingQueue<>(1000));
    13.         threadPool.submit(() -> {
    14.             // 客户端消息处理
    15.             processMessage(clientSocket);
    16.         });
    17.     }
    18.     /**
    19.      * 客户端消息处理
    20.      * @param clientSocket
    21.      */
    22.     private static void processMessage(Socket clientSocket) {
    23.         // Socket 封装对象
    24.         SocketPacket socketPacket = new SocketPacket();
    25.         // 获取客户端发送的消息对象
    26.         try (InputStream inputStream = clientSocket.getInputStream()) {
    27.             while (true) {
    28.                 // 获取消息头(也就是消息体的长度)
    29.                 int bodyLength = socketPacket.getHeader(inputStream);
    30.                 // 消息体 byte 数组
    31.                 byte[] bodyByte = new byte[bodyLength];
    32.                 // 每次实际读取字节数
    33.                 int readCount = 0;
    34.                 // 消息体赋值下标
    35.                 int bodyIndex = 0;
    36.                 // 循环接收消息头中定义的长度
    37.                 while (bodyIndex <= (bodyLength - 1) &&
    38.                         (readCount = inputStream.read(bodyByte, bodyIndex, bodyLength)) != -1) {
    39.                     bodyIndex += readCount;
    40.                 }
    41.                 bodyIndex = 0;
    42.                 // 成功接收到客户端的消息并打印
    43.                 System.out.println("接收到客户端的信息:" + new String(bodyByte));
    44.             }
    45.         } catch (IOException ioException) {
    46.             System.out.println(ioException.getMessage());
    47.         }
    48.     }
    49. }

    以上程序的执行结果如下：

    从上述结果可以看出，消息通讯正常，客户端和服务器端的交互中并没有出现粘包问题。

    优缺点分析

    此解决方案虽然可以解决粘包问题，但消息的设计和代码的实现复杂度比较高，所以也不是理想的解决方案。

    解决方案3：特殊字符结尾

    以特殊字符结尾就可以知道流的边界了，它的具体实现是：使用 Java 中自带的 BufferedReader 和 BufferedWriter，也就是带缓冲区的输入字符流和输出字符流，通过写入的时候加上 \n 来结尾，读取的时候使用 readLine 按行来读取数据，这样就知道流的边界了，从而解决了粘包的问题。服务器端实现代码如下：

    1. /**
    2.  * 服务器端，改进版三(只负责收消息)
    3.  */
    4. static class ServSocketV3 {
    5.     public static void main(String[] args) throws IOException {
    6.         // 创建 Socket 服务器端
    7.         ServerSocket serverSocket = new ServerSocket(9092);
    8.         // 获取客户端连接
    9.         Socket clientSocket = serverSocket.accept();
    10.         // 使用线程池处理更多的客户端
    11.         ThreadPoolExecutor threadPool = new ThreadPoolExecutor(100, 150, 100,
    12.                 TimeUnit.SECONDS, new LinkedBlockingQueue<>(1000));
    13.         threadPool.submit(() -> {
    14.             // 消息处理
    15.             processMessage(clientSocket);
    16.         });
    17.     }
    18.     /**
    19.      * 消息处理
    20.      * @param clientSocket
    21.      */
    22.     private static void processMessage(Socket clientSocket) {
    23.         // 获取客户端发送的消息流对象
    24.         try (BufferedReader bufferedReader = new BufferedReader(
    25.                 new InputStreamReader(clientSocket.getInputStream()))) {
    26.             while (true) {
    27.                 // 按行读取客户端发送的消息
    28.                 String msg = bufferedReader.readLine();
    29.                 if (msg != null) {
    30.                     // 成功接收到客户端的消息并打印
    31.                     System.out.println("接收到客户端的信息:" + msg);
    32.                 }
    33.             }
    34.         } catch (IOException ioException) {
    35.             ioException.printStackTrace();
    36.         }
    37.     }
    38. }

    PS：上述代码使用了线程池来解决多个客户端同时访问服务器端的问题，从而实现了一对多的服务器响应。

    客户端的实现代码如下：

    1. /**
    2.  * 客户端，改进版三(只负责发送消息)
    3.  */
    4. static class ClientSocketV3 {
    5.     public static void main(String[] args) throws IOException {
    6.         // 启动 Socket 并尝试连接服务器
    7.         Socket socket = new Socket("127.0.0.1", 9092);
    8.         final String message = "Hi,Java."; // 发送消息
    9.         try (BufferedWriter bufferedWriter = new BufferedWriter(
    10.                 new OutputStreamWriter(socket.getOutputStream()))) {
    11.             // 给服务器端发送 10 次消息
    12.             for (int i = 0; i < 10; i++) {
    13.                 // 注意:结尾的 \n 不能省略,它表示按行写入
    14.                 bufferedWriter.write(message + "\n");
    15.                 // 刷新缓冲区(此步骤不能省略)
    16.                 bufferedWriter.flush();
    17.             }
    18.         }
    19.     }
    20. }

    以上代码的执行结果如下图所示：

    优缺点分析

    以特殊符号作为粘包的解决方案的最大优点是实现简单，但存在一定的局限性，比如当一条消息中间如果出现了结束符就会造成半包的问题，所以如果是复杂的字符串要对内容进行编码和解码处理，这样才能保证结束符的正确性。

    总结

    粘包和半包问题是数据传输中比较常见的问题，它的解决方案有很多，比较常见的解决方案有：设置固定的数据传输大小、自定义请求协议的封装，在请求头中加入传输数据的长度、使用特殊符号作为结束符等。

     

     

  • 相关阅读:
    kubeadm v1.20 部署K8S 集群架构
    面试面经|Java面试基础题17道
    Vue3中无法为el-tree-select设置反选问题分析
    9、osg的texture转换为虚幻引擎的UTexture2D
    分布式链路追踪- SkyWalking使用手册
    日常学习记录随笔-seata
    如何优化谷歌商店里应用的评分评论1
    k8s上部署Harbor通过Nginx-Ingress域名访问
    postgresql存储过程基本语法
    计算机毕业设计 基于SpringBoot高校竞赛管理系统的设计与实现 Javaweb项目 Java实战项目 前后端分离 文档报告 代码讲解 安装调试
  • 原文地址：https://blog.csdn.net/m0_71777195/article/details/126138441