小型旅游网站建设方案,无锡企业网站制作公司,莞城微信网站建设,nana wordpress目录
一、粘包与拆包是什么#xff1f;
二、粘包与拆包为什么发生#xff1f;
三、遇到粘包、拆包怎么办#xff1f;
解决方案1#xff1a;固定数据大小
解决方案2#xff1a;自定义请求协议
解决方案3#xff1a;特殊字符结尾 四、HTTP如何解决粘包问题的#xf…目录
一、粘包与拆包是什么
二、粘包与拆包为什么发生
三、遇到粘包、拆包怎么办
解决方案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 描述
http server接收数据时发现header中有Content-Length属性则读取Content-Length的值确定需要读取body的长度。http server发送数据时根据需要发送byte的长度在header中增加Content-Length项其中value为byte的长度然后将byte数据当做body发送到客户端。
4.2.2、 chunked描述
http server接收数据时发现header中有Transfer-Encoding: chunked则会按照chunked协议分批读取数据。http server发送数据时如果需要分批发送到客户端则需要在header中加上Transfer-Encoding:chunked然后按照chunked协议分批发送数据。
chunked协议具体如下图 1、主要包含三部分: chunklast-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)难以处理比如如何对分块数据进行转发。
