Python编程——基于TCP的套接字通信包【开源】

最新推荐文章于 2022-08-18 02:37:01 发布

魔法攻城狮MRL

最新推荐文章于 2022-08-18 02:37:01 发布

阅读量2.2k

点赞数 11

分类专栏： Python程序设计文章标签： socket python 网络网络通信 tcpip

本文链接：https://blog.csdn.net/qq_41959920/article/details/115380403

版权

Python程序设计专栏收录该内容

28 篇文章 8 订阅

订阅专栏

提示：转载请注明出处，如果该文章对您有帮助，请点赞支持下

文章目录

前言

基于TCP的套接字通信是深入学习Python程序的必备技能之一，套接字不仅可以用于网络编程，在本地不同进程之间的通信、不同编程语言的程序通信中也应用十分广泛。
本篇文章是在之前了解套接字编程接口的基础上进一步扩展，写出一套真正可用于实际程序通信的代码。

本篇文章将会集中研究套接字通信中的分包和粘包问题、自定义通信协议的方法，方便入门套接字的同学进阶，本篇文章的代码将会在GitHub上开源，之后还会推出C#版本等。

如果您不了解基础的基于Python的TCP套接字接口，可以先简单阅读我的博客Python编程——基于TCP的套接字简单通信，如果觉得对您有帮助，欢迎收藏、点赞。

一、TCP套接字的优点与不足

众所周知，套接字是主流语言提供的用于进行网络进程通信的程序接口，其中最常见的是基于TCP协议的套接字编程，基于TCP协议的套接字可以保证：

可靠传播。在一般情况下，数据传输过程中数据不会发生丢失，并且数据发送和接收的顺序不会改变，即我发送一个“Hello”和“World”，对方一定会按顺序先后收到“Hello”和“World”。

数据可靠。在一般情况下，数据传输过程中无论数据包被如何组合拆分等，都不会添加与发送信息无关的无效信息，即数据不会被污染，按照指定编码方式进行解码即可还原原来的信息。

但是在实际进行TCP编程的过程中，如果使用原生的套接字接口，在处理消息通信时，需要处理以下两个典型问题：

1、分包和粘包问题

（1）分包问题

TCP是以段（Segment）为单位发送数据的，建立TCP链接后，有一个最大消息长度（MSS）。如果应用层数据包超过MSS，就会把应用层数据包拆分，分成两个段来发送。这个时候接收端的应用层就要拼接这两个TCP包，才能正确处理数据。

简单理解，分包现象就是一次传输的数据过多时，TCP协议会自动将本次的数据拆分成多个消息包进行发送。

例如，发送方发送字符串”helloworld”，接收方却接收到了两个字符串”hello”和”world”。

（2）粘包问题

在某些特殊环境下，TCP为了提高网络的利用率，会使用一个叫做Nagle的算法。该算法是指，发送端即使有要发送的数据，如果很少的话，会延迟发送。如果应用层给TCP传送数据很快的话，就会把两个应用层数据包“粘”在一起，TCP最后只发一个TCP数据包给接收端。

简单理解，粘包现象就是当网络繁忙时，TCP协议会将多份小的消息包打包成一个消息包进行发送。

例如，发送方发送两个字符串”hello”+”world”，接收方却一次性接收到了”helloworld”。

2、自定义通信协议

TCP套接字可以提供基本的字符串类型的信息传输，但是字符串可以代表什么含义，怎么解释它需要开发者来自定义。更重要的是，为了解决分包和粘包问题，我们也必须自定义一个简单的通信协议。

通信协议听起来很高大上，其实本质上就是发送方和接收方达成的约定，对每个完整的消息包格式做出规定，接收数据时按照这个格式进行检查，从而得到一个个正确的消息包。

最简单的消息格式就是我们在消息正文的前方加入一个固定长度的数字表示消息正文的长度，这样就可以基本解决分包和粘包问题。

但是为了之后可以判断我们的消息类型，也为了便于设计客户端和服务端，我们这里稍微复杂一点，即本文定义的消息格式如下：

本文定义的消息格式
消息头			消息正文
正文长度（bodySize）	指令类型（cmd）	是否回复（recv）	正文
无符号32位整型变量	无符号32位整型变量	无符号32位整型变量	——
4字节	4字节	4字节	——

接下来我们就会详细介绍如何实现上述设计。

二、自定义通信协议类

我们自定义一个通信协议类MsgProtol来帮助我们实现发送的消息的打包和拆包功能，同时为了区分不同的消息类型，我们会先定义一个枚举类MsgCmd

1.定义消息类型

这个枚举类十分简单，不再介绍。

from enum import Enum

class MsgCmd(Enum):
    INFORM = 1 # 通知，不需要回复
    REQUEST = 2 # 请求，需要回复
    PARAM =3 # 参数

2、定义消息协议类

我们先接受这个消息协议类定义的全局变量，之后我们在本节设计的每个方法都是该类的公有方法。

class MsgProtol(object):
    def __init__(self):
        self.dataBuffer = bytes() # 接收消息的缓存
        self.headerSize = 12 # 3*4，消息头的字节总数

3、打包方法

打包方法的逻辑比较简单，就是将由整数组成的消息头和其他类型组成的消息正文分别编码成字节格式，然后组合在一起。

首先我们知道的是，网络上传输的数据格式都是字节形式（byte）。

消息头都是整数形式，我们使用struct来打包，struct可以将python中的整形数字打包成字节形式，这也是网络编程中打包数字最常见的方式；

消息正文使用的json来打包，json打包是将python的字典打包成json对象格式，本质上还是字符串，然后我们调用字符串的编码格式转换成字节。

为什么我们要专门转换成json对象格式？

Json对象可以转换Python字典，字典可以帮助我们传输参数；

Json对象格式十分通用，可以方便地在不同语言进行转换。

详细的打包方法如下：

def pack(self,cmd,_body,_recv=1):
    body = json.dumps(_body) # 将消息正文转换成Json格式
    header = [body.__len__(),cmd,_recv] # 将消息头按顺序组成一个列表
    headPack= struct.pack("!3I", *header) #  使用struct打包消息头,得到字节编码
    sendData = headPack+body.encode()  # 将消息头字节和消息正文字节组合在一起
    return sendData

一个简单的调用案例如下，需要注意其中传入cmd的形式,其必须是整形数字：

# 自定义消息
data={}
data["source"]="客户端"
data["msg"]="你好"
# 打包消息
msg = self.msg_protol.pack(MsgCmd.PARAM.value,data,_recv=0) 
# 发送消息
self._socket.send(msg)

4、解包方法

解包比打包要复杂一点，因为我们要处理一下分包和粘包问题。首先我们看一下我们的解包方法如何调用：

            while True:
                msg = self._client_socket.recv(self._buffer_size)# 接收消息
                flag = self.msg_protol.unpack(msg,self._handle_msg)# 解封消息包

上述是服务端的调用代码，因为我们的服务端要时刻接收客户端消息，所以我们这里使用了一个循环，如果想暂停，可以判断flag。

接下来我们看解包方法：

            self.dataBuffer += data
            while True:
                # 数据量不足消息头部时跳出函数继续接收数据
                if len(self.dataBuffer) < self.headerSize:
                    #print("数据包（%s Byte）小于消息头部长度，跳出小循环" % len(self.dataBuffer))
                    break
                # struct中:!代表Network order，3I代表3个unsigned int数据
                headPack = struct.unpack('!3I', self.dataBuffer[:self.headerSize])# 解码出消息头部
                # 获取消息正文长度
                bodySize = headPack[0]
                # 分包情况处理，跳出函数继续接收数据
                if len(self.dataBuffer) < self.headerSize + bodySize:
                    #print("数据包（%s Byte）不完整（总共%s Byte），跳出小循环" % (len(self.dataBuffer), self.headerSize + bodySize))
                    break
                # 读取消息正文的内容
                body = self.dataBuffer[self.headerSize:self.headerSize + bodySize]
                msgHandler(headPack,body.decode())
                # 粘包情况的处理，获取下一个数据包部分
                self.dataBuffer = self.dataBuffer[self.headerSize + bodySize:]
            if len(self.dataBuffer)!=0:
                return True # 继续接收消息
            else:
                return False  # 不再接收消息

在上述代码中，我们首先将本次接收到的data放入我们的缓存中，然后此时判断缓存大小，如果不够消息头长度，说明此时接收的还远远不够，跳出循环，解包方法返回外部继续接收数据data；

假如此时再次进入，data再次加入我们的缓存后，已经超过了消息头长度，那么我们就可以将消息头解包出来得到消息正文长度，然后和消息正文长度+消息头长度的和比较，就能判断这个消息包是否完整；

如果不完整继续跳出循环去接收数据data，如果已经完成则解码出消息正文body，将消息头headpack和消息正文body传入msgHandler去处理该完整的消息即可。

此时我们从缓存中取出上一个已经交付处理的完整消息包的长度，继续该循环来看剩下的缓存中是否还有数据。

如果我们不想无限制的接收消息，例如客户端，那么只需要在经过上述处理后判断下此时的缓存大小是否为0，如果为0则表示此时没有残余数据，可以不用继续接收数据，如果不为0，则表示现在的消息数据还没有处理完应该继续接收。