Python读取标准HTTP协议，彻底解决粘包问题

前言

最近在项目中需要接收大量带HTTP标准协议格式的数据包，在实际开发中遇到了粘包和半包问题，为了彻底的解决此问题，特此附上解决方案和可用方案代码。

一、什么是粘包

粘包问题是指当发送两条消息时，例如发送 1234 和 5678两条数据，但另一端接收到的却是 12345，像这种一次性读取了两条数据的情况就叫做粘包。正常情况下应该是读取成两条数据。产生原因如下：

1. 发送方每次写入数据 < 套接字（Socket）缓冲区大小。
2. 接收方读取套接字（Socket）缓冲区数据不够及时。

二、什么是半包

半包问题是指当发送的消息是 12345时，另一端却接收到的是 123 和 45 两条信息，像这种情况就叫做半包。产生原因如下：

1. 发送方每次写入数据 > 套接字（Socket）缓冲区大小。
2. 发送的数据大于协议的 MTU (Maximum Transmission Unit，最大传输单元)，因此必须拆包。

三、什么是缓冲区

缓冲区又称为缓存，它是内存空间的一部分。也就是说，在内存空间中预留了一定的存储空间，这些存储空间用来缓冲输入或输出的数据，这部分预留的空间就叫做缓冲区。

缓冲区的优势以文件流的写入为例，如果我们不使用缓冲区，那么每次写操作 CPU 都会和低速存储设备也就是磁盘进行交互，那么整个写入文件的速度就会受制于低速的存储设备（磁盘）。但如果使用缓冲区的话，每次写操作会先将数据保存在高速缓冲区内存上，当缓冲区的数据到达某个阈值之后，再将文件一次性写入到磁盘上。因为内存的写入速度远远大于磁盘的写入速度，所以当有了缓冲区之后，文件的写入速度就被大大提升了。

四、HTTP标准格式例子

POST /API/V1/Controller/HeartInfo HTTP/1.1
Host: 192.168.0.100:8848
Content-Type: application/json
Content-Length: 180
Connection: keep-alive

{
"resId": "a75a04f5-1a52-4a9d-8c0a-b7a23140f6e2",
"time": "2021-05-26 14:21:45",
"nextTime": "2021-05-26 14:22:15",
"deviceID": "21045521532085612",
"deviceType": 1
}

五、代码分部实现和说明

1.代码分步实现

①从给定套接字读取HTTP Response。将该Response用tuple (header, body)接收两个字节的值。

@classmethod
def read_until(self, sock, condition, length_start=0, chunk_size=4096):
    '''
    从给定套接字读取，直到条件返回True。返回从套接字读取的字节数组。
    条件是有一个有两个参数的函数，condition(length, data)，其中length为读取的字节总数
    data是最近读取的数据块。基于这两个值，条件必须返回True时才停止并返回到目前为止所读取的数据。
    '''
    data = bytes()
    chunk = bytes()
    length = length_start
    try:
        while not condition(length, chunk):
            chunk = sock.recv(chunk_size)
            if not chunk:
                break
            else:
                data += chunk
                length += len(chunk)
    except socket.timeout:
        pass
    return data

②将body和header分开

@classmethod
def separate_header_and_body(self, data):
    '''
    从给定的字节数组返回一个tuple (header, body)。
    如果给定的数组不包含头结束信息，那么假设它都是头文件。
    '''
    try:
        index = data.index(self.http_header_delimiter)
    except:
        return (data, bytes())
    else:
        index += len(self.http_header_delimiter)
        return (data[:index], data[index:])

③从header中获取内容长度

@classmethod
def get_content_length(self, header):
    '''
    如果在给定的字节序列中找到Content-Length，则返回由Content-Length HTTP字段给出的整数值。
    否则返回0。
    '''
    for line in header.split(b'\r\n'):
        if self.content_length_field in line:
            return int(line[len(self.content_length_field):])
    return 0

④读取body长度直到结束

self.body += self.read_until(sock, self.end_of_content, len(self.body))

2.解析处理类代码

import socket


class HTTPResourceParse:
    http_header_delimiter = b'\r\n\r\n'
    content_length_field = b'Content-Length:'

    @classmethod
    def read_until(self, sock, condition, length_start=0, chunk_size=4096):
        '''
        从给定套接字读取，直到条件返回True。返回从套接字读取的字节数组。
        条件是有一个有两个参数的函数，condition(length, data)，其中length为读取的字节总数
        data是最近读取的数据块。
        基于这两个值，条件必须返回True时才停止并返回到目前为止所读取的数据。
        '''
        data = bytes()
        chunk = bytes()
        length = length_start
        try:
            while not condition(length, chunk):
                chunk = sock.recv(chunk_size)
                if not chunk:
                    break
                else:
                    data += chunk
                    length += len(chunk)
        except socket.timeout:
            pass
        return data

    @classmethod
    def separate_header_and_body(self, data):
        '''
        从给定的字节数组返回一个tuple (header, body)。
        如果给定的数组不包含头结束信息，那么假设它都是头文件。
        '''
        try:
            index = data.index(self.http_header_delimiter)
        except:
            return (data, bytes())
        else:
            index += len(self.http_header_delimiter)
            return (data[:index], data[index:])

    @classmethod
    def get_content_length(self, header):
        '''
        如果在给定的字节序列中找到Content-Length，则返回由Content-Length 
        HTTP字段给出的整数值。否则返回0。
        '''
        for line in header.split(b'\r\n'):
            if self.content_length_field in line:
                return int(line[len(self.content_length_field):])
        return 0

    def __init__(self):
        self.header = bytes()
        self.content_length = 0
        self.body = bytes()

    def end_of_header(self, length, data):
        '''
        如果data包含报头结束标记，则返回true。
        '''
        return b'\r\n\r\n' in data

    def end_of_content(self, length, data):
        '''
        如果length不满足content_length则返回true。
        '''
        return self.content_length <= length

    def recv(self, sock):
        '''
        从给定套接字读取HTTP Response。将该Response用tuple (header, body)接收两个字节的值。
        '''
        # 读取到header的末尾
        self.data = self.read_until(sock, self.end_of_header)

        # 将body和header分开
        self.header, self.body = self.separate_header_and_body(self.data)

        # 从header中获取内容长度
        self.content_length = self.get_content_length(self.header)

        # 读取body长度直到结束
        self.body += self.read_until(sock, self.end_of_content, len(self.body))

        return (self.header, self.body)

3.Socket服务类代码

import socket
import threading
from HTTPResourceParse import HTTPResourceParse

connections = []
sock = None


def accept_client():
    """
    receive connection
    """
    while True:
        client, address = sock.accept()
        connections.append(client)
        thread = threading.Thread(target=message_handle, args=(client, address))
        thread.setDaemon(True)
        thread.start()


def message_handle(client, address):
    """
    handle message
    """
    try:
        while 1:
            try:
                header, body = HTTPResourceParse().recv(client)
                if len(header) > 0 and len(body) > 0:
                    data_header = header.decode('utf-8')
                    data_body = body.decode('utf-8')
                    print(data_header, data_body)
                    full_data = header.decode('utf-8') + body.decode('utf-8')
                    print(full_data)
            except Exception as e:
                print(e)
    except Exception as e:
        print(e)


def start_connect():
    global sock
    # 将此主机地址更改为你的自定义IP
    host = "192.168.0.100"  
    # 将此端口更改为你的自定义端口
    port = 8848  
    print("server host: " + host)
    # create a socket service
    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    sock.bind((host, port))
    sock.listen(32)
    thread = threading.Thread(target=accept_client)
    thread.start()

总结

本文介绍了TCP 粘包和半包问题，粘包是指读取到了两条信息，正常情况下消息应该是一条一条读取的，而半包问题是指读取了一半信息。导致粘包和半包的原因是 TCP 的传输是以流的形式进行的，而流数据是没有明确的开始和结尾标识的，因此就导致了此问题。