Socket通用TCP通信协议设计及实现（防止粘包，可移植，可靠）

最新推荐文章于 2024-01-03 15:38:32 发布
最新推荐文章于 2024-01-03 15:38:32 发布
阅读量1.4k 收藏 3
点赞数
分类专栏： C# 文章标签： Socke TCP 协议通信

Socket通用TCP通信协议设计及实现（防止粘包，可移植，可靠）

 

引文

我们接收Socket字节流数据一般都会定义一个数据包协议。我们每次开发一个软件的通信模块时，尽管具体的数据内容是不尽相同的，但是大体上的框架，以及常用的一些函数比如转码，校验等等都是相似甚至一样的。所以我感觉设计一个通用的通信协议，可以在之后的开发中进行移植实现高效率的开发是很有必要的。另外，本协议结合我自己所了解的通信知识尽可能的提升了可靠性和移植性，可处理类似粘包这样的问题。对于本文中可能存在的问题，欢迎各位大神多多指点。

 

报文设计

         本报文的字段结构分为Hex编码和BCD（8421）编码两种。由于BCD编码的取值范围其实是Hex编码的真子集，也就是所谓的16进制编码中的“ABCDEF”这六个字母对应的数值是在BCD编码中无法取值的。所以我利用这个特点，将报文中的用于标识的不含实际数据的抽象字段用Hex编码，且取值范围在A~F之间。将反应实际数据的字段用BCD编码。这样，具有标识作用的字段与实际数据字段的取值是互不交叉的。这无形中就避免了很多出现的问题，增强了报文的可靠性。例如：我使用”0xFFFF”代表报文起始符，这个取值是不会在任何一个数据字段中出现的，应为它们是BCD编码。也就是是说，字节流缓冲区中只要出现”0xFFFF”我们就可以判断这个是一个数据包的开头（我在实现在缓冲区中找寻数据包算法时还做了另外的控制，进行双重保障）。

         对于正文部分，我设计成了“标识符|数据”成对出现的形式。每个标识符用来指示后面出现的数据的含义，数据字段用于传输真实的数据。这种对的形式，增强了报文的移植性，在新的一次开发到来时，我们只要按需求定义好正文部分的“标识符|数据”对即可。另外，这种设计还增强了发送报文方的灵活性。标识符的存在使得各项数据可以按照任意的顺序发送，没有的数据也可以不发。

         基于以上的这些考虑，我把报文设计成了如下形式：

 

通用报文协议

序号

名称

编码说明

 1

报文起始符

2字节Hex编码    0xFFFF

 2

功能码（报文类型）

2字节Hex编码    0xD1D1

 3

密码

4字节BCD编码    00 00 00 01

 4

长度

2字节BCD编码    正文实际长度

 5

标识符1

2字节Hex编码   自定义数据标识符  0xA001

 6

数据1

N字节BCD编码  N根据实际情况自定义

 7

标识符2

2字节Hex编码   自定义数据标识符  0xA002

 8

数据2

N字节BCD编码  N根据实际情况自定义

 ...

…

 

 

报文终止符

2字节Hex编码   0xEEEE

 

校验码

校验码前所有字节的CRC校验，生成多项式：X16+X15+X2+1，高位字节在前，低位字节在后。

 

报文示例：

示例背景：发送报文通知远程服务器第1号设备开关的当前状态为开启

需自定义正文部分，含两个字段，设备编号和开关状态

发送的字节数组：255 255 | 209209 | 0 0 0 1 | 0 6 | 160 1 | 1 | 160 2| 0 | 238 238 | 245 40 |

对应含义解释：   起始符FFFF | 功能码D1D1 | 密码00 00 00 01 | 长度（正文）00 06|    标识符A001 | 数据 1 | 标识符A002 | 数据 0 | 报文终止符 EEEE | 校验结果 |

 

粘包问题的解决

针对我的协议，我设计了一个缓冲区中找寻数据包算法，这两者的配合完美的实现了防止粘包，过滤噪声数据等类似的各种令人头疼的问题。此算法思路来自博文点击打开链接 

算法流程图如下：


算法C#代码具体实现：

[csharp]  view plain  copy
 print ?
  1. /// <summary>  
  2.     /// 数据缓冲区  
  3.     /// </summary>  
  4.     public class DataBuffer  
  5.     {  
  6.         //字节缓冲区  
  7.         private List<byte> m_buffer = new List<byte>();  
  8.  
  9.         #region 私有方法  
  10.   
  11.         /// <summary>  
  12.         /// 寻找第一个报头 （0xFFFF）  
  13.         /// </summary>  
  14.         /// <returns>返回报文起始符索引，没找到返回-1</returns>  
  15.         private int findFirstDataHead()  
  16.         {  
  17.             int tempIndex=m_buffer.FindIndex(o => o == 0xFF);  
  18.             if (tempIndex == -1)  
  19.                 return -1;  
  20.             if ((tempIndex + 1) < m_buffer.Count)  //防止越界  
  21.                 if (m_buffer[tempIndex + 1] != 0xFF)  
  22.                     return -1;  
  23.   
  24.             return tempIndex;  
  25.         }  
  26.   
  27.         /// <summary>  
  28.         /// 寻找第一个报尾 （0xEEEE）  
  29.         /// </summary>  
  30.         /// <returns></returns>  
  31.         private int findFirstDataEnd()  
  32.         {  
  33.             int tempIndex = m_buffer.FindIndex(o => o == 0xEE);  
  34.             if (tempIndex == -1)  
  35.                 return -1;  
  36.             if((tempIndex+1)<m_buffer.Count)  //防止越界  
  37.                 if (m_buffer[tempIndex + 1] != 0xEE)  
  38.                     return -1;  
  39.   
  40.             return tempIndex;  
  41.         }  
  42.  
  43.         #endregion  
  44.   
  45.   
  46.         /// <summary>  
  47.         /// 在缓冲区中寻找完整合法的数据包  
  48.         /// </summary>  
  49.         /// <returns>找到返回数据包长度len，数据包范围即为0~（len-1）；未找到返回0</returns>  
  50.         public int Find()  
  51.         {  
  52.             if (m_buffer.Count == 0)  
  53.                 return 0;  
  54.   
  55.             int HeadIndex = findFirstDataHead();//查找报头的位置  
  56.   
  57.             if (HeadIndex == -1)  
  58.             {  
  59.                 //没找到报头  
  60.                 m_buffer.Clear();  
  61.                 return 0;   
  62.             }  
  63.   
  64.             if (HeadIndex >= 1)//不为开头移掉之前的字节  
  65.                 m_buffer.RemoveRange(0, HeadIndex);  
  66.   
  67.             int length = GetLength();  
  68.   
  69.             if (length==0)  
  70.             {  
  71.                 //报文还未全部接收  
  72.                 return 0;  
  73.             }  
  74.   
  75.             int TailIndex = findFirstDataEnd(); //查找报尾的位置  
  76.   
  77.             if (TailIndex == -1)  
  78.             {  
  79.                 return 0;  
  80.             }  
  81.             else if (TailIndex + 4 != length) //包尾与包长度不匹配  
  82.             {  
  83.                 //退出前移除当前报头  
  84.                 m_buffer.RemoveRange(0, 2);  
  85.   
  86.                 return 0;  
  87.             }  
  88.   
  89.             return length;  
  90.         }  
  91.   
  92.         /// <summary>  
  93.         /// 包长度  
  94.         /// </summary>  
  95.         /// <returns></returns>  
  96.         public int GetLength()  
  97.         {  
  98.             //报文起始符 功能码 密码 正文长度 报文终止符 CRC校验码 这六个基础结构占14字节  
  99.             //因此报文长度至少为14  
  100.   
  101.             if (m_buffer.Count >= 14)  
  102.             {  
  103.                 int length = m_buffer[8] * 256 + m_buffer[9];//正文长度  
  104.                 return length + 14;  
  105.             }  
  106.             return 0;  
  107.         }  
  108.   
  109.         /// <summary>  
  110.         /// 提取数据  
  111.         /// </summary>  
  112.         public void Dequeue(byte[] buffer, int offset, int size)  
  113.         {  
  114.             m_buffer.CopyTo(0, buffer, offset, size);  
  115.             m_buffer.RemoveRange(offset, size);  
  116.         }  
  117.   
  118.         /// <summary>  
  119.         /// 队列数据  
  120.         /// </summary>  
  121.         /// <param name="buffer"></param>  
  122.         public void Enqueue(byte[] buffer)  
  123.         {  
  124.             m_buffer.AddRange(buffer);  
  125.         }  
  126.   
  127.   
  128.     }  


调用示例：

[csharp]  view plain  copy
 print ?
  1. private void receive()  
  2.         {  
  3.             while (true)//循环直至用户主动终止线程  
  4.             {  
  5.                 int len = Server.Available;  
  6.                 if (len > 0)  
  7.                 {  
  8.                     byte[] temp = new byte[len];  
  9.                     Server.Receive(temp,len,SocketFlags.None);  
  10.                     buffer.Enqueue(temp);  
  11.                     while (buffer.Find()!=0) //while可处理同时接收到多个包的情况    
  12.                     {  
  13.                         int length = buffer.GetLength();  
  14.                         byte[] readBuffer = new byte[len];  
  15.                         buffer.Dequeue(readBuffer, 0, length);  
  16.                         //OnReceiveDataEx(readBuffer); //这里自己写一个委托或方法就OK了，封装收到一个完整数据包后的工作   
  17.                         //示例,这里简单实用静态属性处理：  
  18.                         DataPacketEx da = Statute.UnPackMessage(readBuffer);  
  19.                         ComFun.receiveList.Add(da);  
  20.                     }  
  21.   
  22.                 }  
  23.   
  24.                 Thread.Sleep(100);//这里需要根据实际的数据吞吐量合理选定线程挂起时间  
  25.             }  
  26.         }  
 其中DataPacketEx是封装数据包正文部分的类，其中的属性记录了要发送的数据
使用时只需开启一个线程，不断的将收到的字节流数据加入缓冲区中。调用Find()方法找寻下一个数据包，如果该方法返回0，说明当前缓冲区中不存在数据包（数据尚未完整接收/存在错误数据，该方法可自行进行处理），如果返回一个正数n，则当前缓冲区中索引0-（n-1）的数据即为一个收到的完整的数据包。对其进行处理即可。


协议的实现

在实现协议前，首先我在自定义的TransCoding类中实现了几个静态方法用于Hex、BCD、string等之间的转换。

[csharp]  view plain  copy
 print ?
  1. /// <summary>  
  2.         /// 将十进制形式字符串转换为BCD码的形式  
  3.         /// </summary>  
  4.         /// <param name="str">十进制形式的待转码字符串，每个字符需为0~9的十进制数字</param>  
  5.         /// <returns></returns>  
  6.         public static byte[] BCDStrToByte(string str)  
  7.         {  
  8.             #region 原方法  
  9.   
  10.             //长度为奇数，队首补0  
  11.             if (str.Length % 2 != 0)  
  12.             {  
  13.                 str = '0' + str;  
  14.             }  
  15.   
  16.             byte[] bcd = new byte[str.Length / 2];  
  17.   
  18.             for (int i = 0; i < str.Length / 2; i++)  
  19.             {  
  20.                 int index = i * 2;  
  21.   
  22.                 //计算BCD[index]处的字节  
  23.                 byte high = (byte)(str[index] - 48);  //高四位  
  24.                 high = (byte)(high << 4);  
  25.                 byte low = (byte)(str[index + 1] - 48); //低四位  
  26.   
  27.                 bcd[i] = (byte)(high | low);  
  28.             }  
  29.   
  30.             return bcd;  
  31.  
  32.             #endregion  
  33.   
  34.         }  
  35.   
  36.         /// <summary>  
  37.         /// 将字节数据转化为16进制的字符串(注意：同样适用与转8421格式的BCD码！！！！)  
  38.         /// </summary>  
  39.         /// <param name="hex"></param>  
  40.         /// <param name="index"></param>  
  41.         /// <returns></returns>  
  42.         public static string ByteToHexStr(byte[] hex, int index)  
  43.         {  
  44.             string hexStr = "";  
  45.             if (index >= hex.Length || index < 0)  
  46.                 throw new Exception("索引超出界限");  
  47.             for (int i = index; i < hex.Length; i++)  
  48.             {  
  49.                 if (Convert.ToInt16(hex[i]) >= 16)  
  50.                 {  
  51.                     hexStr += Convert.ToString(hex[i], 16).ToUpper();  
  52.                 }  
  53.                 else  
  54.                 {  
  55.                     hexStr += "0" + Convert.ToString(hex[i], 16).ToUpper();  
  56.                 }  
  57.             }  
  58.             return hexStr;  
  59.         }  
  60.   
  61.         /// <summary>  
  62.         /// 将16进制字符串转化为字节数据  
  63.         /// </summary>  
  64.         /// <param name="hexStr"></param>  
  65.         /// <returns></returns>  
  66.         public static byte[] HexStrToByte(string hexStr)  
  67.         {  
  68.             if (hexStr.Trim().Length % 2 != 0)  
  69.             {  
  70.                 hexStr = "0" + hexStr;  
  71.             }  
  72.             byte[] hexByte = new byte[hexStr.Length / 2];  
  73.             for (int i = 0; i < hexByte.Length; i++)  
  74.             {  
  75.                 string hex = hexStr[i * 2].ToString(CultureInfo.InvariantCulture) + hexStr[i * 2 + 1].ToString(CultureInfo.InvariantCulture);  
  76.                 hexByte[i] = byte.Parse(hex, NumberStyles.AllowHexSpecifier);  
  77.             }  
  78.             return hexByte;  
  79.  
  80.             #region 使用Convert.ToByte转换  
  81.             //长度为奇数，队首补0,确保整数  
  82.             //if (str.Length % 2 != 0)  
  83.             //{  
  84.             //    str = '0' + str;  
  85.             //}  
  86.   
  87.             //string temp = "";  
  88.             //byte[] BCD = new byte[str.Length / 2];  
  89.   
  90.             //for (int index = 0; index < str.Length; index += 2)  
  91.             //{  
  92.             //    temp = str.Substring(index, 2);  
  93.             //    BCD[index / 2] = Convert.ToByte(temp, 16);  
  94.             //}  
  95.   
  96.             //return BCD;  
  97.             #endregion  
  98.         }  

以下是协议的实现的两个核心方法，装包和解包

装包方法将已有的具体的不同数据类型的数据转换成byte字节流，以便进行socket通信

解包方法将socket接收到的完整数据包字节流解析成封装数据包的类DataPacketEx

[csharp]  view plain  copy
 print ?
  1. /// <summary>  
  2.         ///  构造向终端发送的消息（示例）  
  3.         /// </summary>  
  4.         /// <param name="data">记录发送消息内容的数据包</param>  
  5.         /// <returns>发送的消息</returns>  
  6.         public byte[] BuildMessage(DataPacketEx data)  
  7.         {  
  8.             List<byte> msg = new List<byte>(); //先用消息链表，提高效率  
  9.   
  10.             //帧起始符  
  11.             byte[] tempS = TransCoding.HexStrToByte("FFFF");  
  12.             ComFun.bytePaste(msg, tempS);  
  13.               
  14.             //功能码  
  15.             tempS = TransCoding.HexStrToByte("D1D1");  
  16.             ComFun.bytePaste(msg, tempS);  
  17.   
  18.             //密码  
  19.             tempS = TransCoding.BCDStrToByte("00000001");  
  20.             ComFun.bytePaste(msg, tempS);  
  21.   
  22.             //长度  
  23.             tempS = TransCoding.BCDStrToByte("0006");  
  24.             ComFun.bytePaste(msg, tempS);  
  25.   
  26.             //开关设备编号标识符  
  27.             tempS = TransCoding.HexStrToByte("A001");  
  28.             ComFun.bytePaste(msg, tempS);  
  29.   
  30.             //开关设备编号  
  31.             tempS = TransCoding.BCDStrToByte(data.ObjectID);  
  32.             ComFun.bytePaste(msg, tempS);  
  33.   
  34.             //开/关标识符  
  35.             tempS = TransCoding.HexStrToByte("A002");  
  36.             ComFun.bytePaste(msg, tempS);  
  37.   
  38.             //开/关  
  39.             tempS = TransCoding.BCDStrToByte(data.IsOpen);  
  40.             ComFun.bytePaste(msg, tempS);  
  41.   
  42.             //报文终止符  
  43.             tempS = TransCoding.HexStrToByte("EEEE");  
  44.             ComFun.bytePaste(msg, tempS);  
  45.               
  46.             //CRC校验  
  47.             byte[] message = new byte[msg.Count];  
  48.             for (int i = 0; i < msg.Count; i++)  
  49.             {  
  50.                 message[i] = msg[i];  
  51.             }  
  52.             byte[] crc = new byte[2];  
  53.             Checksum.CalculateCrc16(message, out crc[0], out crc[1]);  
  54.   
  55.             message = new byte[msg.Count + 2];  
  56.             for (int i = 0; i < msg.Count; i++)  
  57.             {  
  58.                 message[i] = msg[i];  
  59.             }  
  60.             message[message.Length - 2] = crc[0];  
  61.             message[message.Length - 1] = crc[1];  
  62.   
  63.             return message;  
  64.   
  65.         }  
  66.   
  67.   
  68.         /// <summary>  
  69.         /// 解包数据  
  70.         /// </summary>  
  71.         /// <param name="message">需要解包的数据</param>  
  72.         /// <returns>成功解析返回true，否则返回false </returns>  
  73.         public DataPacketEx UnPackMessage(byte[] message)  
  74.         {  
  75.             //先校验信息是否传输正确  
  76.             if (!CheckRespose(message))  
  77.                 return null;  
  78.   
  79.             //检查密码是否正确.(假设当前密码为00 00 00 01，需在应用时根据实际情况解决)  
  80.             byte[] temp = new byte[4];  
  81.             temp[0] = message[4];  
  82.             temp[1] = message[5];  
  83.             temp[2] = message[6];  
  84.             temp[3] = message[7];  
  85.             if (TransCoding.ByteToHexStr(temp, 0) != "00000001")  
  86.                 return null;  
  87.   
  88.             DataPacketEx DataPacket = new DataPacketEx("", "", "");  
  89.   
  90.             //获取功能码  
  91.             byte[] funType = new byte[2] { message[2], message[3] };  
  92.             string functionStr = TransCoding.ByteToHexStr(funType, 0);  
  93.  
  94.             #region 具体解包过程，需根据实际情况修改  
  95.   
  96.             int index = 10; //(当前索引指向第一个标识符)  
  97.             string tempStr="";  
  98.   
  99.             switch (functionStr)  
  100.             {  
  101.                 case "D1D1":  
  102.                     temp = new byte[2] { message[index], message[index + 1] };  
  103.                     index = index + 2;  
  104.                     tempStr = TransCoding.ByteToHexStr(temp, 0);  
  105.                     while (tempStr != "EEEE")  
  106.                     {  
  107.                         switch (tempStr)  
  108.                         {  
  109.                             //注意：每种标识符对应的数据长度是协议中自定义的  
  110.                             case "A001":  
  111.                                 //开关设备编号  
  112.                                 temp = new byte[1] { message[index] };  
  113.                                 index = index + 1;  
  114.                                 tempStr = TransCoding.ByteToHexStr(temp, 0);  
  115.                                 DataPacket.ObjectID = tempStr;  
  116.                                 break;  
  117.                             case "A002":  
  118.                                 //开or关(开：00 关：11)  
  119.                                 temp = new byte[1] { message[index] };  
  120.                                 index = index + 1;  
  121.                                 tempStr = TransCoding.ByteToHexStr(temp, 0);  
  122.                                 DataPacket.IsOpen = tempStr;  
  123.                                 break;  
  124.                             //case "其他标识符":  
  125.                             //    //对应信息  
  126.                             //    break;  
  127.                         }  
  128.                         temp = new byte[2] { message[index], message[index + 1] };  
  129.                         index = index + 2;  
  130.                         tempStr = TransCoding.ByteToHexStr(temp, 0);  
  131.                     }  
  132.                     break;  
  133.                   
  134.                 //case "其他功能码":  
  135.                 //    //对应功能  
  136.                 //    break;  
  137.             }  
  138.  
  139.             #endregion  
  140.   
  141.             return DataPacket;  
  142.         }  

对于通信可靠性的验证

对此，我制作了两个简单的demo，一个服务器端，一个客户端。

客户端可想服务器端循环发送数据，其中以0.5的概率夹杂着随机长度随机取值的干扰数据，以此来判断本协议在实际应用中的可行性。

服务器端负责循环接收并处理显示收到的数据

最终的运行结果如下图：



由运行结果可以看出，服务器端完美屏蔽掉了客户端发出的错误数据，全部解析出了客户端发送的实际数据。证明本协议可以解决类似粘包，传错等等类似的通讯中的棘手问题。当然，协议中如果有不完美的地方，希望各位大神指教。另外，上面的demo只是为了验证协议所做，还存在一些零零碎碎的小bug。

亲测以上代码可以正常使用，下面的连接是作者提供的：http://download.csdn.net/detail/u011583927/8653701 

昵称不好奇
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C# Socket通信协议（可移植可扩展防粘包）
05-02
本文将深入探讨C#中的Socket通信协议设计，并介绍如何实现可移植性和防止“粘包”现象。 首先，让我们了解什么是Socket。Socket是操作系统提供的接口，用于进程间的网络通信，它允许应用程序通过TCP/IP协议发送和...
C#TCP\Socket粘包处理(加长度头)
04-11
在计算机网络编程中，TCP（传输控制协议）是一种面向连接的、可靠的、基于字节流的传输层通信协议。然而，TCP本身并不保证数据包的边界，也就是说，多个小的数据包可能会被合并成一个大的数据包发送，或者一个大的...
理解基于 TCP 的应用层通信协议
每天进步一点点的专栏
07-10 3212
TCP 协议示意 TCP协议 关于七层网络通信的基本原理，特别推荐这篇图文并茂的长文《TCP/IP笔记 - 综述》 TCP 通信基本特征 TCP数据流 特征 1. 消息（结构化数据）被编码成字节流写入 TCP 通道。 2. TCP 通道不能保证字节流一定到达目的地，但能保证到达的字节流是正确、有序的。对于发送端而言，可以不停的写入数据，当网络出问题 ACK 超...
计算机网络学习笔记一：基础篇
上山的人
05-03 3898
2.1 TCP/IP 网络模型有哪几层？ 问大家，为什么要有 TCP/IP 网络模型？ 对于同一台设备上的进程间通信（管道、消息队列、共享内存、信号等）。 不同设备上的进程间通信，就需要网络通信，而设备是多样性的，所以要兼容多种多样的设备，就协商出了一套通用的网络协议。 这个网络协议是分层的，每一层都有各自的作用和职责，接下来就根据「 TCP/IP 网络模型」分别对每一层进行介绍。 应用层 应用层只需要专注于为用户提供应用功能，比如 HTTP、FTP、Telnet、DNS、SMTP等。 ..
BIN,BCD,ASCII码分别对应的Hex（16进制）数
小肥丸
08-25 6613
BIN,BCD,ASCII码分别对应的Hex（16进制）数 以十进制的 56 为例: BIN 码 对应二进制数为 0011 1000 对应Hex数据为 0x38 BIN码就是二进制数； 压缩BCD 码 对应二进制数为 0101 0110 对应Hex数据为 0x56 压缩BCD 码：一个字节可存放一个两位十进制数，其中高四位存放十位数，低四位存放个位数； 非压缩BCD 码 对应二进制数为0000 0101 0000 0110 对应Hex数据为 0x05 0x06 非压缩BC
利用TCP协议通过Socket编写的网络聊天工具2-通用类设计
www.v5qq.com的技术博客
05-14 103
在上一节中，还有即将给出的服务器代码，都使用了共同的工具类，包括一个Command类，用来负责表示通讯中的命令控制，一个ServerConfig类，用来表示服务器的配置，这个在客户端中也要使用，还有一个验证用户信息的类，在客户端使用。因为这三个类的通用新比较高，所以单独用一个dll工程来开发的这三个类，这样在客户端工程和服务器端工程中直接可以添加这个新的工程的DLL的引用。 整个项目源码下载...
socket tcp如何防止多次send的包被合成一个包(粘包)发送.zip
01-18
- 可以在设计通信协议时规定每个消息都有固定的长度，接收端可以根据固定长度来切割接收到的数据，从而避免粘包。这种方法需要在两端都实现相应的解析逻辑。 3. **添加消息边界**： - 在每次send的数据前加上消息...
python TCP Socket的粘包和分包的处理详解
09-20
主要介绍了python TCP Socket的粘包和分包的处理详解，分享了相关代码示例，小编觉得还是挺不错的，具有一定借鉴价值，需要的朋友可以参考下
Python使用socket模块实现简单tcp通信
12-17
`socket.AF_INET`表示使用IPv4地址族，`socket.SOCK_STREAM`代表使用TCP协议。接着，通过`bind()`函数将socket绑定到指定的IP地址和端口号，这里使用的是`127.0.0.1`（本地环回地址）和`11552`端口。`listen(2)`函数...
socket实现TCP/UDP通信协议设计
overwhelmed的博客
11-28 1247
基于套接字编程的TCP/UDP通信协议设计 tcp提供客户与服务器的连接，一个TCP客户建立一个与服务器的连接，并与能够服务器交换数据，然后终止连接，提供可靠性。当TCP向另一端发送数据时，它要求对端返回一个确认，如果确认没有收到，TCP自动重传数据，并等待更长时间。 UDP是一个简单的传输层协议，提供无连接的服务，不需要与客户端建立连接。UDP客户端与服务器不必存在长期的关系，缺乏可靠性。协议不保证分组能够最终到达目的地，不保证各个分组按先后顺序跨网络保持不变，也不保证每个分组只到达一次。 Socket编
Socket 套接字-通信方式
weixin_44121529的博客
04-19 6285
转载自： 网络编程懒人入门(十四)：到底什么是Socket？一文即懂！ 1、引言 对于即时通讯IM这方面的应用层开发者来说，跟计算机网络打道的其实是各种API接口。 本篇文章就来聊一下网络应用程序员最熟悉的Socket这个东西，抛开生涩的计算机网络理论，从应用层的角度来理解到底什么是Socket。 对于 Socket 的认识，本文将从以下几个方面着手介绍： 1）Socket 是什么； 2）Socket 是如何创建的； 3）Socket 是如何连接的； 4）Soc
基于TCP的Socket网络编程
weixin_47604497的博客
10-30 3063
基于TCP的Socket网络编程
socket通信的环形缓冲-TCPQQ
htjx99的专栏
10-15 3253
孙靖      2009.5.5 Email：jing_sun999@126.com QQ：272964426 前段时间实现了一个小型的C/S架构的多人在线即时通信工具，JIGQQ。其中对使用TCP通信有点心得。 记得在我大学时代，就用VB做过TCP的通信。当然那时候是很初级的，发送的数据量也很小的应用。当时就觉得，有时候发送的数据接收端不能接收到，有时候呢觉得一次性没有接受完毕。 前段时间
网络中出现TCP、UDP粘包、分包的两点解决办法
热门推荐
cherish_2012的专栏
12-02 3万+
粘包产生原因： 先说TCP：由于TCP协议本身的机制（面向连接的可靠地协议-三次握手机制）客户端与服务器会维持一个连接（Channel），数据在连接不断开的情况下，可以持续不断地将多个数据包发往服务器，但是如果发送的网络数据包太小，那么他本身会启用Nagle算法（可配置是否启用）对较小的数据包进行合并（基于此，TCP的网络延迟要UDP的高些）然后再发送（超时或者包大小足够）。那么这样的话，服
Socket 解决粘包半包问题及代码实现
最新发布
m0_62197239的博客
01-03 1265
收到对端数据时，操作系统将数据存入Socket接受缓冲区，操作系统层面上的缓冲区由操作系统操作，程序不能直接操作它们，只能通过socket.Receive、soket.Send等方法间接操作。Socket Receive方法把接受缓冲区的数据提取出来，比如Receive(readBuff,0,2)，接受两个字节的数据到readbuff。如果系统接受缓冲区为空，该方法会阻塞。Send方法同理。如果发送端快速发送多条数据，接收端没有及时调用Receive，那么数据便会在接收端的缓冲区中。
【socket】网卡内部缓冲区、socket缓冲区、滑动窗口
数字人生
10-27 1465
网卡内部缓冲区、socket缓冲区、滑动窗口 三者的关系
java socket报文通信（一）socket的建立
weixin_34163553的博客
12-26 491
java socket报文通信（一） socket的建立 今天来和大家分享一下java中如何使用socket进行通信。先来啰嗦两句，看看Tcp/ip和udp: TCP是Transfer Control Protocol的 简称，是一种面向连接的保证可靠传输的协议。通过TCP协议传输，得到的是一个顺序的无差错的数据流。发送方和接收方的成对的两个socket之间必须建 立连接，以便在TCP协议的...
unity实现socket通讯(内含tcp粘包/拆包解决)
09-02
Unity实现Socket通讯时，常常会遇到TCP粘包和拆包的问题。下面我将介绍在Unity中如何解决这些问题。 TCP粘包是指在传输过程中，由于数据缓冲区的限制，多个小的数据包可能会被合并成一个大的数据包，导致数据的解析...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值