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

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

半包问题是指接收端只收到了局部数据，而非残缺的数据的状况就叫做半包。比方发送了一条音讯是“ABC”，而接收端却收到的是“AB”和“C”两条信息，这种状况就叫做半包，如下图所示：

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());            }        }    }}

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

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

3.解决方案

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

发送方和接管方固定发送数据的大小，当字符长度不够时用空字符补救，有了固定大小之后就晓得每条音讯的具体边界了，这样就没有粘包的问题了；
在 TCP 协定的根底上封装一层自定义数据协定，在自定义数据协定中，蕴含数据头（存储数据的大小）和数据的具体内容，这样服务端失去数据之后，通过解析数据头就能够晓得数据的具体长度了，也就没有粘包的问题了；
以非凡的字符结尾，比方以“\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);         }     } }}

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

优缺点剖析

从以上代码能够看出，尽管这种形式能够解决粘包问题，但这种固定数据大小的传输方式，当数据量比拟小时会应用空字符来填充，所以会额定的减少网络传输的累赘，因而不是现实的解决方案。

解决方案2：自定义申请协定

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

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

编写一个音讯封装类
编写客户端
编写服务器端

接下来咱们一一来实现。

① 音讯封装类

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

/** * 音讯封装类 */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());        }    }}

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

从上述后果能够看出，音讯通信失常，客户端和服务器端的交互中并没有呈现粘包问题。

优缺点剖析

此解决方案尽管能够解决粘包问题，但音讯的设计和代码的实现复杂度比拟高，所以也不是现实的解决方案。

解决方案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();            }        }    }}

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

优缺点剖析

以特殊符号作为粘包的解决方案的最大长处是实现简略，但存在肯定的局限性，比方当一条音讯两头如果呈现了结束符就会造成半包的问题，所以如果是简单的字符串要对内容进行编码和解码解决，这样能力保障结束符的正确性。

总结

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

是非审之于己，毁誉听之于人，得失安之于数。
公众号：Java面试真题解析
面试合集：https://gitee.com/mydb/interview