面试突击70:什么是粘包和半包?怎么解决?

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

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

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

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

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

2.粘包问题代码演示

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

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

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

/**  * 服务器端(只负责接收消息)  */ class ServSocket {     // 字节数组的长度     private static final int BYTE_LENGTH = 20;       public static void main(String[] args) throws IOException {         // 创建 Socket 服务器         ServerSocket serverSocket = new ServerSocket(8888);         // 获取客户端连接         Socket clientSocket = serverSocket.accept();         // 得到客户端发送的流对象         try (InputStream inputStream = clientSocket.getInputStream()) {             while (true) {                 // 循环获取客户端发送的信息                 byte[] bytes = new byte[BYTE_LENGTH];                 // 读取客户端发送的信息                 int count = inputStream.read(bytes, 0, BYTE_LENGTH);                 if (count > 0) {                     // 成功接收到有效消息并打印                     System.out.println("接收到客户端的信息是:" + new String(bytes));                 }                 count = 0;             }         }     } } 

客户端实现代码如下:

/**  * 客户端(只负责发送消息)  */ static class ClientSocket {     public static void main(String[] args) throws IOException {         // 创建 Socket 客户端并尝试连接服务器端         Socket socket = new Socket("127.0.0.1", 8888);         // 发送的消息内容         final String message = "Hi,Java.";          // 使用输出流发送消息         try (OutputStream outputStream = socket.getOutputStream()) {             // 给服务器端发送 10 次消息             for (int i = 0; i < 10; i++) {                 // 发送消息                 outputStream.write(message.getBytes());             }         }     } } 

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

3.解决方案

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

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

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

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

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

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

    /** * 服务器端,改进版本一(只负责接收消息) */ static class ServSocketV1 {  private static final int BYTE_LENGTH = 1024;  // 字节数组长度(收消息用)  public static void main(String[] args) throws IOException {      ServerSocket serverSocket = new ServerSocket(9091);      // 获取到连接      Socket clientSocket = serverSocket.accept();      try (InputStream inputStream = clientSocket.getInputStream()) {          while (true) {              byte[] bytes = new byte[BYTE_LENGTH];              // 读取客户端发送的信息              int count = inputStream.read(bytes, 0, BYTE_LENGTH);              if (count > 0) {                  // 接收到消息打印                  System.out.println("接收到客户端的信息是:" + new String(bytes).trim());              }              count = 0;          }      }  } } 

    客户端的实现代码如下:

    /** * 客户端,改进版一(只负责接收消息) */ static class ClientSocketV1 {  private static final int BYTE_LENGTH = 1024;  // 字节长度  public static void main(String[] args) throws IOException {      Socket socket = new Socket("127.0.0.1", 9091);      final String message = "Hi,Java."; // 发送消息      try (OutputStream outputStream = socket.getOutputStream()) {          // 将数据组装成定长字节数组          byte[] bytes = new byte[BYTE_LENGTH];          int idx = 0;          for (byte b : message.getBytes()) {              bytes[idx] = b;              idx++;          }          // 给服务器端发送 10 次消息          for (int i = 0; i < 10; i++) {              outputStream.write(bytes, 0, BYTE_LENGTH);          }      }  } } 

    以上代码的执行结果如下图所示:
    image.png

    优缺点分析

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

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

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

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

  4. 编写一个消息封装类

  5. 编写客户端

  6. 编写服务器端

接下来我们一一来实现。

① 消息封装类

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

/**  * 消息封装类  */ class SocketPacket {     // 消息头存储的长度(占 8 字节)     static final int HEAD_SIZE = 8;      /**      * 将协议封装为:协议头 + 协议体      * @param context 消息体(String 类型)      * @return byte[]      */     public byte[] toBytes(String context) {         // 协议体 byte 数组         byte[] bodyByte = context.getBytes();         int bodyByteLength = bodyByte.length;         // 最终封装对象         byte[] result = new byte[HEAD_SIZE + bodyByteLength];         // 借助 NumberFormat 将 int 转换为 byte[]         NumberFormat numberFormat = NumberFormat.getNumberInstance();         numberFormat.setMinimumIntegerDigits(HEAD_SIZE);         numberFormat.setGroupingUsed(false);         // 协议头 byte 数组         byte[] headByte = numberFormat.format(bodyByteLength).getBytes();         // 封装协议头         System.arraycopy(headByte, 0, result, 0, HEAD_SIZE);         // 封装协议体         System.arraycopy(bodyByte, 0, result, HEAD_SIZE, bodyByteLength);         return result;     }      /**      * 获取消息头的内容(也就是消息体的长度)      * @param inputStream      * @return      */     public int getHeader(InputStream inputStream) throws IOException {         int result = 0;         byte[] bytes = new byte[HEAD_SIZE];         inputStream.read(bytes, 0, HEAD_SIZE);         // 得到消息体的字节长度         result = Integer.valueOf(new String(bytes));         return result;     } } 

② 客户端

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

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

③ 服务器端

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

/**  * 服务器端  */ class MySocketServer {     public static void main(String[] args) throws IOException {         // 创建 Socket 服务器端         ServerSocket serverSocket = new ServerSocket(9093);         // 获取客户端连接         Socket clientSocket = serverSocket.accept();         // 使用线程池处理更多的客户端         ThreadPoolExecutor threadPool = new ThreadPoolExecutor(100, 150, 100,                 TimeUnit.SECONDS, new LinkedBlockingQueue<>(1000));         threadPool.submit(() -> {             // 客户端消息处理             processMessage(clientSocket);         });     }     /**      * 客户端消息处理      * @param clientSocket      */     private static void processMessage(Socket clientSocket) {         // Socket 封装对象         SocketPacket socketPacket = new SocketPacket();         // 获取客户端发送的消息对象         try (InputStream inputStream = clientSocket.getInputStream()) {             while (true) {                 // 获取消息头(也就是消息体的长度)                 int bodyLength = socketPacket.getHeader(inputStream);                 // 消息体 byte 数组                 byte[] bodyByte = new byte[bodyLength];                 // 每次实际读取字节数                 int readCount = 0;                 // 消息体赋值下标                 int bodyIndex = 0;                 // 循环接收消息头中定义的长度                 while (bodyIndex <= (bodyLength - 1) &&                         (readCount = inputStream.read(bodyByte, bodyIndex, bodyLength)) != -1) {                     bodyIndex += readCount;                 }                 bodyIndex = 0;                 // 成功接收到客户端的消息并打印                 System.out.println("接收到客户端的信息:" + new String(bodyByte));             }         } catch (IOException ioException) {             System.out.println(ioException.getMessage());         }     } } 

以上程序的执行结果如下:
image.png
从上述结果可以看出,消息通讯正常,客户端和服务器端的交互中并没有出现粘包问题。

优缺点分析

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

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

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

/**  * 服务器端,改进版三(只负责收消息)  */ static class ServSocketV3 {     public static void main(String[] args) throws IOException {         // 创建 Socket 服务器端         ServerSocket serverSocket = new ServerSocket(9092);         // 获取客户端连接         Socket clientSocket = serverSocket.accept();         // 使用线程池处理更多的客户端         ThreadPoolExecutor threadPool = new ThreadPoolExecutor(100, 150, 100,                 TimeUnit.SECONDS, new LinkedBlockingQueue<>(1000));         threadPool.submit(() -> {             // 消息处理             processMessage(clientSocket);         });     }     /**      * 消息处理      * @param clientSocket      */     private static void processMessage(Socket clientSocket) {         // 获取客户端发送的消息流对象         try (BufferedReader bufferedReader = new BufferedReader(                 new InputStreamReader(clientSocket.getInputStream()))) {             while (true) {                 // 按行读取客户端发送的消息                 String msg = bufferedReader.readLine();                 if (msg != null) {                     // 成功接收到客户端的消息并打印                     System.out.println("接收到客户端的信息:" + msg);                 }             }         } catch (IOException ioException) {             ioException.printStackTrace();         }     } } 

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

客户端的实现代码如下:

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

以上代码的执行结果如下图所示:
image.png

优缺点分析

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

总结

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

是非审之于己,毁誉听之于人,得失安之于数。

公众号:Java面试真题解析

面试合集:https://gitee.com/mydb/interview

商匡云商
Logo
对比商品
  • 合计 (0)
对比
0
购物车