Python网络编程04/recv原理/高大上版解决粘包方式

Posted 2020-11-10 LBZHK

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Python网络编程04/recv原理/高大上版解决粘包方式相关的知识，希望对你有一定的参考价值。

Python网络编程04 /recv工作原理、展示收发问题、粘包现象

Python网络编程04 /recv工作原理、展示收发问题、粘包现象

1. recv工作原理

源码解释：

Receive up to buffersize bytes from the socket.
# 接收来自socket缓冲区的字节数据，
For the optional flags argument, see the Unix manual.
# 对于这些设置的参数，可以查看Unix手册。
When no data is available, block untilat least one byte is available or until the remote end is closed.
# 当缓冲区没有数据可取时，recv会一直处于阻塞状态，直到缓冲区至少有一个字节数据可取，或者远程端关闭。
When the remote end is closed and all data is read, return the empty string.
# 关闭远程端并读取所有数据后，返回空字符串。

验证recv工作原理

1.验证服务端缓冲区数据没有取完，又执行了recv执行，recv会继续取值

# server服务端
import socket

server = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
server.bind((\'127.0.0.1\',8080))
server.listen(5)

conn, client_addr = server.accept()
from_client_data1 = conn.recv(2)
print(from_client_data1)
from_client_data2 = conn.recv(2)
print(from_client_data2)
from_client_data3 = conn.recv(1)
print(from_client_data3)

conn.close()
server.close()
# client客户端
import socket
client = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
client.connect((\'127.0.0.1\',8080))
client.send(\'hello\'.encode(\'utf-8\'))
client.close()

2.验证服务端缓冲区取完了，又执行了recv执行，此时客户端20秒内不关闭的前提下，recv处于阻塞状态

# server服务端
import socket

server = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
server.bind((\'127.0.0.1\',8080))
server.listen(5)

conn, client_addr = server.accept()
from_client_data = conn.recv(1024)
print(from_client_data)
print(111)
conn.recv(1024)  # 此时程序阻塞20秒左右，因为缓冲区的数据取完了，并且20秒内，客户端没有关闭。
print(222)

conn.close()
server.close()

# client客户端
import socket
import time
client = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
client.connect((\'127.0.0.1\',8080))
client.send(\'hello\'.encode(\'utf-8\'))
time.sleep(20)

client.close()

3.验证服务端缓冲区取完了，又执行了recv执行，此时客户端处于关闭状态，则recv会取到空字符串

# server服务端
import socket

server = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
server.bind((\'127.0.0.1\',8080))
server.listen(5)

conn, client_addr = server.accept()
from_client_data1 = conn.recv(1024)
print(from_client_data1)
from_client_data2 = conn.recv(1024)
print(from_client_data2)
from_client_data3 = conn.recv(1024)
print(from_client_data3)

conn.close()
server.close()

# client客户端
import socket
import time
client = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
client.connect((\'127.0.0.1\',8080))
client.send(\'hello\'.encode(\'utf-8\'))
client.close()

# recv空字符串: 对方客户端关闭了,且服务端的缓冲区没有数据了,我再recv取到空bytes.

2. 展示收发问题示例

发多次收一次

# server服务端
import socket

server = socket.socket()
server.bind((\'127.0.0.1\',8848))
server.listen(5)

conn,addr = server.accept()

from_client_data = conn.recv(1024)
print(f\'来自客户端{addr}消息:{from_client_data.decode("utf-8")}\')

conn.close()
server.close()

# client客户端
import socket

phone = socket.socket()
phone.connect((\'127.0.0.1\',8848))

phone.send(b\'he\')
phone.send(b\'llo\')

phone.close()

发一次收多次

# server服务端
import socket

server = socket.socket()
server.bind((\'127.0.0.1\',8848))
server.listen(5)

conn,addr = server.accept() 

from_client_data = conn.recv(3)
print(f\'来自客户端{addr}消息:{from_client_data.decode("utf-8")}\')

from_client_data = conn.recv(3)
print(f\'来自客户端{addr}消息:{from_client_data.decode("utf-8")}\')

from_client_data = conn.recv(3)
print(f\'来自客户端{addr}消息:{from_client_data.decode("utf-8")}\')

from_client_data = conn.recv(3)
print(f\'来自客户端{addr}消息:{from_client_data.decode("utf-8")}\')

conn.close()
server.close()

# client客户端
import socket

client = socket.socket()
client.connect((\'127.0.0.1\',8848))

client.send(b\'hello world\')

client.close()

3. 粘包现象

粘包现象概述：

发送方发送的若干包数据到接收方接收时粘成一包，从接收缓冲区看，后一包数据的头紧接着前一包数据的尾

粘包第一种：

send的数据过大，大于对方recv的上限时，对方第二次recv时，会接收上一次没有recv完的剩余的数据。

# server服务端
import socket
import subprocess

server = socket.socket()
server.bind((\'127.0.0.1\',8848))
server.listen(2)

while 1:
    server,addr = server.accept()  # 等待客户端链接我,阻塞状态中

    while 1:
        try:
            from_client_data = conn.recv(1024)
            if from_client_data.upper() == b\'Q\':
                print(\'客户端正常退出聊天了\')
                break

            obj = subprocess.Popen(from_client_data.decode(\'utf-8\'),
                                   shell=True,
                                   stdout=subprocess.PIPE,
                                   stderr=subprocess.PIPE,

                                   )
            result = obj.stdout.read() + obj.stderr.read()
            print(f\'总字节数：{len(result)}\')
            conn.send(result)
        except ConnectionResetError:
            print(\'客户端链接中断了\')
            break
    conn.close()
server.close()


# client客户端
import socket

client = socket.socket()
client.connect((\'127.0.0.1\',8848))

while 1:
    to_server_data = input(\'>>>输入q或者Q退出\').strip().encode(\'utf-8\')
    if not to_server_data:
        print(\'发送内容不能为空\')
        continue
    client.send(to_server_data)
    
    if to_server_data.upper() == b\'Q\':
        break
        
    from_server_data = client.recv(300)  # 最多接受1024字节
    # 这里可能出现一个字符没有接受完整，进而在解码的时候会报错
    # print(f\'{from_server_data.decode("gbk")}\')
    print(len(from_server_data))

client.close()

粘包第二种：

连续短暂的send多次(数据量很小),的数据会统一发送出去.

# server服务端
import socket

server = socket.socket()
server.bind((\'127.0.0.1\',8848))
server.listen(5)

conn,addr = server.accept()

from_client_data = conn.recv(1024)
print(f\'来自客户端{addr}消息:{from_client_data.decode("utf-8")}\')
conn.close()
server.close()

# client客户端
import socket

client = socket.socket()
client.connect((\'127.0.0.1\',8848))

client.send(b\'he\')
client.send(b\'ll\')
client.send(b\'o\')

client.close()

# Nagle算法：就是为了尽可能发送大块数据，避免网络中充斥着许多小数据块。
# Nagle算法的规则：
# 1.如果包长度达到MSS，则允许发送；
# 2.如果该包含有FIN，则允许发送；
# 3.设置了TCP_NODELAY选项，则允许发送；
# 4.未设置TCP_CORK选项时，若所有发出去的小数据包（包长度小于MSS）均被确认，则允许发送；
# 5.上述条件都未满足，但发生了超时（一般为200ms），则立即发送。

3. 解决粘包现象

解决粘包现象的思路:

服务端发一次数据 5000字节,  
客户端接收数据时,循环接收,每次(至多)接收1024个字节,直至将所有的字节全部接收完毕.将接收的数据拼接在一起,最后解码.

1. 遇到的问题: recv的次数无法确定.
   发送总具体数据之前,先发一个总数据的长度:5000个字节。然后在发送总数据。
   客户端： 先接收一个总数据的长度，再根据总数据的长度接收相应长度的字节。
   然后再循环recv 控制循环的条件就是只要接收的数据< 5000 一直接收。
    
2. 遇到的问题： 如何将总数据的长度转化成固定的字节数

3.将不固定长度的int类型转化成固定长度的bytes并且还可以翻转回来：struct模块

struct

instruct模块的使用：

import struct

# 将一个数字转化成等长度的bytes类型。
ret = struct.pack(\'i\', 183346)
print(ret, type(ret), len(ret))
# 结果：b\'2\\xcc\\x02\\x00\' <class \'bytes\'> 4

# 通过unpack反解回来
ret1 = struct.unpack(\'i\',ret)[0]
print(ret1, type(ret1))
# 结果：183346 <class \'int\'>


# 但是通过struct 处理不能处理太大
ret = struct.pack(\'l\', 4323241232132324)
print(ret, type(ret), len(ret))  # 报错
# struct.error: argument out of range

4. low版解决粘包现象

server服务端

import socket
import subprocess
import struct

server = socket.socket()
server.bind((\'127.0.0.1\',8848))
server.listen(2)

while 1:
    conn,addr = server.accept()
    while 1:
        try:
            from_client_data = conn.recv(1024)  # 接收命令

            if from_client_data.upper() == b\'Q\':
                print(\'客户端正常退出聊天了\')
                break

            obj = subprocess.Popen(from_client_data.decode(\'utf-8\'),
                                   shell=True,
                                   stdout=subprocess.PIPE,
                                   stderr=subprocess.PIPE,

                                   )
            result = obj.stdout.read() + obj.stderr.read()
            total_size = len(result)
            
            print(f\'总字节数：{total_size}\')

            # 1. 制作固定长度的报头
            head_bytes = struct.pack(\'i\',total_size)

            # 2. 发送固定长度的报头
            conn.send(head_bytes)

            # 3. 发送总数据
            conn.send(result)
        except ConnectionResetError:
            print(\'客户端链接中断了\')
            break
    conn.close()
server.close()

client客户端

import socket
import struct

phone = socket.socket()
phone.connect((\'127.0.0.1\',8848))

while 1:
    to_server_data = input(\'>>>输入q或者Q退出\').strip().encode(\'utf-8\')
    
    if not to_server_data:
        print(\'发送内容不能为空\')
        continue
    phone.send(to_server_data)
    
    if to_server_data.upper() == b\'Q\':
        break

    # 1. 接收报头
    head_bytes = phone.recv(4)
    
    # 2. 反解报头
    total_size = struct.unpack(\'i\',head_bytes)[0]

    total_data = b\'\'
    while len(total_data) < total_size:
        total_data += phone.recv(1024)

    print(len(total_data))
    print(total_data.decode(\'gbk\'))

phone.close()

5. 高级版解决粘包方式(自定制报头)

解决思路

制作固定的报头,现在有两段不固定长度的bytes类型,需要固定的报头,所以
1. 获取不固定报头的长度,总数据的长度放在报头中(字典)
2. 利用struct模块将不固定的长度转化成固定的字节数 4个字节
3. 先发4个字节,再发报头数据,再发总数据

server服务端

import socket
import subprocess
import struct
import json

server = socket.socket()
server.bind((\'127.0.0.1\',8848))
server.listen(2)

while 1:
    conn,addr = server.accept()  

    while 1:
        try:

            from_client_data = conn.recv(1024)  # 接收命令


            if from_client_data.upper() == b\'Q\':
                print(\'客户端正常退出聊天了\')
                break

            obj = subprocess.Popen(from_client_data.decode(\'utf-8\'),
                                   shell=True,
                                   stdout=subprocess.PIPE,
                                   stderr=subprocess.PIPE,

                                   )
            result = obj.stdout.read() + obj.stderr.read()
            total_size = len(result)

            # 1. 自定义报头
            head_dic = {
                \'file_name\': \'test1\',
                \'md5\': 6567657678678,
                \'total_size\': total_size,

            }
            # 2. json形式的报头
            head_dic_json = json.dumps(head_dic)

            # 3. bytes形式报头
            head_dic_json_bytes = head_dic_json.encode(\'utf-8\')

            # 4. 获取bytes形式的报头的总字节数
            len_head_dic_json_bytes = len(head_dic_json_bytes)

            # 5. 将不固定的int总字节数变成固定长度的4个字节
            four_head_bytes = struct.pack(\'i\',len_head_dic_json_bytes)

            # 6. 发送固定的4个字节
            conn.send(four_head_bytes)

            # 7. 发送报头数据
            conn.send(head_dic_json_bytes)

            # 8. 发送总数据
            conn.send(result)

        except ConnectionResetError:
            print(\'客户端链接中断了\')
            break
    conn.close()
server.close()

client客户端

import socket
import struct
import json

client = socket.socket()
client.connect((\'127.0.0.1\',8848))

while 1:
    to_server_data = input(\'>>>输入q或者Q退出\').strip().encode(\'utf-8\')
                                                         
    if not to_server_data:
        print(\'发送内容不能为空\')
        continue
    client.send(to_server_data)
                                                         
    if to_server_data.upper() == b\'Q\':
        break

    # 1. 接收固定长度的4个字节
    head_bytes = client.recv(4)

    # 2. 获得bytes类型字典的总字节数
    len_head_dic_json_bytes = struct.unpack(\'i\',head_bytes)[0]

    # 3. 接收bytes形式的dic数据
    head_dic_json_bytes = client.recv(len_head_dic_json_bytes)

    # 4. 转化成json类型dic
    head_dic_json = head_dic_json_bytes.decode(\'utf-8\')

    # 5. 转化成字典形式的报头
    head_dic = json.loads(head_dic_json)
    \'\'\'
    head_dic = {
                \'file_name\': \'test1\',
                \'md5\': 6567657678678,
                \'total_size\': total_size,
            }
    \'\'\'
    total_data = b\'\'
    while len(total_data) < head_dic[\'total_size\']:
        total_data += client.recv(1024)

    # print(len(total_data))
    print(total_data.decode(\'gbk\'))

client.close()

总结：

1. 高大上版: 自定制报头
dic = {\'filename\': XX, \'md5\': 654654676576776, \'total_size\': 26743}
2. 高大上版:可以解决文件过大的问题.

以上是关于Python网络编程04/recv原理/高大上版解决粘包方式的主要内容，如果未能解决你的问题，请参考以下文章

网络编程

middlebury立体匹配评估使用方法总结——线上版教程

Java 项目权威排名：Nacos 未上版，Gradle 排名第二，Maven 排名 28

脱单盲盒源码，线上脱单盲盒网站源码分析下载，脱单盲盒线上版源码开发

Python有哪些高大上的项目？

编程经典书籍：龙书虎书魔法书