• 粘包和半包问题及解决办法

    粘包问题是指数据在传输时，在一条消息中读取到了另一条消息的部分数据，这种现象就叫做粘包。

    半包问题是指数据在传输时，接收端只收到了部分数据，而非完整的数据，就叫做半包。

    产生粘包和半包问题原因：

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

    大部分情况下我们都把粘包问题和半包问题看成同一个问题

    问题代码演示

    • 服务器端用来接收消息
    • 客户端用来发送一段固定的消息。

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

    1. package com.nien.test.sticky;
    2.  
    3. import java.io.IOException;
    4. import java.io.InputStream;
    5. import java.net.ServerSocket;
    6. import java.net.Socket;
    7.  
    8. /**
    9.  * @author ally-coding
    10.  * @Date: 2023/10/16 23:47
    11.  * @Project cetc_test
    12.  * @Description: 粘包服务器端测试
    13.  */
    14. public class ServSocket {
    15.     private static final int BYTE_LENGTH = 20;
    16.     public static void main(String[] args) throws IOException {
    17.         ServerSocket serverSocket = new ServerSocket(8888);
    18.         //获取客户端连接
    19.         Socket clientSocker = serverSocket.accept();
    20.         //得到客户端发送的流对象
    21.         try(InputStream inputStream = clientSocker.getInputStream()){
    22.             while(true){
    23.                 //循环获取客户端发送的信息
    24.                 byte[] bytes = new byte[BYTE_LENGTH];
    25.                 // 读取客户端发送的信息
    26.                 int count = inputStream.read(bytes, 0, BYTE_LENGTH);
    27.                 if(count>0){
    28.                     System.out.println("接受到客户端的信息是："+new String(bytes));
    29.                 }
    30.                 count=0;
    31.             }
    32.         }
    33.     }
    34. }

     客户端代码：

    1. package com.nien.test.sticky;
    2.  
    3. import java.io.IOException;
    4. import java.io.OutputStream;
    5. import java.net.Socket;
    6.  
    7. /**
    8.  * @author ally-coding
    9.  * @Date: 2023/10/16 23:54
    10.  * @Project cetc_test
    11.  * @Description: 粘包客户端端测试
    12.  */
    13. public class ClientSocket {
    14.  
    15.     public static void main(String[] args) throws IOException {
    16.         Socket socket = new Socket("127.0.0.1",8888);
    17.         final String message = "Hello world!";
    18.         try(OutputStream outputStream = socket.getOutputStream()){
    19.             for (int i = 0; i < 10; i++) {
    20.                 outputStream.write(message.getBytes());
    21.             }
    22.         }
    23.     }
    24. }

    执行结果如下所示。

    可以明显看出，服务器端发生了粘包问题。

    解决办法

    1.发送方和接收方固定发送数据的大小，当字符长度不够时用空字符弥补，有了固定大小之后就知道每条消息的具体边界了，这样就没有粘包的问题了；
2.在 TCP 协议的基础上封装一层自定义数据协议，在自定义数据协议中，包含数据头（存储数据的大小）和数据的具体内容，这样服务端得到数据之后，通过解析数据头就可以知道数据的具体长度了，也就没有粘包的问题了；
3.以特殊的字符结尾，比如以“\n”结尾，这样我们就知道数据的具体边界了，从而避免了粘包问题（推荐方案）

    方法1 固定发送数据的大小

    代码实现：

    服务端代码：

    1. package com.nien.test.sticky.solver1;
    2.  
    3. import java.io.IOException;
    4. import java.io.InputStream;
    5. import java.net.ServerSocket;
    6. import java.net.Socket;
    7.  
    8. /**
    9.  * @author ally-coding
    10.  * @Date: 2023/10/17 0:40
    11.  * @Project cetc_test
    12.  * @Description: 粘包问题解决1-服务端
    13.  */
    14. public class Server1 {
    15.     private static final int BYTE_LENGTH = 1024;
    16.     public static void main(String[] args) throws IOException {
    17.         ServerSocket serverSocket = new ServerSocket(9091);
    18.         //获取客户端连接
    19.         Socket clientSocker = serverSocket.accept();
    20.         //得到客户端发送的流对象
    21.         try(InputStream inputStream = clientSocker.getInputStream()){
    22.             while(true){
    23.                 //循环获取客户端发送的信息
    24.                 byte[] bytes = new byte[BYTE_LENGTH];
    25.                 // 读取客户端发送的信息
    26.                 int count = inputStream.read(bytes, 0, BYTE_LENGTH);
    27.                 if(count>0){
    28.                     System.out.println("接受到客户端的信息是："+new String(bytes).trim());
    29.                 }
    30.                 count=0;
    31.             }
    32.         }
    33.     }
    34. }

    客户端代码：

    1. package com.nien.test.sticky.solver1;
    2.  
    3. import java.io.IOException;
    4. import java.io.OutputStream;
    5. import java.net.Socket;
    6.  
    7. /**
    8.  * @author ally-coding
    9.  * @Date: 2023/10/17 0:40
    10.  * @Project cetc_test
    11.  * @Description: 粘包问题解决1-客户端
    12.  */
    13. public class Client1 {
    14.  
    15.     private static final int BYTE_LENGTH=1024;
    16.  
    17.     public static void main(String[] args) throws IOException {
    18.         Socket socket = new Socket("127.0.0.1",9091);
    19.         final String messgae = "Hello world!";
    20.         try(OutputStream outputStream = socket.getOutputStream()){
    21.             byte[] bytes = new byte[BYTE_LENGTH];
    22.             int idx = 0;
    23.             for (byte b : messgae.getBytes()){
    24.                 bytes[idx] = b;
    25.                 idx++;
    26.             }
    27.             for (int i = 0; i < 10; i++) {
    28.                 outputStream.write(bytes, 0, BYTE_LENGTH);
    29.             }
    30.         }
    31.     }
    32. }

    执行结果如下所示。

    虽然这种方式可以解决粘包问题，但这种固定数据大小的传输方式，当数据量比较小时会使用空字符来填充，所以会额外的增加网络传输的负担。

    方法2 在 TCP 协议的基础上封装一层自定义数据协议

    步骤1 编写一个消息封装类 2编写客户端 3编写服务器

    1.编写消息封装类代码：

    1. package com.nien.test.sticky.solver2;
    2.  
    3. import com.sun.org.apache.regexp.internal.RE;
    4.  
    5. import java.io.IOException;
    6. import java.io.InputStream;
    7. import java.text.NumberFormat;
    8.  
    9. /**
    10.  * @author ally-coding
    11.  * @Date: 2023/10/17 0:52
    12.  * @Project cetc_test
    13.  * @Description: 消息封装类
    14.  */
    15. public class SocketPacket {
    16.  
    17.     static final int HEAD_SIZE=8;
    18.  
    19.     /**
    20.      * 将协议封装为:协议头 + 协议体
    21.      * @param content
    22.      * @return
    23.      */
    24.     public byte[] toBytes(String content){
    25.         //协议体 byte数据
    26.         byte[] bodyByte = content.getBytes();
    27.         int bodyByteLength = bodyByte.length;
    28.         // 最终封装对象
    29.         byte[] result = new byte[HEAD_SIZE + bodyByteLength];
    30.         // 借助 NumberFormat 将 int 转换为 byte[]
    31.         NumberFormat numberFormat = NumberFormat.getNumberInstance();
    32.         numberFormat.setMinimumIntegerDigits(HEAD_SIZE);
    33.         numberFormat.setGroupingUsed(false);
    34.         //协议头 byte数组
    35.         byte[] headByte = numberFormat.format(bodyByteLength).getBytes();
    36.         // 封装协议头
    37.         System.arraycopy(headByte, 0, result, 0, HEAD_SIZE);
    38.         // 封装协议体
    39.         System.arraycopy(bodyByte,0, result, HEAD_SIZE, bodyByteLength);
    40.         return result;
    41.     }
    42.  
    43.     /**
    44.      * 获取消息头的内容(也就是消息体的长度)
    45.      * @param inputStream
    46.      * @return
    47.      * @throws IOException
    48.      */
    49.     public int getHeader(InputStream inputStream) throws IOException {
    50.         int result = 0;
    51.         byte[] bytes = new byte[HEAD_SIZE];
    52.         inputStream.read(bytes, 0, HEAD_SIZE);
    53.         //得到消息体的字节长度
    54.         result = Integer.valueOf(new String(bytes));
    55.         return result;
    56.     }
    57. }

    2.编写客户端代码

    1. package com.nien.test.sticky.solver2;
    2.  
    3. import java.io.IOException;
    4. import java.io.OutputStream;
    5. import java.net.Socket;
    6. import java.util.Random;
    7.  
    8. /**
    9.  * @author ally-coding
    10.  * @Date: 2023/10/17 1:30
    11.  * @Project cetc_test
    12.  * @Description: 客户端
    13.  */
    14. public class Client2 {
    15.  
    16.     public static void main(String[] args) throws IOException {
    17.         Socket socket = new Socket("127.0.0.1",9093);
    18.         String[] message = {"Hello world","Hello java"};
    19.         SocketPacket socketPacket = new SocketPacket();
    20.         try(OutputStream outputStream = socket.getOutputStream()){
    21.             for (int i = 0; i < 10; i++) {
    22.                 String msg = message[new Random().nextInt(message.length)];
    23.                 byte[] bytes = socketPacket.toBytes(msg);
    24.                 outputStream.write(bytes, 0, bytes.length);
    25.                 outputStream.flush();
    26.             }
    27.         }
    28.     }
    29. }

    3.编写服务端

    1. package com.nien.test.sticky.solver2;
    2.  
    3. import java.io.IOException;
    4.  
    5. import java.io.InputStream;
    6. import java.net.ServerSocket;
    7. import java.net.Socket;
    8. import java.util.concurrent.LinkedBlockingQueue;
    9. import java.util.concurrent.ThreadPoolExecutor;
    10. import java.util.concurrent.TimeUnit;
    11.  
    12. /**
    13.  * @author ally-coding
    14.  * @Date: 2023/10/17 9:19
    15.  * @Project cetc_test
    16.  * @Description: 服务器端 使用线程池来处理每个客户端的业务请求
    17.  */
    18. public class Server2 {
    19.  
    20.     public static void main(String[] args) throws IOException {
    21.         ServerSocket serverSocket = new ServerSocket(9093);
    22.         // 获取客户端连接
    23.         Socket clientSocket = serverSocket.accept();
    24.         // 用线程池处理更多的客户端
    25.         ThreadPoolExecutor threadPoolExecutor  = new ThreadPoolExecutor(100,150,100,
    26.                 TimeUnit.SECONDS, new LinkedBlockingQueue<>(1000));
    27.         threadPoolExecutor.submit(()->{
    28.             //客户端消息处理
    29.             processMessage(clientSocket);
    30.         });
    31.     }
    32.  
    33.  
    34.     private static void processMessage(Socket clientSocket){
    35.         // Socket 封装对象
    36.         SocketPacket socketPacket = new SocketPacket();
    37.         // 获取客户端发送的消息对象
    38.         try(InputStream inputStream = clientSocket.getInputStream()) {
    39.             while (true){
    40.                 // 获取消息头(也就是消息体的长度)
    41.                 int bodyLength = socketPacket.getHeader(inputStream);
    42.                 // 消息体 byte 数组
    43.                 byte[] bodyBytes = new byte[bodyLength];
    44.                 // 每次实际读取字节数
    45.                 int readCount = 0;
    46.                 // 消息体赋值下标
    47.                 int bodyIndex = 0;
    48.                 // 循环接收消息头中定义的长度
    49.                 while (bodyIndex<=(bodyLength-1) &&
    50.                         (readCount = inputStream.read(bodyBytes, bodyIndex, bodyLength))!= -1){
    51.                     bodyIndex += readCount;
    52.                 }
    53.                 bodyIndex=0;
    54.                 // 成功接收到客户端的消息并打印
    55.                 System.out.println("接收到客户端的信息:" + new String(bodyBytes));
    56.             }
    57.         } catch (IOException e) {
    58.             System.out.println(e.getMessage());
    59.         }
    60.     }
    61. }

    ​运行结果如下所示。

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

    方法3 以特殊的字符结尾

    代码实现：

    服务器代码：

    1. package com.nien.test.sticky.solver3;
    2.  
    3. import java.io.BufferedReader;
    4. import java.io.IOException;
    5. import java.io.InputStreamReader;
    6. import java.net.ServerSocket;
    7. import java.net.Socket;
    8. import java.util.concurrent.LinkedBlockingQueue;
    9. import java.util.concurrent.ThreadPoolExecutor;
    10. import java.util.concurrent.TimeUnit;
    11.  
    12. /**
    13.  * @author ally-coding
    14.  * @Date: 2023/10/18 0:40
    15.  * @Project cetc_test
    16.  * @Description:
    17.  */
    18. public class Server3 {
    19.  
    20.     public static void main(String[] args) throws IOException {
    21.         ServerSocket serverSocket = new ServerSocket(9092);
    22.         // 获取客户端连接
    23.         Socket clientSocket = serverSocket.accept();
    24.         // 使用线程池处理更多的客户端
    25.         ThreadPoolExecutor threadPool = new ThreadPoolExecutor(100,150,100,
    26.                 TimeUnit.SECONDS, new LinkedBlockingQueue<>(1000));
    27.         threadPool.submit(()->{
    28.            //消息处理
    29.             processMessage(clientSocket);
    30.         });
    31.     }
    32.  
    33.     /**
    34.      * 消息处理
    35.      * @param clientSocket
    36.      */
    37.     private static void processMessage(Socket clientSocket){
    38.         // 获取客户端发送的消息流对象
    39.         try(BufferedReader bufferedReader = new BufferedReader(
    40.                 new InputStreamReader(clientSocket.getInputStream()))) {
    41.             while (true){
    42.                 // 按行读取客户端发送的消息
    43.                 String msg = bufferedReader.readLine();
    44.                 if(msg!=null){
    45.                     System.out.println("接收到客户端的信息:" + msg);
    46.                 }
    47.             }
    48.         } catch (IOException e) {
    49.             e.printStackTrace();
    50.         }
    51.     }
    52. }

    客户端代码：

    1. package com.nien.test.sticky.solver3;
    2.  
    3. import java.io.BufferedWriter;
    4. import java.io.IOException;
    5. import java.io.OutputStreamWriter;
    6. import java.net.Socket;
    7.  
    8. /**
    9.  * @author ally-coding
    10.  * @Date: 2023/10/18 0:40
    11.  * @Project cetc_test
    12.  * @Description:
    13.  */
    14. public class Client3 {
    15.  
    16.     public static void main(String[] args) throws IOException {
    17.         // 启动 Socket 并尝试连接服务器
    18.         Socket socket = new Socket("127.0.0.1", 9092);
    19.         String message = "Hi,Java."; // 发送消息
    20.         try (BufferedWriter bufferedWriter = new BufferedWriter(
    21.                 new OutputStreamWriter(socket.getOutputStream()))) {
    22.             // 给服务器端发送 10 次消息
    23.             for (int i = 0; i < 10; i++) {
    24.                 // 注意:结尾的 \n 不能省略,它表示按行写入
    25.                 bufferedWriter.write(message + "\n");
    26.                 // 刷新缓冲区(此步骤不能省略)
    27.                 bufferedWriter.flush();
    28.             }
    29.         }
    30.     }
    31. }

    执行结果如下图所示。

    该方法最大优点是实现简单，但存在一定的局限性，比如当一条消息中间如果出现了结束符就会造成半包的问题，所以如果是复杂的字符串要对内容进行编码和解码处理，这样才能保证结束符的正确性。
  • 相关阅读:
    一零四、大数据可视化技术与应用实训（展示大屏幕）
    vue中预览xml并高亮显示
    MATLAB数值计算与数据分析(3)
    Centos7 TiDB 数据库安装部署
    C语言实现用弦截法求 f(x)=x^3-5*x^2+16*x-80=0 的根
    洛谷 P1148 拱猪计分
    应用案例 | 基于三维机器视觉的机器人麻袋拆垛应用解决方案
    Java Heap Space: Understanding and Resolving Memory Issues
    C#对字典容器Dictionary＜TKey, TValue＞内容进行XML序列化或反序列化报错解决方法
    机器学习部分知识点总结
  • 原文地址：https://blog.csdn.net/Ally441/article/details/133905639