网络收发数据中涉及的黏包问题及解决办法

---

一、什么是黏包:

粘包指的是数据和数据之间没有明确的分界线，导致不能正确读取数据
应用程序无法直接操作硬件,应用程序想要发送数据则必须将数据交给操作系统，而操作系统需要同时为所有应用程序提供数据传输服务，也就意味着，操作系统不可能立马就能将应用程序的数据发送出去,就需要为应用程
序提供一个缓冲区，用于临时存放数据，具体流程如下:

这意味着UDP根本不会粘包，但是会丢数据，不可靠。
意味着: TCP传输数据是可靠的，但是会粘包。

二、用代码说明黏包问题（发送方出现的粘包问题）：

服务器端：

from socket import *

# todo 1、创建服务器端socket，SOCK_STREAM：基于TCP协议的
server_socket = socket(AF_INET, SOCK_STREAM)

# todo 2、创建目标服务器，绑定一个IP和端口  服务器里面空的字符串代表server_socket绑定这台机器下的任何ip地址
host_port = ('', 8080)
server_socket.bind(host_port)

# todo 3、监听服务器的socket，listen让socket处于被动，这时可以接收客户端的连接请求了
server_socket.listen(5)

# todo 4、等待客户端的连接请求，当前函数是线程阻塞的函数，accept返回2个值，第一个：新的socket，第二个是客户端地址。
#  新创建的socket是server_socket中的子socket，只是和当前的客户端（一个客户端）收发数据

new_socket, client_addr = server_socket.accept()

# todo 5、服务器接收客户端发送过来的数据，recv一般用于TCP协议的结束数据，recvfrom用于UDP
data1 = new_socket.recv(1024)  # 接收1kb的数据
data2 = new_socket.recv(1024)  # 接收1kb的数据

print('第一条数据', data1)
print('第二条数据', data2)

# todo 6、关闭当前客户端的服务
new_socket.close()
# todo 7、整个服务器全部关闭
server_socket.close()

客户端：

from socket import *

# todo 1、创建客户端的socket，SOCK_STREAM：TCP协议
client_socket = socket(AF_INET, SOCK_STREAM)

# todo 2、客户端发送连接的请求（不是传输数据的请求，是创建连接的请求）
client_socket.connect(('192.168.1.112', 8080))

# todo 3、发送数据
client_socket.send('hello'.encode('utf-8'))

client_socket.send('zhil'.encode('utf-8'))

# todo 4、关闭客户端套接字
client_socket.close()

启动服务器端和客户端之后
运行结果为

第一条数据 b'hellozhil'
第二条数据 b''

上述运行结果很明显出现了粘包问题
客户端发送了两个数据包，但是在服务器端接受data1的时候，把这两个包的数据全部接受了,这种显现就是黏包。其实如果服务器点代码改成recv(2)也会造成粘(黏)包。客户端发了一段数据，服务端只收了一-小部分，也产生粘包。

三、用代码说明黏包问题（接收方出现的粘包问题）：

服务器端：

from socket import *
import time

# 黏包问题：接收方出现的粘包问题
# todo 1、创建服务器端socket，SOCK_STREAM：表示TCP协议
server_socket = socket(AF_INET, SOCK_STREAM)

# todo 2、绑定服务器端的ip和协议，空字符串表示server_socket可以绑定当台机器下的任何ip
server_socket.bind(('', 9999))

# todo 3、监听服务器端的socket，listen让socket处于被动，这时可以接收客户端的连接请求
server_socket.listen(5)

# todo 4、当前函数是阻塞的函数，客户端发送连接请求，accept返回2个值，第一个：新的socket，第二个：客户端地址
new_socket, client_addr = server_socket.accept()
print('连接成功', client_addr)

# todo 5、接收客户端发送过来的数据
data1 = new_socket.recv(3)  # 第一次没有接收完整
print('第一个数据包', data1.decode('utf-8'))

time.sleep(6)

data2 = new_socket.recv(10)  # 第二次会接收旧数据，然后如果还有空间再接收新数据。第一次没有接收完整，把剩下的数据接收完，
print('第二个数据包', data2.decode('utf-8'))

# todo 6、关闭子socket
new_socket.close()
# todo 7、关闭整个服务器端socket
server_socket.close()

客户端：

from socket import *
import time  # time模块保证客户端发送多个数据包的时候，间隔时间长

# todo 1、创建客户端socket，SOCK_STREAM：表示TCP协议
client_socket = socket(AF_INET, SOCK_STREAM)
# todo 2、连接目标服务器
client_socket.connect(('192.168.1.112', 9999))
# todo 3、发送数据
client_socket.send('mashibing'.encode('utf-8'))

time.sleep(5)  # 让当前的线程休眠5秒
# todo 第二次发送数据
client_socket.send('laoxiao'.encode('utf-8'))
# todo 4、关闭客户端套接字
client_socket.close()

启动服务器端和客户端之后
运行结果为

连接成功 ('192.168.1.112', 52352)
第一个数据包 mas
第二个数据包 hibinglaox

四、黏包成因：

所谓粘包问题主要还是因为:
1、接收方不知道消息之间的界限，不知道一个消息要提取多少字节的数据所造成的。 (服务器端出现黏包)
2、tcp在发送数据少且间隔时间短的数据时，会将几条和并一起发送。(客户端出现黏包)

五、黏包的解决办法

目前比较合理的处理方法是:为字节流加上一个报头,告诉发送的字节流总大小，然后接收端来一个死循环接收完所有数据。用struck将序列化后的数据长度打包成4个字节(4个字节完全够用)。
使用struct模块可以用于将Python的值根据格式符，转换为C语言的结构(byte类型)，便于数据流传输。
案例:客户端传送一个文件到服务器端(基于TCP协议)，同时要解决黏包问题。
服务器端

from socket import *
import struct  # 打包
import os

server = socket(AF_INET, SOCK_STREAM)
server.bind(('', 8088))
server.listen(5)

new_socket, addr = server.accept()

f = open(r'D:\服务器.txt', 'wb')

#todo 接收客户端发送过来的包头
header_data = new_socket.recv(4)
# todo size表示数据包的长度
size = struct.unpack('!i', header_data)[0]  # unpack返回的都是一个元组，元组的第一个值就是长度

recv_size = 0  # 已经接收到多长的数据
while recv_size < size:
    data = new_socket.recv(1024)
    recv_size += len(data)  # 接收的字节长度要累加
    f.write(data)
print('服务器端接收完成')

f.close()
new_socket.close()
server.close()

客户端：

from socket import *
import struct  # 打包
import os

client_socket = socket(AF_INET, SOCK_STREAM)
client_socket.connect(('192.168.1.112', 8088))

# 客户端传送文件到服务器 new.mp4
file_path = 'new.txt'
f = open(file_path, 'rb')

# todo 在发送真正的文件数据之前，先准备一个报头
size = os.path.getsize(file_path)  # 文件的字节长度
# todo 创建一个报头，i为4个字节的int。
header = struct.pack('!i', size)  # 接收方会使用struct解包，得到一个int类型的数字
# todo 发送包头
client_socket.send(header)

# todo 发送文件内容
while True:
    data = f.read(1024)  # 每次读取1024字节
    if not data:
        break
    client_socket.send(data)  # 发送给服务器的文件内容

print('客户端上传文件完成')
f.close()
client_socket.close()

执行结果：


总结:客户端把数据长度封装成一个固定大小的数据， 这时服务端就可以指定读取固定大小的内容,不会读取数据的内容，服务端只要根据数据长度再来接收数据内容就好了，所以客户端连续两次发数据(文件) , 不会粘包,因为服务器端每次接收都只接收了本次该接收的数据。