概述
在进行TCP Socket开发时,都需要处理数据包粘包和分包的情况。本文详细讲解解决该问题的步骤。使用的语言是Python。实际上解决该问题很简单,在应用层下,定义一个协议:消息头部+消息长度+消息正文即可。
那什么是粘包和分包呢?
关于分包和粘包
粘包:发送方发送两个字符串”hello”+”world”,接收方却一次性接收到了”helloworld”。
分包:发送方发送字符串”helloworld”,接收方却接收到了两个字符串”hello”和”world”。
虽然socket环境有以上问题,但是TCP传输数据能保证几点:
- 顺序不变。例如发送方发送hello,接收方也一定顺序接收到hello,这个是TCP协议承诺的,因此这点成为我们解决分包、黏包问题的关键。
- 分割的包中间不会插入其他数据。
因此如果要使用socket通信,就一定要自己定义一份协议。目前最常用的协议标准是:消息头部(包头)+消息长度+消息正文
TCP为什么会分包
TCP是以段(Segment)为单位发送数据的,建立TCP链接后,有一个最大消息长度(MSS)。如果应用层数据包超过MSS,就会把应用层数据包拆分,分成两个段来发送。这个时候接收端的应用层就要拼接这两个TCP包,才能正确处理数据。
相关的,路由器有一个MTU( 最大传输单元),一般是1500字节,除去IP头部20字节,留给TCP的就只有MTU-20字节。所以一般TCP的MSS为MTU-20=1460字节。
当应用层数据超过1460字节时,TCP会分多个数据包来发送。
扩展阅读
TCP的RFC定义MSS的默认值是536,这是因为 RFC 791里说了任何一个IP设备都得最少接收576尺寸的大小(实际上来说576是拨号的网络的MTU,而576减去IP头的20个字节就是536)。
TCP为什么会粘包
有时候,TCP为了提高网络的利用率,会使用一个叫做Nagle的算法。该算法是指,发送端即使有要发送的数据,如果很少的话,会延迟发送。如果应用层给TCP传送数据很快的话,就会把两个应用层数据包“粘”在一起,TCP最后只发一个TCP数据包给接收端。
开发环境
- Python版本:3.5.1
- 操作系统:Windows 10 x64
消息头部(包含消息长度)
消息头部不一定只能是一个字节比如0xAA什么的,也可以包含协议版本号,指令等,当然也可以把消息长度合并到消息头部里,唯一的要求是包头长度要固定的,包体则可变长。下面是我自定义的一个包头:
版本号(ver) | 消息长度(bodySize) | 指令(cmd) |
---|
版本号,消息长度,指令数据类型都是无符号32位整型变量,于是这个消息长度固定为4×3=12字节。在Python由于没有类型定义,所以一般是使用struct模块生成包头。示例:
1
2
3
4
5
6
7
8
9
10
|
import struct import json ver = 1 body = json.dumps( dict (hello = "world" )) print (body) # {"hello": "world"} cmd = 101 header = [ver, body.__len__(), cmd] headPack = struct.pack( "!3I" , * header) print (headPack) # b'\x00\x00\x00\x01\x00\x00\x00\x12\x00\x00\x00e' |
关于用自定义结束符分割数据包
有的人会想用自定义的结束符分割每一个数据包,这样传输数据包时就不需要指定长度甚至也不需要包头了。但是如果这样做,网络传输性能损失非常大,因为每一读取一个字节都要做一次if判断是否是结束符。所以建议还是选择消息头部+消息长度+消息正文这种方式。
而且,使用自定义结束符的时候,如果消息正文中出现这个符号,就会把后面的数据截止,这个时候还需要处理符号转义,类比于\r\n的反斜杠。所以非常不建议使用结束符分割数据包。
消息正文
消息正文的数据格式可以使用Json格式,这里一般是用来存放独特信息的数据。在下面代码中,我使用{"hello","world"}数据来测试。在Python使用json模块来生成json数据
Python示例
下面使用Python代码展示如何处理TCP Socket的粘包和分包。核心在于用一个FIFO队列接收缓冲区dataBuffer和一个小while循环来判断。
具体流程是这样的:把从socket读取出来的数据放到dataBuffer后面(入队),然后进入小循环,如果dataBuffer内容长度小于消息长度(bodySize),则跳出小循环继续接收;大于消息长度,则从缓冲区读取包头并获取包体的长度,再判断整个缓冲区是否大于消息头部+消息长度,如果小于则跳出小循环继续接收,如果大于则读取包体的内容,然后处理数据,最后再把这次的消息头部和消息正文从dataBuffer删掉(出队)。
下面用Markdown画了一个流程图。
服务器端代码
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
|
# Python Version:3.5.1 import socket import struct HOST = '' PORT = 1234 dataBuffer = bytes() headerSize = 12 sn = 0 def dataHandle(headPack, body): global sn sn + = 1 print ( "第%s个数据包" % sn) print ( "ver:%s, bodySize:%s, cmd:%s" % headPack) print (body.decode()) print ("") if __name__ = = '__main__' : with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.bind((HOST, PORT)) s.listen( 1 ) conn, addr = s.accept() with conn: print ( 'Connected by' , addr) while True : data = conn.recv( 1024 ) if data: # 把数据存入缓冲区,类似于push数据 dataBuffer + = data while True : if len (dataBuffer) < headerSize: print ( "数据包(%s Byte)小于消息头部长度,跳出小循环" % len (dataBuffer)) break # 读取包头 # struct中:!代表Network order,3I代表3个unsigned int数据 headPack = struct.unpack( '!3I' , dataBuffer[:headerSize]) bodySize = headPack[ 1 ] # 分包情况处理,跳出函数继续接收数据 if len (dataBuffer) < headerSize + bodySize : print ( "数据包(%s Byte)不完整(总共%s Byte),跳出小循环" % ( len (dataBuffer), headerSize + bodySize)) break # 读取消息正文的内容 body = dataBuffer[headerSize:headerSize + bodySize] # 数据处理 dataHandle(headPack, body) # 粘包情况的处理 dataBuffer = dataBuffer[headerSize + bodySize:] # 获取下一个数据包,类似于把数据pop出 |
测试服务器端的客户端代码
下面附上测试粘包和分包的客户端代码
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
|
# Python Version:3.5.1 import socket import time import struct import json host = "localhost" port = 1234 ADDR = (host, port) if __name__ = = '__main__' : client = socket.socket() client.connect(ADDR) # 正常数据包定义 ver = 1 body = json.dumps( dict (hello = "world" )) print (body) cmd = 101 header = [ver, body.__len__(), cmd] headPack = struct.pack( "!3I" , * header) sendData1 = headPack + body.encode() # 分包数据定义 ver = 2 body = json.dumps( dict (hello = "world2" )) print (body) cmd = 102 header = [ver, body.__len__(), cmd] headPack = struct.pack( "!3I" , * header) sendData2_1 = headPack + body[: 2 ].encode() sendData2_2 = body[ 2 :].encode() # 粘包数据定义 ver = 3 body1 = json.dumps( dict (hello = "world3" )) print (body1) cmd = 103 header = [ver, body1.__len__(), cmd] headPack1 = struct.pack( "!3I" , * header) ver = 4 body2 = json.dumps( dict (hello = "world4" )) print (body2) cmd = 104 header = [ver, body2.__len__(), cmd] headPack2 = struct.pack( "!3I" , * header) sendData3 = headPack1 + body1.encode() + headPack2 + body2.encode() # 正常数据包 client.send(sendData1) time.sleep( 3 ) # 分包测试 client.send(sendData2_1) time.sleep( 0.2 ) client.send(sendData2_2) time.sleep( 3 ) # 粘包测试 client.send(sendData3) time.sleep( 3 ) client.close() |
服务器端打印结果
下面是测试出来的打印结果,可见接收方已经完美的处理粘包和分包问题了。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
Connected by ( '127.0.0.1' , 23297 ) 第 1 个数据包 ver: 1 , bodySize: 18 , cmd: 101 { "hello" : "world" } 数据包( 0 Byte)小于包头长度,跳出小循环 数据包( 14 Byte)不完整(总共 31 Byte),跳出小循环 第 2 个数据包 ver: 2 , bodySize: 19 , cmd: 102 { "hello" : "world2" } 数据包( 0 Byte)小于包头长度,跳出小循环 第 3 个数据包 ver: 3 , bodySize: 19 , cmd: 103 { "hello" : "world3" } 第 4 个数据包 ver: 4 , bodySize: 19 , cmd: 104 { "hello" : "world4" } |
在框架下处理粘包和分包
其实无论是使用阻塞还是异步socket开发框架,框架本身都会提供一个接收数据的方法提供给开发者,一般来说开发者都要覆写这个方法。下面是在Twidted开发框架处理粘包和分包的示例,只上核心程序:
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
|
# Twiested class MyProtocol(Protocol): _data_buffer = bytes() # 代码省略 def dataReceived( self , data): """Called whenever data is received.""" self ._data_buffer + = data headerSize = 12 while True : if len ( self ._data_buffer) < headerSize: return # 读取消息头部 # struct中:!代表Network order,3I代表3个unsigned int数据 headPack = struct.unpack( '!3I' , self ._data_buffer[:headerSize]) # 获取消息正文长度 bodySize = headPack[ 1 ] # 分包情况处理 if len ( self ._data_buffer) < headerSize + bodySize : return # 读取消息正文的内容 body = self ._data_buffer[headerSize:headerSize + bodySize] # 处理数据 self .dataHandle(headPack, body) # 粘包情况的处理 self ._data_buffer = self ._data_buffer[headerSize + bodySize:] |
总结
以上就是本文关于python TCP Socket的粘包和分包的处理详解的全部内容,希望对大家有所帮助。感兴趣的朋友可以继续参阅本站其他相关专题,如有不足之处,欢迎留言指出。感谢朋友们对本站的支持!
原文链接:http://blog.csdn.net/yannanxiu/article/details/52096465