完整的可运行的开源版本

第一次发布的版本

Author: MagicDeveloperDRL

ClientSocket.py

@@ -0,0 +1,101 @@
+'''''''''
+@file: ClientSocket.py
+@author: MRL Liu
+@time: 2021/3/31 21:48
+@env: Python3
+@desc: 提供基于Python程序的客户端通信功能
+@ref:https://blog.csdn.net/yannanxiu/article/details/52096465
+@blog: https://blog.csdn.net/qq_41959920
+'''''''''
+import json
+import logging
+import socket
+from MsgProtol import MsgCmd,MsgProtol
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger("client")
+
+class ClientSocket(object):
+    def __init__(self, ip="127.0.0.1", port=5006):
+        self.ip = ip  # ip地址
+        self.port = port  # 端口号
+        self._buffer_size = 12000  # 接收客户端消息的内存大小
+        self.msg_protol =MsgProtol() # 网络通信协议
+
+    def Connect(self):
+        """初始化套接字"""
+        try:
+            self._socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)  # 创建Socket对象
+            self._socket.connect((self.ip,self.port)) # 连接服务器
+            logger.info("客户端的IP地址是{}:{}".format(self.ip,self.port))
+        except socket.error:
+            self.close()
+            raise socket.error("无法连接服务器，可能是服务器没有启动")
+
+    def Send(self,cmd,data,recv):
+        try:
+            msg = self.msg_protol.pack(cmd,data,recv)
+            self._socket.send(msg)  # 发送消息
+            logger.info("发送1个数据包->cmd:" + MsgCmd(cmd).name+" body:"+str(data))
+            # 是否接收回复
+            if recv==1:
+                self.Receive()
+        except socket.error:
+            raise
+
+    def Receive(self):
+        try:
+            flag = True
+            logger.info("开始接收消息...")
+            while flag:
+                msg = self._socket.recv(self._buffer_size)  # 接收消息
+                flag = self.msg_protol.unpack(msg, self._handle_msg)  # 解封消息包
+            logger.info("接收消息结束...")
+        except socket.error as e:
+            logging.debug("客户端接收消息出错")
+            self.close()
+            raise
+
+    def _handle_msg(self,headPack,body):
+        """分类处理接收到的消息字符串"""
+        if  self._socket:
+            # 数据处理
+            cmd = MsgCmd(headPack[1]).name  # 获取Code的值
+            is_recv = headPack[2]
+            logging.info("收到1个数据包->bodySize:{}, cmd:{},recv:{}".format(headPack[0],cmd,is_recv))
+            p = json.loads(body)  # 将字符串解码并且反序列化为json对象
+            #print(body)
+            # 检查消息类型
+            if cmd == "EXIT": # 关闭消息
+                self.close()
+                return
+            elif cmd == "INFORM": # 通知消息
+                #msg = p["msg"]
+                print(p)
+            else:
+                logging.error("\n未知的cmd:{0}".format(cmd))
+            # 继续接收消息
+            #self._recv_bytes()
+
+    def close(self):
+        try:
+            if(self._socket!=None):
+                self._socket.close()
+                logger.info('socket closed')
+        except socket.error:
+            logging.debug("socket closed exception")
+            raise
+
+if __name__ == '__main__':
+    client = ClientSocket()
+    client.Connect()
+    # 发送一个字典并且让服务端回复
+    protol={}
+    protol["type"] = MsgCmd.PARAM.name
+    protol["apiNumber"]="大家伙"
+    protol["AcademyName"] = "s"
+    protol["logPath"] = "s"
+    protol["brainNames"] = "s"
+    protol["externalBrainNames"] = "s"
+    # 发送消息
+    client.Send(MsgCmd.PARAM.value,protol,1)

MsgProtol.py

@@ -0,0 +1,60 @@
+'''''''''
+@file: MsgProtol.py
+@author: MRL Liu
+@time: 2021/4/1 11:04
+@env: Python3
+@desc: 网络通信的消息协议
+@ref: https://blog.csdn.net/yannanxiu/article/details/52096465
+@blog: https://blog.csdn.net/qq_41959920
+'''''''''
+import json
+import struct
+from enum import Enum
+
+class MsgCmd(Enum):
+    INFORM = 1 # 通知，不需要回复
+    REQUEST = 2 # 请求，需要回复
+    PARAM =3 # 参数
+
+class MsgProtol(object):
+    def __init__(self):
+        self.dataBuffer = bytes() # 接收消息的缓存
+        self.headerSize = 12 # 3*4，消息头的字节总数
+
+
+    def pack(self,cmd,_body,_recv=1):
+        body = json.dumps(_body).encode() # 将消息正文转换成Json格式，并转换成字节编码
+        header = [body.__len__(),cmd,_recv] # 将消息头按顺序组成一个列表
+        headPack= struct.pack("!3I", *header) #  使用struct打包消息头,得到字节编码
+        sendData = headPack+body  # 将消息头字节和消息正文字节组合在一起
+        return sendData
+
+    def unpack(self,data,msgHandler):
+        if data:
+            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  # 不再接收消息
+        else:
+            return False # 不再接收消息
+
+

README.md

@@ -1,2 +1,82 @@
 # MNetSocket-Python
+
+[TOC]
+
+# 一、项目简介
+
 本项目是一个只有4份Python代码的开源小工程，用来学习基于TCP的套接字通信包，可以自定义通信协议，处理分包和粘包。内置一个服务端和客户端程序，也有对应的博客讲解代码。整个工程基本基于良好的面向对象思想，代码注释清晰简洁。
+
+这个小项目共有4份代码，各自作用如下：
+
+| **代码模块**    | **主要功能**                                 |
+| --------------- | -------------------------------------------- |
+| MsgProtol.py    | 网络通信的消息协议，提供消息打包和解包功能   |
+| ServerSocket.py | 提供基于Python程序的服务端通信功能           |
+| ClientSocket.py | 提供基于Python程序的客户端通信功能           |
+| testPack.py     | 本模块用来设计测试服务端处理分包和粘包的能力 |
+
+# 二、背景知识
+
+基于TCP的**套接字通信**是深入学习Python程序的必备技能之一，**套接字**不仅可以用于**网络编程**，在本地**不同进程之间的通信**、**不同编程语言的程序通信**中也应用十分广泛。
+本篇文章是在之前**了解套接字编程接口**的基础上进一步扩展，写出一套**真正可用于实际程序通信的代码**。
+
+本项目会集中研究套接字通信中的**分包和粘包问题**、**自定义通信协议**的方法，方便入门套接字的同学进阶。
+
+如果您不了解基础的基于Python的TCP套接字接口，可以先简单阅读我的博客**[Python编程——基于TCP的套接字简单通信](https://blog.csdn.net/qq_41959920/article/details/115328992?spm=1001.2014.3001.5501)，如果觉得对您有帮助，欢迎收藏、点赞。**
+
+完整的项目开源信息如下：
+
+| **MNetSocket-Python** |                   基于Python的网络通信包                    |
+| --------------------- | :---------------------------------------------------------: |
+| **开发者**            |                           MRL Liu                           |
+| **编程语言**          |                           Python3                           |
+| **项目描述**          |  基于TCP的套接字通信包，可以自定义通信协议，处理分包和粘包  |
+| **博客**              | https://blog.csdn.net/qq_41959920/article/details/115380403 |
+| **GitHub**            |   https://github.com/MagicDeveloperDRL/MNetSocket-Python    |
+| **参考博客**          |  https://blog.csdn.net/yannanxiu/article/details/52096465   |
+
+# **三、项目研究问题**
+
+众所周知，套接字是主流语言提供的用于进行网络进程通信的程序接口，其中最常见的是基于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字节              | ——   |
+
+本人博客会详细介绍如何实现上述设计。

ServerSocket.py

@@ -0,0 +1,133 @@
+'''''''''
+@file: ServerSocket.py
+@author: MRL Liu
+@time: 2021/3/31 17:05
+@env: Python3
+@desc: 提供基于Python程序的服务端通信功能
+@ref: https://blog.csdn.net/yannanxiu/article/details/52096465
+@blog: https://blog.csdn.net/qq_41959920
+'''''''''
+import json
+import logging
+import socket
+from MsgProtol import MsgCmd,MsgProtol
+
+logging.basicConfig(level=logging.INFO) # 定义日志输出的水平
+logger = logging.getLogger("server")
+
+
+
+class ServerSocket(object):
+    def __init__(self, ip="127.0.0.1", port=5006):
+        self.ip = ip  # ip地址
+        self.port = port  # 端口号
+        self._buffer_size = 12000  # 接收客户端消息的内存大小
+        self._is_init_socket = False  # 套接字是否初始化
+        self._recv_init_msg = False  # 是否接收到客户端连接发送来的初始化参数
+        self.msg_protol = MsgProtol() # 网络消息，为了调用其打包和解包功能
+        self._init_socket() # 初始化套接字
+        self._socket.settimeout(30)  # 设置套接字的监听时间
+        self._conn_client() # 连接客户端
+
+    def _init_socket(self):
+        """初始化套接字"""
+        try:
+            # 初始化Socket
+            self._socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) # 创建Socket对象
+            self._socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) # 设置Socket对象
+            ip_port = (self.ip, self.port) # 定义IP地址和端口号
+            logging.info("服务端的IP地址是 {}:{}".format(self.ip,self.port))
+            self._socket.bind(ip_port)# 绑定IP地址
+            self._socket.setblocking(False)# 设置阻塞模式为False
+            self._is_init_socket = True
+        except socket.error:
+            self._is_init_socket = True
+            self.close()
+            raise socket.error("无法初始化服务端套接字 ")
+
+    def _conn_client(self):
+        """连接客户端"""
+        try:
+            try:
+                self._socket.listen(1)# 开启侦听
+                self._client_socket, addr = self._socket.accept()# 接收到请求
+                logging.info('接收到客户端连接')
+                self._client_socket.settimeout(30) # 设置客户端套接字的连接时长
+            except socket.timeout as e:
+                raise socket.error("客户端连接超时")
+
+            self._recv_bytes() # 接收消息
+        except socket.error:
+            logging.debug("连接客户端出错")
+            self.close()
+            raise
+
+    def _recv_bytes(self):
+        """接收客户端的字节消息，按照消息长度切分成一个完整的字符串"""
+        try:
+            flag = True
+            logger.info("开始接收消息...")
+            while True:
+                msg = self._client_socket.recv(self._buffer_size)# 接收消息
+                flag = self.msg_protol.unpack(msg,self._handle_msg)# 解封消息包
+            #logger.info("接收消息结束...")
+        except socket.timeout as e:
+            logging.debug("客户端发送消息超时, 即将关闭客户端套接字")
+            self.close()
+
+    def _handle_msg(self,headPack,body):
+        """分类处理接收到的消息字符串"""
+        if  self._is_init_socket:
+            # 数据处理
+            cmd = MsgCmd(headPack[1]).name  # 获取Code的值
+            is_recv = headPack[2]
+            logging.info("收到1个数据包->bodySize:{}, cmd:{},recv:{}".format(headPack[0],cmd,is_recv))
+            p = json.loads(body)  # 将字符串解码并且反序列化为json对象
+            #print(body)
+            # 检查消息类型
+            if cmd == "EEXIT":
+                self.close()
+                return
+            elif cmd == "INFORM":
+                print(p)
+            elif cmd == "PARAM":
+                # 存储参数信息
+                self._log_path = p["logPath"]
+                self._brain_names = p["brainNames"]
+                print(self._log_path)
+                print(self._brain_names)
+                self._recv_init_msg = True
+                if is_recv ==1:
+                    print("应该发送消息")
+                    self._send(MsgCmd.INFORM.value,"这是消息")
+            else:
+                logging.error("\n未知的cmd:{0}".format(cmd))
+            # 继续接收消息
+            #self._recv_bytes()
+
+    def _send(self,cmd,data,is_recv=0):
+        """发送一个消息字符串"""
+        try:
+            #obj = {"type": MsgType.REQUEST.name, "msg":msg,"time": time.strftime('%Y-%m-%d %H:%M:%S',time.localtime(time.time()))}
+            msg = self.msg_protol.pack(cmd, data,is_recv)
+            self._client_socket.send(msg)  # 发送消息
+            logger.info("发送1个数据包->cmd:" + MsgCmd(cmd).name + " body：" + str(data))
+        except socket.error:
+            raise
+
+    def close(self):
+        logger.info("服务端套接字正在关闭..._loaded:" + str(self._recv_init_msg) + " _open_socket:" + str(self._is_init_socket))
+        # 当服务端套接字被初始化过并且连接到了客户端连接则关闭客户端套接字
+        if self._recv_init_msg & self._is_init_socket:
+            self._client_socket.send(b"EXIT") # 通知客户端关闭连接
+            self._client_socket.close() #关闭客户端调节
+            self._recv_init_msg = False
+        # 当服务套接字被初始化过
+        if self._is_init_socket:
+            self._socket.close() # 关闭服务端套接字
+            self._is_init_socket = False
+        else:
+            raise socket.error("无法关闭服务端套接字，因为没有初始化")
+
+if __name__=='__main__':
+    server = ServerSocket()