关于java:Socket粘包问题的3种解决方案最后一种最完美

在 Java 语言中，传统的 Socket 编程分为两种实现形式，这两种实现形式也对应着两种不同的传输层协定：TCP 协定和 UDP 协定，但作为互联网中最罕用的传输层协定 TCP，在应用时却会导致粘包和半包问题，于是为了彻底的解决此问题，便诞生了此篇文章。

什么是 TCP 协定？

TCP 全称是 Transmission Control Protocol（传输控制协议），它由 IETF 的 RFC 793 定义，是一种面向连贯的点对点的传输层通信协议。

TCP 通过应用序列号和确认音讯，从发送节点提供无关传输到指标节点的数据包的传递的信息。TCP 确保数据的可靠性，端到端传递，从新排序和重传，直到达到超时条件或接管到数据包的确认为止。

TCP 是 Internet 上最罕用的协定，它也是实现 HTTP（HTTP 1.0/HTTP 2.0）通信的根底，当咱们在浏览器中申请网页时，计算机会将 TCP 数据包发送到 Web 服务器的地址，要求它将网页返还给咱们，Web 服务器通过发送 TCP 数据包流进行响应，而后浏览器将这些数据包缝合在一起以造成网页。

TCP 的全副意义在于它的可靠性，它通过对数据包编号来对其进行排序，而且它会通过让服务器将响应发送回浏览器说“已收到”来进行谬误查看，因而在传输过程中不会失落或毁坏任何数据。

目前市场上支流的 HTTP 协定应用的版本是 HTTP/1.1，如下图所示：

什么是粘包和半包问题？

粘包问题是指当发送两条音讯时，比方发送了 ABC 和 DEF，但另一端接管到的却是 ABCD，像这种一次性读取了两条数据的状况就叫做粘包（失常状况应该是一条一条读取的）。

半包问题是指，当发送的音讯是 ABC 时，另一端却接管到的是 AB 和 C 两条信息，像这种状况就叫做半包。

为什么会有粘包和半包问题？

这是 因为 TCP 是面向连贯的传输协定，TCP 传输的数据是以流的模式，而流数据是没有明确的开始结尾边界，所以 TCP 也没方法判断哪一段流属于一个音讯。

粘包的次要起因：

• 发送方每次写入数据 < 套接字（Socket）缓冲区大小；
• 接管方读取套接字（Socket）缓冲区数据不够及时。

半包的次要起因：

• 发送方每次写入数据 > 套接字（Socket）缓冲区大小；
• 发送的数据大于协定的 MTU (Maximum Transmission Unit，最大传输单元)，因而必须拆包。

小知识点：什么是缓冲区？

缓冲区又称为缓存，它是内存空间的一部分。也就是说，在内存空间中预留了肯定的存储空间，这些存储空间用来缓冲输出或输入的数据，这部分预留的空间就叫做缓冲区。

缓冲区的劣势以文件流的写入为例，如果咱们不应用缓冲区，那么每次写操作 CPU 都会和低速存储设备也就是磁盘进行交互，那么整个写入文件的速度就会受制于低速的存储设备（磁盘）。但如果应用缓冲区的话，每次写操作会先将数据保留在高速缓冲区内存上，当缓冲区的数据达到某个阈值之后，再将文件一次性写入到磁盘上。因为内存的写入速度远远大于磁盘的写入速度，所以当有了缓冲区之后，文件的写入速度就被大大晋升了。

粘包和半包问题演示

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

• 服务器端用来接管音讯；
• 客户端用来发送一段固定的音讯。

而后通过打印服务器端接管到的信息来察看粘包和半包问题。

服务器端代码如下：

/**
 * 服务器端（只负责接管音讯）*/
class ServSocket {
    // 字节数组的长度
    private static final int BYTE_LENGTH = 20;  
    public static void main(String[] args) throws IOException {
        // 创立 Socket 服务器
        ServerSocket serverSocket = new ServerSocket(9999);
        // 获取客户端连贯
        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", 9999);
        // 发送的音讯内容
        final String message = "Hi,Java."; 
        // 应用输入流发送音讯
        try (OutputStream outputStream = socket.getOutputStream()) {
            // 给服务器端发送 10 次音讯
            for (int i = 0; i < 10; i++) {
                // 发送音讯
                outputStream.write(message.getBytes());
            }
        }
    }
}

以上程序的通信后果如下图所示：

通过上述后果咱们能够看出，服务器端产生了粘包和半包的问题，因为客户端发送了 10 次固定的“Hi,Java.”的音讯，失常的后果应该是服务器端也接管到了 10 次固定的音讯才对，但事实的后果并非如此。

粘包和半包的解决方案

粘包和半包的解决方案有以下 3 种：

1. 发送方和接管方规定固定大小的缓冲区，也就是发送和接管都应用固定大小的 byte[] 数组长度，当字符长度不够时应用空字符补救；
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);
            }
        }
    }
}

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

优缺点剖析

从以上代码能够看出，尽管这种形式能够解决粘包和半包的问题，但这种固定缓冲区大小的形式减少了不必要的数据传输，因为这种形式当发送的数据比拟小时会应用空字符来补救，所以这种形式就大大的减少了网络传输的累赘，所以它也不是最佳的解决方案。

解决方案二：封装申请协定

这种解决方案的实现思路是将申请的数据封装为两局部：数据头 + 数据注释，在数据头中存储数据注释的大小，当读取的数据小于数据头中的大小时，持续读取数据，直到读取的数据长度等于数据头中的长度时才进行。

因为这种形式能够拿到数据的边界，所以也不会导致粘包和半包的问题，但这种实现形式的编码老本较大也不够优雅，因而不是最佳的实现计划，因而咱们这里就略过，间接来看最终的解决方案吧。

解决方案三：特殊字符结尾，按行读取

以特殊字符结尾就能够晓得流的边界了，因而也能够用来解决粘包和半包的问题，此实现计划是咱们举荐最终解决方案。

这种解决方案的外围是，应用 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();}
        }
    }
}

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

总结

本文咱们讲了 TCP 粘包和半包问题，粘包是指读取到了两条信息，失常状况下音讯应该是一条一条读取的，而半包问题是指读取了一半信息。导致粘包和半包的起因是 TCP 的传输是以流的模式进行的，而流数据是没有明确的开始和结尾标识的，因而就导致了此问题。

本文咱们提供了 3 种粘包和半包的解决方案，其中最举荐的是应用 BufferedReader 和 BufferedWriter 按行来读、写和辨别音讯，也就是本文的第三种解决方案。

参考 & 鸣谢

https://zhuanlan.zhihu.com/p/126279630

https://www.jianshu.com/p/6a4ec6095f2c

关注公众号「Java 中文社群」发现更多干货。

查看 Github 发现更多精彩：https://github.com/vipstone/a…