项目背景详细介绍

随着微服务与云原生架构普及，RESTful API 已成为后端服务间交互和前端—后端通信的事实标准。很多场景需要用 C++ 提供高性能、低延迟、资源敏感的 HTTP/REST 服务，例如高频交易、实时数据流处理、物联网网关、游戏服务器的管理接口、以及需与已有 C/C++ 代码库无缝整合的系统。

虽然用 Java、Go、Node.js 可以很快实现 RESTful 服务，但在对性能、内存占用、延迟和对底层控制要求较高的场景下，C++仍然具有不可替代的优势。本项目旨在用现代 C++（C++17）实现一个可读、可扩展、可用于教学的 RESTful API 服务模板，包含：路由、JSON 解析、请求参数校验、简单持久层（内存实现）、错误处理与基本并发控制。目标是为学习者或工程项目快速搭建 C++ 服务端基础框架，同时强调生产环境应考虑安全、日志、监控等更多工程化细节。

项目需求详细介绍

本项目需要实现的功能清单（最小可交付）：

1. HTTP RESTful 服务：监听 0.0.0.0:8080，支持 GET/POST/PUT/DELETE 等常用方法。

2. 资源示例：用户（User）：

   • GET /users — 列表（支持分页查询）

   • GET /users/{id} — 读取单个用户

   • POST /users — 创建用户（传 JSON）

   • PUT /users/{id} — 更新用户

   • DELETE /users/{id} — 删除用户

3. JSON 请求与响应：请求体与响应均为 JSON 格式，含标准响应结构（code/message/data）。

4. 路由与简单参数校验：验证必需字段（name/email），返回 400 错误与信息。

5. 并发处理能力：使用线程池或异步 I/O 处理并发请求（示例采用 Boost.Asio + Beast 的异步/多线程模型）。

6. 内存持久层：演示性地将用户数据保存在进程内的线程安全 map 中（std::unordered_map + mutex），供示例和单元测试使用。

7. 良好代码结构：分层（主服务/路由/控制器/模型/存储/工具）结构，便于扩展到数据库/认证/日志等。

8. 可编译、注释详尽：代码可直接在支持 Boost（Beast/Asio）和 nlohmann::json 的环境下编译（明确在代码注释中说明依赖）。

注意：示例以教育与工程启发为主，生产环境应加入 HTTPS、认证、限流、日志、监控、持久化数据库、配置管理、进程守护与自动化部署等。

相关技术详细介绍

实现这个 RESTful 服务我们将使用以下关键技术与库（都为跨平台或在 Linux/Windows 均可用的主流组件）：

1. Boost.Asio / Boost.Beast

   • Boost.Asio 提供跨平台异步 I/O（网络/计时器/线程等），是构建高性能网络服务的基础。

   • Boost.Beast 基于 Asio，提供 HTTP/WebSocket 协议解析、序列化与处理，适用于实现 HTTP 服务器与客户端。

   • 我们将采用 Beast 的 HTTP 解析器和异步 I/O 模型，结合线程池以实现并发请求处理。

2. nlohmann::json（JSON for Modern C++）

   • 简洁易用的 JSON 库，支持序列化/反序列化。常用于 C++ REST 服务中的请求体解析与响应生成。

3. 现代 C++（C++17）特性

   • 智能指针（std::shared_ptr/std::unique_ptr）、std::optional、结构化绑定、线程安全容器 + mutex 等，有助于写出安全与可维护的代码。

4. 线程安全内存存储

   • 为示例实现一个线程安全的 in-memory repository（用户存储），演示并发下的数据访问保护。

5. HTTP 设计与 RESTful 实践

   • 使用标准的 HTTP 状态码（200/201/400/404/500 等），以及资源 URI 设计，返回统一 JSON 包装体（code/message/data）。

实现思路详细介绍

整体架构与处理流程如下：

1. 主入口与 I/O 线程池

   • 程序启动时创建一个 Boost.Asio io_context，并启动若干 worker 线程（根据硬件线程数或配置）。

   • 在 io_context 上监听 TCP 端口（8080），使用异步 accept 接受连接。

2. 会话（Session）与请求处理

   • 每个建立的 TCP 连接将有对应的 HTTP session 对象，负责读取请求缓冲、解析 HTTP 请求（使用 Beast），并将解析到的请求派发到路由层。

3. 路由层（Router）

   • 简单的路由匹配逻辑：基于方法 + 路径（支持路径参数如 /users/{id}）。

   • 路由负责把请求交给对应的控制器（Controller）函数，并接收返回的业务结果（或错误）。

4. 控制器（Controller）

   • 实现 User 控制器的一系列处理函数（list/create/get/update/delete）。控制器负责：解析 JSON、验证、调用存储层、构造响应。

5. 存储层（Repository）

   • 提供用户数据的 CRUD 接口，内部使用线程安全的 unordered_map，并在必要处加锁（std::mutex 或 std::shared_mutex）。

   • 在真实场景下，这个层可替换为数据库访问（例如 MySQL/Postgres/Redis）。

6. 响应构造与错误处理

   • 定义统一响应模型（code/message/data），错误时返回相应 HTTP 状态码与错误信息。

   • 日志和详细错误信息在示例中以简单 std::cerr 输出，生产中应使用完善的日志库。

7. 可扩展点

   • 中间件（认证、限流、日志、CORS）可以在路由/请求派发阶段插入。

   • 数据持久化改为数据库，使用连接池。

   • 使用证书（TLS）替换监听器以提供 HTTPS 支持（Beast 支持 TLS via OpenSSL）。

完整实现代码

/***************************************************************
 * 文件合并视图：RestServer.cpp
 * 说明：为便于展示把“多个文件”合并在一个文件中 -- 用注释分隔。
 * 生产环境建议按模块拆分为多个源文件/头文件。
 ***************************************************************/

//////////////////////////////////////////
// 依赖与宏（顶部）
//////////////////////////////////////////
#include <boost/beast/core.hpp>
#include <boost/beast/http.hpp>
#include <boost/beast/version.hpp>
#include <boost/asio.hpp>
#include <boost/asio/dispatch.hpp>
#include <boost/asio/strand.hpp>
#include <boost/config.hpp>

#include <nlohmann/json.hpp> // 请确保已将 nlohmann::json 的头文件放在 include 路径

#include <algorithm>
#include <cstdlib>
#include <iostream>
#include <memory>
#include <string>
#include <thread>
#include <unordered_map>
#include <mutex>
#include <shared_mutex>
#include <vector>
#include <chrono>
#include <optional>

namespace beast = boost::beast;         // from <boost/beast.hpp>
namespace http = beast::http;           // from <boost/beast/http.hpp>
namespace asio = boost::asio;           // from <boost/asio.hpp>
using tcp = boost::asio::ip::tcp;       // from <boost/asio/ip/tcp.hpp>
using json = nlohmann::json;

/***************************************************************
 * 简单日志宏（教学用）
 ***************************************************************/
#define LOG_INFO(x)  (std::cout << "[INFO] " << x << std::endl)
#define LOG_ERROR(x) (std::cerr << "[ERROR] " << x << std::endl)

//////////////////////////////////////////
// Models（用户模型）
//////////////////////////////////////////
/*
 * User 模型：演示性字段 id/name/email/created_at
 */
struct User {
    int id;
    std::string name;
    std::string email;
    std::string created_at; // 简单字符串，生产中用时间类型

    // 将 User 序列化为 JSON
    json to_json() const {
        return json{
            {"id", id},
            {"name", name},
            {"email", email},
            {"created_at", created_at}
        };
    }

    // 从 JSON 构造 User（部分字段）
    static std::optional<User> from_json(const json& j) {
        if (!j.contains("name") || !j.contains("email")) {
            return std::nullopt;
        }
        User u;
        u.id = j.value("id", 0);
        u.name = j.value("name", "");
        u.email = j.value("email", "");
        u.created_at = j.value("created_at", "");
        return u;
    }
};

//////////////////////////////////////////
// Repository（线程安全的内存存储）
// 用于演示：真实环境请接入数据库
//////////////////////////////////////////
class UserRepository {
public:
    UserRepository(): next_id_(1) {}

    // 创建用户，返回创建后的 User 对象
    User create(const User& u) {
        std::unique_lock lock(mutex_);
        User copy = u;
        copy.id = next_id_++;
        if (copy.created_at.empty()) {
            copy.created_at = now_str();
        }
        store_[copy.id] = copy;
        return copy;
    }

    // 获取单个用户
    std::optional<User> get(int id) {
        std::shared_lock lock(mutex_);
        auto it = store_.find(id);
        if (it == store_.end()) return std::nullopt;
        return it->second;
    }

    // 更新用户（partial update 替换 name/email）
    std::optional<User> update(int id, const User& u) {
        std::unique_lock lock(mutex_);
        auto it = store_.find(id);
        if (it == store_.end()) return std::nullopt;
        if (!u.name.empty()) it->second.name = u.name;
        if (!u.email.empty()) it->second.email = u.email;
        return it->second;
    }

    // 删除用户
    bool remove(int id) {
        std::unique_lock lock(mutex_);
        return store_.erase(id) > 0;
    }

    // 列表（分页）
    std::vector<User> list(int page, int page_size) {
        std::shared_lock lock(mutex_);
        std::vector<User> all;
        all.reserve(store_.size());
        for (auto &p : store_) all.push_back(p.second);
        // 简单按 id 排序
        std::sort(all.begin(), all.end(), [](const User &a, const User &b){ return a.id < b.id; });
        int start = (page - 1) * page_size;
        if (start < 0) start = 0;
        std::vector<User> out;
        for (int i = start; i < (int)all.size() && (int)out.size() < page_size; ++i) out.push_back(all[i]);
        return out;
    }

private:
    std::string now_str() {
        using namespace std::chrono;
        auto t = system_clock::now();
        std::time_t tt = system_clock::to_time_t(t);
        char buf[64];
        std::strftime(buf, sizeof(buf), "%Y-%m-%d %H:%M:%S", std::localtime(&tt));
        return std::string(buf);
    }

    std::unordered_map<int, User> store_;
    mutable std::shared_mutex mutex_;
    int next_id_;
};

//////////////////////////////////////////
// HTTP Helpers：统一响应格式
//////////////////////////////////////////
/*
 * 统一返回结构体：{ "code": 0, "message": "OK", "data": ... }
 * code: 0 表示成功，非 0 表示业务错误
 */
json make_response(int code, const std::string &message, const json &data = nullptr) {
    json j;
    j["code"] = code;
    j["message"] = message;
    j["data"] = data;
    return j;
}

//////////////////////////////////////////
// Router 与 Controller（用户资源）
// 简化实现：通过路径字符串解析参数
//////////////////////////////////////////
class UserController {
public:
    UserController(std::shared_ptr<UserRepository> repo) : repo_(repo) {}

    // 处理列表 GET /users?page=1&page_size=10
    json list(const http::request<http::string_body>& req) {
        // 简单解析查询参数（不支持 URL 解码复杂场景）
        int page = 1, page_size = 10;
        auto target = req.target().to_string();
        // parse ?page=...&page_size=...
        auto pos = target.find('?');
        if (pos != std::string::npos) {
            auto qs = target.substr(pos+1);
            std::vector<std::string> parts;
            size_t start = 0;
            while (start < qs.size()) {
                auto amp = qs.find('&', start);
                if (amp == std::string::npos) amp = qs.size();
                parts.push_back(qs.substr(start, amp-start));
                start = amp + 1;
            }
            for (auto &p : parts) {
                auto eq = p.find('=');
                if (eq == std::string::npos) continue;
                auto k = p.substr(0, eq);
                auto v = p.substr(eq+1);
                if (k=="page") page = std::max(1, std::atoi(v.c_str()));
                if (k=="page_size") page_size = std::clamp(std::atoi(v.c_str()), 1, 100);
            }
        }
        auto users = repo_->list(page, page_size);
        json arr = json::array();
        for (auto &u : users) arr.push_back(u.to_json());
        return make_response(0, "OK", {{"items", arr}, {"page", page}, {"page_size", page_size}});
    }

    // GET /users/{id}
    json get(int id) {
        auto opt = repo_->get(id);
        if (!opt) return make_response(404, "User not found");
        return make_response(0, "OK", opt->to_json());
    }

    // POST /users
    json create(const http::request<http::string_body>& req) {
        try {
            auto j = json::parse(req.body());
            auto maybe = User::from_json(j);
            if (!maybe) return make_response(400, "Invalid body: require name and email");
            User u = maybe.value();
            // 简单校验 email
            if (u.email.empty() || u.name.empty()) return make_response(400, "name/email cannot be empty");
            User created = repo_->create(u);
            return make_response(0, "Created", created.to_json());
        } catch (const std::exception& e) {
            return make_response(400, std::string("Invalid JSON: ") + e.what());
        }
    }

    // PUT /users/{id}
    json update(int id, const http::request<http::string_body>& req) {
        try {
            auto j = json::parse(req.body());
            User u;
            u.id = id;
            u.name = j.value("name", "");
            u.email = j.value("email", "");
            auto opt = repo_->update(id, u);
            if (!opt) return make_response(404, "User not found");
            return make_response(0, "OK", opt->to_json());
        } catch (const std::exception& e) {
            return make_response(400, std::string("Invalid JSON: ") + e.what());
        }
    }

    // DELETE /users/{id}
    json remove(int id) {
        bool ok = repo_->remove(id);
        if (!ok) return make_response(404, "User not found");
        return make_response(0, "Deleted");
    }

private:
    std::shared_ptr<UserRepository> repo_;
};

//////////////////////////////////////////
// Session：每个 TCP 连接对应的会话
// 负责读取请求、调用路由、发送响应
//////////////////////////////////////////
class HttpSession : public std::enable_shared_from_this<HttpSession> {
public:
    // socket 已用 move 传入
    HttpSession(tcp::socket socket, std::shared_ptr<UserController> controller)
        : stream_(std::move(socket)), controller_(controller), buffer_(), req_() {}

    // 开始会话（读取请求）
    void run() {
        // 设置超时（可选）
        do_read();
    }

private:
    beast::tcp_stream stream_;
    beast::flat_buffer buffer_;
    http::request<http::string_body> req_;
    std::shared_ptr<UserController> controller_;

    void do_read() {
        auto self = shared_from_this();
        http::async_read(stream_, buffer_, req_,
            [self](beast::error_code ec, std::size_t bytes_transferred) {
                boost::ignore_unused(bytes_transferred);
                if (ec == http::error::end_of_stream) {
                    // 远端关闭连接
                    self->do_close();
                    return;
                }
                if (ec) {
                    LOG_ERROR("read: " << ec.message());
                    return;
                }
                // 处理请求并发送响应
                self->handle_request();
            });
    }

    // 解析路径并路由到 controller
    void handle_request() {
        try {
            std::string method = req_.method_string().to_string();
            std::string target = req_.target().to_string();
            LOG_INFO("Received: " << method << " " << target);

            // 简单路由匹配：支持 /users 和 /users/{id}
            // 去掉 query string
            std::string path = target;
            auto qpos = path.find('?');
            if (qpos != std::string::npos) path = path.substr(0, qpos);

            json result;
            http::status status = http::status::ok;

            if (req_.method() == http::verb::get && path == "/users") {
                result = controller_->list(req_);
            } else if (req_.method() == http::verb::post && path == "/users") {
                result = controller_->create(req_);
                // created code 可自定义
                status = http::status::created;
            } else if (starts_with(path, "/users/")) {
                // parse id
                auto idstr = path.substr(strlen("/users/"));
                int id = std::atoi(idstr.c_str());
                if (req_.method() == http::verb::get) {
                    result = controller_->get(id);
                    if (result["code"].get<int>() != 0) status = http::status::not_found;
                } else if (req_.method() == http::verb::put) {
                    result = controller_->update(id, req_);
                    if (result["code"].get<int>() != 0) status = http::status::not_found;
                } else if (req_.method() == http::verb::delete_) {
                    result = controller_->remove(id);
                    if (result["code"].get<int>() != 0) status = http::status::not_found;
                } else {
                    result = make_response(405, "Method Not Allowed");
                    status = http::status::method_not_allowed;
                }
            } else {
                result = make_response(404, "Not Found");
                status = http::status::not_found;
            }

            // 发送响应
            send_response(status, result.dump());
        } catch (const std::exception& e) {
            LOG_ERROR("handle_request exception: " << e.what());
            json r = make_response(500, "Internal Server Error");
            send_response(http::status::internal_server_error, r.dump());
        }
    }

    void send_response(http::status status, const std::string &body) {
        // 构造 HTTP 响应
        auto res = std::make_shared<http::response<http::string_body>>(status, req_.version());
        res->set(http::field::server, "cpp-rest-server/0.1");
        res->set(http::field::content_type, "application/json; charset=utf-8");
        res->keep_alive(req_.keep_alive());
        res->body() = body;
        res->prepare_payload();

        auto self = shared_from_this();
        http::async_write(stream_, *res,
            [self, res](beast::error_code ec, std::size_t) {
                if (ec) {
                    LOG_ERROR("write: " << ec.message());
                    return;
                }
                // 若客户端要求保持连接，则继续读取下一个请求
                if (res->keep_alive()) {
                    // 清空 request 与 buffer 并继续读取
                    self->req_ = {};
                    self->do_read();
                } else {
                    self->do_close();
                }
            });
    }

    void do_close() {
        beast::error_code ec;
        stream_.socket().shutdown(tcp::socket::shutdown_send, ec);
        // 忽略错误
    }

    // 简单的前缀判断
    static bool starts_with(const std::string& s, const std::string& prefix) {
        return s.size() >= prefix.size() && s.compare(0, prefix.size(), prefix) == 0;
    }
};

//////////////////////////////////////////
// Listener：接受连接并分发 Session
//////////////////////////////////////////
class Listener : public std::enable_shared_from_this<Listener> {
public:
    Listener(asio::io_context& ioc, tcp::endpoint endpoint, std::shared_ptr<UserController> controller)
        : acceptor_(ioc), socket_(ioc), controller_(controller) {
        beast::error_code ec;

        // 打开 acceptor
        acceptor_.open(endpoint.protocol(), ec);
        if (ec) throw beast::system_error(ec);
        // 允许复用地址
        acceptor_.set_option(asio::socket_base::reuse_address(true), ec);
        if (ec) throw beast::system_error(ec);
        // 绑定到端口
        acceptor_.bind(endpoint, ec);
        if (ec) throw beast::system_error(ec);
        // 开始监听
        acceptor_.listen(asio::socket_base::max_listen_connections, ec);
        if (ec) throw beast::system_error(ec);
    }

    void run() {
        do_accept();
    }

private:
    tcp::acceptor acceptor_;
    tcp::socket socket_;
    std::shared_ptr<UserController> controller_;

    void do_accept() {
        auto self = shared_from_this();
        acceptor_.async_accept(socket_, [self](beast::error_code ec) {
            if (!ec) {
                // 为每个连接创建一个 session（交由 io_context 的线程处理）
                std::make_shared<HttpSession>(std::move(self->socket_), self->controller_)->run();
            } else {
                LOG_ERROR("accept: " << ec.message());
            }
            // 继续接收下一个连接
            self->do_accept();
        });
    }
};

//////////////////////////////////////////
// 主函数：初始化 repo/controller/listener 并运行 io_context 多线程
//////////////////////////////////////////
int main(int argc, char* argv[]) {
    try {
        // 配置
        const int port = 8080;
        const int threads = std::max(1u, std::thread::hardware_concurrency());

        LOG_INFO("Starting RESTful server on port " << port << " with " << threads << " threads");

        asio::io_context ioc{threads};

        // 共享资源
        auto repo = std::make_shared<UserRepository>();
        auto controller = std::make_shared<UserController>(repo);

        // 启动监听器（0.0.0.0:8080）
        auto endpoint = tcp::endpoint(tcp::v4(), port);
        std::make_shared<Listener>(ioc, endpoint, controller)->run();

        // 启动 worker 线程池（io_context）
        std::vector<std::thread> v;
        v.reserve(threads - 1);
        for (int i = 0; i < threads - 1; ++i) {
            v.emplace_back([&ioc]() { ioc.run(); });
        }
        // 主线程也运行
        ioc.run();

        // join threads（通常不会到这一步，除非 ioc.run 返回）
        for (auto &t : v) t.join();
    } catch (const std::exception &e) {
        LOG_ERROR("Fatal: " << e.what());
        return EXIT_FAILURE;
    }
    return EXIT_SUCCESS;
}

代码详细解读

下面按照模块逐个简要说明每个方法/类的职责，帮助你理解总体设计（注意：不重复代码本体）：

1. User（模型）

   • to_json：把 User 实例序列化为 JSON 对象，便于在响应体中返回。

   • from_json：从 JSON 中反序列化为 User 对象（做基本字段存在性检查），用于解析客户端提交的请求体。

2. UserRepository（存储层）

   • create：生成自增 ID、填充创建时间，并把用户保存到内部 map。

   • get：根据 ID 返回用户（若不存在返回空）。

   • update：对已有用户做局部更新（如 name/email），并返回更新后的对象或空。

   • remove：删除指定 ID 的用户并返回是否成功。

   • list：按页返回用户列表（对内部 map 排序并分页），实现简单分页逻辑。

   • 内部使用读写锁（shared_mutex）保证并发安全，避免数据竞争。

3. make_response（工具）

   • 统一构造 JSON 响应结构（包含 code/message/data），方便控制器与 session 层统一返回格式。

4. UserController（业务逻辑层）

   • list：解析查询参数（page/page_size），调用 repository 返回分页结果并包装为统一响应。

   • get：通过 id 获取用户并返回相应的结果/错误信息。

   • create：解析请求体 JSON、校验必需字段、调用 repository 创建资源并返回创建结果。

   • update：解析请求体，局部更新用户并返回结果或 404。

   • remove：删除用户并返回删除结果或 404。

   • 控制器负责输入校验、调用存储层、并封装响应语义（业务等级的 code/message）。

5. HttpSession（连接/会话层）

   • run：开启会话的读取循环。

   • do_read：异步读取 HTTP 请求并在完成时调用处理逻辑。

   • handle_request：对请求做路由解析（方法 + 路径），将请求派发给控制器相应方法，并处理控制器返回的 JSON 来决定 HTTP 状态码。

   • send_response：构造并异步发送 HTTP 响应，支持 keep-alive；写完成后要么继续读取新请求，要么关闭连接。

   • do_close：关闭底层 socket 的发送端（优雅关闭）。

   • 该层与 Beast 的 HTTP 解析紧密结合，管理每个连接的生命周期以及请求—响应循环。

6. Listener（接收器）

   • 构造函数负责打开 socket、绑定地址、监听端口，并设置 socket 选项（如地址复用）。

   • run：开始 accept 循环，异步接受新连接。

   • do_accept：为每个新连接分配一个 HttpSession 并启动它。

7. main（程序入口）

   • 初始化 io_context 与线程池（线程数依据硬件并发）。

   • 创建共享的 repository 与 controller 实例（注入依赖）。

   • 创建 Listener 并开始接受连接。

   • 启动多线程执行 io_context 以处理并发请求。

项目详细总结

本项目展示了如何用现代 C++ 与 Boost.Beast/Asio 构建一个基础的 RESTful API 服务。它覆盖了从网络 I/O、HTTP 请求解析、路由派发到业务逻辑与线程安全存储的完整链路，适合作为学习网络编程、异步模型与 C++ 服务端设计的入门与模板。

优势：

• 性能较高、可控性强：C++ 与 Asio 的异步 I/O 提供高吞吐与低延迟。

• 可扩展性好：存储层可替换为数据库，控制器可增加认证/限流中间件等。

• 教学价值高：从源码到运行机制都可跟踪，利于系统学习。

局限与注意事项：

• 示例中未实现 HTTPS（TLS）、认证、完善的 URL 解码、请求体大小限制、上传处理等生产特性。

• 错误处理与日志较为简化，生产中应使用成熟日志库和更细粒度的错误分类。

• 内存存储仅用于演示，真实系统需接入持久化（数据库）与迁移策略。

项目常见问题及解答

Q1：如何编译运行？
A1：需要安装 Boost（包含 Asio/Beast）和 nlohmann::json 头文件。使用 g++/clang++，启用 C++17。示例编译命令（请根据你系统的 Boost 安装位置调整 include/link 参数）：

g++ -std=c++17 -O2 -pthread RestServer.cpp -o rest_server -lboost_system

如果 Beast/Asio 为 header only，可能无需额外链接。nlohmann::json 只需头文件。

Q2：如何支持 HTTPS？
A2：使用 Boost.Beast 与 OpenSSL 配合，创建 ssl::context，使用 ssl::stream 包装 socket，并在 listener/session 层做相应调整。注意证书管理与性能权衡。

Q3：如何替换为数据库持久化？
A3：把 UserRepository 的实现替换为调用数据库客户端（如 libpqxx/MySQL Connector/C++/soci），并使用连接池与事务处理。

Q4：如何做路由更复杂的匹配？
A4：可以引入路由库，或实现更强的路由解析器（支持正则路径、参数解析、中间件链）。

Q5：如何做单元测试？
A5：将业务逻辑（controller + repository）与网络 I/O 解耦，使用 GoogleTest 或 Catch2 对 controller 与 repository 编写单元测试；对网络层做集成测试可以启动一个测试实例并用 HTTP 客户端发起请求。

扩展方向与性能优化

1. TLS/HTTPS 支持：使用 OpenSSL 与 Beast 集成，强制 HTTPS 并配置证书自动更新（例如 ACME）。

2. 连接/请求限流与熔断：保护服务免遭流量洪峰，可在路由层加入令牌桶或漏桶实现。

3. 负载均衡与多实例部署：把服务容器化（Docker），使用 Kubernetes 做弹性伸缩和流量分配。

4. 引入中间件链：实现日志、认证、CORS、IP 黑白名单等通用中间件。

5. 性能剖析与优化：使用 perf、valgrind、async-profiler 分析热点，减少锁粒度或使用无锁数据结构。

6. 异步与协程：C++20 协程或 libcppcoro 能简化异步代码路径，提高可读性；但需谨慎选择并发模型。

7. 持久化与缓存：使用 Redis 做缓存、数据库做持久化，支持读写分离与连接池。

8. SLA 与可观测性：加入监控指标（Prometheus）、分布式追踪（OpenTelemetry）、结构化日志。