如何在Boost.Beast中提前访问未完全接收的HTTP响应体（兼容分块与非分块编码）

这个问题确实说到了Boost.Beast处理大响应的一个痛点——默认情况下，非分块的长Content-Length响应会等到所有数据接收完毕才返回，没法中途开始处理。不过咱们可以通过自定义一个支持流式回调的body类型，完美实现统一处理分块和非分块响应的需求，不用再区分on_chunk_header和on_chunk_body，直接在数据到来时就处理。

核心思路：自定义流式String Body #

默认的boost::beast::http::string_body会把所有响应数据缓存起来，直到全部接收完成才交付给你。我们可以基于它的逻辑，扩展出一个带流式回调的body类型：每次有数据块到达时，先触发我们的处理回调，再把数据追加到缓存中（如果你需要完整响应体的话）。这样不管是分块编码还是非分块的长响应，都能以相同的方式处理每一块数据。

实现代码示例 #

1. 自定义流式String Body类型

#include <boost/beast.hpp>
#include <functional>
#include <string>

namespace http = boost::beast::http;

// 自定义支持流式回调的string body
struct streaming_string_body
{
    // 和原生string_body一致的存储类型
    using value_type = std::string;

    // 回调函数类型：接收当前数据块、是否为最后一块的标记
    using on_data_callback = std::function<void(boost::string_view, bool)>;

    // 存储回调函数的成员
    on_data_callback on_data;

    // Writer类：负责处理数据写入逻辑
    class writer
    {
    public:
        using const_buffers_type = boost::asio::const_buffer;

        template<bool isRequest, class Fields>
        writer(http::header<isRequest, Fields>&, value_type& body, streaming_string_body& opts)
            : body_(body), opts_(opts)
        {}

        // 每次接收到数据块时都会被调用
        boost::system::error_code
        write(const_buffers_type const& buffer)
        {
            // 将buffer转为string_view，避免内存拷贝
            boost::string_view data(
                static_cast<const char*>(buffer.data()),
                buffer.size());

            // 触发流式处理回调
            if(opts_.on_data)
                opts_.on_data(data, false);

            // 将数据追加到缓存中（如果需要完整响应体的话）
            body_.append(data.data(), data.size());
            return {};
        }

        // 响应体接收完成时调用，标记最后一块
        void
        finish()
        {
            if(opts_.on_data)
                opts_.on_data({}, true);
        }

    private:
        value_type& body_;
        streaming_string_body& opts_;
    };

    // 实现body类型必需的接口（和原生string_body对齐）
    static constexpr bool is_mutable = true;

    static void
    resize(value_type& body, std::size_t size)
    {
        body.resize(size);
    }

    static std::pair<const_buffers_type, bool>
    prepare(value_type& body, std::size_t n)
    {
        body.reserve(body.size() + n);
        return {boost::asio::buffer(body.data() + body.size(), body.capacity() - body.size()), false};
    }

    static void
    commit(value_type& body, std::size_t n)
    {
        body.resize(body.size() + n);
    }

    static const_buffers_type
    data(value_type const& body)
    {
        return boost::asio::buffer(body);
    }
};

2. 使用自定义Body处理响应

// 初始化parser，使用我们的流式body
http::response_parser<streaming_string_body> parser;

// 设置流式处理回调：每块数据到达时触发
parser.body().on_data = [](boost::string_view chunk, bool is_final) {
    if(!chunk.empty()) {
        // 这里写你的流式处理逻辑：比如解析JSON片段、写入磁盘、实时统计等
        std::cout << "Received data chunk: " << chunk.size() << " bytes" << std::endl;
    }
    if(is_final) {
        // 可以做一些流式处理的收尾工作（注意：最终完整响应的回调会在async_read完成后触发）
        std::cout << "All data chunks have been streamed" << std::endl;
    }
};

// 第一步：读取响应头
http::async_read_header(stream, buffer, parser,
    [&](boost::system::error_code ec, std::size_t bytes_transferred) {
        if(ec) {
            std::cerr << "Read header failed: " << ec.message() << std::endl;
            return;
        }

        // 注意：如果是200MB的大响应，必须手动设置body大小限制，否则会被默认限制截断
        parser.body_limit(200 * 1024 * 1024);

        // 第二步：读取响应体（不管分块还是非分块，都会流式触发回调）
        http::async_read(stream, buffer, parser,
            [&](boost::system::error_code ec, std::size_t bytes_transferred) {
                if(ec) {
                    std::cerr << "Read body failed: " << ec.message() << std::endl;
                    return;
                }

                // 获取完整的响应对象，调用最终回调
                auto full_response = parser.release();
                std::cout << "Full response received, total body size: " << full_response.body().size() << " bytes" << std::endl;
                // your_final_callback(std::move(full_response));
            });
    });

方案优势 #

• 统一处理逻辑：不管响应是分块编码还是带Content-Length的长响应，都用同一个回调处理数据块，不用区分两种场景。
• 实时处理数据：不需要等200MB数据全部接收，每一块数据到达就可以立即处理，节省时间和内存（如果不需要完整响应体，甚至可以修改body类型不缓存数据，只做流式处理）。
• 兼容原有需求：最后依然能拿到完整的响应对象，满足你在全部数据接收完成后调用回调的需求。

注意事项 #

• 线程安全：Beast的异步操作在io_context的线程池中执行，如果你处理逻辑涉及共享资源，要确保回调函数的线程安全（比如加锁、使用线程安全的数据结构）。
• Body大小限制：默认情况下Boost.Beast会限制响应体大小（比如1MB），处理大响应时必须手动调用parser.body_limit()设置足够大的阈值。
• 错误处理：要在async_read_header和async_read的回调中正确处理网络错误、超时等异常情况，避免程序崩溃。

内容来源于stack exchange