【Python】TCPSocket的粘包和分包的处理
Reference: blog.csdn/yannanxiu/article/details/52096465
概述
在进⾏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模块⽣成包头。⽰例：
import struct
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'
1
2
3
4
5
6
7
8
9
10
关于⽤⾃定义结束符分割数据包
有的⼈会想⽤⾃定义的结束符分割每⼀个数据包，这样传输数据包时就不需要指定长度甚⾄也不需要包
头了。但是如果这样做，⽹络传输性能损失⾮常⼤，因为每⼀读取⼀个字节都要做⼀次if判断是否是结束符。所以建议还是选择消息头部+消息长度+消息正⽂这种⽅式。
⽽且，使⽤⾃定义结束符的时候，如果消息正⽂中出现这个符号，就会把后⾯的数据截⽌，这个时候还需要处理符号转义，类⽐于\r\n的反斜杠。所以⾮常不建议使⽤结束符分割数据包。
消息正⽂
消息正⽂的数据格式可以使⽤Json格式，这⾥⼀般是⽤来存放独特信息的数据。在下⾯代码中，我使⽤{"hello","world"}数据来测试。在Python 使⽤json模块来⽣成json数据
Python⽰例
下⾯使⽤Python代码展⽰如何处理TCP Socket的粘包和分包。核⼼在于⽤⼀个FIFO队列接收缓冲区dataBuffer和⼀个⼩while循环来判断。
具体流程是这样的：把从socket读取出来的数据放到dataBuffer后⾯（⼊队），然后进⼊⼩循环，如果dataBuffer内容长度⼩于消息长度（bodySize），则跳出⼩循环继续接收；⼤于消息长度，则从缓冲区读取包头并获取包体的长度，再判断整个缓冲区是否⼤于消息头部+消息长度，如果⼩于则跳出⼩循环继续接收，如果⼤于则读取包体的内容，然后处理数据，最后再把这次的消息头部和消息正⽂从dataBuf
fer 删掉（出队）。
下⾯⽤Markdown画了⼀个流程图。
开始等待数据到达把数据push缓冲区缓冲区⼩于消息长度？读取消息头部的内容缓冲区⼩于消息头部和消息正⽂长度？读取消息正⽂的内容处理数据从缓冲区pop数据yesnoyesno
服务器端代码
# 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))
conn, addr = s.accept()
with conn:
print('Connected by', addr)
while True:
data = v(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
44
45
46
47
48
49
50
51
52
53
测试服务器端的客户端代码
下⾯附上测试粘包和分包的客户端代码：
# 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()
# 正常数据包定义
ver = 1
body = json.dumps(dict(hello="world"))
print(body)
cmd = 101
header = [ver, body.__len__(), cmd]
headPack = struct.pack("!3I", *header)
sendData1 = de()
# 分包数据定义
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 = de()+de()    # 正常数据包
client.send(sendData1)
time.sleep(3)
# 分包测试
client.send(sendData2_1)
time.sleep(0.2)
client.send(sendData2_2)
time.sleep(3)
# 粘包测试
client.close()
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

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。