devbox
凡人多烦事01
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

粘包/半包及解决方案

作者：凡人多烦事01 | 2024-03-29 00:57:11

赞

踩

粘包/半包及解决方案

一、粘包/半包介绍

1：粘包

粘包（Packet Concatenation）通常发生在基于流式传输协议（如 TCP）的通信中，因为 TCP 是面向流的传输协议，它不保证数据包的边界，而是将数据视为连续的字节流，它表示客户端发送多条消息，服务端只收到了一条消息

2：半包

半包（Half Packet）与粘包问题相反。在半包问题中，接收端接收到的数据包不完整，即接收到的数据包只是完整数据包的一部分，无法完整地解析和处理。

3：原因

①网络延迟/阻塞

②发送方连续发送数据

③接收端缓冲区大小限制

④数据包丢失

二、粘包/半包解决方案

1：长度信息法

在每个数据包前面加上长度信息，每次接收数据后，先读取长度，如果缓冲区数据长度大于要取的字节数，则取出相应字节，否则等待下一次接收,举个例子

①客户端第一次发送包含长度信息的内容

②客户端第二次发送包含长度信息的内容

③服务端第一次接收到了4个字节，存入缓冲区，但是这时候并不处理，因为收到了10，所以要等到11个字节完整再处理

④服务端等到客户端发送剩下的7个字节，但是第二次接收到了9个字节，服务端把之前的6个字节再读取，然后拼接，把10helloworld进行处理，读取到标志长度4，等待下次处理

⑤服务端最后一次收到ove，就把之前的l一起拼接，返回完整的4love

*一般的游戏是16位的整型数来存放长度信息

2：固定长度法

每次都发送相同长度的数据，一次不足的数据用.来补充，.位补充字符，没有实际意义

如果接收到的字符数大于10，就只提取前10个字符

3：结束符号法

规定一个结束符号作为消息的分隔符，比如Hello$World就是两条信息

三、代码示例

1：发送数据
  1.         byte[] bodyBytes = System.Text.Encoding.Default.GetBytes(SendStr);
  2.         Int16 len = (Int16)bodyBytes.Length;
  3.         //把长度转化为Int16
  4.         byte[] lenBytes = BitConverter.GetBytes(len);
  5.         //此时SendBytes包含长度字符串和内容字符串
  6.         byte[] sendBytes = lenBytes.Concat(bodyBytes).ToArray();

2：接收数据

定义一个接收缓冲区和接收缓冲区长度。缓冲区会保存尚未处理的数据

  1.     //接收缓冲区
  2.     byte[] readBuff = new byte[1024];
  3.     //接收缓冲区长度
  4.     int buffCount = 0;

之前的BeginReceive函数原型如下：

public IAsyncResult BeginReceive (  byte[] buffer,  int offset,  int size,  SocketFlags socketFlags,  AsyncCallback callback, object state )

现在的参数应该写成这个样子：

socket.BeginReceive(readBuff, buffCount 1024-buffCount, 0,  ReceiveCallback, socket);

readBuff 是缓冲区

buffCount 是开始读取的位置

1024 - buffCount 是剩余多少可读取的大小

3：处理数据

  1. public void OnReceiveData(){
  2.  
  3.  //消息长度小于2，直接返回等待下一次接收
  4.  if(buffCount <= 2)
  5.  return;
  6.  
  7.  //消息的长度
  8.  Int16 bodyLength = BitConverter.ToInt16(readBuff, 0);
  9.  //消息体
  10.     
  11.  //如果消息长度小于我消息内容和长度的字节，就返回继续读取
  12.  if(buffCount < 2+bodyLength)
  13.  return;
  14.     
  15.  //如果长度够用，就转化为string类型
  16.  string s = System.Text.Encoding.UTF8.GetString(readBuff, 2,buffCount);
  17.  
  18.  //更新缓冲区
  19.  int start = 2 + bodyLength;
  20.  int count = buffCount - start;
  21.  
  22.  //Copy函数把缓冲区后面的内容提到前面
  23.  Array.Copy(readBuff, start, readBuff, 0, count);
  24.  buffCount -= start;
  25.  
  26.  //继续读取消息
  27.  if(readBuff.length > 2){
  28.  OnReceiveData();
  29.  }
  30. }

Copy的原型函数如下：

  1. public static void Copy(
  2.  Array sourceArray,//源数组
  3.  long sourceIndex,//目标数据
  4.  Array destinationArray,//目标数组
  5.  long destinationIndex,//目标数组起始位置
  6.  long length//复制消息的长度
  7. )

四、完整示例

1：客户端
  1. using System;
  2. using System.Linq;
  3. using System.Net.Sockets;
  4. using UnityEngine;
  5. using UnityEngine.UI;
  6.  
  7. public class SendScr : MonoBehaviour
  8. {
  9.     Socket socket;
  10.     public InputField inputField;
  11.     public Text text;
  12.     byte[] readBuff = new byte[1024];
  13.     int buffCount = 0;//缓冲区数据长度
  14.     string recvStr = "";
  15.     public void Connection()
  16.     {
  17.         socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
  18.         socket.Connect("127.0.0.1", 8888);
  19.         socket.BeginReceive(readBuff, buffCount, 1024 - buffCount, 0, ReceiveCallback, socket);
  20.     }
  21.  
  22.     private void ReceiveCallback(IAsyncResult ar)
  23.     {
  24.         try
  25.         {
  26.             Socket socket = (Socket)ar.AsyncState;
  27.             //获取接收数据长度
  28.             int count = socket.EndReceive(ar);
  29.             buffCount += count;
  30.             //处理二进制消息
  31.             OnReceiveData();
  32.             //继续接收数据
  33.             socket.BeginReceive(readBuff, buffCount, 1024 - buffCount, 0, ReceiveCallback, socket);
  34.         }
  35.         catch (SocketException ex)
  36.         {
  37.             Debug.Log("Socket Receive fail" + ex.ToString());
  38.         }
  39.     }
  40.  
  41.     private void OnReceiveData()
  42.     {
  43.         Debug.Log("[Recv 1] buffCount = " + buffCount);
  44.         Debug.Log("[Recv 2] readbuff = " + BitConverter.ToString(readBuff));
  45.  
  46.         if (buffCount <= 2) return;
  47.  
  48.         Int16 bodyLength = BitConverter.ToInt16(readBuff, 0);
  49.         Debug.Log("[Recv 3] bodyLength=" + bodyLength);
  50.  
  51.         //消息体
  52.         if (buffCount < 2 + bodyLength) return;
  53.  
  54.         string s = System.Text.Encoding.UTF8.GetString(readBuff, 2, buffCount);
  55.         Debug.Log("[Recv 4] s=" + s);
  56.  
  57.         //更新缓冲区
  58.         int start = 2 + bodyLength;
  59.         int count = buffCount - start;
  60.         Array.Copy(readBuff, start, readBuff, 0, count);
  61.         buffCount -= start;
  62.         Debug.Log("[Recv 5] buffCount=" + buffCount);
  63.  
  64.         //消息处理
  65.         recvStr = s + "\n" + recvStr;
  66.  
  67.         //继续读取消息
  68.         OnReceiveData();
  69.     }
  70.  
  71.     public void Send()
  72.     {
  73.         string sendStr = inputField.text;
  74.         byte[] bodyBytes = System.Text.Encoding.Default.GetBytes(sendStr);
  75.         Int16 len = (Int16)bodyBytes.Length;
  76.         byte[] lenBytes = BitConverter.GetBytes(len);
  77.         //此时SendBytes包含长度字符串和内容字符串
  78.         byte[] sendBytes = lenBytes.Concat(bodyBytes).ToArray();
  79.         socket.Send(sendBytes);
  80.         Debug.Log("[Send]" + BitConverter.ToString(sendBytes));
  81.     }
  82.     private void Update()
  83.     {
  84.         text.text = recvStr;
  85.     }
  86.  
  87. }

捋一下客户端的功能：

当进入场景点击Connection，创建新的Socket连接，绑定服务端口，开始接收信息

这里的BeginReceive就是我们接受消息的函数，它传入我们的缓冲区readBuff，缓冲区长度buffCount，1024 - buffCount表示我们还剩多少字节数据，然后进入回调函数

Receive回调函数中创建新的Socket对象来解析获取到的socket对象，count用于跟踪每次异步接收操作实际接收到的数据长度，然后把count加到buffCount上，这样更新了缓冲区的长度

然后使用OnReceiveData处理数据，继续读取数据，点击发送就调用Send()

2：服务端
  1. using System.Net.Sockets;
  2. using System.Net;
  3. internal class ClientState
  4. {
  5.     public Socket socket;
  6.     public byte[] readBuff = new byte[1024];
  7. }
  8. class Class
  9. {
  10.     static Socket listenfd;
  11.     static Dictionary<Socket, ClientState> clients = new Dictionary<Socket, ClientState>();
  12.     public static void Main(string[] args)
  13.     {
  14.         listenfd = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
  15.         IPAddress ipAdr = IPAddress.Parse("127.0.0.1");
  16.         IPEndPoint ipEp = new IPEndPoint(ipAdr, 8888);
  17.         listenfd.Bind(ipEp);
  18.         listenfd.Listen(0);
  19.         Console.WriteLine("[服务器]启动成功");
  20.  
  21.         List<Socket> checkRead = new List<Socket>();
  22.  
  23.         while (true)
  24.         {
  25.             //填充checkRead列表
  26.             checkRead.Clear();
  27.             checkRead.Add(listenfd);
  28.             foreach (ClientState s in clients.Values)
  29.             {
  30.                 checkRead.Add(s.socket);
  31.             }
  32.             //select
  33.             Socket.Select(checkRead, null, null, 1000);
  34.             //检查可读对象
  35.             foreach (Socket s in checkRead)
  36.             {
  37.                 if (s == listenfd)
  38.                 {
  39.                     ReadListenfd(s);
  40.                 }
  41.                 else
  42.                 {
  43.                     ReadClientfd(s);
  44.                 }
  45.             }
  46.         }
  47.     }
  48.     public static void ReadListenfd(Socket listenfd)
  49.     {
  50.         Console.WriteLine("Accept");
  51.         Socket clientfd = listenfd.Accept();
  52.         ClientState state = new ClientState();
  53.         state.socket = clientfd;
  54.         clients.Add(clientfd, state);
  55.     }
  56.     public static bool ReadClientfd(Socket clientfd)
  57.     {
  58.         ClientState state = clients[clientfd];
  59.         //接收
  60.         int count = clientfd.Receive(state.readBuff);
  61.         if (count == 0)
  62.         {
  63.             clientfd.Close();
  64.             clients.Remove(clientfd);
  65.             Console.WriteLine("Socket Close");
  66.             return false;
  67.         }
  68.         //广播
  69.         string recvStr = System.Text.Encoding.Default.GetString(state.readBuff, 2, count - 2);
  70.         Console.WriteLine("Receive" + recvStr);
  71.         byte[] sendBytes = new byte[count];
  72.  
  73.         Array.Copy(state.readBuff, 0, sendBytes, 0, count);
  74.  
  75.         foreach (ClientState cs in clients.Values)
  76.         {
  77.             cs.socket.Send(sendBytes);
  78.         }
  79.         return true;
  80.     }
  81. }

这里的服务端代码和Select部分的代码基本相同

3：测试

打开服务器，客户端连接后输入UNITY

①客户端反馈

Recv1的buffCount就是接收到服务端所返回的消息，服务端所返回的信息是客户端发送的拼接数组，就是UNITY+lenBytes，就是7

Rec2的readbuff就是缓冲区存储的内容

Recv3是当消息没有接受完整的时候的消息本体长度

Recv4是完整的消息内容

Recv5是接受完成UNITY后更新后的新buffCount新长度，因为没有后续的，所以是0

②服务端反馈

服务端接受到的消息

四、模拟粘包

客户端修改

  1. using System;
  2. using System.Linq;
  3. using System.Net.Sockets;
  4. using UnityEngine;
  5. using UnityEngine.UI;
  6.  
  7. public class SendScr : MonoBehaviour
  8. {
  9.     Socket socket;
  10.     public InputField inputField;
  11.     public Text text;
  12.     byte[] readBuff = new byte[1024];
  13.     int buffCount = 0;//缓冲区数据长度
  14.     string recvStr = "";
  15.     public void Connection()
  16.     {
  17.         socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
  18.         socket.Connect("127.0.0.1", 8888);
  19.         socket.BeginReceive(readBuff, buffCount, 1024 - buffCount, 0, ReceiveCallback, socket);
  20.     }
  21.  
  22.     private void ReceiveCallback(IAsyncResult ar)
  23.     {
  24.         try
  25.         {
  26.             Socket socket = (Socket)ar.AsyncState;
  27.             //获取接收数据长度
  28.             int count = socket.EndReceive(ar);
  29.             buffCount += count;
  30.             //处理二进制消息
  31.             OnReceiveData();
  32.  
  33.             System.Threading.Thread.Sleep(1000*30);
  34.  
  35.             //继续接收数据
  36.             socket.BeginReceive(readBuff, buffCount, 1024 - buffCount, 0, ReceiveCallback, socket);
  37.         }
  38.         catch (SocketException ex)
  39.         {
  40.             Debug.Log("Socket Receive fail" + ex.ToString());
  41.         }
  42.     }
  43.  
  44.     private void OnReceiveData()
  45.     {
  46.         Debug.Log("[Recv 1] buffCount = " + buffCount);
  47.         Debug.Log("[Recv 2] readbuff = " + BitConverter.ToString(readBuff));
  48.  
  49.         if (buffCount <= 2) return;
  50.  
  51.         Int16 bodyLength = BitConverter.ToInt16(readBuff, 0);
  52.         Debug.Log("[Recv 3] bodyLength=" + bodyLength);
  53.  
  54.         //消息体
  55.         if (buffCount < 2 + bodyLength) return;
  56.  
  57.         string s = System.Text.Encoding.UTF8.GetString(readBuff, 2, buffCount);
  58.         Debug.Log("[Recv 4] s=" + s);
  59.  
  60.         //更新缓冲区
  61.         int start = 2 + bodyLength;
  62.         int count = buffCount - start;
  63.         Array.Copy(readBuff, start, readBuff, 0, count);
  64.         buffCount -= start;
  65.         Debug.Log("[Recv 5] buffCount=" + buffCount);
  66.  
  67.         //消息处理
  68.         recvStr = s + "\n" + recvStr;
  69.  
  70.         //继续读取消息
  71.         OnReceiveData();
  72.     }
  73.  
  74.     public void Send()
  75.     {
  76.         string sendStr = inputField.text;
  77.         byte[] bodyBytes = System.Text.Encoding.Default.GetBytes(sendStr);
  78.         Int16 len = (Int16)bodyBytes.Length;
  79.         byte[] lenBytes = BitConverter.GetBytes(len);
  80.         //此时SendBytes包含长度字符串和内容字符串
  81.         byte[] sendBytes = lenBytes.Concat(bodyBytes).ToArray();
  82.         socket.Send(sendBytes);
  83.         Debug.Log("[Send]" + BitConverter.ToString(sendBytes));
  84.     }
  85.     private void Update()
  86.     {
  87.         text.text = recvStr;
  88.     }
  89.  
  90. }

*在接收数据的时候，强制等待30s再进行下一次接收，ReceiveCallback是在子线程执行，调用Sleep函数并不会卡住主线程，客户端不会被卡住，在30s内多次发送数据，经由服务端转发，再次调用BeginReceive的时候，缓冲区有很多数据，会产生粘包。

客户端快速发送三条消息，发送不会堵塞，每次接收都会等待30s，但是接收到的消息不是在一起的，而是分开的

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/凡人多烦事01/article/detail/332659
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号