python TCP Socket的粘包和分包的处理详解

概述概述在进行TCPSocket开发时，都需要处理数据包粘包和分包的情况。本文详细讲解解决该问题的步骤。使用的语言是Python。实际上解决该问题很简单，在应用层下，定义一个协议：消息头部+消息长度+消息正文即可。那什么是粘包和分包呢？关于分包和粘包粘包：发送方发送两个字符串”hell 概述

在进行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    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画了一个流程图。

服务器端代码

    # 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出

测试服务器端的客户端代码

下面附上测试粘包和分包的客户端代码

    # 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()

服务器端打印结果

下面是测试出来的打印结果，可见接收方已经完美的处理粘包和分包问题了。

    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开发框架处理粘包和分包的示例，只上核心程序：

    # 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的粘包和分包的处理详解的全部内容，希望对大家有所帮助。感兴趣的朋友可以继续参阅本站其他相关专题，如有不足之处，欢迎留言指出。感谢朋友们对本站的支持！

总结

以上是内存溢出为你收集整理的python TCP Socket的粘包和分包的处理详解全部内容，希望文章能够帮你解决python TCP Socket的粘包和分包的处理详解所遇到的程序开发问题。

如果觉得内存溢出网站内容还不错，欢迎将内存溢出网站推荐给程序员好友。