Python进阶----粘包,解决粘包(旗舰版)

一丶粘包

只有TCP有粘包现象，UDP永远不会粘包

什么是粘包

    存在于客户端接收数据时,不能一次性收取全部缓冲区中的数据.当下一次再有数据来时,缓冲区中剩余的数据会和新的数据'粘连'在一起.这就是粘包现象

### 什么是粘包？ # 存在于TCP/IP协议中数据粘连在一起, ### socket中造成粘包现象的原因是什么？ # 客户端不能一次性接收完缓冲区里的所有数据, # 服务端接受客户端发送数据时,由于缓冲区没有存满,回先把数据'聚合'在客户端的缓冲区中,当客户端缓存区存满之后,在发给服务端 ### 那些情况会发生粘包现象？ # 1. 客户端多次send少量数据, 会在客户端send输出缓冲区堆积, 当缓冲区堆积到一定程度 .会一次性把缓冲区的数据发给服务端 # 造成粘包现象 # 2. 客户端接收服务端发送的数据,会在客户端的recv输入缓存堆积,由于每次接收数据有限,当第二次服务端把数据发送过来时 # 数据会堆积在客户端的输入缓冲区.造成粘包

简单代码,产生粘包现象:?

### 客户端 # -*-coding:utf-8-*- # Author:Ds import socket client=socket.socket() client.connect(('127.0.0.1',7777)) while 1: ui=input('请输入有命令:>>').strip() client.send(ui.encode('utf-8')) # 向服务端发送指令 ###***重点 # 客户端 send完之后, 就会执行recv() 等待接收数据 # 第一次 输入:dir指令 能够一次性接收完服务端返回的数据 # 第二次 输入:ipconfig指令 不能一次性接收完服务端返回的数据,部分残余数据放在缓冲区中 # 第三次 输入:dir指令时 由于上一次的返回的数据还没全部取完,新的指令数据还未到达缓冲区. # 总结: 如果缓冲区承载的数据过大时,每次只接收1024字节,当新的指令执行完,返回回来的数据会'怼'到缓冲区,造成数据粘连现象. 这就是粘包 ser_data=client.recv(1024) # 接收到服务端发送的字节码 print(ser_data.decode('utf-8')) # 解码 输出 client.close() ### 服务端 # -*-coding:utf-8-*- # Author:Ds import socket import subprocess # 执行 系统cmd指令 server=socket.socket() server.bind(("127.0.0.1",7777)) # 绑定IP和端口 server.listen(5) while 1: conn , addr=server.accept() # 等待接收连接 print(conn,addr) while 1: try: cmd=conn.recv(1024) # 接收客户端发送过来的数据 cmd=cmd.decode('utf-8') # 将客户端发送过来的字节进行解码 # 执行客户端发来的系统命令 obj=subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE) # 这是执行系统命令之后产生正确结果或错误结果, # 字节形式 result=(obj.stdout.read()+obj.stderr.read()).decode('gbk') conn.send(result.encode('utf-8') ) # 向客户端发送结果,字节形式 except Exception : break conn.close() server.close()

二丶系统缓冲区

socket缓冲区

    如下图:?

      1.每个socket被创建后,都会分配两个缓冲区,输入缓冲区(recv)和输出缓冲区(send)

      2.send和recv都不是直接从网络中直接读取数据,而是从各自缓冲区读入和输出数据.

      3.数据有可能刚被写入缓冲区就发送到网络，也可能在缓冲区中不断积压，多次写入的数据被一次性发送到网络，这取决于当时的网络情况、当前线程是否空闲等诸多因素，不由程序员控制

​

I/O缓存区特性

# 1.I/O缓冲区在每个TCP套接字中单独存在； # 2.I/O缓冲区在创建套接字时自动生成； # 3.即使关闭套接字也会继续传送输出缓冲区中遗留的数据； # 4.关闭套接字将丢失输入缓冲区中的数据。

缓冲区的作用:

a、提高执行效率。 协调数据的收发（接受和处理）速度 b、减少内存负担。 减少和磁盘的交互 c、保持数据稳定性

利用socket查看系统缓冲区的大小(8K)

# -*-coding:utf-8-*- # Author:Ds import socket server = socket.socket() server.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1) # 重用ip地址和端口 server.bind(('127.0.0.1',8010)) server.listen(3) print(server.getsockopt(socket.SOL_SOCKET,socket.SO_SNDBUF)) # 输出缓冲区大小 print(server.getsockopt(socket.SOL_SOCKET,socket.SO_RCVBUF)) # 输入缓冲区大小 # 65536 1K=1024B 1B=8bit

三丶产生粘包的原因

两种原因:

    一:客户端(recv)不能一次性读取缓冲区中的数据.服务端发送的数据大于客户端能够接受的数据量,客户端下次接收的时候先去接收上次遗留在缓冲区中的数据.造成粘包

    代码如下:?

### 服务端 # -*-coding:utf-8-*- # Author:Ds import socket import subprocess phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM) phone.bind(('127.0.0.1', 8080)) phone.listen(5) while 1: # 循环连接客户端 conn, client_addr = phone.accept() print(client_addr) while 1: try: cmd = conn.recv(1024) ret = subprocess.Popen(cmd.decode('utf-8'), shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE) correct_msg = ret.stdout.read() error_msg = ret.stderr.read() conn.send(correct_msg + error_msg) except ConnectionResetError: break conn.close() phone.close() #### 客户端 # -*-coding:utf-8-*- # Author:Ds import socket phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM) # 买电话 phone.connect(('127.0.0.1',8080)) # 与客户端建立连接， 拨号 while 1: cmd = input('>>>') phone.send(cmd.encode('utf-8')) from_server_data = phone.recv(1024) print(from_server_data.decode('gbk')) phone.close() # 由于客户端发的命令获取的结果大小已经超过1024，那么下次在输入命令，会继续取上次残留到缓存区的数据

    二:客户端(send)向服务端发送数据的时候,发送多条少量数据. 由于缓冲区的没有存满,缓冲区会把这些数据聚集在一起发送个服务端.造成粘包

    代码如下:?

### 服务端 # -*-coding:utf-8-*- # Author:Ds import socket server=socket.socket() server.bind(('127.0.0.1',7878)) server.listen(5) conn ,addr = server.accept() print(conn,addr) data1=conn.recv(1024) data2=conn.recv(1024) data=data1+data2 print(data.decode('utf-8')) conn.close() server.close() #### 客户端 # -*-coding:utf-8-*- # Author:Ds import socket client=socket.socket() client.connect(('127.0.0.1',7878)) client.send('123'.encode('utf-8')) client.send('abc'.encode('utf-8')) client.close() ## 两次返送信息时间间隔太短，数据小，造成服务端一次收取

​

四丶解决粘包(recv的工作原理)

简易版解决粘包

### 客户端 # -*-coding:utf-8-*- # Author:Ds import socket client=socket.socket() client.connect(('127.0.0.1',9989)) while 1: ui=input('请输入指令:>>>').strip() if len(ui)<0:continue if ui.upper()=='Q':break client.send(ui.encode('utf-8')) message_size=int(client.recv(1024).decode('utf-8')) client.send(b'recv_ready') recv_size=0 data=b'' while recv_size<message_size: data+=client.recv(1024) recv_size+=len(data) print(data.decode('utf-8')) ### 服务端 # -*-coding:utf-8-*- # Author:Ds import socket import subprocess server=socket.socket() server.bind(('127.0.0.1',9989)) server.listen(5) while 1: conn,addr=server.accept() print(conn,addr) while 1: cmd=conn.recv(1024).decode('utf-8') obj=subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE) result=(obj.stdout.read()+obj.stderr.read()).decode('gbk').encode('utf-8') conn.send(str(len(result)).encode('utf-8')) data=conn.recv(1024).decode('utf-8') if data=='recv_ready': conn.sendall(result) conn.close() server.close()

使用struct模块

  将一串数字转换成等长的字节.

    格式多种: 常用 i

    代码如下:?

# -*-coding:utf-8-*- # Author:Ds import struct # 'i' 的取值范围 -2147483648 <= number <= 2147483647 # i 模式 等长四位 , 将一个数字转化成等长度的bytes类型。 res=struct.pack('i',123456) print(res,len(res)) ### 通过unpack反解回来 data=struct.unpack('i',res) print(data) ### 但是通过struct 处理不能处理太大 ret = struct.pack('q', 4323241232132324) print(ret, type(ret), len(ret)) # 报错

low版本解决粘包

### 服务端 import socket import subprocess import struct phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM) phone.bind(('127.0.0.1', 8080)) phone.listen(5) while 1: conn, client_addr = phone.accept() print(client_addr) while 1: try: cmd = conn.recv(1024) ret = subprocess.Popen(cmd.decode('utf-8'), shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE) correct_msg = ret.stdout.read() error_msg = ret.stderr.read() # 1 制作固定报头 total_size = len(correct_msg) + len(error_msg) header = struct.pack('i', total_size) # 2 发送报头 conn.send(header) # 发送真实数据： conn.send(correct_msg) conn.send(error_msg) except ConnectionResetError: break conn.close() phone.close() # 但是low版本有问题： # 1，报头不只有总数据大小，而是还应该有MD5数据，文件名等等一些数据。 # 2，通过struct模块直接数据处理，不能处理太大。 ### 客户端 import socket import struct phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM) phone.connect(('127.0.0.1',8080)) while 1: cmd = input('>>>').strip() if not cmd: continue phone.send(cmd.encode('utf-8')) # 1，接收固定报头 header = phone.recv(4) # 2，解析报头 print(struct.unpack('i', header)) # 这是一个元组 (xxx,) total_size = struct.unpack('i', header)[0] # 取第一个元素 # 3，根据报头信息，接收真实数据 recv_size = 0 res = b'' while recv_size < total_size: recv_data = phone.recv(1024) res += recv_data recv_size += len(recv_data) print(res.decode('gbk')) phone.close()

旗舰版解决粘包

### 步骤解释 # 报头做成字典，字典里包含将要发送的真实数据的详细信息，然后json序列化，然后用struck将序列化后的数据长度打包成4个字节 #发送时： 1.先发报头长度 2.再编码报头内容然后发送 3.最后发真实内容 #接收时： 1.先手报头长度，用struct取出来 2.根据取出的长度收取报头内容，然后解码，反序列化 3.从反序列化的结果中取出待取数据的详细信息，然后去取真实的数据内容

​ 案例代码,如下?:

### 客户端 # -*-coding:utf-8-*- # Author:Ds import socket import struct import json client = socket.socket() # 实例化 socket对象 client.connect(('127.0.0.1', 8898)) # socket 连接IP和端口 while 1: ui = input('请输入指令:>>').strip() # 1. 发送 用户输入 指令 client.send(ui.encode('utf-8')) #2. 接收 struct 封装的头 字节形式 , 接收4个字节 head head = client.recv(4) # 3. struct反解 ,获得自定义报头的长度 dic_length = struct.unpack('i', head)[0] #4. 接收自定义字典报头内容 字节形式 head_dic = client.recv(int(dic_length)) #5. 反序列化自定义字典,先解码在反序列化 dic = json.loads(head_dic.decode('utf-8')) #6. 得到 真实内容的长度 content_length = dic['size'] # 7 设置一个字节变量 用于接收真实数据 content = b'' # 8 设置一个客户端接收长度 recv_size = 0 # 9 当客户端接收长度 小于 源数据长度,一直接收 while recv_size < content_length: # 累加 真实数据,以字节形式 content += client.recv(1024) # 累加 客户端接收的长度 recv_size += len(content) # 接收完毕,解码内容 print(content.decode('utf-8')) client.close() ### 服务端 # -*-coding:utf-8-*- # Author:Ds import socket import struct import json import time import subprocess server = socket.socket() # 实例化 socket对象 server.bind(('127.0.0.1', 8898)) # 绑定ip和端口 server.listen(5) # 邦迪监听连接 while 1: conn, addr = server.accept() # 等待连接 print(conn, addr) # 打印连接,和连接ip while 1: try: # 1. 接收客户端发送的 指令 ,字节形式 cmd = conn.recv(1024) # 2. 执行指令,得到结果 , 指令是字符形式(需要解码) obj = subprocess.Popen(cmd.decode('utf-8'), shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE) #3.得到结果字节 ,转换成utf-8的字节格式 result = (obj.stdout.read() + obj.stderr.read()).decode('gbk').encode('utf-8') #4. 获得真实数据的字节长度 total_res_bytes = len(result) #5. 自定制字典报头 head_dic = { 'time': time.localtime(time.time()), 'size': total_res_bytes, # 字节长度 'MD5': 'XXXXX', 'file_name': '婚前视频', } # 6. 序列化字典 ,并将其转换成字节形式 head_dic_bytes = json.dumps(head_dic).encode('utf-8') #7. 使用 struct 封装报头字典head_dic_bytes ,固定长度(4个字节) # 封装成字节,发送给客户端,还是按照字节取出来. head = struct.pack('i', len(head_dic_bytes)) # 8 , 先将固定头发送给客户端 conn.send(head) # 9 . 再将自定制报头发送给客户端 conn.send(head_dic_bytes) # 10. 最后将真实结果发送给客户端 conn.send(result) ### 这里就是拼接字节 # 格式: 固定头 + 自定义报头 +真实数据 except Exception: break conn.close() server.close()

转载于:https://www.cnblogs.com/dengl/p/11202806.html

相关资源：Python进阶者笔记（粘包、粘包解决方案）