C++构建高性能HTTP服务器的最佳实践指南

// 使用raii管理所有系统资源
class httpserver {
private:
    std::unique_ptr<socket> listener_;
    std::unique_ptr<threadpool> thread_pool_;
    std::atomic<bool> running_{false};
    
public:
    httpserver(const std::string& address, uint16_t port)
        : listener_(std::make_unique<socket>())
        , thread_pool_(std::make_unique<threadpool>()) {
        
        // raii方式初始化：构造函数获取资源
        // 如果任何一步失败，异常会阻止对象构造，确保资源正确清理
        listener_->bind(address, port);
        listener_->listen(1024);
        
        std::cout << "http服务器初始化完成，监听 " 
                  << address << ":" << port << std::endl;
    }
    
    ~httpserver() {
        // 析构函数自动释放资源，无需手动清理
        stop(); 
        std::cout << "http服务器资源已释放" << std::endl;
    }
    
    // 删除拷贝操作，避免意外共享
    // 拷贝语义在资源管理类中通常是危险的
    httpserver(const httpserver&) = delete;
    httpserver& operator=(const httpserver&) = delete;
    
    // 允许移动语义，支持资源所有权的转移
    httpserver(httpserver&&) = default;
    httpserver& operator=(httpserver&&) = default;
    
    void run() {
        running_.store(true, std::memory_order_release);
        std::cout << "启动http服务器主循环..." << std::endl;
        
        // 主事件循环
        while (running_.load(std::memory_order_acquire)) {
            try {
                auto client_socket = listener_->accept();
                if (client_socket.is_valid()) {
                    handle_new_connection(std::move(client_socket));
                }
            } catch (const std::exception& e) {
                std::cerr << "接受连接时发生错误: " << e.what() << std::endl;
            }
        }
    }
    
    void stop() {
        running_.store(false, std::memory_order_release);
    }
};

// 连接类继承enable_shared_from_this，允许在回调中安全地延长生命周期
class connection : public std::enable_shared_from_this<connection> {
private:
    std::unique_ptr<socket> socket_;
    std::vector<char> buffer_;
    std::string request_data_;
    requestparser parser_;
    
public:
    explicit connection(std::unique_ptr<socket> socket)
        : socket_(std::move(socket))  // 明确的所有权转移
        , buffer_(8192) {             // 预分配读缓冲区
        
        std::cout << "创建新连接，fd: " << socket_->fd() << std::endl;
    }
    
    ~connection() {
        std::cout << "关闭连接，fd: " << socket_->fd() << std::endl;
    }
    
    void start() {
        // 使用shared_from_this()确保在异步操作期间对象不会被销毁
        auto self = shared_from_this();  
        
        // 将连接注册到事件循环中
        eventloop::instance().add_socket(
            socket_->fd(), 
            epollin | epollet,  // 边缘触发模式
            [self](uint32_t events) {
                if (events & epollin) {
                    self->do_read();
                }
                if (events & epollout) {
                    self->do_write();
                }
                if (events & (epollerr | epollhup)) {
                    self->handle_error();
                }
            }
        );
        
        do_read();
    }
    
    int fd() const { return socket_->fd(); }
    
private:
    void do_read() {
        auto self = shared_from_this();
        
        // 异步读取数据
        socket_->async_read_some(buffer_, 
            [self](std::error_code ec, size_t bytes_transferred) {
                if (!ec && bytes_transferred > 0) {
                    self->on_data_received(bytes_transferred);
                } else {
                    self->handle_error();
                }
            });
    }
    
    void on_data_received(size_t bytes_read) {
        // 将数据追加到请求缓冲区
        request_data_.append(buffer_.data(), bytes_read);
        
        // 尝试解析完整的http请求
        auto result = parser_.parse(request_data_);
        if (result.has_value()) {
            handle_request(std::move(result.value()));
            request_data_.clear();  // 准备处理下一个请求
        } else if (result.error() == parseerror::needmoredata) {
            // 需要更多数据，继续读取
            do_read();
        } else {
            // 解析错误，返回400 bad request
            send_error_response(http::statuscode::badrequest);
        }
    }
    
    void do_write(std::string_view response) {
        auto self = shared_from_this();
        
        socket_->async_write(response,
            [self](std::error_code ec, size_t bytes_written) {
                if (!ec) {
                    // 写入成功，检查是否要保持连接
                    if (self->should_keep_alive()) {
                        self->do_read();  // 继续读取下一个请求
                    } else {
                        // 关闭连接
                        self->socket_->close();
                    }
                } else {
                    self->handle_error();
                }
            });
    }
    
    void handle_request(request&& request);
    void send_error_response(http::statuscode code);
    bool should_keep_alive() const;
};

// 工厂函数，使用make_shared确保单次内存分配
auto create_connection(std::unique_ptr<socket> socket) {
    return std::make_shared<connection>(std::move(socket));
}

namespace http {
    // 强类型枚举，避免隐式转换
    enum class method { 
        get, 
        post, 
        put, 
        delete, 
        head, 
        options, 
        patch 
    };
    
    enum class version { 
        http1_0, 
        http1_1, 
        http2_0 
    };
    
    // 枚举底层类型指定，确保二进制兼容性
    enum class statuscode : uint16_t {
        // 2xx success
        ok = 200,
        created = 201,
        accepted = 202,
        nocontent = 204,
        
        // 3xx redirection
        movedpermanently = 301,
        found = 302,
        notmodified = 304,
        
        // 4xx client errors
        badrequest = 400,
        unauthorized = 401,
        forbidden = 403,
        notfound = 404,
        methodnotallowed = 405,
        
        // 5xx server errors
        internalerror = 500,
        notimplemented = 501,
        badgateway = 502,
        serviceunavailable = 503
    };
    
    // 大小写不敏感的头部映射
    class headers {
    private:
        struct caseinsensitivehash {
            size_t operator()(const std::string& key) const {
                std::string lower_key;
                std::transform(key.begin(), key.end(), 
                             std::back_inserter(lower_key), ::tolower);
                return std::hash<std::string>{}(lower_key);
            }
        };
        
        struct caseinsensitiveequal {
            bool operator()(const std::string& lhs, 
                          const std::string& rhs) const {
                if (lhs.length() != rhs.length()) return false;
                return std::equal(lhs.begin(), lhs.end(), rhs.begin(),
                                [](char a, char b) {
                                    return ::tolower(a) == ::tolower(b);
                                });
            }
        };
        
        std::unordered_map<std::string, std::string, 
                          caseinsensitivehash, 
                          caseinsensitiveequal> headers_;
    public:
        void set(std::string_view key, std::string_view value) {
            headers_[std::string(key)] = std::string(value);
        }
        
        std::optional<std::string_view> get(std::string_view key) const {
            auto it = headers_.find(std::string(key));
            if (it != headers_.end()) {
                return std::string_view(it->second);
            }
            return std::nullopt;
        }
        
        bool contains(std::string_view key) const {
            return headers_.find(std::string(key)) != headers_.end();
        }
        
        auto begin() const { return headers_.begin(); }
        auto end() const { return headers_.end(); }
    };
    
    // http请求类
    class request {
    private:
        method method_;
        std::string uri_;
        version version_;
        headers headers_;
        std::string body_;
        
    public:
        request(method method, std::string uri, version version = version::http1_1)
            : method_(method), uri_(std::move(uri)), version_(version) {}
        
        // 访问器方法
        method method() const { return method_; }
        const std::string& uri() const { return uri_; }
        version version() const { return version_; }
        const headers& headers() const { return headers_; }
        headers& headers() { return headers_; }
        const std::string& body() const { return body_; }
        std::string& body() { return body_; }
        
        void set_method(method method) { method_ = method; }
        void set_uri(std::string uri) { uri_ = std::move(uri); }
        void set_version(version version) { version_ = version; }
        void set_body(std::string body) { body_ = std::move(body); }
    };
    
    // http响应类
    class response {
    private:
        statuscode status_code_;
        headers headers_;
        std::string body_;
        
    public:
        response(statuscode status_code = statuscode::ok) 
            : status_code_(status_code) {}
        
        statuscode status_code() const { return status_code_; }
        const headers& headers() const { return headers_; }
        headers& headers() { return headers_; }
        const std::string& body() const { return body_; }
        std::string& body() { return body_; }
        
        void set_status_code(statuscode code) { status_code_ = code; }
        void set_body(std::string body) { 
            body_ = std::move(body); 
            headers_.set("content-length", std::to_string(body_.size()));
        }
        
        // 便捷方法
        static response text_response(std::string content) {
            response resp(statuscode::ok);
            resp.headers().set("content-type", "text/plain; charset=utf-8");
            resp.set_body(std::move(content));
            return resp;
        }
        
        static response json_response(std::string json) {
            response resp(statuscode::ok);
            resp.headers().set("content-type", "application/json");
            resp.set_body(std::move(json));
            return resp;
        }
        
        static response error_response(statuscode code, std::string message) {
            response resp(code);
            resp.headers().set("content-type", "text/plain; charset=utf-8");
            resp.set_body(std::move(message));
            return resp;
        }
    };
}

// 类型安全的请求解析器
class requestparser {
public:
    std::expected<http::request, parseerror> parse(std::string_view data);
    
private:
    std::expected<http::method, parseerror> 
    parse_method(std::string_view method_str);
    
    std::expected<http::version, parseerror> 
    parse_version(std::string_view version_str);
    
    std::expected<uint16_t, parseerror> 
    parse_status_code(std::string_view code_str);
};

enum class parsererror {
    invalidmethod,
    malformedrequestline,
    invalidversion,
    malformedheaders,
    bodytoolarge,
    invalidencoding,
    needmoredata
};

class requestparser {
private:
    static constexpr size_t max_request_size = 1024 * 1024; // 1mb
    static constexpr size_t max_headers_size = 8192;        // 8kb
    
public:
    std::expected<http::request, parsererror> parse(std::string_view input) {
        if (input.empty()) {
            return std::unexpected(parsererror::needmoredata);
        }
        
        // 解析请求行
        auto request_line_end = input.find("\r\n");
        if (request_line_end == std::string_view::npos) {
            return std::unexpected(parsererror::needmoredata);
        }
        
        auto request_line = input.substr(0, request_line_end);
        auto method_result = parse_method(extract_method(request_line));
        if (!method_result) {
            return std::unexpected(method_result.error());
        }
        
        auto uri_result = extract_uri(request_line);
        if (!uri_result) {
            return std::unexpected(uri_result.error());
        }
        
        auto version_result = parse_version(extract_version(request_line));
        if (!version_result) {
            return std::unexpected(version_result.error());
        }
        
        http::request request(*method_result, std::move(*uri_result), *version_result);
        
        // 解析头部
        auto headers_start = request_line_end + 2;
        auto headers_end = input.find("\r\n\r\n", headers_start);
        if (headers_end == std::string_view::npos) {
            return std::unexpected(parsererror::needmoredata);
        }
        
        auto headers_result = parse_headers(input.substr(headers_start, 
                                                       headers_end - headers_start));
        if (!headers_result) {
            return std::unexpected(headers_result.error());
        }
        
        request.headers() = std::move(*headers_result);
        
        // 解析消息体
        auto body_start = headers_end + 4;
        if (body_start < input.length()) {
            auto body_result = parse_body(input.substr(body_start), request.headers());
            if (!body_result) {
                return std::unexpected(body_result.error());
            }
            request.body() = std::move(*body_result);
        }
        
        return request;
    }
    
private:
    std::expected<http::method, parsererror> 
    parse_method(std::string_view method_str) {
        static const std::unordered_map<std::string_view, http::method> method_map = {
            {"get", http::method::get},
            {"post", http::method::post},
            {"put", http::method::put},
            {"delete", http::method::delete},
            {"head", http::method::head},
            {"options", http::method::options},
            {"patch", http::method::patch}
        };
        
        auto it = method_map.find(method_str);
        if (it != method_map.end()) {
            return it->second;
        }
        return std::unexpected(parsererror::invalidmethod);
    }
    
    std::expected<std::string, parsererror> 
    extract_uri(std::string_view request_line) {
        auto method_end = request_line.find(' ');
        if (method_end == std::string_view::npos) {
            return std::unexpected(parsererror::malformedrequestline);
        }
        
        auto uri_start = method_end + 1;
        auto uri_end = request_line.find(' ', uri_start);
        if (uri_end == std::string_view::npos) {
            return std::unexpected(parsererror::malformedrequestline);
        }
        
        return std::string(request_line.substr(uri_start, uri_end - uri_start));
    }
    
    std::expected<http::headers, parsererror> 
    parse_headers(std::string_view headers_data) {
        http::headers headers;
        size_t start = 0;
        
        while (start < headers_data.length()) {
            auto line_end = headers_data.find("\r\n", start);
            if (line_end == std::string_view::npos) {
                break;
            }
            
            auto line = headers_data.substr(start, line_end - start);
            auto colon_pos = line.find(':');
            if (colon_pos != std::string_view::npos) {
                auto key = line.substr(0, colon_pos);
                auto value = line.substr(colon_pos + 1);
                
                // 去除value前后的空白字符
                value.remove_prefix(std::min(value.find_first_not_of(" \t"), value.size()));
                value.remove_suffix(value.size() - std::min(value.find_last_not_of(" \t") + 1, value.size()));
                
                headers.set(key, value);
            }
            
            start = line_end + 2;
        }
        
        return headers;
    }
    
    std::expected<std::string, parsererror>
    parse_body(std::string_view body_data, const http::headers& headers) {
        // 检查content-length
        if (auto content_length = headers.get("content-length")) {
            size_t expected_size = 0;
            try {
                expected_size = std::stoul(std::string(*content_length));
            } catch (const std::exception&) {
                return std::unexpected(parsererror::invalidencoding);
            }
            
            if (body_data.length() < expected_size) {
                return std::unexpected(parsererror::needmoredata);
            }
            
            if (expected_size > max_request_size) {
                return std::unexpected(parsererror::bodytoolarge);
            }
            
            return std::string(body_data.substr(0, expected_size));
        }
        
        // 检查transfer-encoding: chunked
        if (auto transfer_encoding = headers.get("transfer-encoding")) {
            if (*transfer_encoding == "chunked") {
                return parse_chunked_body(body_data);
            }
        }
        
        // 没有消息体
        return std::string();
    }
    
    std::expected<std::string, parsererror>
    parse_chunked_body(std::string_view chunked_data) {
        std::string body;
        size_t pos = 0;
        
        while (pos < chunked_data.length()) {
            // 解析块大小
            auto line_end = chunked_data.find("\r\n", pos);
            if (line_end == std::string_view::npos) {
                return std::unexpected(parsererror::needmoredata);
            }
            
            auto size_line = chunked_data.substr(pos, line_end - pos);
            size_t chunk_size = 0;
            try {
                chunk_size = std::stoul(std::string(size_line), nullptr, 16);
            } catch (const std::exception&) {
                return std::unexpected(parsererror::invalidencoding);
            }
            
            if (chunk_size == 0) {
                // 最后一个块
                break;
            }
            
            pos = line_end + 2;
            
            // 检查是否有足够的数据
            if (pos + chunk_size + 2 > chunked_data.length()) {
                return std::unexpected(parsererror::needmoredata);
            }
            
            // 添加块数据到消息体
            body.append(chunked_data.data() + pos, chunk_size);
            pos += chunk_size + 2; // 跳过块数据和\r\n
        }
        
        return body;
    }
};

#include <queue>
#include <thread>
#include <future>
#include <atomic>
#include <latch>
#include <barrier>

class threadpool {
private:
    std::vector<std::jthread> workers_;
    moodycamel::concurrentqueue<std::function<void()>> tasks_;
    std::atomic<bool> stop_{false};
    std::mutex queue_mutex_;
    std::condition_variable condition_;
    std::atomic<size_t> active_tasks_{0};
    std::latch shutdown_latch_;
    
public:
    explicit threadpool(size_t num_threads = std::thread::hardware_concurrency())
        : shutdown_latch_(num_threads) {
        
        std::cout << "初始化线程池，线程数: " << num_threads << std::endl;
        workers_.reserve(num_threads);
        
        for (size_t i = 0; i < num_threads; ++i) {
            workers_.emplace_back([this, i] { 
                worker_loop(i); 
            });
        }
        
        // 等待所有线程启动完成
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
        std::cout << "线程池初始化完成" << std::endl;
    }
    
    ~threadpool() {
        shutdown();
    }
    
    void shutdown() {
        if (stop_.exchange(true)) {
            return; // 已经在关闭过程中
        }
        
        std::cout << "开始关闭线程池..." << std::endl;
        
        // 唤醒所有等待的线程
        condition_.notify_all();
        
        // 等待所有线程完成
        shutdown_latch_.wait();
        
        std::cout << "线程池关闭完成" << std::endl;
    }
    
    template<typename f, typename... args>
    auto submit(f&& f, args&&... args) 
        -> std::future<std::invoke_result_t<f, args...>> {
        
        using return_type = std::invoke_result_t<f, args...>;
        
        if (stop_.load()) {
            throw std::runtime_error("向已停止的线程池提交任务");
        }
        
        auto task = std::make_shared<std::packaged_task<return_type()>>(
            [f = std::forward<f>(f), args = std::make_tuple(std::forward<args>(args)...)]() mutable {
                return std::apply(f, std::move(args));
            }
        );
        
        std::future<return_type> result = task->get_future();
        
        // 使用无锁队列提交任务
        tasks_.enqueue([task]() { (*task)(); });
        
        // 通知一个等待的线程
        condition_.notify_one();
        
        return result;
    }
    
    size_t pending_tasks() const {
        return tasks_.size_approx();
    }
    
    size_t active_tasks() const {
        return active_tasks_.load();
    }
    
    size_t total_threads() const {
        return workers_.size();
    }

private:
    void worker_loop(size_t thread_id) {
        std::cout << "工作线程 " << thread_id << " 启动" << std::endl;
        
        // 设置线程名称（平台相关）
        #ifdef __linux__
        std::string thread_name = "worker_" + std::to_string(thread_id);
        pthread_setname_np(pthread_self(), thread_name.c_str());
        #endif
        
        while (!stop_.load(std::memory_order_acquire)) {
            std::function<void()> task;
            
            // 优先从无锁队列获取任务
            if (tasks_.try_dequeue(task)) {
                active_tasks_.fetch_add(1, std::memory_order_relaxed);
                
                try {
                    task();
                } catch (const std::exception& e) {
                    std::cerr << "工作线程 " << thread_id 
                              << " 执行任务时发生异常: " << e.what() << std::endl;
                }
                
                active_tasks_.fetch_sub(1, std::memory_order_relaxed);
                continue;
            }
            
            // 无锁队列为空，使用条件变量等待
            std::unique_lock lock(queue_mutex_);
            condition_.wait_for(lock, std::chrono::milliseconds(100), [this] {
                return stop_.load() || !tasks_.empty();
            });
        }
        
        std::cout << "工作线程 " << thread_id << " 关闭" << std::endl;
        shutdown_latch_.count_down();
    }
};

// 专用的i/o线程池，用于处理网络i/o密集型任务
class iothreadpool {
private:
    std::vector<std::jthread> io_workers_;
    moodycamel::concurrentqueue<std::function<void()>> io_tasks_;
    std::atomic<bool> io_stop_{false};
    
public:
    iothreadpool(size_t num_threads = std::max(1u, std::thread::hardware_concurrency() / 2))
        : io_workers_(num_threads) {
        
        for (size_t i = 0; i < num_threads; ++i) {
            io_workers_[i] = std::jthread([this, i] {
                io_worker_loop(i);
            });
        }
    }
    
    ~iothreadpool() {
        io_stop_.store(true);
        // jthread 会自动 join
    }
    
    template<typename f>
    void submit_io_task(f&& task) {
        io_tasks_.enqueue(std::forward<f>(task));
    }

private:
    void io_worker_loop(size_t thread_id) {
        #ifdef __linux__
        std::string thread_name = "io_worker_" + std::to_string(thread_id);
        pthread_setname_np(pthread_self(), thread_name.c_str());
        #endif
        
        while (!io_stop_.load()) {
            std::function<void()> task;
            if (io_tasks_.try_dequeue(task)) {
                try {
                    task();
                } catch (const std::exception& e) {
                    std::cerr << "i/o工作线程 " << thread_id 
                              << " 执行任务时发生异常: " << e.what() << std::endl;
                }
            } else {
                std::this_thread::yield();
            }
        }
    }
};

#include <sys/epoll.h>
#include <unistd.h>

class epoll {
private:
    int epoll_fd_;
    std::vector<epoll_event> events_;
    std::unordered_map<int, std::function<void(uint32_t)>> callbacks_;
    std::mutex callback_mutex_;
    
public:
    epoll(size_t max_events = 1024) 
        : epoll_fd_(epoll_create1(0))
        , events_(max_events) {
        
        if (epoll_fd_ == -1) {
            throw std::system_error(errno, std::system_category(), "epoll_create1失败");
        }
        
        std::cout << "epoll初始化完成，最大事件数: " << max_events << std::endl;
    }
    
    ~epoll() {
        if (epoll_fd_ != -1) {
            close(epoll_fd_);
        }
    }
    
    // 删除拷贝操作
    epoll(const epoll&) = delete;
    epoll& operator=(const epoll&) = delete;
    
    // 允许移动
    epoll(epoll&& other) noexcept 
        : epoll_fd_(std::exchange(other.epoll_fd_, -1))
        , events_(std::move(other.events_))
        , callbacks_(std::move(other.callbacks_)) {}
    
    epoll& operator=(epoll&& other) noexcept {
        if (this != &other) {
            if (epoll_fd_ != -1) {
                close(epoll_fd_);
            }
            epoll_fd_ = std::exchange(other.epoll_fd_, -1);
            events_ = std::move(other.events_);
            callbacks_ = std::move(other.callbacks_);
        }
        return *this;
    }
    
    void add(int fd, uint32_t events, std::function<void(uint32_t)> callback) {
        epoll_event ev;
        ev.events = events;
        ev.data.fd = fd;
        
        if (epoll_ctl(epoll_fd_, epoll_ctl_add, fd, &ev) == -1) {
            throw std::system_error(errno, std::system_category(), 
                                  "epoll_ctl add失败");
        }
        
        std::lock_guard lock(callback_mutex_);
        callbacks_[fd] = std::move(callback);
        
        std::cout << "添加fd到epoll: " << fd << ", 事件: " << events << std::endl;
    }
    
    void modify(int fd, uint32_t events) {
        epoll_event ev;
        ev.events = events;
        ev.data.fd = fd;
        
        if (epoll_ctl(epoll_fd_, epoll_ctl_mod, fd, &ev) == -1) {
            throw std::system_error(errno, std::system_category(), 
                                  "epoll_ctl mod失败");
        }
        
        std::cout << "修改epoll事件: fd=" << fd << ", 新事件=" << events << std::endl;
    }
    
    void remove(int fd) {
        if (epoll_ctl(epoll_fd_, epoll_ctl_del, fd, nullptr) == -1) {
            // 如果fd已经关闭，忽略错误
            if (errno != ebadf) {
                std::cerr << "epoll_ctl del失败，fd: " << fd 
                          << ", 错误: " << strerror(errno) << std::endl;
            }
        }
        
        std::lock_guard lock(callback_mutex_);
        callbacks_.erase(fd);
        
        std::cout << "从epoll移除fd: " << fd << std::endl;
    }
    
    int wait(int timeout_ms = -1) {
        int num_events = epoll_wait(epoll_fd_, events_.data(), 
                                  static_cast<int>(events_.size()), timeout_ms);
        
        if (num_events == -1) {
            if (errno != eintr) {
                throw std::system_error(errno, std::system_category(), 
                                      "epoll_wait失败");
            }
            return 0; // 被信号中断
        }
        
        // 处理就绪的事件
        for (int i = 0; i < num_events; ++i) {
            int fd = events_[i].data.fd;
            uint32_t events = events_[i].events;
            
            std::function<void(uint32_t)> callback;
            {
                std::lock_guard lock(callback_mutex_);
                auto it = callbacks_.find(fd);
                if (it != callbacks_.end()) {
                    callback = it->second;
                }
            }
            
            if (callback) {
                try {
                    callback(events);
                } catch (const std::exception& e) {
                    std::cerr << "处理epoll事件时发生异常，fd: " << fd 
                              << ", 错误: " << e.what() << std::endl;
                }
            }
        }
        
        return num_events;
    }
};

class eventloop {
private:
    std::unique_ptr<epoll> epoll_;
    std::atomic<bool> running_{false};
    std::jthread event_thread_;
    std::chrono::steady_clock::time_point last_stats_time_;
    std::atomic<uint64_t> total_events_processed_{0};
    
    // 定时器支持
    struct timer {
        std::chrono::steady_clock::time_point expiry;
        std::function<void()> callback;
        bool repeated;
        std::chrono::milliseconds interval;
        
        bool operator<(const timer& other) const {
            return expiry > other.expiry; // 最小堆
        }
    };
    
    std::priority_queue<timer> timers_;
    std::mutex timer_mutex_;
    
public:
    eventloop() 
        : epoll_(std::make_unique<epoll>())
        , last_stats_time_(std::chrono::steady_clock::now()) {}
    
    void run() {
        running_.store(true, std::memory_order_release);
        
        event_thread_ = std::jthread([this](std::stop_token st) {
            event_loop(st);
        });
        
        std::cout << "事件循环启动" << std::endl;
    }
    
    void stop() {
        running_.store(false, std::memory_order_release);
        if (event_thread_.joinable()) {
            event_thread_.request_stop();
        }
    }
    
    void add_socket(int fd, uint32_t events, std::function<void(uint32_t)> callback) {
        epoll_->add(fd, events, std::move(callback));
    }
    
    void modify_socket(int fd, uint32_t events) {
        epoll_->modify(fd, events);
    }
    
    void remove_socket(int fd) {
        epoll_->remove(fd);
    }
    
    // 添加定时器
    void add_timer(std::chrono::milliseconds delay, 
                   std::function<void()> callback,
                   bool repeated = false) {
        auto expiry = std::chrono::steady_clock::now() + delay;
        
        std::lock_guard lock(timer_mutex_);
        timers_.push(timer{expiry, std::move(callback), repeated, delay});
    }
    
    uint64_t events_processed() const {
        return total_events_processed_.load();
    }

private:
    void event_loop(std::stop_token st) {
        #ifdef __linux__
        pthread_setname_np(pthread_self(), "event_loop");
        #endif
        
        std::cout << "事件循环线程启动" << std::endl;
        
        while (!st.stop_requested() && running_.load(std::memory_order_acquire)) {
            // 计算下一个定时器到期时间
            int timeout_ms = calculate_timeout();
            
            // 等待事件
            int num_events = epoll_->wait(timeout_ms);
            total_events_processed_.fetch_add(num_events, std::memory_order_relaxed);
            
            // 处理到期定时器
            process_timers();
            
            // 定期输出统计信息
            output_stats();
        }
        
        std::cout << "事件循环线程结束" << std::endl;
    }
    
    int calculate_timeout() {
        std::lock_guard lock(timer_mutex_);
        if (timers_.empty()) {
            return 100; // 100ms超时，避免忙等待
        }
        
        auto now = std::chrono::steady_clock::now();
        auto next_timer = timers_.top().expiry;
        
        if (next_timer <= now) {
            return 0; // 立即返回，处理到期定时器
        }
        
        auto timeout = std::chrono::duration_cast<std::chrono::milliseconds>(
            next_timer - now);
        return static_cast<int>(timeout.count());
    }
    
    void process_timers() {
        auto now = std::chrono::steady_clock::now();
        std::vector<timer> expired_timers;
        
        {
            std::lock_guard lock(timer_mutex_);
            while (!timers_.empty() && timers_.top().expiry <= now) {
                expired_timers.push_back(std::move(const_cast<timer&>(timers_.top())));
                timers_.pop();
            }
        }
        
        // 执行定时器回调
        for (auto& timer : expired_timers) {
            try {
                timer.callback();
            } catch (const std::exception& e) {
                std::cerr << "定时器回调异常: " << e.what() << std::endl;
            }
            
            // 如果是重复定时器，重新添加
            if (timer.repeated) {
                add_timer(timer.interval, std::move(timer.callback), true);
            }
        }
    }
    
    void output_stats() {
        auto now = std::chrono::steady_clock::now();
        if (now - last_stats_time_ > std::chrono::seconds(10)) {
            std::cout << "事件循环统计 - 处理事件总数: " 
                      << total_events_processed_.load() << std::endl;
            last_stats_time_ = now;
        }
    }
};

// 全局事件循环实例
class globaleventloop {
private:
    static std::unique_ptr<eventloop> instance_;
    static std::once_flag init_flag_;
    
public:
    static eventloop& instance() {
        std::call_once(init_flag_, []() {
            instance_ = std::make_unique<eventloop>();
            instance_->run();
        });
        return *instance_;
    }
    
    static void shutdown() {
        if (instance_) {
            instance_->stop();
            instance_.reset();
        }
    }
};

std::unique_ptr<eventloop> globaleventloop::instance_ = nullptr;
std::once_flag globaleventloop::init_flag_;

class requestparser {
private:
    enum class state {
        start,
        headers,
        body,
        complete,
        error
    };
    
    state state_ = state::start;
    size_t content_length_ = 0;
    bool chunked_encoding_ = false;
    std::string current_chunk_size_;
    
public:
    std::expected<http::request, parseerror> parse(std::string_view data) {
        if (state_ == state::error) {
            return std::unexpected(parseerror::invalidformat);
        }
        
        http::request request;
        size_t bytes_consumed = 0;
        
        try {
            if (state_ == state::start) {
                auto result = parse_request_line(data, request);
                if (!result) {
                    state_ = state::error;
                    return std::unexpected(result.error());
                }
                bytes_consumed += result.value();
            }
            
            if (state_ == state::start || state_ == state::headers) {
                auto headers_data = data.substr(bytes_consumed);
                auto result = parse_headers(headers_data, request);
                if (result.has_value()) {
                    bytes_consumed += result.value();
                    state_ = state::body;
                    
                    // 检查是否需要解析消息体
                    auto content_length = request.headers().get("content-length");
                    if (content_length) {
                        content_length_ = std::stoul(std::string(*content_length));
                    }
                    
                    auto transfer_encoding = request.headers().get("transfer-encoding");
                    if (transfer_encoding && *transfer_encoding == "chunked") {
                        chunked_encoding_ = true;
                    }
                } else if (result.error() == parseerror::needmoredata) {
                    return std::unexpected(parseerror::needmoredata);
                } else {
                    state_ = state::error;
                    return std::unexpected(result.error());
                }
            }
            
            if (state_ == state::body) {
                auto body_data = data.substr(bytes_consumed);
                auto result = parse_body(body_data, request);
                if (result.has_value()) {
                    bytes_consumed += result.value();
                    state_ = state::complete;
                } else if (result.error() == parseerror::needmoredata) {
                    return std::unexpected(parseerror::needmoredata);
                } else {
                    state_ = state::error;
                    return std::unexpected(result.error());
                }
            }
            
        } catch (const std::exception& e) {
            state_ = state::error;
            return std::unexpected(parseerror::invalidformat);
        }
        
        if (state_ == state::complete) {
            state_ = state::start; // 重置状态以解析下一个请求
            return request;
        }
        
        return std::unexpected(parseerror::needmoredata);
    }
    
    void reset() {
        state_ = state::start;
        content_length_ = 0;
        chunked_encoding_ = false;
        current_chunk_size_.clear();
    }

private:
    std::expected<size_t, parseerror> 
    parse_request_line(std::string_view data, http::request& request) {
        auto line_end = data.find("\r\n");
        if (line_end == std::string_view::npos) {
            return std::unexpected(parseerror::needmoredata);
        }
        
        auto request_line = data.substr(0, line_end);
        
        // 解析方法
        auto method_end = request_line.find(' ');
        if (method_end == std::string_view::npos) {
            return std::unexpected(parseerror::malformedrequestline);
        }
        
        auto method_str = request_line.substr(0, method_end);
        auto method = parse_method(method_str);
        if (!method) {
            return std::unexpected(method.error());
        }
        
        // 解析uri
        auto uri_start = method_end + 1;
        auto uri_end = request_line.find(' ', uri_start);
        if (uri_end == std::string_view::npos) {
            return std::unexpected(parseerror::malformedrequestline);
        }
        
        auto uri = request_line.substr(uri_start, uri_end - uri_start);
        
        // 解析版本
        auto version_start = uri_end + 1;
        auto version_str = request_line.substr(version_start);
        auto version = parse_version(version_str);
        if (!version) {
            return std::unexpected(version.error());
        }
        
        request.set_method(*method);
        request.set_uri(std::string(uri));
        request.set_version(*version);
        
        return line_end + 2; // 返回消耗的字节数
    }
    
    std::expected<size_t, parseerror>
    parse_headers(std::string_view data, http::request& request) {
        size_t bytes_consumed = 0;
        
        while (bytes_consumed < data.length()) {
            auto line_end = data.find("\r\n", bytes_consumed);
            if (line_end == std::string_view::npos) {
                return std::unexpected(parseerror::needmoredata);
            }
            
            // 空行表示头部结束
            if (line_end == bytes_consumed) {
                return bytes_consumed + 2; // 消耗空行
            }
            
            auto line = data.substr(bytes_consumed, line_end - bytes_consumed);
            
            auto colon_pos = line.find(':');
            if (colon_pos == std::string_view::npos) {
                return std::unexpected(parseerror::malformedheaders);
            }
            
            auto key = line.substr(0, colon_pos);
            auto value = line.substr(colon_pos + 1);
            
            // 去除value前后的空白字符
            value.remove_prefix(std::min(value.find_first_not_of(" \t"), value.size()));
            value.remove_suffix(value.size() - std::min(value.find_last_not_of(" \t") + 1, value.size()));
            
            request.headers().set(key, value);
            
            bytes_consumed = line_end + 2;
        }
        
        return std::unexpected(parseerror::needmoredata);
    }
    
    std::expected<size_t, parseerror>
    parse_body(std::string_view data, http::request& request) {
        if (chunked_encoding_) {
            return parse_chunked_body(data, request);
        } else if (content_length_ > 0) {
            return parse_content_length_body(data, request);
        } else {
            // 没有消息体
            request.set_body("");
            return 0;
        }
    }
    
    std::expected<size_t, parseerror>
    parse_content_length_body(std::string_view data, http::request& request) {
        if (data.length() < content_length_) {
            return std::unexpected(parseerror::needmoredata);
        }
        
        request.set_body(std::string(data.substr(0, content_length_)));
        return content_length_;
    }
    
    std::expected<size_t, parseerror>
    parse_chunked_body(std::string_view data, http::request& request) {
        std::string body;
        size_t pos = 0;
        
        while (pos < data.length()) {
            // 如果正在解析块大小
            if (current_chunk_size_.empty()) {
                auto line_end = data.find("\r\n", pos);
                if (line_end == std::string_view::npos) {
                    return std::unexpected(parseerror::needmoredata);
                }
                
                auto size_line = data.substr(pos, line_end - pos);
                current_chunk_size_ = std::string(size_line);
                
                pos = line_end + 2;
            }
            
            // 解析当前块的大小
            size_t chunk_size = 0;
            try {
                chunk_size = std::stoul(current_chunk_size_, nullptr, 16);
            } catch (const std::exception&) {
                return std::unexpected(parseerror::invalidencoding);
            }
            
            if (chunk_size == 0) {
                // 最后一个块，跳过尾部头部
                auto trailer_end = data.find("\r\n\r\n", pos);
                if (trailer_end == std::string_view::npos) {
                    return std::unexpected(parseerror::needmoredata);
                }
                
                request.set_body(std::move(body));
                return trailer_end + 4;
            }
            
            // 检查是否有足够的块数据
            if (pos + chunk_size + 2 > data.length()) {
                return std::unexpected(parseerror::needmoredata);
            }
            
            // 添加块数据
            body.append(data.data() + pos, chunk_size);
            pos += chunk_size + 2; // 跳过块数据和\r\n
            current_chunk_size_.clear();
        }
        
        return std::unexpected(parseerror::needmoredata);
    }
    
    // 辅助方法
    std::expected<http::method, parseerror> parse_method(std::string_view method_str) {
        static const std::unordered_map<std::string_view, http::method> methods = {
            {"get", http::method::get}, {"post", http::method::post},
            {"put", http::method::put}, {"delete", http::method::delete},
            {"head", http::method::head}, {"options", http::method::options},
            {"patch", http::method::patch}
        };
        
        auto it = methods.find(method_str);
        if (it != methods.end()) {
            return it->second;
        }
        return std::unexpected(parseerror::invalidmethod);
    }
    
    std::expected<http::version, parseerror> parse_version(std::string_view version_str) {
        if (version_str == "http/1.0") return http::version::http1_0;
        if (version_str == "http/1.1") return http::version::http1_1;
        if (version_str == "http/2.0") return http::version::http2_0;
        return std::unexpected(parseerror::invalidversion);
    }
};

class router {
private:
    using handler = std::function<http::response(const http::request&)>;
    using middleware = std::function<void(const http::request&, http::response&)>;
    
    struct route {
        std::regex pattern;
        handler handler;
        http::method method;
        std::string description;
    };
    
    std::vector<route> routes_;
    std::vector<middleware> middlewares_;
    std::unordered_map<std::string, std::string> static_files_;
    
public:
    router() {
        setup_default_routes();
    }
    
    void add_middleware(middleware middleware) {
        middlewares_.push_back(std::move(middleware));
    }
    
    template<typename handler>
    void add_route(http::method method, std::string pattern, 
                   handler&& handler, std::string description = "") {
        routes_.push_back({
            std::regex(std::move(pattern)),
            std::forward<handler>(handler),
            method,
            std::move(description)
        });
        
        std::cout << "注册路由: " << to_string(method) << " " 
                  << pattern << " - " << description << std::endl;
    }
    
    void add_static_file(std::string url_path, std::string file_path) {
        static_files_[std::move(url_path)] = std::move(file_path);
    }
    
    std::optional<http::response> route(const http::request& request) {
        // 首先检查静态文件
        if (request.method() == http::method::get) {
            auto static_response = try_serve_static(request);
            if (static_response) {
                return apply_middlewares(request, std::move(*static_response));
            }
        }
        
        // 然后检查动态路由
        for (const auto& route : routes_) {
            if (route.method != request.method()) {
                continue;
            }
            
            std::smatch match;
            if (std::regex_match(request.uri(), match, route.pattern)) {
                auto response = route.handler(request);
                return apply_middlewares(request, std::move(response));
            }
        }
        
        // 没有匹配的路由
        return std::nullopt;
    }
    
    void print_routes() const {
        std::cout << "\n=== 注册的路由 ===" << std::endl;
        for (const auto& route : routes_) {
            std::cout << to_string(route.method) << " " 
                      << route.pattern.str() << " - " 
                      << route.description << std::endl;
        }
        std::cout << "==================\n" << std::endl;
    }

private:
    void setup_default_routes() {
        // 健康检查端点
        add_route(http::method::get, "/health", 
            [](const http::request&) {
                return http::response::text_response("ok");
            }, "健康检查");
        
        // 接口信息端点
        add_route(http::method::get, "/api/info", 
            [this](const http::request&) {
                nlohmann::json info = {
                    {"server", "modern c++ http server"},
                    {"version", "1.0.0"},
                    {"routes", routes_.size()},
                    {"timestamp", std::time(nullptr)}
                };
                return http::response::json_response(info.dump());
            }, "服务器信息");
        
        // 404处理
        add_route(http::method::get, ".*", 
            [](const http::request& req) {
                return http::response::error_response(
                    http::statuscode::notfound,
                    "未找到路径: " + req.uri()
                );
            }, "默认404处理");
    }
    
    std::optional<http::response> try_serve_static(const http::request& request) {
        auto it = static_files_.find(request.uri());
        if (it != static_files_.end()) {
            return serve_file(it->second);
        }
        
        // 检查静态文件目录
        if (request.uri().starts_with("/static/")) {
            std::string file_path = "static" + request.uri().substr(7);
            return serve_file(file_path);
        }
        
        return std::nullopt;
    }
    
    http::response serve_file(const std::string& file_path) {
        std::ifstream file(file_path, std::ios::binary);
        if (!file) {
            return http::response::error_response(
                http::statuscode::notfound,
                "文件未找到: " + file_path
            );
        }
        
        std::string content((std::istreambuf_iterator<char>(file)),
                           std::istreambuf_iterator<char>());
        
        http::response response(http::statuscode::ok);
        response.set_body(std::move(content));
        
        // 设置content-type
        auto ext_pos = file_path.find_last_of('.');
        if (ext_pos != std::string::npos) {
            auto ext = file_path.substr(ext_pos + 1);
            response.headers().set("content-type", get_mime_type(ext));
        }
        
        return response;
    }
    
    std::string get_mime_type(const std::string& extension) {
        static const std::unordered_map<std::string, std::string> mime_types = {
            {"html", "text/html"},
            {"css", "text/css"},
            {"js", "application/javascript"},
            {"json", "application/json"},
            {"png", "image/png"},
            {"jpg", "image/jpeg"},
            {"jpeg", "image/jpeg"},
            {"gif", "image/gif"},
            {"txt", "text/plain"}
        };
        
        auto it = mime_types.find(extension);
        return it != mime_types.end() ? it->second : "application/octet-stream";
    }
    
    http::response apply_middlewares(const http::request& request, 
                                   http::response response) {
        for (const auto& middleware : middlewares_) {
            middleware(request, response);
        }
        return response;
    }
    
    std::string to_string(http::method method) const {
        switch (method) {
            case http::method::get: return "get";
            case http::method::post: return "post";
            case http::method::put: return "put";
            case http::method::delete: return "delete";
            case http::method::head: return "head";
            case http::method::options: return "options";
            case http::method::patch: return "patch";
            default: return "unknown";
        }
    }
};

// 便捷的路由构建器
class routebuilder {
private:
    router& router_;
    
public:
    explicit routebuilder(router& router) : router_(router) {}
    
    routebuilder& get(std::string pattern, router::handler handler, 
                     std::string description = "") {
        router_.add_route(http::method::get, std::move(pattern), 
                         std::move(handler), std::move(description));
        return *this;
    }
    
    routebuilder& post(std::string pattern, router::handler handler,
                      std::string description = "") {
        router_.add_route(http::method::post, std::move(pattern), 
                         std::move(handler), std::move(description));
        return *this;
    }
    
    routebuilder& put(std::string pattern, router::handler handler,
                     std::string description = "") {
        router_.add_route(http::method::put, std::move(pattern), 
                         std::move(handler), std::move(description));
        return *this;
    }
    
    routebuilder& del(std::string pattern, router::handler handler,
                     std::string description = "") {
        router_.add_route(http::method::delete, std::move(pattern), 
                         std::move(handler), std::move(description));
        return *this;
    }
};

// 使用示例
void setup_advanced_routes(router& router) {
    routebuilder builder(router);
    
    // restful api 示例
    builder.get("/api/users", 
        [](const http::request& req) {
        // 获取用户列表
nlohmann::json users = {
{"users", {
{{"id", 1}, {"name", "alice"}, {"email", "alice@example.com"}},
{{"id", 2}, {"name", "bob"}, {"email", "bob@example.com"}},
{{"id", 3}, {"name", "charlie"}, {"email", "charlie@example.com"}}
}},
{"total", 3},
{"page", 1}
};
return http::response::json_response(users.dump());
}, "获取用户列表")
 .get("/api/users/(\\d+)", 
    [](const http::request& req) {
        // 提取用户id
        std::smatch match;
        if (std::regex_match(req.uri(), match, std::regex("/api/users/(\\d+)"))) {
            int user_id = std::stoi(match[1]);
            nlohmann::json user = {
                {"id", user_id},
                {"name", "user " + std::to_string(user_id)},
                {"email", "user" + std::to_string(user_id) + "@example.com"}
            };
            return http::response::json_response(user.dump());
        }
        return http::response::error_response(http::statuscode::badrequest, "无效的用户id");
    }, "获取用户详情")
    
 .post("/api/users", 
    [](const http::request& req) {
        try {
            auto body = nlohmann::json::parse(req.body());
            std::string name = body.value("name", "");
            std::string email = body.value("email", "");
            
            if (name.empty() || email.empty()) {
                return http::response::error_response(
                    http::statuscode::badrequest, 
                    "姓名和邮箱不能为空"
                );
            }
            
            nlohmann::json response = {
                {"id", 100}, // 模拟新用户id
                {"name", name},
                {"email", email},
                {"message", "用户创建成功"}
            };
            
            auto resp = http::response::json_response(response.dump());
            resp.set_status_code(http::statuscode::created);
            return resp;
            
        } catch (const nlohmann::json::exception& e) {
            return http::response::error_response(
                http::statuscode::badrequest,
                "无效的json格式: " + std::string(e.what())
            );
        }
    }, "创建用户")
    
 .put("/api/users/(\\d+)", 
    [](const http::request& req) {
        std::smatch match;
        if (std::regex_match(req.uri(), match, std::regex("/api/users/(\\d+)"))) {
            int user_id = std::stoi(match[1]);
            
            try {
                auto body = nlohmann::json::parse(req.body());
                nlohmann::json response = {
                    {"id", user_id},
                    {"name", body.value("name", "updated user")},
                    {"email", body.value("email", "updated@example.com")},
                    {"message", "用户更新成功"}
                };
                return http::response::json_response(response.dump());
                
            } catch (const nlohmann::json::exception& e) {
                return http::response::error_response(
                    http::statuscode::badrequest,
                    "无效的json格式"
                );
            }
        }
        return http::response::error_response(http::statuscode::badrequest, "无效的用户id");
    }, "更新用户")
    
 .del("/api/users/(\\d+)", 
    [](const http::request& req) {
        std::smatch match;
        if (std::regex_match(req.uri(), match, std::regex("/api/users/(\\d+)"))) {
            int user_id = std::stoi(match[1]);
            nlohmann::json response = {
                {"message", "用户 " + std::to_string(user_id) + " 已删除"}
            };
            return http::response::json_response(response.dump());
        }
        return http::response::error_response(http::statuscode::badrequest, "无效的用户id");
    }, "删除用户");
    // 中间件示例
void setup_middlewares(router& router) {
// 日志中间件
router.add_middleware([](const http::request& req, http::response& resp) {
auto timestamp = std::chrono::system_clock::now();
std::time_t time = std::chrono::system_clock::to_time_t(timestamp);


    std::cout << "[" << std::ctime(&time) 
              << "] " << to_string(req.method()) << " " << req.uri()
              << " -> " << static_cast<int>(resp.status_code()) 
              << " " << resp.body().size() << " bytes" << std::endl;
});

// cors 中间件
router.add_middleware([](const http::request& req, http::response& resp) {
    resp.headers().set("access-control-allow-origin", "*");
    resp.headers().set("access-control-allow-methods", "get, post, put, delete, options");
    resp.headers().set("access-control-allow-headers", "content-type, authorization");
});

// 安全头部中间件
router.add_middleware([](const http::request& req, http::response& resp) {
    resp.headers().set("x-content-type-options", "nosniff");
    resp.headers().set("x-frame-options", "deny");
    resp.headers().set("x-xss-protection", "1; mode=block");
});
}

// 编译时路由检查概念
template<typename t>
concept requesthandler = requires(t handler, const http::request& req) {
    { handler(req) } -> std::convertible_to<http::response>;
    requires std::is_nothrow_move_constructible_v<t>;
};

// 编译时路由表
template<size_t maxroutes = 64>
class compiletimerouter {
private:
    struct route {
        std::string_view pattern;
        http::method method;
        std::function<http::response(const http::request&)> handler;
        std::string_view description;
    };
    
    std::array<route, maxroutes> routes_{};
    size_t route_count_{0};
    
public:
    // 编译时路由注册
    template<requesthandler handler>
    consteval void add_route(std::string_view pattern, 
                           http::method method, 
                           handler&& handler,
                           std::string_view description = "") {
        static_assert(route_count_ < maxroutes, "路由数量超过限制");
        
        routes_[route_count_] = route{
            pattern,
            method,
            std::function<http::response(const http::request&)>(std::forward<handler>(handler)),
            description
        };
        route_count_++;
    }
    
    // 运行时路由查找
    auto find_handler(const http::request& request) const 
        -> std::optional<std::function<http::response(const http::request&)>> {
        
        for (size_t i = 0; i < route_count_; ++i) {
            const auto& route = routes_[i];
            if (route.method == request.method()) {
                std::regex pattern(route.pattern.data(), route.pattern.length());
                if (std::regex_match(request.uri(), pattern)) {
                    return route.handler;
                }
            }
        }
        return std::nullopt;
    }
    
    constexpr size_t size() const { return route_count_; }
    
    // 编译时路由信息输出
    constexpr void print_routes() const {
        std::cout << "\n=== 编译时路由表 ===" << std::endl;
        for (size_t i = 0; i < route_count_; ++i) {
            const auto& route = routes_[i];
            std::cout << to_string(route.method) << " " 
                      << route.pattern << " - " 
                      << route.description << std::endl;
        }
        std::cout << "====================\n" << std::endl;
    }
};

// 编译时路由构建器
template<size_t n>
consteval auto create_router() {
    compiletimerouter<n> router;
    
    // 编译时注册路由
    router.add_route("/api/health", http::method::get,
        [](const http::request&) -> http::response {
            return http::response::text_response("ok");
        }, "健康检查");
    
    router.add_route("/api/version", http::method::get,
        [](const http::request&) -> http::response {
            nlohmann::json version_info = {
                {"name", "modern c++ http server"},
                {"version", "2.0.0"},
                {"compiler", __version__},
                {"standard", __cplusplus}
            };
            return http::response::json_response(version_info.dump());
        }, "版本信息");
    
    return router;
}

// 使用编译时常量路由表
constexpr auto global_router = create_router<32>();

// 线程安全的对象池
template<typename t, size_t growthsize = 64>
class objectpool {
private:
    struct pooledobject {
        t object;
        bool in_use = false;
    };
    
    std::vector<std::unique_ptr<pooledobject>> pool_;
    std::stack<pooledobject*> available_;
    std::mutex mutex_;
    std::atomic<size_t> total_objects_{0};
    std::atomic<size_t> active_objects_{0};
    
public:
    template<typename... args>
    objectpool(size_t initial_size = 32, args&&... args) {
        expand(initial_size, std::forward<args>(args)...);
        std::cout << "对象池初始化: " << initial_size << " 个对象" << std::endl;
    }
    
    ~objectpool() {
        std::lock_guard lock(mutex_);
        std::cout << "对象池销毁 - 总对象: " << total_objects_
                  << ", 活跃对象: " << active_objects_ << std::endl;
    }
    
    // 获取对象
    template<typename... args>
    auto acquire(args&&... args) -> std::unique_ptr<t, std::function<void(t*)>> {
        std::lock_guard lock(mutex_);
        
        if (available_.empty()) {
            expand(growthsize, std::forward<args>(args)...);
        }
        
        auto* pooled_obj = available_.top();
        available_.pop();
        
        pooled_obj->in_use = true;
        active_objects_.fetch_add(1, std::memory_order_relaxed);
        
        // 自定义删除器，将对象返回到池中
        auto deleter = [this](t* obj) {
            this->release(obj);
        };
        
        return std::unique_ptr<t, std::function<void(t*)>>(
            &pooled_obj->object, std::move(deleter));
    }
    
    size_t total_objects() const { return total_objects_.load(); }
    size_t active_objects() const { return active_objects_.load(); }
    size_t available_objects() const { 
        std::lock_guard lock(mutex_);
        return available_.size(); 
    }

private:
    template<typename... args>
    void expand(size_t count, args&&... args) {
        for (size_t i = 0; i < count; ++i) {
            auto pooled_obj = std::make_unique<pooledobject>();
            // 原位构造对象
            new (&pooled_obj->object) t(std::forward<args>(args)...);
            
            available_.push(pooled_obj.get());
            pool_.push_back(std::move(pooled_obj));
        }
        total_objects_.fetch_add(count, std::memory_order_relaxed);
        
        std::cout << "对象池扩容: +" << count 
                  << " 对象，总计: " << total_objects_ << std::endl;
    }
    
    void release(t* obj) {
        std::lock_guard lock(mutex_);
        
        // 找到对应的pooledobject
        for (auto& pooled_obj : pool_) {
            if (&pooled_obj->object == obj) {
                pooled_obj->in_use = false;
                available_.push(pooled_obj.get());
                active_objects_.fetch_sub(1, std::memory_order_relaxed);
                break;
            }
        }
    }
};

// 连接专用的对象池
class connectionpool {
private:
    objectpool<connection> pool_;
    
public:
    connectionpool(size_t initial_size = 1000)
        : pool_(initial_size) {}
    
    auto create_connection(std::unique_ptr<socket> socket) {
        return pool_.acquire(std::move(socket));
    }
    
    void print_stats() const {
        std::cout << "连接池统计 - 总数: " << pool_.total_objects()
                  << ", 活跃: " << pool_.active_objects()
                  << ", 可用: " << pool_.available_objects() << std::endl;
    }
};

// 缓冲池，用于管理读/写缓冲区
class bufferpool {
private:
    static constexpr size_t buffer_size = 8192;
    objectpool<std::array<char, buffer_size>> pool_;
    
public:
    bufferpool(size_t initial_size = 500) : pool_(initial_size) {}
    
    auto acquire_buffer() {
        return pool_.acquire();
    }
    
    size_t buffer_size() const { return buffer_size; }
};

// 在http服务器中使用对象池
class highperformancehttpserver {
private:
    connectionpool connection_pool_;
    bufferpool buffer_pool_;
    threadpool thread_pool_;
    router router_;
    
    // 统计信息
    std::atomic<uint64_t> total_requests_{0};
    std::atomic<uint64_t> active_connections_{0};
    std::chrono::steady_clock::time_point start_time_;
    
public:
    highperformancehttpserver()
        : connection_pool_(1000)
        , buffer_pool_(500)
        , thread_pool_()
        , start_time_(std::chrono::steady_clock::now()) {
        
        setup_routes();
        setup_middlewares(router_);
        
        std::cout << "高性能http服务器初始化完成" << std::endl;
        print_stats(); // 初始统计
    }
    
    void handle_new_connection(std::unique_ptr<socket> socket) {
        auto connection = connection_pool_.create_connection(std::move(socket));
        auto buffer = buffer_pool_.acquire_buffer();
        
        active_connections_.fetch_add(1, std::memory_order_relaxed);
        
        // 在线程池中处理连接
        thread_pool_.submit([this, conn = std::move(connection), 
                            buf = std::move(buffer)]() mutable {
            process_connection(std::move(conn), std::move(buf));
        });
    }
    
    void print_stats() const {
        auto now = std::chrono::steady_clock::now();
        auto uptime = std::chrono::duration_cast<std::chrono::seconds>(now - start_time_);
        
        std::cout << "\n=== 服务器统计 ===" << std::endl;
        std::cout << "运行时间: " << uptime.count() << " 秒" << std::endl;
        std::cout << "总请求数: " << total_requests_.load() << std::endl;
        std::cout << "活跃连接: " << active_connections_.load() << std::endl;
        std::cout << "请求速率: " << (total_requests_.load() / std::max(uptime.count(), 1ll)) 
                  << " 请求/秒" << std::endl;
        
        connection_pool_.print_stats();
        std::cout << "==================\n" << std::endl;
    }

private:
    void setup_routes() {
        setup_advanced_routes(router_);
        
        // 性能监控端点
        router_.add_route(http::method::get, "/api/stats", 
            [this](const http::request&) {
                auto now = std::chrono::steady_clock::now();
                auto uptime = std::chrono::duration_cast<std::chrono::seconds>(now - start_time_);
                
                nlohmann::json stats = {
                    {"uptime", uptime.count()},
                    {"total_requests", total_requests_.load()},
                    {"active_connections", active_connections_.load()},
                    {"request_rate", total_requests_.load() / std::max(uptime.count(), 1ll)},
                    {"connection_pool", {
                        {"total", connection_pool_.total_objects()},
                        {"active", connection_pool_.active_objects()},
                        {"available", connection_pool_.available_objects()}
                    }},
                    {"thread_pool", {
                        {"threads", thread_pool_.total_threads()},
                        {"active_tasks", thread_pool_.active_tasks()},
                        {"pending_tasks", thread_pool_.pending_tasks()}
                    }}
                };
                return http::response::json_response(stats.dump());
            }, "服务器统计信息");
    }
    
    void process_connection(std::unique_ptr<connection, 
                          std::function<void(connection*)>> conn,
                          std::unique_ptr<std::array<char, 8192>, 
                          std::function<void(std::array<char, 8192>*)>> buffer) {
        
        // 连接处理逻辑
        try {
            conn->start();
            total_requests_.fetch_add(1, std::memory_order_relaxed);
        } catch (const std::exception& e) {
            std::cerr << "处理连接时发生错误: " << e.what() << std::endl;
        }
        
        active_connections_.fetch_sub(1, std::memory_order_relaxed);
        
        // 定期打印统计信息
        if (total_requests_.load() % 1000 == 0) {
            print_stats();
        }
    }
};

// 测试配置文件
struct testconfig {
    std::string host = "127.0.0.1";
    uint16_t port = 8080;
    int test_duration_seconds = 30;
    int concurrent_clients = 100;
    size_t request_size = 1024;
};

// 基础测试夹具
class httpservertest : public ::testing::test {
protected:
    void setup() override {
        server_thread_ = std::jthread([this] {
            server_ = std::make_unique<highperformancehttpserver>();
            server_->run("127.0.0.1", 8080);
        });
        
        // 等待服务器启动
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
    }
    
    void teardown() override {
        if (server_) {
            server_->stop();
        }
    }
    
    std::unique_ptr<highperformancehttpserver> server_;
    std::jthread server_thread_;
};

// 单元测试
test_f(httpservertest, requestparservalidrequest) {
    requestparser parser;
    std::string request = 
        "get /api/users/123 http/1.1\r\n"
        "host: localhost:8080\r\n"
        "user-agent: testclient/1.0\r\n"
        "accept: application/json\r\n"
        "\r\n";
    
    auto result = parser.parse(request);
    assert_true(result.has_value());
    expect_eq(result->method(), http::method::get);
    expect_eq(result->uri(), "/api/users/123");
    expect_eq(result->version(), http::version::http1_1);
}

test_f(httpservertest, requestparserchunkedencoding) {
    requestparser parser;
    std::string request = 
        "post /api/data http/1.1\r\n"
        "host: localhost:8080\r\n"
        "transfer-encoding: chunked\r\n"
        "\r\n"
        "5\r\n"
        "hello\r\n"
        "6\r\n"
        " world\r\n"
        "0\r\n"
        "\r\n";
    
    auto result = parser.parse(request);
    assert_true(result.has_value());
    expect_eq(result->method(), http::method::post);
    expect_eq(result->body(), "hello world");
}

test_f(httpservertest, routerbasicrouting) {
    router router;
    router.add_route(http::method::get, "/api/test", 
        [](const http::request&) {
            return http::response::text_response("ok");
        });
    
    http::request request(http::method::get, "/api/test");
    auto response = router.route(request);
    
    assert_true(response.has_value());
    expect_eq(response->status_code(), http::statuscode::ok);
    expect_eq(response->body(), "ok");
}

// 性能基准测试
class httpserverbenchmark : public ::benchmark::fixture {
protected:
    void setup(const ::benchmark::state& state) override {
        server_ = std::make_unique<highperformancehttpserver>();
        server_thread_ = std::jthread([this] {
            server_->run("127.0.0.1", 8080);
        });
        std::this_thread::sleep_for(std::chrono::milliseconds(50));
    }
    
    void teardown(const ::benchmark::state& state) override {
        server_->stop();
    }
    
    std::unique_ptr<highperformancehttpserver> server_;
    std::jthread server_thread_;
};

benchmark_define_f(httpserverbenchmark, requestparsing)(benchmark::state& state) {
    requestparser parser;
    std::string request = 
        "get /api/users/123 http/1.1\r\n"
        "host: localhost:8080\r\n"
        "user-agent: benchmark/1.0\r\n"
        "\r\n";
    
    for (auto _ : state) {
        auto result = parser.parse(request);
        benchmark::donotoptimize(result);
    }
    
    state.setitemsprocessed(state.iterations());
}
benchmark_register_f(httpserverbenchmark, requestparsing);

benchmark_define_f(httpserverbenchmark, routermatching)(benchmark::state& state) {
    router router;
    for (int i = 0; i < 100; ++i) {
        router.add_route(http::method::get, "/api/endpoint" + std::to_string(i),
            [](const http::request&) {
                return http::response::text_response("ok");
            });
    }
    
    http::request request(http::method::get, "/api/endpoint50");
    
    for (auto _ : state) {
        auto response = router.route(request);
        benchmark::donotoptimize(response);
    }
    
    state.setitemsprocessed(state.iterations());
}
benchmark_register_f(httpserverbenchmark, routermatching);

// 集成测试
class httpserverintegrationtest : public ::testing::test {
protected:
    void setup() override {
        // 启动测试服务器
        server_ = std::make_unique<highperformancehttpserver>();
        server_thread_ = std::jthread([this] {
            server_->run("127.0.0.1", 8080);
        });
        std::this_thread::sleep_for(std::chrono::milliseconds(200));
    }
    
    void teardown() override {
        server_->stop();
    }
    
    std::unique_ptr<highperformancehttpserver> server_;
    std::jthread server_thread_;
};

test_f(httpserverintegrationtest, healthcheck) {
    httpclient client("127.0.0.1", 8080);
    auto response = client.get("/health");
    
    expect_eq(response.status_code, 200);
    expect_eq(response.body, "ok");
}

test_f(httpserverintegrationtest, concurrentrequests) {
    constexpr int num_clients = 50;
    constexpr int requests_per_client = 100;
    
    std::vector<std::future<int>> futures;
    std::atomic<int> successful_requests{0};
    
    for (int i = 0; i < num_clients; ++i) {
        futures.push_back(std::async(std::launch::async, [i, &successful_requests] {
            httpclient client("127.0.0.1", 8080);
            int success_count = 0;
            
            for (int j = 0; j < requests_per_client; ++j) {
                try {
                    auto response = client.get("/api/health");
                    if (response.status_code == 200) {
                        success_count++;
                    }
                } catch (const std::exception& e) {
                    // 请求失败
                }
            }
            
            successful_requests.fetch_add(success_count);
            return success_count;
        }));
    }
    
    // 等待所有客户端完成
    int total_success = 0;
    for (auto& future : futures) {
        total_success += future.get();
    }
    
    expect_ge(total_success, num_clients * requests_per_client * 0.95); // 95% 成功率
    expect_eq(total_success, successful_requests.load());
}

// 压力测试工具
class stresstester {
private:
    testconfig config_;
    std::atomic<uint64_t> total_requests_{0};
    std::atomic<uint64_t> successful_requests_{0};
    std::atomic<uint64_t> failed_requests_{0};
    
public:
    explicit stresstester(testconfig config = {}) : config_(std::move(config)) {}
    
    struct testresults {
        uint64_t total_requests;
        uint64_t successful_requests;
        uint64_t failed_requests;
        double requests_per_second;
        double success_rate;
        std::chrono::duration<double> duration;
    };
    
    testresults run_stress_test() {
        auto start_time = std::chrono::steady_clock::now();
        
        std::vector<std::jthread> clients;
        clients.reserve(config_.concurrent_clients);
        
        // 启动并发客户端
        for (int i = 0; i < config_.concurrent_clients; ++i) {
            clients.emplace_back([this] { client_worker(); });
        }
        
        // 运行指定时间
        std::this_thread::sleep_for(std::chrono::seconds(config_.test_duration_seconds));
        
        // 停止测试
        stop_test_ = true;
        
        auto end_time = std::chrono::steady_clock::now();
        auto duration = end_time - start_time;
        
        // 等待所有客户端结束
        for (auto& client : clients) {
            if (client.joinable()) {
                client.join();
            }
        }
        
        return calculate_results(duration);
    }
    
    void print_results(const testresults& results) const {
        std::cout << "\n=== 压力测试结果 ===" << std::endl;
        std::cout << "持续时间: " << results.duration.count() << " 秒" << std::endl;
        std::cout << "总请求数: " << results.total_requests << std::endl;
        std::cout << "成功请求: " << results.successful_requests << std::endl;
        std::cout << "失败请求: " << results.failed_requests << std::endl;
        std::cout << "请求速率: " << results.requests_per_second << " 请求/秒" << std::endl;
        std::cout << "成功率: " << (results.success_rate * 100) << "%" << std::endl;
        std::cout << "====================\n" << std::endl;
    }

private:
    std::atomic<bool> stop_test_{false};
    
    void client_worker() {
        httpclient client(config_.host, config_.port);
        
        while (!stop_test_.load()) {
            try {
                auto response = client.get("/api/health");
                total_requests_.fetch_add(1);
                
                if (response.status_code == 200) {
                    successful_requests_.fetch_add(1);
                } else {
                    failed_requests_.fetch_add(1);
                }
            } catch (const std::exception&) {
                total_requests_.fetch_add(1);
                failed_requests_.fetch_add(1);
            }
            
            // 短暂休息，避免过度占用cpu
            std::this_thread::sleep_for(std::chrono::microseconds(100));
        }
    }
    
    testresults calculate_results(std::chrono::duration<double> duration) const {
        auto total = total_requests_.load();
        auto success = successful_requests_.load();
        auto failed = failed_requests_.load();
        
        return testresults{
            total,
            success,
            failed,
            total / duration.count(),
            static_cast<double>(success) / total,
            duration
        };
    }
};

// 示例测试运行器
void run_comprehensive_tests() {
    std::cout << "开始全面测试..." << std::endl;
    
    // 单元测试
    ::testing::gtest_flag(output) = "xml:unit_test_results.xml";
    ::testing::initgoogletest();
    auto unit_test_result = run_all_tests();
    
    // 性能测试
    ::benchmark::initialize(nullptr, nullptr);
    ::benchmark::runspecifiedbenchmarks();
    
    // 压力测试
    testconfig stress_config;
    stress_config.concurrent_clients = 200;
    stress_config.test_duration_seconds = 60;
    
    stresstester tester(stress_config);
    auto results = tester.run_stress_test();
    tester.print_results(results);
    
    std::cout << "全面测试完成" << std::endl;
}