工商注册官方网站,抖音代运营比较有名的公司,网站建设的报价为什么不同,什么是网络营销的tgi值粘包问题是指数据在传输时#xff0c;在一条消息中读取到了另一条消息的部分数据#xff0c;这种现象就叫做粘包。
半包问题是指数据在传输时#xff0c;接收端只收到了部分数据#xff0c;而非完整的数据#xff0c;就叫做半包。
产生粘包和半包问题原因#xff1a;
…粘包问题是指数据在传输时在一条消息中读取到了另一条消息的部分数据这种现象就叫做粘包。
半包问题是指数据在传输时接收端只收到了部分数据而非完整的数据就叫做半包。
产生粘包和半包问题原因
这些问题发生在 TCP/IP 协议中因为 TCP 是面向连接的传输协议它是以“流”的形式传输数据的而“流”数据是没有明确的开始和结尾边界的所以就会出现粘包问题。
大部分情况下我们都把粘包问题和半包问题看成同一个问题
问题代码演示
服务器端用来接收消息客户端用来发送一段固定的消息。
通过输出服务器端接收到的信息来观察粘包问题。服务器端代码实现如下 package com.nien.test.sticky;import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;/*** author ally-coding* Date: 2023/10/16 23:47* Project cetc_test* Description: 粘包服务器端测试*/
public class ServSocket {private static final int BYTE_LENGTH 20;public static void main(String[] args) throws IOException {ServerSocket serverSocket new ServerSocket(8888);//获取客户端连接Socket clientSocker serverSocket.accept();//得到客户端发送的流对象try(InputStream inputStream clientSocker.getInputStream()){while(true){//循环获取客户端发送的信息byte[] bytes new byte[BYTE_LENGTH];// 读取客户端发送的信息int count inputStream.read(bytes, 0, BYTE_LENGTH);if(count0){System.out.println(接受到客户端的信息是new String(bytes));}count0;}}}
}客户端代码
package com.nien.test.sticky;import java.io.IOException;
import java.io.OutputStream;
import java.net.Socket;/*** author ally-coding* Date: 2023/10/16 23:54* Project cetc_test* Description: 粘包客户端端测试*/
public class ClientSocket {public static void main(String[] args) throws IOException {Socket socket new Socket(127.0.0.1,8888);final String message Hello world!;try(OutputStream outputStream socket.getOutputStream()){for (int i 0; i 10; i) {outputStream.write(message.getBytes());}}}
}执行结果如下所示。 可以明显看出服务器端发生了粘包问题。
解决办法
1.发送方和接收方固定发送数据的大小当字符长度不够时用空字符弥补有了固定大小之后就知道每条消息的具体边界了这样就没有粘包的问题了
2.在 TCP 协议的基础上封装一层自定义数据协议在自定义数据协议中包含数据头存储数据的大小和数据的具体内容这样服务端得到数据之后通过解析数据头就可以知道数据的具体长度了也就没有粘包的问题了
3.以特殊的字符结尾比如以“\n”结尾这样我们就知道数据的具体边界了从而避免了粘包问题推荐方案
方法1 固定发送数据的大小
代码实现
服务端代码
package com.nien.test.sticky.solver1;import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;/*** author ally-coding* Date: 2023/10/17 0:40* Project cetc_test* Description: 粘包问题解决1-服务端*/
public class Server1 {private static final int BYTE_LENGTH 1024;public static void main(String[] args) throws IOException {ServerSocket serverSocket new ServerSocket(9091);//获取客户端连接Socket clientSocker serverSocket.accept();//得到客户端发送的流对象try(InputStream inputStream clientSocker.getInputStream()){while(true){//循环获取客户端发送的信息byte[] bytes new byte[BYTE_LENGTH];// 读取客户端发送的信息int count inputStream.read(bytes, 0, BYTE_LENGTH);if(count0){System.out.println(接受到客户端的信息是new String(bytes).trim());}count0;}}}
}客户端代码
package com.nien.test.sticky.solver1;import java.io.IOException;
import java.io.OutputStream;
import java.net.Socket;/*** author ally-coding* Date: 2023/10/17 0:40* Project cetc_test* Description: 粘包问题解决1-客户端*/
public class Client1 {private static final int BYTE_LENGTH1024;public static void main(String[] args) throws IOException {Socket socket new Socket(127.0.0.1,9091);final String messgae Hello world!;try(OutputStream outputStream socket.getOutputStream()){byte[] bytes new byte[BYTE_LENGTH];int idx 0;for (byte b : messgae.getBytes()){bytes[idx] b;idx;}for (int i 0; i 10; i) {outputStream.write(bytes, 0, BYTE_LENGTH);}}}
}执行结果如下所示。 虽然这种方式可以解决粘包问题但这种固定数据大小的传输方式当数据量比较小时会使用空字符来填充所以会额外的增加网络传输的负担。方法2 在 TCP 协议的基础上封装一层自定义数据协议
步骤1 编写一个消息封装类 2编写客户端 3编写服务器
1.编写消息封装类代码
package com.nien.test.sticky.solver2;import com.sun.org.apache.regexp.internal.RE;import java.io.IOException;
import java.io.InputStream;
import java.text.NumberFormat;/*** author ally-coding* Date: 2023/10/17 0:52* Project cetc_test* Description: 消息封装类*/
public class SocketPacket {static final int HEAD_SIZE8;/*** 将协议封装为:协议头 协议体* param content* return*/public byte[] toBytes(String content){//协议体 byte数据byte[] bodyByte content.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* throws IOException*/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;}
}2.编写客户端代码
package com.nien.test.sticky.solver2;import java.io.IOException;
import java.io.OutputStream;
import java.net.Socket;
import java.util.Random;/*** author ally-coding* Date: 2023/10/17 1:30* Project cetc_test* Description: 客户端*/
public class Client2 {public static void main(String[] args) throws IOException {Socket socket new Socket(127.0.0.1,9093);String[] message {Hello world,Hello java};SocketPacket socketPacket new SocketPacket();try(OutputStream outputStream socket.getOutputStream()){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();}}}
}3.编写服务端
package com.nien.test.sticky.solver2;import java.io.IOException;import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;/*** author ally-coding* Date: 2023/10/17 9:19* Project cetc_test* Description: 服务器端 使用线程池来处理每个客户端的业务请求*/
public class Server2 {public static void main(String[] args) throws IOException {ServerSocket serverSocket new ServerSocket(9093);// 获取客户端连接Socket clientSocket serverSocket.accept();// 用线程池处理更多的客户端ThreadPoolExecutor threadPoolExecutor new ThreadPoolExecutor(100,150,100,TimeUnit.SECONDS, new LinkedBlockingQueue(1000));threadPoolExecutor.submit(()-{//客户端消息处理processMessage(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[] bodyBytes new byte[bodyLength];// 每次实际读取字节数int readCount 0;// 消息体赋值下标int bodyIndex 0;// 循环接收消息头中定义的长度while (bodyIndex(bodyLength-1) (readCount inputStream.read(bodyBytes, bodyIndex, bodyLength))! -1){bodyIndex readCount;}bodyIndex0;// 成功接收到客户端的消息并打印System.out.println(接收到客户端的信息: new String(bodyBytes));}} catch (IOException e) {System.out.println(e.getMessage());}}
}运行结果如下所示。 此方法虽然可以解决粘包问题但消息的设计和代码的实现复杂度比较高所以也不是理想的解决方案。
方法3 以特殊的字符结尾
代码实现
服务器代码
package com.nien.test.sticky.solver3;import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;/*** author ally-coding* Date: 2023/10/18 0:40* Project cetc_test* Description:*/
public class Server3 {public static void main(String[] args) throws IOException {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 e) {e.printStackTrace();}}
}客户端代码
package com.nien.test.sticky.solver3;import java.io.BufferedWriter;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.net.Socket;/*** author ally-coding* Date: 2023/10/18 0:40* Project cetc_test* Description:*/
public class Client3 {public static void main(String[] args) throws IOException {// 启动 Socket 并尝试连接服务器Socket socket new Socket(127.0.0.1, 9092);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();}}}
}执行结果如下图所示。 该方法最大优点是实现简单但存在一定的局限性比如当一条消息中间如果出现了结束符就会造成半包的问题所以如果是复杂的字符串要对内容进行编码和解码处理这样才能保证结束符的正确性。
