Python之网络编程（粘包、粘包解决方案）

àì夳堔傛蜴生んèń 2023-07-18 02:41 49阅读 0赞

### 文章目录 ###

*   *   *  tcp粘包
         *   *  第一种粘包
             *  第二种粘包
         *  udp粘包
         *  解决粘包现象

*粘包现象是指发送方发送的若干数据到接收方接收时粘成一包，从接收缓冲区看，**后一包数据的头紧接着前一包数据的尾。粘包现象只会在tcp中出现**，udp中不会有，因为udp是基于包来传输信息的，就一个sendto()对应另一个recvfrom()*

### tcp粘包 ###

#### 第一种粘包 ####

发送端需要等缓冲区满才发送出去，造成粘包(发送数据时间间隔很短，数据也很小，会合到一起发送，产生粘包)  
**服务端测试代码：**

from socket import *
    import subprocess
    
    ip_port=('192.168.43.247',8080)  #记录ip地址
    back_log = 5  #端口数为5
    buffer_size = 1024  #表示可以发送消息的大小为1024字节
    
    tcp_server= socket(AF_INET,SOCK_STREAM)  #建立socket对象
    tcp_server.bind(ip_port)  #绑定ip地址
    tcp_server.listen(back_log)  #监听端口
    
    conn, addr= tcp_server.accept()  #获取客户端链接
    
    #第一种粘包，能收的量太大了
    #会出现第一种粘包现象，因为可以收的数据远大于真实传来的数据，
    #tcp内的优化算法会把几个短的数据合成一个数据来发送
    
    #接收消息
    data1 = conn.recv(buffer_size)  #都能收1024字节
    print('第一个消息：',data1.decode('utf-8'))
    data2 = conn.recv(buffer_size) 
    print('第二个消息：',data2.decode('utf-8'))
    data3 = conn.recv(buffer_size)
    print('第三个消息：',data3.decode('utf-8'))
    
    conn.close()  #关闭链接

**客户端测试代码：**  
可以看到是一个简单的发送3条消息

from socket import *
    import subprocess
    
    ip_port=('192.168.43.247',8080)  #记录ip地址
    back_log = 5  #端口数为5
    buffer_size = 1024  #表示可以发送消息的大小为1024字节
    
    tcp_client= socket(AF_INET,SOCK_STREAM)  #建立socket对象
    tcp_client.connect(ip_port)  #连接服务端的地址
    
    #发送消息
    tcp_client.send('hello'.encode('utf-8'))
    tcp_client.send('world'.encode('utf-8'))
    tcp_client.send('view'.encode('utf-8'))

**运行结果1：**  
![粘包1][1]  
*可以看到，在客户端明明是发送了3次的三条消息合并成一条了*

**最简单的解决方案**就是控制好接收消息的量，将其调小一点，也就是把服务端中的**接收消息部分**改成如下：

#解决方案，控制好能收的数据量
    data1 = conn.recv(5)
    print('第一个消息：',data1.decode('utf-8'))
    data2 = conn.recv(5) 
    print('第二个消息：',data2.decode('utf-8'))
    data3 = conn.recv(5)
    print('第三个消息：',data3.decode('utf-8'))

**运行结果2：**  
![粘包2][2]  
*这样就正常得分成3条消息发送了*

#### 第二种粘包 ####

接收方没有及时接收缓冲区的包，造成多个包接收(客户端发送了一段数据，服务端只收了一小部分，服务端下次再接收的时候还是从缓冲区拿上次遗留的数据，产生粘包现象)  
测试代码与上文相同，只是将**服务端中的接收消息部分改成如下：**

#第二种粘包，能收的量太小了
    #出现第二种粘包现象，因为可以收的数据小于真实传来的数据，
    #所以tcp内部的优化算法会把上一段消息中没收完的部分，放到下一段消息里面
    data1 = conn.recv(1)  #只能收1个字节
    print('第一个消息：',data1.decode('utf-8'))
    data2 = conn.recv(5) 
    print('第二个消息：',data2.decode('utf-8'))
    data3 = conn.recv(1)
    print('第三个消息：',data3.decode('utf-8'))

**运行结果3：**  
![粘包3][3]  
*可以看到，上一次没有发送完的消息，会留到下一次发送的后面接着发送。也就是hello中第一次只接收了h,第二次接收5个字节，所以接着后面的ellow，最后再接收1个字节就是o*

### udp粘包 ###

udp没有那种将短消息合成一条消息的优化算法，所以另外两条消息没有服务端接收，就直接丢失了；  
所以udp不会出现粘包现象，因为udp发消息不管有没有人收，都能发出去，没人收的话消息就直接丢失了  
也就是说，udp中一个sendto()对应一个recvfrom()  
**服务端测试代码：**

from socket import *
    ip_port = ('192.168.43.247',8080)
    buffer_size = 1024
    
    #创建对象
    udp_server = socket(AF_INET,SOCK_DGRAM)  #数据报，即udp协议
    udp_server.bind(ip_port)
    
    #接收消息
    data1,addr = udp_server.recvfrom(1024)
    print('第一个消息：',data1.decode('utf-8'))

**客户端测试代码：**

from socket import *
    ip_port = ('192.168.43.247',8080)
    buffer_size = 1024
    
    #创建对象
    udp_client = socket(AF_INET,SOCK_DGRAM)  #数据报，即udp协议
    
    #发送消息
    udp_client.sendto('hello'.encode('utf-8'),ip_port)
    udp_client.sendto('world'.encode('utf-8'),ip_port)
    udp_client.sendto('view'.encode('utf-8'),ip_port)

**运行结果：**  
![粘包4][4]  
*可以看到，客户端发送的3条消息都非常短，但是服务端并没有将3条都合并成一条接收，而是严格地只接收了第一条消息hello*

### 解决粘包现象 ###

（1）问题的根源就是在于，接收端不知道发送端将要传送的字节流的长度；  
（2）所以解决粘包就是围绕，如何让发送端在发送数据前，把自己将要发送的字节流总大小让接收端知道；  
（3）然后接收端来一个死循环接收完所有的数据  
**服务端测试代码：**

from socket import *
    import subprocess
    
    ip_port=('192.168.43.247',8080)  #记录ip地址
    back_log = 5  #端口数为5
    buffer_size = 1024  #表示可以发送消息的大小为1024字节
    
    tcp_server= socket(AF_INET,SOCK_STREAM)  #建立socket对象
    tcp_server.bind(ip_port)  #绑定ip地址
    tcp_server.listen(back_log)  #监听端口
    
    conn, addr= tcp_server.accept()  #获取客户端链接,赋到conn中
    
    while True:  #循环收发消息
        #解决粘包
        length = conn.recv(buffer_size)  #接收对方消息的长度
        conn.send(b'ready')
    
        length = int(length.decode('utf-8')) #将长度解码，并转成数字型
    
        recv_size=0  #记录长度
        recv_msg=b''  #存放收到的数据
        while recv_size < length:  #分多次收，如果长度小于数据长度就一直收
            r_m = conn.recv(buffer_size)  #接收1024字节的消息
            recv_msg += r_m  #将消息内容追加到存放数据的变量中
            recv_size += len(r_m)  #再动态更新一下已收到的数据长度
    
        print('客户端发来的消息是：',recv_msg)
    
    conn.close()  #关闭链接

**客户端测试代码：**

from socket import *
    import subprocess
    
    ip_port=('192.168.43.247',8080)  #记录ip地址
    back_log = 5  #端口数为5
    buffer_size = 1024  #表示可以发送消息的大小为1024字节
    
    tcp_client= socket(AF_INET,SOCK_STREAM)  #建立socket对象
    tcp_client.connect(ip_port)  #连接服务端的地址
    
    while True:
        #解决粘包
        msg = input('请输入您的消息：')  #输入内容
    
        if not msg:continue  #如果是空就回到循环
        if msg == 'quit':break  #如果是quit就结束循环
        
        length = str(len(msg))  #统计消息的长度,因为发送的消息只能是字符串，所以要str
        tcp_client.send(length.encode('utf-8'))  #将长度发送给服务端
        #接收服务端发来的指令，是否成功收到消息的长度信息
        server_ready = tcp_client.recv(buffer_size)
    
        #发送消息
        if server_ready == b'ready':  #如果服务端返回一个二进制的'ready'，则标明服务端收到了长度
            tcp_client.send(msg.encode('utf-8'))  #则发送消息
    
    tcp_cliend.close()

**运行结果：**  
![粘包5][5]  
*可以看到，无论客户端发来多少消息，服务端都能全部接收，不会接收多了和接收少了，也就是没有粘包现象了*

[1]: /images/20230528/d096017ae7ff45309a9fe5c6ed1d7447.png
[2]: /images/20230528/a84ec27930924d1caad93952ceb9bbdc.png
[3]: /images/20230528/cb8482a29bbf4173b4d49068521051bb.png
[4]: /images/20230528/47f110e26ba249b5b70895530daa845e.png
[5]: /images/20230528/2e6e54807ab147cf862d28bad7de0bb3.png