Socket开发之通讯协议及处理(解决粘包问题)

最新推荐文章于 2024-03-25 15:55:37 发布
翻译 最新推荐文章于 2024-03-25 15:55:37 发布 · 2.6k 阅读 · 6
标签
#socket #通讯 #粘包

在Socket应用开发中，还有一个话题是讨论的比较多的，那就是数据接收后如何处理的问题。这也是一个令刚接触Socket开发的人很头疼的问题。


因为Socket的TCP通讯中有一个“粘包”的现象，既：大多数时候发送端多次发送的小数据包会被连在一起被接收端同时接收到，多个小包被组成一个大包被接收。有时候一个大数据包又会被拆成多个小数据包发送。这样就存在一个将数据包拆分和重新组合的问题。那么如何去处理这个问题呢？这就是我今天要讲的通讯协议。
 
所谓的协议就是通讯双方协商并制定好要传送的数据的结构与格式。并按制定好的格式去组合与分析数据。从而使数据得以被准确的理解和处理。
 
那么我们如何去制定通讯协议呢？很简单，就是指定数据中各个字节所代表的意义。比如说：第一位代表封包头，第二位代表封类型，第三、四位代表封包的数据长度。然后后面是实际的数据内容。
 
如下面这个例子：

 

01

01

0600

01 0f ef 87 56 34

协议类型

协议代码

数据长度

实际数据

前面三部分称之为封包头，它的长度是固定的，第四部分是封包数据，它的长度是不固定的，由第三部分标识其长度。因为我们的协议将用在TCP中，所以我没有加入校验位。原因是TCP可以保证数据的完整性。校验位是没有必要存在的。 

接下来我们要为这个数据封包声明一个类来封装它：

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
public class Message
   {
       private byte _class;
       private byte _flag;
       private int _size;
       private byte[] _content;
 
       public byte[] Content
       {
           get { return _content; }
           set { _content = value; }
       }
 
       public int Size
       {
           get { return _size; }
           set { _size = value; }
       }
 
       public byte Flag
       {
           get { return _flag; }
           set { _flag = value; }
       }
 
       public byte Class
       {
           get { return _class; }
           set { _class = value; }
       }
 
       public Message()
       {
 
       }
 
       public Message(byte @class, byte flag, byte[] content)
       {
           _class = @class;
           _flag = flag;
           _size = content.Length;
           _content = content;
       }
 
       public byte[] ToBytes()
       {
           byte[] _byte;
           using (MemoryStream mem = new MemoryStream())
           {
               BinaryWriter writer = new BinaryWriter(mem);
               writer.Write(_class);
               writer.Write(_flag);
               writer.Write(_size);
               if (_size > 0)
               {
                   writer.Write(_content);
               }
               _byte = mem.ToArray();
               writer.Close();
           }
           return _byte;
       }
 
       public static Message FromBytes(byte[] Buffer)
       {
           Message message = new Message();
           using (MemoryStream mem = new MemoryStream(Buffer))
           {
               BinaryReader reader = new BinaryReader(mem);
               message._class = reader.ReadByte();
               message._flag = reader.ReadByte();
               message._size = reader.ReadInt32();
               if (message._size > 0)
               {
                   message._content = reader.ReadBytes(message._size);
               }
               reader.Close();
           }
           return message;
       }
 
   }

 

我们可以用Tobytes()和FromBytes()将封包转换成二进制数组和从二进制数组转换回来。
 
事情看起来已经解决了，但……真的是这样子吗？不然，我们知道，TCP数据是以流的形式被传送的，我们并不知道一个数据包是否被传送完毕，也不知道我们接收回来的数据包中是否有多个数据包，如果直接使用FromBytes()来转换的话，很可能会因为数据不完整而出现异常，也有可能会因为数据中含有多个数据包而导致数据丢失（因为你并不知道这些数据中含有多少个数据包）。那我们该怎么办？这也不难，我们先把接收回来的数据写入一个流中。然后分析其中是否有完整的数据包，如果有，将其从流中取出，并将这部分数据从流中清除。直到流中没有完整的数据为止，以后接收回来的数据就将其写入流的结尾处，并从头继续分析。直到结束。
 
让我们来看看这部分的代码：

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
public class MessageStream
   {
       private byte[] _buffer;
       private int _position;
       private int _length;
       private int _capacity;
 
       public MessageStream()
       {
           _buffer = new byte[0];
           _position = 0;
           _length = 0;
           _capacity = 0;
       }
 
       private byte ReadByte()
       {
           if (this._position >= this._length)
           {
               return 0;
           }
           return this._buffer[this._position++];
       }
 
       private int ReadInt()
       {
           int num = this._position += 4;
           if (num > this._length)
           {
               this._position = this._length;
               return -1;
           }
           return (((this._buffer[num - 4] | (this._buffer[num - 3] << 8)) | (this._buffer[num - 2] << 0x10)) | (this._buffer[num - 1] << 0x18));
       }
 
       private byte[] ReadBytes(int count)
       {
           int num = this._length - this._position;
           if (num > count)
           {
               num = count;
           }
           if (num <= 0)
           {
               return null;
           }
           byte[] buffer = new byte[num];
           if (num <= 8)
           {
               int num2 = num;
               while (--num2 >= 0)
               {
                   buffer[num2] = this._buffer[this._position + num2];
               }
           }
           else
           {
               Buffer.BlockCopy(this._buffer, this._position, buffer, 0, num);
           }
           this._position += num;
           return buffer;
       }
 
       public bool Read(out Message message)
       {
           message = null;
           _position = 0;
           if (_length > 6)
           {
               message = new Message();
               message.Class = ReadByte();
               message.Flag = ReadByte();
               message.Size = ReadInt();
               if (message.Size <= 0 || message.Size <= _length - _position)
               {
                   if (message.Size > 0)
                   {
                       message.Content = ReadBytes(message.Size);
                   }
                   Remove(message.Size + 6);
                   return true;
               }
               else
               {
                   message = null;
                   return false;
               }
           }
           else
           {
               return false;
           }
       }
 
       private void EnsureCapacity(int value)
       {
           if (value <= this._capacity)
               return;
           int num1 = value;
           if (num1 < 0x100)
               num1 = 0x100;
           if (num1 < (this._capacity * 2))
               num1 = this._capacity * 2;
           byte[] buffer1 = new byte[num1];
           if (this._length > 0)
               Buffer.BlockCopy(this._buffer, 0, buffer1, 0, this._length);
           this._buffer = buffer1;
           this._capacity = num1;
       }
 
       public void Write(byte[] buffer, int offset, int count)
       {
           if (buffer.Length - offset < count)
           {
               count = buffer.Length - offset;
           }
           EnsureCapacity(buffer.Length + count);
           Array.Clear(_buffer, _length, _capacity - _length);
           Buffer.BlockCopy(buffer, offset, _buffer, _length, count);
           _length += count;
       }
 
       private void Remove(int count)
       {
           if (_length >= count)
           {
               Buffer.BlockCopy(_buffer, count, _buffer, 0, _length - count);
               _length -= count;
               Array.Clear(_buffer, _length, _capacity - _length);
           }
           else
           {
               _length = 0;
               Array.Clear(_buffer, 0, _capacity);
           }
       }
   }


这个类的使用非常简单，你只要用Write(byte[] buffer, int offset, int count)将接收到的数据写入数据流中，并用bool Read(out Message message)将数据中的第一个数据包取出，如果函数返回True，就说明取回一个封包成功，如果返回False，则说明流中已经没有完整的封包，你需要继续接收后面的数据以组成一个完整的封包。

smart-socket,一种高性能的Java AIO框架.zip
09-25
智能插座套接字，Java AAIO智能插座。
C#Socket通信，解决粘包和分包问题
热门推荐
Trinity_Force的博客
11-19 1万+
源码下载，学习的时候做的，现在可以做到一个服务端对应多个客户端同时接受消息，也解决了分包和粘包的问题，欢迎下载 (16条消息) 网络通信编程学习.7z-C#文档类资源-CSDN文库https://download.csdn.net/download/Trinity_Force/44900216 什么是粘包分包 TCP是面向连接的协议 TCP是点到点的通信 TCP提供可靠的传输服务 TCP协议提供全双工的通信 TCP协议面向字节流进行传输的，可以对用户的数据进行拆分或合并 TCP...
Socket粘包分包解析
weixin_43803688的博客
02-18 5019
一.粘包分包现象(来自Unity 3D网络实战一书) 由于TCP协议本身的机制，客户端与服务器会维持一个连接发送数据，如果发送的网络数据包太小，TCP会等待，然后合并较小的数据包在发送，接收端便无法区分哪些数据是发送端自己分开的，因此便会产生粘包现象，或者接收端把数据放到接受缓冲区中，如果数据没有及时从缓冲区取走，下次取数据时可能出现一次取出多个数据包的情况，如例，客户端发送两次数据，服务器一次接受: 客户端 Send： h e l l o 客户端 Send： u n i t y 服务器 Recv :
Linux Socket 分包 和 粘包 问题 - 解决方案
cpp_learner的博客
06-01 2834
针对TCP分包和粘包的问题，提供解决办法！
socket粘包
JonnyLeezh
07-08 292
继上次写了socket简单server和client通信后，将程序放到了linux上试了一下。在执行命令时，出现了粘包，即以下两条指令紧挨着执行了。  conn.send(str(len(cmd_res.encode('utf-8'))).encode('utf-8')) #先发送大小给客户端 conn.send(cmd_res.encode('utf-8')) 解决...
Socket封包、拆包、粘包
gengbaolong的博客
07-19 8483
Socket 粘包 封包 拆包
Socket开发之通讯协议及处理
yangyangku的博客
11-01 145
在Socket应用开发中，还有一个话题是讨论的比较多的，那就是数据接收后如何处理的问题。这也是一个令刚接触Socket开发的人很头疼的问题。 因为Socket的TCP通讯中有一个“粘包”的现象，既：大多数时候发送端多次发送的小数据包会被连在一起被接收端同时接收到，多个小包被组成一个大包被接收。有时候一个大数据包又会被拆成多个小数据包发送。这样就存在一个将数据包拆分和重新组合的问题。那么如何去处理...
Socket应用开发
施昌权专栏
03-11 593
在Socket应用开发中，还有一个话题是讨论的比较多的，那就是数据接收后如何处理的问题。这也是一个令刚接触Socket开发的人很头疼的问题。因为Socket的TCP通讯中有一个“粘包”的现象，既：大多数时候发送端多次发送的小数据包会被连在一起被接收端同时接收到，多个小包被组成一个大包被接收。有时候一个大数据包又会被拆成多个小数据包发送。这样就存在一个将数据包拆分和重新组合的问题。那么如何去处理
smart-socket如何实现字符串通信
weixin_34410662的博客
08-25 640
2019独角兽企业重金招聘Python工程师标准>>> ...
粘包/半包及解决方案
leikang111的博客
03-25 3988
粘包（Packet Concatenation）通常发生在基于流式传输协议（如 TCP）的通信中，因为 TCP 是面向流的传输协议，它不保证数据包的边界，而是将数据视为连续的字节流，它表示客户端发送多条消息，服务端只收到了一条消息。
Socket 通讯 接受到多条命令混合到一块问题
feitiankoulan的专栏
11-22 2245
这是我做舞台控制软件时，遇到的问题，把它记录下来，方便以后再遇到。问题情况是这样的：服务端不断向终端发送命令，结果不时的出现几条命令混合到一块去了，导致命令判断时，判断不出来，测试有时正确，有时出问题。检测代码，没有逻辑上的大问题，经过反复推敲和测试，发现在发送命令端出的问题，发送命令是通过for循环发送的，中间没有间停，导致接收端从数据缓存区取出数据时，就有几条命令连接到一块的问题。解决办法时，
socket 拆包、粘包_计算机通信之谜，带你彻底理解socket网络编程（五）
weixin_36210904的博客
01-13 270
今天和大家讲一下socket网络编程中粘包和拆包的问题。1、出现粘包拆包的原因假设一个这样的场景，客户端要利用send()函数发送字符“asd”到服务端，连续发送3次，但是服务端休眠10秒之后再去缓冲池中接收。那么请问10秒之后服务端从缓冲区接收到的信息是“asd”还是“asdasdasd”呢？如果大家有去做实验的话，可以知道服务端收到的是“asdasdasd”，为什么会这样呢？按正常的...
使用socket遇到的问题以及解决
宋梦科的专栏
12-13 1736
在最近的项目中，要用到socket建立三个设备的连接用手机控制开灯，以前只能做到：一起开许多灯，实现原理之前也写过博客说过，非常简单，但是这次我想实现的是在手机上控制开关具体的某个灯，然后与做安卓端的同学沟通好之后就动工了，在手机上进入灯光控制界面之后就能查看当前的灯光状态以及控制开灯关灯，由于最近考试和实验课比较烦，所以项目就一直搁置着，然后开工之后遇到了一个问题，就是我要求安卓端的同学在进入灯
【问题解决】socket黏包
本末实验室
07-14 1191
问题描述： 建立TCP连接之后， client端write fd，向server端发送数据。server端read fd。结果出现收发不一致的现象，原本的期望是client发一次，server收一次。但是却出现了收发不一致的现象。 client：write 连续写两次 server：read读一次 问题分析： 两端同时对socket缓冲区操作，client连续两次writ...
解决 Socket 网络通讯中的粘包、半包问题
weixin_44262126的博客
05-02 1230
1）本文章针对 Java 以及 Python 两种语言的不同特性来解决 Socket 网络通讯中的粘包、半包问题，这两种解决办法的代码实现自己思考了很久，所以讨个赞不过分吧。 1 什么是半包、粘包问题 TCP通讯为何存在粘包呢？主要原因是 TCP 是以流的方式来处理数据，再加上网络上 MTU 的往往小于在应用处理的消息数据，所以就会引发一次接收的数据无法满足消息的需要，导致粘包的存在。 处理粘包的唯一方法就是制定应用层的数据通讯协议，通过协议来规范现有接收的数据是否满足消息数据的需要。   2.
Socket 循环接收消息 粘包 半包（C#）
BusyMonkey
11-02 3120
这两天在向同事学习socket收发消息的问题，学到了新知识，非常感谢 yss 的 hwh 1、对于一次接收到大于接收缓存的消息，并且连续接收消息，两段消息可能同时被接受到一端缓存中，叫粘包； 2、收到的消息不足一个接收缓存，交半包； 程序的几个注意点： 1、必须要循环接收消息； 2、消息头必须要有长度标志字节（这里是用的前四个字节来保存实际消息体的长度）； 3、除了接收缓存rev...
TCP通信中的数据包解析（处理拆包粘包）
09-17 1352
这个解码器最主要是解决TCP粘包拆包问题 package com.wunaozai.iot.nettyplatform.code; import java.util.List; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import io.netty.buffer.ByteBuf; import io.netty.channel.ChannelHandlerContext; import io.netty.handler.co
socket TCP中的粘包和分包处理--数据解析
Tang_AHMET的博客
03-21 1804
socket TCP中的粘包和分包处理–数据解析 1：这里要讲的是socket中的粘包和分包处理，先看看粘合和分包是如何形成的 1.1粘包和分包问题：粘包和分包是利用socket在TCP协议下的内部优化机制 粘包： 多条消息粘包，导致这种情况是发送内容比较频繁，内容较小，进行粘合，节约资源 分包： 对发送的数据比较大的时候，进行分开发送，类似于分段发送，进行拆分的发送 2：遇到这种情况，我们该如...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值