Python Socket文件传输前元数据发送粘包问题求助

嘿，这绝对是Socket通信里最常见的坑之一——粘包！两次send的元数据被操作系统合并成一次发送，结果接收端直接把两段数据当一段解析，split之后逻辑全乱了对吧？我给你捋两个靠谱的解决方案，你可以根据自己的场景选：

方案一：用分隔符标记元数据边界（快速改，改动小） #

这个思路最简单，就是给每个元数据条目加一个不会出现在元数据里的分隔符（比如换行符\n），这样接收端就知道什么时候一段元数据结束了。

发送端修改 #

只需要在__sendHeader里给每个元数据末尾加个换行符：

def __sendHeader(self, name, value):
    # 给每个头部条目加换行符作为结束标记
    self.s.send((name + ":" + value + "\n").encode('utf-8'))

接收端修改 #

核心是要维护一个缓存，不能一收到数据就直接解析——因为可能一次收到半条或者多条元数据。我们先把数据攒起来，直到读到换行符再处理完整的条目：

首先在初始化的时候加个缓存变量：

self.header_buffer = b""  # 用来缓存不完整的头部数据
stage = 0

然后修改主接收循环：

while True:
    c, addr = self.s.accept()
    l = c.recv(1024)
    while l:
        if stage < 2:
            self.header_buffer += l
            # 循环处理所有完整的头部行
            while b"\n" in self.header_buffer:
                # 分割出第一行完整数据，剩下的留到下次处理
                line_bytes, self.header_buffer = self.header_buffer.split(b"\n", 1)
                self.__recvHeader(line_bytes)
                stage += 1
                if stage >= 2:  # 头部收完了，跳出处理头部的循环
                    break
        else:
            self.f.write(l)
        l = c.recv(1024)

最后调整__recvHeader，现在传进来的是完整的一行字节，记得strip掉可能的空白：

def __recvHeader(self, data):
    try:
        line = data.decode("utf-8").strip().split(":")
        if line[0] == "Name":
            self.filename = line[1].strip()
            self.f = open("/tmp/" + self.filename, 'wb')
        elif line[0] == "Size":
            self.size = int(line[1].strip())
        else:
            print(f"ERROR: Invalid header line: {data.decode('utf-8')}")
    except Exception as e:
        print(f"Header parse error: {str(e)}")

注意：如果你的文件名里可能包含换行符，那得换个分隔符（比如|||这种不太可能出现的组合），或者对特殊字符做转义。

方案二：固定长度的元数据协议（更可靠，适合复杂场景） #

如果想彻底避免粘包问题，最稳妥的方式是定义一个固定格式的协议——先发送字段的长度，再发送字段内容，这样接收端就知道该读多少字节。这个方案需要调整解析逻辑，但可靠性拉满。

我们可以用struct模块来打包/解包固定长度的整数（比如用大端字节序，保证跨平台兼容）。

发送端修改 #

import struct

def __sendHeader(self, filename, file_size):
    # 第一步：发送文件名的长度（4字节大端整数）
    filename_len = struct.pack('!I', len(filename))
    self.s.send(filename_len)
    # 第二步：发送文件名内容
    self.s.send(filename.encode('utf-8'))
    # 第三步：发送文件大小（8字节大端整数，支持超大文件）
    size_bytes = struct.pack('!Q', file_size)
    self.s.send(size_bytes)

接收端修改 #

首先调整__recvHeader，现在要主动读取固定长度的字节：

import struct

def __recvHeader(self, conn):
    # 读取文件名长度（4字节）
    name_len_data = conn.recv(4)
    if not name_len_data:
        raise Exception("Failed to receive filename length")
    name_len = struct.unpack('!I', name_len_data)[0]
    
    # 读取文件名内容（name_len字节）
    filename_data = conn.recv(name_len)
    self.filename = filename_data.decode('utf-8')
    self.f = open("/tmp/" + self.filename, 'wb')
    
    # 读取文件大小（8字节）
    size_data = conn.recv(8)
    if not size_data:
        raise Exception("Failed to receive file size")
    self.size = struct.unpack('!Q', size_data)[0]

然后修改主接收循环，现在不需要stage的缓存逻辑，直接读取完整的元数据，还要注意接收文件时不能超过指定大小：

while True:
    c, addr = self.s.accept()
    # 先接收完整的头部
    self.__recvHeader(c)
    # 接收文件内容，确保只收指定大小的数据
    received_total = 0
    while received_total < self.size:
        # 每次最多收1024字节，或者剩下的字节数
        chunk_size = min(1024, self.size - received_total)
        l = c.recv(chunk_size)
        if not l:
            break  # 连接中断
        self.f.write(l)
        received_total += len(l)
    self.f.close()
    print(f"File {self.filename} received successfully")

两种方案对比 #

你可以根据自己的场景选——如果文件名不会有特殊字符，分隔符方案足够用；如果是生产环境的复杂场景，固定长度方案更稳妥。

内容的提问来源于stack exchange，提问作者Btc Sources