聊聊TCP协议的粘包、拆包以及http是如何解决的？

目录

一、粘包与拆包是什么？

二、粘包与拆包为什么发生？

三、遇到粘包、拆包怎么办？

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

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

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

 四、HTTP如何解决粘包问题的？

4.1、读取请求行/请求头、响应行/响应头

4.2、 怎么读取body数据呢？

4.2.1、 Content-Length 描述

4.2.2、 chunked描述

4.2.3 优/缺点

---

TCP的粘包和拆包问题往往出现在基于TCP协议的通讯中，比如RPC框架、Netty等。

一、粘包与拆包是什么？

TCP在接受数据的时候，有一个滑动窗口来控制接受数据的大小，这个滑动窗口你就可以理解为一个缓冲区的大小。缓冲区满了就会把数据发送。数据包的大小是不固定的，有时候比缓冲区大有时候小。
如果一次请求发送的数据量比较小，没达到缓冲区大小，TCP则会将多个请求合并为同一个请求进行发送，这就形成了粘包问题；
如果一次请求发送的数据量比较大，超过了缓冲区大小，TCP就会将其拆分为多次发送，这就是拆包，也就是将一个大的包拆分为多个小包进行发送。

 

二、粘包与拆包为什么发生？

1.TCP会发生粘包问题：TCP 是面向连接的传输协议,TCP 传输的数据是以流的形式,而流数据是没有明确的开始结尾边界,所以 TCP 也没办法判断哪一段流属于一个消息;TCP协议是流式协议;所谓流式协议,即协议的内容是像流水一样的字节流,内容与内容之间没有明确的分界标志,需要认为手动地去给这些协议划分边界。
粘包时：发送方每次写入数据 < 接收方套接字(Socket)缓冲区大小。
拆包时：发送方每次写入数据 > 接收方套接字(Socket)缓冲区大小。

2.UDP不会发生粘包问题：UDP具有保护消息边界,在每个UDP包中就有了消息头(UDP长度、源端口、目的端口、校验和)。

粘包拆包问题在数据链路层、网络层以及传输层都有可能发生。日常的网络应用开发大都在传输层进行，由于UDP有消息保护边界，不会发生粘包拆包问题，因此粘包拆包问题只发生在TCP协议中

三、遇到粘包、拆包怎么办？

先用简单的代码来演示一下粘包和拆包问题

package com.cjian.socket.stickBagAndUnpack;import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;/*** @Author: cjian* @Date: 2023/6/5 10:18* @Des:*/
public class Server {// 字节数组的长度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();// 得到客户端发送的流对象InputStream is = clientSocket.getInputStream();while (true) {// 循环获取客户端发送的信息byte[] bytes = new byte[BYTE_LENGTH];// 读取客户端发送的信息try {int count = is.read(bytes, 0, BYTE_LENGTH);if (count > 0) {// 成功接收到有效消息并打印System.out.println("接收到客户端的信息是:" + new String(bytes));}count = 0;} catch (Exception e) {// ignore}}}
}

package com.cjian.socket.stickBagAndUnpack;import java.io.IOException;
import java.io.OutputStream;
import java.net.Socket;/*** @Author: cjian* @Date: 2023/6/5 10:20* @Des:*/
public class Client {public static void main(String[] args) throws IOException {// 创建 Socket 客户端并尝试连接服务器端Socket socket = new Socket("127.0.0.1", 8888);// 发送的消息内容final String message = "Hi,ChenJian.";// 使用输出流发送消息OutputStream os = socket.getOutputStream();// 给服务器端发送 10 次消息for (int i = 0; i < 10; i++) {// 发送消息os.write(message.getBytes());}}
}

通过结果我们可以看出，服务器端有时发生了粘包问题，因为客户端发送了 10 次固定的“Hi,ChenJian.”的消息，正确的结果应该是服务器端也接收到了 10 次固定消息“Hi,ChenJian.”才对，但实际执行结果并非如此，不够长度的还使用了空格字符填充！

对于粘包和拆包问题，常见的解决方案有四种：

1、客户端在发送数据包的时候，每个包都固定长度，比如1024个字节大小，如果客户端发送的数据长度不足1024个字节，则通过补充空格的方式补全到指定长度；

2、客户端在每个包的末尾使用固定的分隔符，例如\r\n，如果一个包被拆分了，则等待下一个包发送过来之后找到其中的\r\n，然后对其拆分后的头部部分与前一个包的剩余部分进行合并，这样就得到了一个完整的包；

3、将消息分为头部和消息体，在头部中保存有当前整个消息的长度，只有在读取到足够长度的消息之后才算是读到了一个完整的消息；

4、通过自定义协议进行粘包和拆包的处理。

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

package com.cjian.socket.stickBagAndUnpack;import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;/*** @Author: cjian* @Date: 2023/6/5 14:27* @Des:*/
public class Server1 {private static final int BYTE_LENGTH = 1024;  // 字节数组长度（收消息用）public static void main(String[] args) throws IOException {ServerSocket serverSocket = new ServerSocket(8888);// 获取到连接Socket clientSocket = serverSocket.accept();InputStream inputStream = clientSocket.getInputStream();while (true) {byte[] bytes = new byte[BYTE_LENGTH];try {// 读取客户端发送的信息int count = inputStream.read(bytes, 0, BYTE_LENGTH);if (count > 0) {// 接收到消息打印System.out.println("接收到客户端的信息是:" + new String(bytes).trim());}count = 0;} catch (Exception e) {// ignore}}}
}

package com.cjian.socket.stickBagAndUnpack;import java.io.IOException;
import java.io.OutputStream;
import java.net.Socket;/*** @Author: cjian* @Date: 2023/6/5 14:28* @Des:*/
public class Client1 {private static final int BYTE_LENGTH = 1024;  // 字节长度public static void main(String[] args) throws IOException {Socket socket = new Socket("127.0.0.1", 8888);final String message = "Hi,ChenJian."; // 发送消息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：自定义请求协议

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

 

定义一个消息封装类：

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

package com.cjian.socket.stickBagAndUnpack.customprotocol;import java.io.IOException;
import java.io.InputStream;
import java.text.NumberFormat;/*** @Author: cjian* @Date: 2023/6/5 14:42* @Des:*/
public class SocketUtils {// 消息头存储的长度(占 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;}}

package com.cjian.socket.stickBagAndUnpack.customprotocol;import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;/*** @Author: cjian* @Date: 2023/6/5 15:00* @Des:*/
public class CustomServer {public static void main(String[] args) throws IOException {// 创建 Socket 服务器端ServerSocket serverSocket = new ServerSocket(8888);// 获取客户端连接Socket clientSocket = serverSocket.accept();// 获取客户端发送的消息对象InputStream inputStream = clientSocket.getInputStream();while (true) {// 获取消息头(也就是消息体的长度)try {int bodyLength = SocketUtils.getHeader(inputStream);// 消息体 byte 数组byte[] bodyByte = new byte[bodyLength];// 每次实际读取字节数int readCount = 0;// 消息体赋值下标int bodyIndex = 0;// 循环接收消息头中定义的长度while (bodyIndex < bodyLength &&(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());break;}}}
}

package com.cjian.socket.stickBagAndUnpack.customprotocol;import java.io.IOException;
import java.io.OutputStream;
import java.net.Socket;
import java.util.Random;/*** @Author: cjian* @Date: 2023/6/5 14:46* @Des:*/
public class CustomClient {public static void main(String[] args) throws IOException {// 启动 Socket 并尝试连接服务器Socket socket = new Socket("127.0.0.1", 8888);// 发送消息合集（随机发送一条消息）final String[] message = {"Hi,Chenjian.", "Hi,LiXi~", "江苏省南京市雨花台区."};// 创建协议封装对象OutputStream outputStream = socket.getOutputStream();// 给服务器端发送 10 次消息for (int i = 0; i < 10; i++) {// 随机发送一条消息String msg = message[new Random().nextInt(message.length)];// 将内容封装为:协议头+协议体byte[] bytes = SocketUtils.toBytes(msg);// 发送消息outputStream.write(bytes, 0, bytes.length);outputStream.flush();}}
}

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

优缺点分析

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

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

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

服务器端实现代码如下：

package com.cjian.socket.stickBagAndUnpack.specialchar;import com.cjian.socket.stickBagAndUnpack.customprotocol.SocketUtils;import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;/*** @Author: cjian* @Date: 2023/6/5 15:00* @Des:*/
public class SpecialCharServer {public static void main(String[] args) throws IOException {// 创建 Socket 服务器端ServerSocket serverSocket = new ServerSocket(8888);// 获取客户端连接Socket clientSocket = serverSocket.accept();while (true) {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) {System.out.println(ioException.getMessage());break;}}}
}

客户端代码：

package com.cjian.socket.stickBagAndUnpack.specialchar;import java.io.BufferedWriter;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.net.Socket;/*** @Author: cjian* @Date: 2023/6/5 15:36* @Des:*/
public class SpecialCharClient {public static void main(String[] args) throws IOException {// 启动 Socket 并尝试连接服务器Socket socket = new Socket("127.0.0.1", 8888);final String message = "Hi,ChenJian."; // 发送消息BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));// 给服务器端发送 10 次消息for (int i = 0; i < 10; i++) {// 注意:结尾的 \n 不能省略,它表示按行写入bufferedWriter.write(message + "\n");// 刷新缓冲区(此步骤不能省略)bufferedWriter.flush();}}
}

优缺点分析

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

 四、HTTP如何解决粘包问题的？

http请求报文格式
1）请求行：以\r\n结束；
2）请求头：以\r\n结束；
3）\r\n；
3）数据；

http响应报文格式
1）响应行：以\r\n结束；
2）响应头：以\r\n结束；
3）\r\n；
4）数据；

4.1、读取请求行/请求头、响应行/响应头

1、遇到第一个\r\n表示读取请求行或响应行结束；
2、遇到\r\n\r\n表示读取请求头或响应头结束；

4.2、 怎么读取body数据呢？

• HTTP协议通常使用Content-Length来标识body的长度。在服务器端，需要先申请对应长度的buffer，然后再赋值。

 

• 如果需要一边生产数据一边发送数据，就需要使用"Transfer-Encoding: chunked" 来代替Content-Length，也就是对数据进行分块传输。

4.2.1、 Content-Length 描述

1. http server接收数据时，发现header中有Content-Length属性，则读取Content-Length的值，确定需要读取body的长度。
2. http server发送数据时，根据需要发送byte的长度，在header中增加Content-Length项，其中value为byte的长度，然后将byte数据当做body发送到客户端。

4.2.2、 chunked描述

1. http server接收数据时，发现header中有Transfer-Encoding: chunked，则会按照chunked协议分批读取数据。
2. http server发送数据时，如果需要分批发送到客户端，则需要在header中加上Transfer-Encoding:chunked，然后按照chunked协议分批发送数据。

chunked协议具体如下图：

 

1、主要包含三部分: chunk，last-chunk和trailer。如果分多次发送，则chunk有多份。

2、 chunk主要包含大小和数据，大小表示这个这个chunk包的大小，使用16进制标示。其中chunk之间的分隔符为CRLF。

3、通过last-chunk来标识chunk发送完成。一般读取到last-chunk(内容为0)的时候，代表chunk发送完成。

4、trailer表示增加header等额外信息，一般情况下header是空。通过CRLF来标识整个chunked数据发送完成。

4.2.3 优/缺点

优点

1、假如body的长度是10K，对于Content-Length则需要申请10K连续的buffer，而对于Transfer-Encoding:chunked可以申请1k的空间，然后循环使用10次。节省了内存空间的开销。

2、如果内容的长度不可知，则可使用chunked方式能有效的解决Content-Length的问题

3、http服务器压缩可以采用分块压缩，而不是整个块压缩。分块压缩可以一边进行压缩，一般发送数据，来加快数据的传输时间。

缺点

1、chunked协议解析比较复杂。

2、在http转发的场景下(比如nginx)难以处理，比如如何对分块数据进行转发。