深入解析 C++ 轻量级 WebServer 实现

WebServer 类封装了服务器主要逻辑包括初始化、事件循环和事件处理，比较核心，所以选择看完 main.cpp 后看 WebServer 类。

Webserver 类的 init 的函数参数讲解

void init(int port , string user, string passWord, string databaseName, int log_write , int opt_linger, int trigmode, int sql_num, int thread_num, int close_log, int actor_model); 

其中 log_write 参数是日志写入方式：分同步写入和异步写入

同步写入：在应用程序执行日志记录语句时，必须等待日志数据被完全、安全地写入到持久化存储（如硬盘）后，才能执行后续代码

异步写入：应用程序执行日志记录语句时，将日志消息放入到一个内存缓冲区后便立即返回，不等待数据落盘。由一个后台线程负责将缓冲区中的日志批量、定期地写入磁盘

opt_linger 参数是优雅关闭选项：

优雅关闭指的是当一个应用程序需要关闭时，它不是强制立即终止，而是通过一个预设的流程，有序的完成正在进行的任务、释放资源、并通知上下游组件，然后才安全退出的过程。

相反的是暴力关闭：即立即向进程发送 SIGKILL（-9）信号，进程会立即停止，无论它在做什么。

trigmode 参数指的是触发模式：

LT（水平触发）：只要条件满足，就会一直通知你

ET（边缘触发）：只有当条件发生变化时，它才会通知你一次。

下面举个例子：

假设有一个 Socket，其接收缓冲区里收到了 2KB 的数据。

1. LT（水平触发）的工作方式 epoll_wait 函数返回，通知你这个 socket 有数据可读（读就绪）。你决定只从缓冲区读取 1KB 的数据。然后你再次调用 epoll_wait。关键点：因为缓冲区里还有 1KB 数据（仍然处于'可读'状态），所以 epoll_wait 会立即再次返回，通知你这个 socket 仍然可读。你再去读取剩下的 1KB 数据。此时缓冲区为空，epoll_wait 才会休眠，直到下次有新数据到来。

LT 的优点：编程更安全。即使你一次没有处理完所有数据，下次还会得到通知，不会丢失数据。

LT 的缺点：可能会导致效率略低。因为如果对方发送数据很快，你每次只读一部分，会导致 epoll_wait 被频繁唤醒，即使还有旧数据没读完。

2. ET（边缘触发）的工作方式 当数据包到达，缓冲区从空变为非空时，epoll_wait 返回，通知你这个 socket 有数据可读。你必须用一个循环，一直读这个 socket，直到 read 系统调用返回 -1，并且错误码 errno 为 EAGAIN 或 EWOULDBLOCK（表示本次通知下的所有数据已读完）。如果你只读了 1KB 就停止了，然后再次调用 epoll_wait。关键点：epoll_wait 会阻塞，即使缓冲区里还有 1KB 数据！因为它只在乎变化的那一瞬间。只要缓冲区里还有数据，状态就没有从'空'变为'非空'的变化（空到非空的意思是没有新数据的加入），所以它不会通知你。只有当对端再次发送数据，导致缓冲区从空（或未满）变为有数据（或更多数据） 时，epoll_wait 才会再次返回。

ET 的优点：减少了事件被触发的次数，理论上性能更高，尤其是在高并发、大流量的场景下。

ET 的缺点：必须使用非阻塞 I/O：因为你必须一次性读完所有数据，如果使用阻塞 I/O，在读完所有数据后，最后一次 read 会阻塞住线程，导致程序卡死。必须保证一次性处理完：如果一次没有读完所有数据，剩下的数据将永远无法被读取，直到下一个数据包到来触发新的通知。

actor_model 参数指的是并发模型：

Reactor 模式（非阻塞 I/O+ 就绪通知)：应用程序向内核询问'I/O 是否就绪'当就绪时，由应用程序自己执行实际的 I/O 操作（将数据从内核缓冲区读到用户空间）。

Proactor 模式（异步 I/O)：应用程序发起一个异步 I/O 操作，内核（或底层框架）负责完成整个 I/O 操作（包括将数据读到用户空间），操作完成后，再通知应用程序。

#ifndef WEBSERVER_H
#define WEBSERVER_H
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <stdio.h>
#include <unistd.h>
#include <errno.h>
#include <fcntl.h>
#include <stdlib.h>
#include <cassert>
#include <sys/epoll.h>
//线程池和 http 处理模块
#include "./threadpool/threadpool.h"
#include "./http/http_conn.h"
const int MAX_FD = 65536; //最大文件描述符数量
const int MAX_EVENT_NUMBER = 10000; // epoll 最大监听事件数
const int TIMESLOT = 5; //定时器超时时间 (秒)
class WebServer {
public:
    WebServer();
    ~WebServer();
    void init(int port , string user, string passWord, string databaseName, int log_write , int opt_linger, int trigmode, int sql_num, int thread_num, int close_log, int actor_model);
    //端口、用户名、密码、数据库名、日志写入方式、优雅关闭连接选项、触发模式，数据库连接数量、线程数量、日志开关、并发模型
    void thread_pool();//初始化线程池
    void sql_pool();//初始化数据库连接池
    void log_write();//初始化日志系统
    void trig_mode();//设置触发模式
    //核心网络方法
    void eventListen();//创建监听 socket 和 epoll
    void eventLoop();//主事件循环
    //事件处理方法
    bool dealclientdata();//处理新客户端连接
    bool dealwithsignal(bool& timeout, bool& stop_server);//处理信号
    void dealwithread(int sockfd);//处理读事件
    void dealwithwrite(int sockfd);//处理写事件
    //定时器管理
    void timer(int connfd, struct sockaddr_in client_address);//创建定时器
    void adjust_timer(util_timer* timer);//调整定时器时间
    void deal_timer(util_timer *timer, int sockfd);//处理定时器连接
public:
    int m_port;//服务器监听的端口号
    char *m_root;//网站根目录
    int m_log_write;//日志写入方式
    int m_close_log;//日志开关
    int m_actormodel;//使用的反应堆模型类型
    int m_pipefd[2];//父子进程通信管道描述符
    int m_epollfd;//epoll 句柄
    http_conn* users;//http 链接数组
    //数据库相关
    connection_pool *m_connPool;//连接池
    string m_user; //登陆数据库用户名
    string m_passWord; //登陆数据库密码
    string m_databaseName; //使用数据库名
    int m_sql_num;//执行的最大 sql 语句数
    //线程池相关
    threadpool<http_conn>* m_pool;//线程池对象
    int m_thread_num;//线程池中的线程数
    //epoll_event 相关
    epoll_event events[MAX_EVENT_NUMBER];//用于存储 epoll_wait 返回的事件的数组
    int m_listenfd;
    int m_OPT_LINGER;// 优雅关闭连接选项
    int m_TRIGMode;// 触发模式
    int m_LISTENTrigmode;// 监听 socket 的触发模式
    int m_CONNTrigmode;// 连接 socket 的触发模式
    //定时器相关
    client_data *users_timer;
    Utils utils;//工具集
};
#endif

Webserver.cpp

WebServer 类的 WebServer 实现：

WebServer::WebServer() {
    //在堆中初始化 http_conn 类对象数组，该数组最大长度为 MAX_FD
    users = new http_conn[MAX_FD];
    char server_path[200];
    getcwd(server_path, 200);//获取当前工作目录，并将其存储在 server_path 字符数组中
    //getcwd() 会将当前工作目录的绝对路径复制到参数 buffer 所指的内存空间中，参数 size 为 buf 的空间大小
    //将根目录的路径存储在 root 字符数组中
    char root[6] = "/root";// '/root/0'
    //使用 malloc 函数在堆上分配一块内存，大小为 server_path 和 root 长度之和加 1（/0）
    m_root = (char *)malloc(strlen(server_path) + strlen(root) + 1);
    // 将 server_path 和 root 连接成一个字符串并存储在 m_root 指针中
    strcpy(m_root, server_path);
    strcat(m_root, root);
    //将源字符串 src 追加到目标字符串 dest 的末尾。
    //如果当前工作目录是 /home/user/project，那么最终 m_root 指向的字符串将 是/home/user/project/root。
    //client_data 是自定义的定时器客户端数据结构
    users_timer = new client_data[MAX_FD];//创建定时器数据数组
}

char *getcwd(char *buf, size_t size);
// 参数说明：
// char *buf：一个指向字符数组的指针，用于存储获取到的当前工作目录路径。如果这个参数为 NULL，函数会根据 size 参数自动分配内存（需要调用者自己释放）。
// size_t size：缓冲区 buf 的大小（以字节为单位）。这个大小必须足以容纳整个路径名加上终止的空字符\0。
// 返回值：
// 成功：返回一个指向包含当前工作目录路径的字符串的指针。这个指针通常与传入的 buf 参数值相同。如果 buf 是 NULL，则返回指向新分配内存的指针。
// 失败：返回 NULL，并设置全局变量 errno 以指示错误类型。

char *strcpy(char *dest, const char *src);
// 参数说明
// char *dest：目标字符串指针，指向用于存放复制内容的内存地址。这块内存必须足够大，足以容纳源字符串，否则会导致缓冲区溢出。
// const char *src：源字符串指针，指向要被复制的字符串。const 关键字表示函数内部不会修改源字符串。
// 返回值 返回 dest 指针本身。

char *strcat(char *dest, const char *src);
// 参数说明
// char *dest：目标字符串指针。它必须是一个已经以\0 结尾的字符串，并且其所在缓冲区必须有足够的剩余空间来容纳 src 字符串的内容（包括其结尾的 \0）。
// const char *src：源字符串指针，指向要被追加到目标字符串末尾的字符串。
// 返回值 返回 dest 指针本身。

WebServer:：~WebServer() 的实现

WebServer::~WebServer() {
    //关闭文件描述符，释放资源
    close(m_epollfd);//关闭 epoll 文件描述符
    close(m_listenfd);//关闭监听 socket
    close(m_pipefd[1]);//关闭管道写端
    close(m_pipefd[0]);//关闭管道读端
    //释放动态分配的内存
    delete[] users;//释放 HTTP 连接对象的数组（管理连接到服务器的客户端连接）
    delete[] users_timer;//释放定时器数据数组（每个元素都对应一个客户端连接，并存储了该连接的信息，如 socket 文件描述符、最后一次活跃时间等）
    delete m_pool;//释放线程池对象
}

WebServer::init() 的实现：

void WebServer::init(int port, string user, string passWord, string databaseName, int log_write, int opt_linger, int trigmode, int sql_num, int thread_num, int close_log, int actor_model) {
    //参数传递
    m_port = port;
    m_user = user;
    m_passWord = passWord;
    m_databaseName = databaseName;
    m_sql_num = sql_num;// 每个线程处理的最大数据库任务数
    m_thread_num = thread_num;//线程池中的线程数
    m_log_write = log_write;//日志写入方式
    m_OPT_LINGER = opt_linger;//优雅关闭连接的方式
    m_TRIGMode = trigmode;//触发模式
    m_close_log = close_log;//是否关闭日志
    m_actormodel = actor_model;//并发模型选择
}

WebServer::trig_mode() 的实现：

void WebServer::trig_mode() {
    //LT + LT
    if (0 == m_TRIGMode) {
        m_LISTENTrigmode = 0;
        m_CONNTrigmode = 0;
    }
    //LT + ET
    else if (1 == m_TRIGMode) {
        m_LISTENTrigmode = 0;
        m_CONNTrigmode = 1;
    }
    m_ else if (2 == m_TRIGMode) {
        m_LISTENTrigmode = 1;
        m_CONNTrigmode = 0;
    }
    //ET + ET
    else if (3 == m_TRIGMode) {
        m_LISTENTrigmode = 1;
        m_CONNTrigmode = 1;
    }
}

WebServer::log_write()

void WebServer::log_write() {
    // 如果 m_close_log 为 0（即不需要关闭），则调用 Log 类的 get_instance 静态方法获得唯一的 Log 实例，并使用其 init 方法初始化日志输出
    if (0 == m_close_log) {
        //初始化日志，如果 m_log_write 为 1，则采用异步写入方式
        if (1 == m_log_write)
            Log::get_instance()->init("./ServerLog", m_close_log, 2000, 800000, 800);
        else
            //同步写入
            Log::get_instance()->init("./ServerLog", m_close_log, 2000, 800000, 0);
    }
}

WebServer::sql_pool()

//初始化数据库连接池
void WebServer::sql_pool() {
    //调用 connection_pool 类的 GetInstance 静态方法获得唯一的连接池实例
    m_connPool = connection_pool::GetInstance();
    m_connPool->init("localhost", m_user, m_passWord, m_databaseName, 3306, m_sql_num, m_close_log);
    //初始化数据库读取表
    users->initmysql_result(m_connPool);
    /*初始化数据库读取表：使用 users 数组中的每个 http_conn 对象的 initmysql_result 方法，
    将数据库连接池对象 m_connPool 作为参数传入。这样，在每个 http_conn 对象被创建时，
    都会自动获取一个可用的数据库连接，并用该连接初始化 mysql_result 对象，以便后续进行数据库查询*/
}

WebServer::thread_pool()

void WebServer::thread_pool() {
    /* new 一个线程池对象
    m_actormodel：并发模型选择
    m_connPool：连接池对象，用于管理和复用客户端与服务器之间的连接。
    m_thread_num：线程池中的线程数。
    */
    m_pool = new threadpool<http_conn>(m_actormodel, m_connPool, m_thread_num);
}

#include <assert.h>

assert(expression);如果 expression 为真（非零），程序继续正常执行如果 expression 为假（零），assert 会：输出错误信息到 stderr 调用 abort() 终止程序

struct linger { int l_onoff; // 是否启用 linger 选项 (0=禁用，非 0=启用) int l_linger; // 等待时间（秒） };

l_onoff 决定 close() 函数的行为模式：**l_onoff = 0**：close() 立即返回，系统后台处理关闭 **l_onoff = 1**：close() 可能阻塞，程序亲自等待关闭完成

l_linger只在 l_onoff = 1 时起作用！当 l_onoff = 0 时：l_linger 被完全忽略当 l_onoff = 1 时：l_linger 决定等待行为

#include <sys/socket.h>

int setsockopt(int sockfd, int level, int optname,const void *optval, socklen_t optlen);

//eventListen 函数主要用于创建套接字、绑定端口、监听连接请求，并初始化 epoll 内核事件表
void WebServer::eventListen() {
    //网络编程基础步骤
    m_listenfd = socket(PF_INET, SOCK_STREAM, 0);
    assert(m_listenfd >= 0);
    /* 断言，用来在程序运行时确保前面的 socket 调用成功。
    如果 m_listenfd < 0，断言失败，程序在调试模式下会中止，并给出断言错误信息。
    */
    //优雅关闭连接选项
    if (0 == m_OPT_LINGER)//后台优雅关闭（快速重启模式）
    {
        struct linger tmp = {0, 1};
        setsockopt(m_listenfd, SOL_SOCKET, SO_LINGER, &tmp, sizeof(tmp));
        // close() 立即返回，系统快速回收端口
        // 服务器可以立即重启
    }
    else if (1 == m_OPT_LINGER)//等待式优雅关闭（安全关闭模式）
    {
        struct linger tmp = {1, 1};
        setsockopt(m_listenfd, SOL_SOCKET, SO_LINGER, &tmp, sizeof(tmp));
        // close() 等待 1 秒完成优雅关闭
        // 确保所有连接正确处理
    }
    int ret = 0;
    struct sockaddr_in address;
    bzero(&address, sizeof(address));//将 address 清零
    address.sin_family = AF_INET;
    address.sin_addr.s_addr = htonl(INADDR_ANY);
    address.sin_port = htons(m_port);
    //端口复用
    int flag = 1;
    setsockopt(m_listenfd, SOL_SOCKET, SO_REUSEADDR, &flag, sizeof(flag));
    ret = bind(m_listenfd, (struct sockaddr *)&address, sizeof(address));
    assert(ret >= 0);
    ret = listen(m_listenfd, 5);
    assert(ret >= 0);
    //初始化 utils 工具类，通过调用 utils 工具类的 init 方法，对定时器参数进行初始化
    utils.init(TIMESLOT);
    //这个数组是 epoll_wait() 函数的输出参数，用于存放所有已经就绪的事件。
    epoll_event events[MAX_EVENT_NUMBER];
    // 使用 epoll_create 函数创建一个 epoll 内核事件表，返回一个文件描述符
    m_epollfd = epoll_create(5);
    assert(m_epollfd != -1);
    // 向 epoll 内核事件表中添加监听套接字（使用 utils 工具类的 addfd 方法）
    //并设置是否采用 LT 模式等触发方式，以及是否启用 ET 模式等触发方式
    utils.addfd(m_epollfd, m_listenfd, false, m_LISTENTrigmode);
    // 设置 http_conn 类的静态成员变量 m_epollfd，将创建好的 epoll 内核事件表的文件描述符赋值给 http_conn 类的静态成员变量 m_epollfd，以便后续 http_conn 对象的创建和管理。
    http_conn::m_epollfd = m_epollfd;
    //使用 socketpair 函数创建一个双向管道，并将文件描述符存储在 m_pipefd 数组中
    ret = socketpair(PF_UNIX, SOCK_STREAM, 0, m_pipefd);
    assert(ret != -1);
    utils.setnonblocking(m_pipefd[1]);//将管道写端设置为非阻塞
    utils.addfd(m_epollfd, m_pipefd[0], false, 0);
    //向 epoll 内核事件表中添加管道读端，使用 utils 工具类的 addfd 方法，将管道读端添加到 epoll 内核事件表中，并设置是否采用 LT 模式等触发方式，以及是否启用 ET 模式等触发方式
    //设置信号处理函数，使用 utils 工具类的 addsig 方法，将 SIGPIPE、SIGALRM 和 SIGTERM 三个信号的处理函数设置为 SIG_IGN 或 utils 的 sig_handler 函数
    utils.addsig(SIGPIPE, SIG_IGN);
    utils.addsig(SIGALRM, utils.sig_handler, false);
    utils.addsig(SIGTERM, utils.sig_handler, false);
    // 定时器初始化，使用 alarm 函数定时器，定时时间为 TIMESLOT 秒
    alarm(TIMESLOT);
    //将双向管道写端、epoll 内核事件表文件描述符等变量存储在 Utils 的静态成员变量 u_pipefd 和 u_epollfd 中，以便后续工具类的操作
    Utils::u_pipefd = m_pipefd;
    Utils::u_epollfd = m_epollfd;
}
/* 在每次有新连接时被调用，用于初始化用户数据和创建定时器：该函数的主要目的是为每个连接套接字创建一个定时器，以便在一定时间内未收到客户端请求时能够自动关闭连接，防止服务器资源浪费 */

void WebServer::timer(int connfd, struct sockaddr_in client_address) {
    // 初始化用户数据，使用连接套接字 connfd 和客户端地址 client_address 初始化一个 User[connfd] 对象，并将其保存在全局数组 users 中，以便后续使用
    users[connfd].init(connfd, client_address, m_root, m_CONNTrigmode, m_close_log, m_user, m_passWord, m_databaseName);
    //初始化 client_data 数据
    users_timer[connfd].address = client_address;
    users_timer[connfd].sockfd = connfd;
    //创建定时器，设置回调函数和超时时间，绑定用户数据，将定时器添加到链表中
    util_timer *timer = new util_timer;
    // 绑定用户数据，将该连接套接字对应的 User 对象的指针保存在定时器的 user_data 成员变量中，以便在定时器回调函数中使用
    timer->user_data = &users_timer[connfd];
    timer->cb_func = cb_func;// 将回调函数设置为 cb_func
    //将定时器的超时时间设置为当前时间加上 3 倍的 TIMESLOT 值
    time_t cur = time(NULL);
    timer->expire = cur + 3 * TIMESLOT;
    users_timer[connfd].timer = timer;
    utils.m_timer_lst.add_timer(timer);// 将定时器添加到链表中
}

void WebServer::adjust_timesr(util_timer *timer) {
    time_t cur = time(NULL);
    // 将定时器的超时时间设置为当前时间 +3 个单位的时间片，这意味着定时器将在当前时间之后的 3 个时间片后过期，即等待数据传输完成后再执行回调函数
    timer->expire = cur + 3 * TIMESLOT;
    utils.m_timer_lst.adjust_timer(timer);// 对定时器在链表上的位置进行调整
    LOG_INFO("%s", "adjust timer once");
}

//用于处理定时器的函数。当定时器超时时，该函数被调用以执行定时器回调函数
void WebServer::deal_timer(util_timer *timer, int sockfd) {
    timer->cb_func(&users_timer[sockfd]);// 用定时器的回调函数
    if (timer)// 如果定时器存在
    {
        // 删除该定时器
        utils.m_timer_lst.del_timer(timer);
    }
    LOG_INFO("close fd %d", users_timer[sockfd].sockfd);
}

bool WebServer::dealclientdata() {
    struct sockaddr_in client_address;
    socklen_t client_addrlength = sizeof(client_address);
    // 根据服务器的触发模式（m_LISTENTrigmode），执行不同的操作
    if (0 == m_LISTENTrigmode) // 如果触发模式为 0，即 LT 模式
    {
        // 则调用 accept() 函数接受客户端连接请求，并传入参数 m_listenfd 作为监听套接字
        int connfd = accept(m_listenfd, (struct sockaddr *)&client_address, &client_addrlength);
        if (connfd < 0)// 如果连接失败，则记录错误信息并返回 false
        {
            LOG_ERROR("%s:errno is:%d", "accept error", errno);
            return false;
        }
        if (http_conn::m_user_count >= MAX_FD)// 如果当前连接数超出最大限制（MAX_FD）
        {
            utils.show_error(connfd, "Internal server busy");
            LOG_ERROR("%s", "Internal server busy");
            return false;
        }
        timer(connfd, client_address); //创建一个定时器，并将套接字和客户端地址作为参数传入
    }
    else //ET
    {
        while (1)
        {
            // 使用 while 循环接受所有连接请求
            int connfd = accept(m_listenfd, (struct sockaddr *)&client_address, &client_addrlength);
            if (connfd < 0)
            {
                LOG_ERROR("%s:errno is:%d", "accept error", errno);
                break;
            }
            if (http_conn::m_user_count >= MAX_FD)
            {
                utils.show_error(connfd, "Internal server busy");
                LOG_ERROR("%s", "Internal server busy");
                break;
            }
            timer(connfd, client_address);
        }
        return false;
    }
    return true;
}

函数原型

recv 函数在 <sys/socket.h> 头文件中声明，其标准原型如下：

参数详解**int sockfd含义：一个已连接的套接字描述符。这个套接字必须是：面向连接的（如 SOCK_STREAM，即 TCP 套接字）。或者是一个已经通过 connect 函数连接到对等方的无连接套接字（如 SOCK_DGRAM，即 UDP 套接字）。对于普通的无连接 UDP 套接字，通常使用 recvfrom 来同时获取数据来源的地址。void *buf含义：指向一个内存缓冲区的指针，用于存放接收到的数据。size_t len含义：缓冲区 buf 的最大长度（以字节为单位）。recv 函数最多会向缓冲区写入 len 个字节的数据。int flags含义：用于修改函数行为的标志位。可以单独使用，也可以通过按位或 | 组合使用。常见的标志有：0: 默认行为，阻塞等待，直到有数据到达。MSG_PEEK: '窥探'数据。将数据从网络缓冲区复制到应用缓冲区 buf 中，但不从内核的网络接收缓冲区中移除这些数据。下一次调用 recv（不带 MSG_PEEK）时，还会收到同样的数据。MSG_WAITALL: 等待所有数据到达。函数会阻塞，直到接收到了恰好 len 个字节的数据，或者连接被关闭/发生错误。注意：即使设置了此标志，如果连接被对端正常关闭（收到 FIN），它也可能返回少于 len 字节的数据。MSG_DONTWAIT**: 以非阻塞方式操作。如果没有数据立即可用，函数会立即返回失败，并设置错误码为 EAGAIN 或 EWOULDBLOCK。

返回值****成功：返回实际接收到的字节数。返回值可能小于参数 len，这很常见。对于 TCP，返回值 0 有特殊含义：表示对端已经关闭了连接（发送了 FIN 包）。这是判断连接是否关闭的重要依据。对于 UDP，返回值 0 是合法的，表示收到了一个长度为 0 的数据报。失败：返回 -1，并设置全局变量 errno 以指示具体的错误。常见的错误有：EAGAIN / EWOULDBLOCK: 套接字被设置为非阻塞，并且没有数据可读。ECONNRESET: 连接被对端强制重置（如对端进程崩溃）。EINTR: 系统调用被信号中断。

bool WebServer::dealwithsignal(bool &timeout, bool &stop_server) {
    int ret = 0;
    int sig;
    char signals[1024];
    // 使用 recv() 函数从管道读取信号，并将信号存储在名为'signals'的字符数组中
    ret = recv(m_pipefd[0], signals, sizeof(signals), 0);
    if (ret == -1) {// 如果读取失败，则返回 false
        return false;
    }
    else if (ret == 0) {// 如果没有收到任何信号，则返回 false
        return false;
    }
    else {
        // 否则，遍历字符数组并根据不同的信号类型执行相应的操作
        for (int i = 0; i < ret; ++i) {
            switch (signals[i]) {
                // 如果收到 SIGALRM 信号，则将 timeout 设置为 true，表示定时器超时
                // 这通常是由定时器到期引起的，可以让主函数检查此标志并执行相应的操作
                case SIGALRM: {
                    timeout = true;
                    break;
                }
                case SIGTERM: {
                    // 如果收到 SIGTERM 信号，则将 stop_server 设置为 true，表示需要停止服务器。
                    // 这通常是由管理员或操作系统发出的信号，用于安全关闭服务器
                    stop_server = true;
                    break;
                }
            }
        }
    }
    return true;
}

//用于处理读事件的函数。当服务器监测到套接字上有可读事件时，该函数将被调用以处理数据
void WebServer::dealwithread(int sockfd) {
    // 获取与套接字相关联的定时器
    util_timer *timer = users_timer[sockfd].timer;
    // 根据服务器模型（m_actormodel）执行不同的操作
    // 如果服务器模型为 1，即采用 Reactor 模型
    if (1 == m_actormodel) {
        if (timer)//调整定时器：给定时器续命 去处理业务 这个设计确保了在处理业务期间连接不会被意外断开。
        {
            adjust_timer(timer);
        }
        //若监测到读事件，将该事件放入请求队列
        m_pool->append(users + sockfd, 0);//users + sockfd 实际上就是 &users[sockfd]，即获取对应客户端的数据结构指针
        while (true) // 使用 while 循环等待其他线程处理请求并更新用户状态，直到发现用户状态已经被改变为'improv=1'才退出循环
        {
            if (1 == users[sockfd].improv) {
                //如果定时器标志为 1
                if (1 == users[sockfd].timer_flag) {
                    //处理定时器事件
                    deal_timer(timer, sockfd);
                    users[sockfd].timer_flag = 0;
                }
                users[sockfd].improv = 0;
                break;
            }
        }
    }
    // 如果服务器模型为 0，即采用 Proactor 模型
    else {
        //主线程进行读取套接字上的数据
        if (users[sockfd].read_once()) {
            LOG_INFO("deal with the client(%s)", inet_ntoa(users[sockfd].get_address()->sin_addr));
            //若监测到读事件，将该事件放入请求队列
            m_pool->append_p(users + sockfd);//append_p 是 Proactor 模式，I/O 已完成，工作只需要业务处理
            if (timer) {
                adjust_timer(timer);
            }
        }
        // 如果读取失败，则调用'deal_timer(timer,sockfd)'函数处理定时器事件（关闭连接）
        else {
            deal_timer(timer, sockfd);
        }
    }
}

//同上
void WebServer::dealwithwrite(int sockfd) {
    // 获取与套接字相关联的定时器
    util_timer *timer = users_timer[sockfd].timer;
    //reactor
    if (1 == m_actormodel) {
        if (timer) {
            adjust_timer(timer);
        }
        m_pool->append(users + sockfd, 1);// 将写事件放入请求队列
        while (true) {
            if (1 == users[sockfd].improv) {
                if (1 == users[sockfd].timer_flag) {
                    deal_timer(timer, sockfd);
                    users[sockfd].timer_flag = 0;
                }
                users[sockfd].improv = 0;
                break;
            }
        }
    }
    else {
        //proactor
        if (users[sockfd].write())// 使用'users[sockfd].write()'函数向客户端发送数据
        {
            LOG_INFO("send data to the client(%s)", inet_ntoa(users[sockfd].get_address()->sin_addr));
            if (timer) {
                adjust_timer(timer);
            }
        }
        else {
            deal_timer(timer, sockfd);
        }
    }
}

函数原型

参数详解

1. epfd作用：epoll 实例的文件描述符来源：由 epoll_create() 或 epoll_create1() 创建

2. events作用：输出参数，用于接收就绪事件的数组类型：struct epoll_event*重要：这是就绪事件的集合，不是所有监控的事件

3. maxevents作用：指定 events 数组的大小要求：必须大于 0建议：通常设置为 events 数组的长度

4. timeout作用：指定超时时间（毫秒）取值：-1：阻塞等待，直到有事件发生 0：立即返回，即使没有事件（非阻塞轮询）>0：最多等待指定的毫秒数

返回值成功：返回就绪的文件描述符数量超时：返回 0（没有事件发生）错误：返回 -1，并设置 errno

void WebServer::eventLoop() {
    bool timeout = false;// 用于表示是否超时
    bool stop_server = false;// 用于表示是否停止服务器
    while (!stop_server) //当 stop_server 变量被设置为 true 时，表示服务器需要停止运行，则跳出循环，结束主函数的执行
    {
        // 调用 epoll_wait 函数等待事件的发生，在有事件发生时返回相应的事件类型和文件描述符
        int number = epoll_wait(m_epollfd, events, MAX_EVENT_NUMBER, -1);
        //错误处理
        if (number < 0 && errno != EINTR) {
            LOG_ERROR("%s", "epoll failure");
            break;
        }
        for (int i = 0; i < number; i++) {
            int sockfd = events[i].data.fd;
            // 如果事件类型是新连接请求，则调用 dealclinetdata 函数进行处理
            if (sockfd == m_listenfd) {
                bool flag = dealclientdata();
                if (false == flag) continue;
            }
            //如果事件类型是客户端断开、服务端关闭连接或出现错误，则移除对应的定时器
            else if (events[i].events & (EPOLLRDHUP | EPOLLHUP | EPOLLERR)) {
                //服务器端关闭连接，移除对应的定时器
                util_timer *timer = users_timer[sockfd].timer;
                deal_timer(timer, sockfd);
            }
            //处理信号
            else if ((sockfd == m_pipefd[0]) && (events[i].events & EPOLLIN)) {
                bool flag = dealwithsignal(timeout, stop_server);
                if (false == flag) LOG_ERROR("%s", "dealclientdata failure");
            }
            //处理客户连接上接收到的数据
            else if (events[i].events & EPOLLIN) {
                dealwithread(sockfd);
            }
            //写事件
            else if (events[i].events & EPOLLOUT) {
                dealwithwrite(sockfd);
            }
        }
        //如果 timeout 变量为 true，则表明当前轮询已经超时，需要处理定时器事件
        if (timeout) {
            // 提供 timer_handler 函数来处理链表中已经到期的定时器事件
            utils.timer_handler();
            LOG_INFO("%s", "timer tick");
            timeout = false;
        }
    }
}

Timer

lst_timer.h

**函数指针：*是 C 语言中的一个高级特性，它允许将函数作为参数传递给其他函数，或者保存函数的地址以便后续调用。函数指针的定义格式通常为：类型名 ( 函数名) (函数参数列表);

void func1(void) {
   printf("test for function pointer.\n");
}
void (*pFunc)(void); // 函数指针定义
pFunc = func1; // 函数指针赋值
(*pFunc)(); // 函数指针调用
// pFunc(); // 调用的第二种写法，效果和上面一样

函数指针的作用：

函数指针的主要作用是两个方面：一是作为回调函数，允许在运行时决定调用哪个函数；二是作为函数的参数，使得函数可以接受不同行为的函数作为参数，提高代码的复用性和灵活性。

#ifndef LST_TIMER
#define LST_TIMER
#include <unistd.h>
#include <signal.h>
#include <sys/types.h>
#include <sys/epoll.h>
#include <fcntl.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <assert.h>
#include <sys/stat.h>
#include <string.h>
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/mman.h>
#include <stdarg.h>
#include <errno.h>
#include <sys/wait.h>
#include <sys/uio.h>
#include <time.h>
#include "../log/log.h"
class util_timer;//先说明，client_data 要用到得先声明
struct client_data {
    sockaddr_in address;//cfd_address
    int sockfd;//cfd
    util_timer *timer;//client_data 内部封装 timer 指针
};
class util_timer {
public:
    util_timer() : prev(NULL), next(NULL) {}//双向链表
public:
    time_t expire; // 超时时间（绝对时间）
    void (*cb_func)(client_data*); // 超时回调函数指针
    client_data* user_data; // 回调函数的用户数据
    util_timer* prev; // 前向指针
    util_timer* next; // 后向指针
};
//有两个类：sort_timer_lst（排序定时器链表）和（工具定时器）以及结构体 client_data（客户端数据）
class sort_timer_lst {
public:
    sort_timer_lst();
    ~sort_timer_lst();
    void add_timer(util_timer* timer); // 添加定时器
    void adjust_timer(util_timer* timer); // 调整定时器位置
    void del_timer(util_timer* timer); // 删除定时器
    void tick(); // 处理超时定时器
private:
    void add_timer(util_timer *timer, util_timer *lst_head);
    util_timer *head;
    util_timer *tail;
};
//开始定义
class Utils //工具类
{
public:
    Utils() {}
    ~Utils() {}
    void init(int timeslot); //对文件描述符设置非阻塞（ET）
    int setnonblocking(int fd); //将内核事件表注册读事件，ET 模式，选择开启 EPOLLONESHOT
    void addfd(int epollfd, int fd, bool one_shot, int TRIGMode); //信号处理函数
    static void sig_handler(int sig); //设置信号函数
    void addsig(int sig, void(handler)(int), bool restart = true); //定时处理任务，重新定时以不断触发 SIGALRM 信号
    void timer_handler();
    void show_error(int connfd, const char *info);
public:
    static int* u_pipefd; // 管道文件描述符（用于信号通知）
    sort_timer_lst m_timer_lst; // 定时器链表
    static int u_epollfd; // epoll 实例
    int m_TIMESLOT; // 超时时间间隔
};
void cb_func(client_data *user_data);//函数 cb_func 可以认为是默认的回调函数
#endif

lst_timer.cpp

#include "lst_timer.h"
#include "../http/http_conn.h"
//初始化链表
sort_timer_lst::sort_timer_lst() {
    head = NULL;
    tail = NULL;
}
sort_timer_lst::~sort_timer_lst() {
    util_timer *tmp = head;
    while (tmp) //一个一个清空
    {
        head = tmp->next;
        delete tmp;
        tmp = head;
    }
}
void sort_timer_lst::add_timer(util_timer *timer) {
    if (!timer) {
        return;
    }
    if (!head) //空链表情况
    {
        head = tail = timer;
        return;
    }
    // 插入到头部 都是些特殊情况
    if (timer->expire < head->expire) {
        timer->next = head;
        head->prev = timer;
        head = timer;
        return;
    }
    add_timer(timer, head);
}
void sort_timer_lst::adjust_timer(util_timer *timer) //新加入的 timer
{
    //第一步：检查是否需要调整
    if (!timer) {
        return;
    }
    util_timer *tmp = timer->next;
    /* !tmp：当前定时器是链表最后一个，不需要调整
       timer->expire < tmp->expire：当前定时器的过期时间仍然比下一个早，位置正确 */
    if (!tmp || (timer->expire < tmp->expire)) {
        return;
    }
    //第二步：处理头节点情况
    if (timer == head) {
        head = head->next; // 头指针后移
        head->prev = NULL; // 新头节点前驱置空
        timer->next = NULL; // 分离当前定时器
        add_timer(timer, head); // 重新插入到合适位置
    }
    //第三步：处理中间节点情况
    else {
        timer->prev->next = timer->next; // 前驱指向后继
        timer->next->prev = timer->prev; // 后继指向前驱
        add_timer(timer, timer->next); // 重新插入
    }
}
void sort_timer_lst::del_timer(util_timer *timer) {
    if (!timer) {
        return;
    }
    if ((timer == head) && (timer == tail)) //空链表的情况
    {
        delete timer;
        head = NULL;
        tail = NULL;
        return;
    }
    if (timer == head) {
        head = head->next;
        head->prev = NULL;
        delete timer;
        return;
    }
    if (timer == tail) {
        tail = tail->prev;
        tail->next = NULL;
        delete timer;
        return;
    }
    timer->prev->next = timer->next;
    timer->next->prev = timer->prev;
    delete timer;
}
void sort_timer_lst::tick() //处理超时的定时器
{
    if (!head) {
        return;
    }
    time_t cur = time(NULL);
    util_timer *tmp = head;
    while (tmp) //从头开始遍历
    {
        if (cur < tmp->expire) //是没超时的情况 时间大于当前时间就是没超时
        {
            break;
        }
        //超时的情况
        tmp->cb_func(tmp->user_data);//执行回调函数
        head = tmp->next;//下一位
        if (head) {
            head->prev = NULL;//前面一位删了
        }
        delete tmp;
        tmp = head;//继续下一位
    }
}
void sort_timer_lst::add_timer(util_timer *timer, util_timer *lst_head) //刚才的是 public 现在是 private 函数
{
    util_timer *prev = lst_head;
    util_timer *tmp = prev->next;//刚才处理了异常的情况
    while (tmp) //当 tmp!=null 的情况
    {
        //现在就是在中间的情况
        if (timer->expire < tmp->expire) //接起来就行
        {
            prev->next = timer;
            timer->next = tmp;
            tmp->prev = timer;
            timer->prev = prev;
            break;
        }
        prev = tmp;
        tmp = tmp->next;//继续向后遍历
    }
    if (!tmp) //tmp=null 的时候 1 是链表初始的时候为空 2 是遍历到链表末尾
    {
        prev->next = timer;
        timer->prev = prev;
        timer->next = NULL;
        tail = timer;
    }
}
//初始化 Util 工具类的类内参数
void Utils::init(int timeslot) {
    m_TIMESLOT = timeslot;
}
//对文件描述符设置非阻塞
int Utils::setnonblocking(int fd) {
    int old_option = fcntl(fd, F_GETFL);//使用 fcntl(fd, F_GETFL) 获取文件描述符 fd 的当前状态标志
    //保存到 old_option 中，以便后续恢复使用
    int new_option = old_option | O_NONBLOCK;//使用位或操作 | 在原有标志基础上添加 O_NONBLOCK 标志
    fcntl(fd, F_SETFL, new_option);//将包含非阻塞标志的新标志设置回文件描述符
    return old_option;//返回修改前的原始标志，方便调用者需要时恢复原状态
}
//Utils 添加 addfd 函数 向 epoll 实例中添加文件描述符并设置相应的事件模式
void Utils::addfd(int epollfd, int fd, bool one_shot, int TRIGMode) {
    epoll_event event;
    event.data.fd = fd;
    if (1 == TRIGMode) //ET
    {
        event.events = EPOLLIN | EPOLLET | EPOLLRDHUP; //EPOLLET: 边缘触发模式
    }
    else //LT
    {
        event.events = EPOLLIN | EPOLLRDHUP; //EPOLLRDHUP: 对端关闭连接或半关闭
    }
    if (one_shot)
    {
        event.events |= EPOLLONESHOT; //EPOLLONESHOT: 保证事件只被触发一次，需要重新注册
    }
    epoll_ctl(epollfd, EPOLL_CTL_ADD, fd, &event);//注册到 epoll 实例 (&event)
    setnonblocking(fd);//ET 要用非阻塞 I/O
}
//Utils 信号处理函数 用于在信号发生时通过管道通知主程序
void Utils::sig_handler(int sig) {
    //为保证函数的可重入性，保留原来的 errno
    int save_errno = errno;
    int msg = sig;
    send(u_pipefd[1], (char *)&msg, 1, 0); // u_pipefd[1]: 管道的写端文件描述符
    // (char *)&msg: 将信号值转换为字符指针，1 是字节大小，0 是默认发送标志
    errno = save_errno;//恢复 errno
}
//设置信号函数
void Utils::addsig(int sig, void(handler)(int), bool restart) {
    struct sigaction sa;
    //创建 sigaction 结构体
    memset(&sa, '\0', sizeof(sa));//清空结构体
    sa.sa_handler = handler;//上面写的信号处理函数
    if (restart)
    {
        sa.sa_flags |= SA_RESTART; //SA_RESTART: 被信号中断的系统调用自动重启，避免系统调用被信号中断后需要手动重试
    }
    sigfillset(&sa.sa_mask);//在处理当前信号时，阻塞所有其他信号
    assert(sigaction(sig, &sa, NULL) != -1); //使用 sigaction 系统调用注册信号处理，使用 assert 确保设置成功，失败时程序终止
}
//定时处理任务，重新定时以不断触发 SIGALRM 信号
void Utils::timer_handler() {
    m_timer_lst.tick();
    alarm(m_TIMESLOT);
}
void Utils::show_error(int connfd, const char *info) {
    send(connfd, info, strlen(info), 0);
    close(connfd);
}
int *Utils::u_pipefd = 0;
int Utils::u_epollfd = 0;
class Utils;
void cb_func(client_data *user_data) //定时器回调函数
{
    assert(user_data);
    epoll_ctl(Utils::u_epollfd, EPOLL_CTL_DEL, user_data->sockfd, 0);//从 epoll 中移除文件描述符
    close(user_data->sockfd);//关闭 socket 连接
    http_conn::m_user_count--;//更新用户计数
}

Threadpool

#ifndef THREADPOOL_H
#define THREADPOOL_H
#include <list>
#include <cstdio>
#include <exception>
#include <pthread.h>
#include "../lock/locker.h"
#include "../CGImysql/sql_connection_pool.h"
//这是一个模板类，T 代表要处理的任务类型。
template <typename T>
class threadpool //由任务队列和线程池工作线程完成
{
public:
    //初始化线程
    threadpool(int actor_model, connection_pool *connPool, int thread_number = 8, int max_request = 10000);
    ~threadpool();
    //往请求队列中添加任务 (任务入队）
    bool append(T *request, int state);//actor 模式
    bool append_p(T *request);//proactor 模式
private:
    //工作线程运行的函数，它不断从工作队列中取出任务并执行之
    static void *worker(void *arg);
    //必须是静态函数：pthread_create 要求回调函数是普通 C 函数或静态成员函数
    void run();
private:
    //线程池相关
    int m_thread_number; //线程池中的线程数
    pthread_t *m_threads; //描述线程池的数组，其大小为 m_thread_number
    //请求队列相关
    std::list<T *> m_workqueue; //请求队列
    int m_max_requests; //请求队列中允许的最大请求数
    locker m_queuelocker; //保护请求队列的互斥锁
    sem m_queuestat; //是否有任务需要处理（信号量，用于线程同步）
    connection_pool *m_connPool;//数据库
    /*数据库主要是跟线程池工作线程有关系，其中客户端发送请求过来，线程接收请求，然后线程进行业务逻辑，接着申请数据库连接，主要是线程要用到数据库的操作*/
    int m_actor_model; //模型切换
};
template <typename T>
threadpool<T>::threadpool(
    int actor_model, connection_pool *connPool, int thread_number, int max_requests)
    : m_actor_model(actor_model), m_thread_number(thread_number), m_max_requests(max_requests), m_threads(NULL), m_connPool(connPool)
    //构造函数 初始化操作
{
    if (thread_number <= 0 || max_requests <= 0) //如果线程数量和最大请求数不合理 抛出异常
    {
        throw std::exception();
    }
    m_threads = new pthread_t[m_thread_number]; //创建线程数组
    if (!m_threads)
    {
        throw std::exception();
    }
    for (int i = 0; i < thread_number; ++i) {
        //创建线程，指定线程执行的函数为 worker，传入当前线程池对象作为参数，NULL 表示使用默认的线程属性
        if (pthread_create(m_threads + i, NULL, worker, this) != 0) {
            delete[] m_threads;
            throw std::exception();
        }
        if (pthread_detach(m_threads[i])) //分离线程
        {
            delete[] m_threads;
            throw std::exception();
        }
    }
}
//线程池的析构函数
template <typename T>
threadpool<T>::~threadpool() {
    delete[] m_threads;
}
//向队列添加任务
template <typename T>
bool threadpool<T>::append(T *request, int state) {
    //1.加锁 保护请求队列的访问
    m_queuelocker.lock();
    //2.判断条件 判断请求队列是否已满
    if (m_workqueue.size() >= m_max_requests) {
        m_queuelocker.unlock();
        return false;
    }
    //3.将请求添加到请求队列中
    request->m_state = state;//设置任务的状态
    m_workqueue.push_back(request);
    //4.解锁
    m_queuelocker.unlock();
    //5.通知有任务需要处理
    m_queuestat.post();//增加信号量的值，唤醒等待的工作线程
    return true;//表示成功添加任务
}
template <typename T>
bool threadpool<T>::append_p(T *request) {
    m_queuelocker.lock();
    if (m_workqueue.size() >= m_max_requests) {
        m_queuelocker.unlock();
        return false;
    }
    m_workqueue.push_back(request);
    m_queuelocker.unlock();
    m_queuestat.post();
    return true;
}
//线程工作函数
template <typename T>
void *threadpool<T>::worker(void *arg) {
    threadpool* pool = (threadpool*)arg;//1.将参数转化为线程池对象指针
    pool->run(); // 2. 调用线程池的 run 方法
    return pool;// 3. 返回线程池指针
}
//pool->run run() 的实现
template <typename T>
void threadpool<T>::run() {
    while (true) // 无限循环，线程持续工作
    {
        //等待任务信号
        m_queuestat.wait();
        //加锁
        m_queuelocker.lock();
        if (m_workqueue.empty()) {
            m_queuelocker.unlock();
            continue;
        }
        T* request = m_workqueue.front();//取出请求队列中的第一个任务
        m_workqueue.pop_front();//拿出后弹出
        m_queuelocker.unlock();
        if (!request)
            continue;
        if (1 == m_actor_model)//Reactor
        {
            if (0 == request->m_state)//读事件
            {
                if (request->read_once())//成功读取
                {
                    request->improv = 1;//标记改进
                    connectionRAII mysqlcon(&request->mysql, m_connPool);//自动管理数据库连接
                    request->process();//处理业务逻辑
                }
                else //读取失败
                {
                    request->improv = 1;
                    request->timer_flag = 1;
                }
            }
            else
            {
                if (request->write()) //写事件
                {
                    request->improv = 1;
                }
                else
                {
                    request->improv = 1;
                    request->timer_flag = 1;
                }
            }
        }
        else //proactor 模式
        {
            connectionRAII mysqlcon(&request->mysql, m_connPool);
            request->process();
        }
    }
}
#endif

CGImysql

sql_connection_pool.h

#ifndef _CONNECTION_POOL_
#define _CONNECTION_POOL_
#include <stdio.h>
#include <list>
#include <mysql/mysql.h>
#include <error.h>
#include <string.h>
#include <iostream>
#include <string>
#include "../lock/locker.h"
#include "../log/log.h"
class connection_pool {
public:
    MYSQL *GetConnection(); //获取可用连接
    bool ReleaseConnection(MYSQL *conn); //释放连接
    int GetFreeConn(); //获取空闲连接
    void DestroyPool(); //销毁所有连接
    //单例模式 获取唯一实例
    static connection_pool *GetInstance();
    void init(string url, string User, string PassWord, string DataBaseName, int Port, int MaxConn, int close_log);
private:
    connection_pool();
    ~connection_pool();
    int m_MaxConn; //最大连接数
    int m_CurConn; //当前已使用的连接数
    int m_FreeConn; //当前空闲的连接数
    locker lock;
    list<MYSQL *> connList; //连接池
    sem reserve;//// 信号量，控制连接获取
public:
    string m_url //主机地址
    string m_Port; //数据库端口号
    string m_User; //登陆数据库用户名
    string m_PassWord; //登陆数据库密码
    string m_DatabaseName; //使用数据库名
    int m_close_log; //日志开关
};
//RAII：这是一种设计模式，能保证数据库安全关闭连接
class connectionRAII{
public:
    connectionRAII(MYSQL **con, connection_pool *connPool);
    ~connectionRAII();
private:
    MYSQL *conRAII;
    connection_pool *poolRAII;
};
#endif

Sql_connection_pool.cpp

#include <mysql/mysql.h>
#include <stdio.h>
#include <string>
#include <string.h>
#include <stdlib.h>
#include <list>
#include <pthread.h>
#include <iostream>
#include "sql_connection_pool.h"
//构造函数
connection_pool::connection_pool() {
    m_CurConn = 0;
    m_FreeConn = 0;
}
//获取唯一实例
connection_pool *connection_pool::GetInstance() {
    static connection_pool connPool;
    return &connPool;
}
//初始化 主要是实现参数初始化、在连接池中添加可用连接（为 maxconn 个）
void connection_pool::init(string url, string User, string PassWord, string DBName, int Port, int MaxConn, int close_log) {
    m_url = url;
    m_Port = Port;
    m_User = User;
    m_PassWord = PassWord;
    m_DatabaseName = DBName;
    m_close_log = close_log;
    for (int i = 0; i < MaxConn; i++) {
        MYSQL *con = NULL;
        con = mysql_init(con);//数据库初始化函数
        if (con == NULL) //初始化失败
        {
            LOG_ERROR("MySQL Error");//在日志上记录
            exit(1);
        }
        con = mysql_real_connect(con, url.c_str(), User.c_str(), PassWord.c_str(), DBName.c_str(), Port, NULL, 0);//连接数据库
        if (con == NULL) {
            LOG_ERROR("MySQL Error");
            exit(1);
        }
        connList.push_back(con);//连接池增加连接
        ++m_FreeConn;//空闲数加 1
    }
    reserve = sem(m_FreeConn);// 创建信号量，初始值为空闲连接数，用于控制并发访问
    m_MaxConn = m_FreeConn;//重新赋值
}
//当有请求时，从数据库连接池中返回一个可用连接，更新使用和空闲连接数
MYSQL *connection_pool::GetConnection() {
    MYSQL *con = NULL;
    if (0 == connList.size())
        return NULL;
    reserve.wait();
    /*如果信号量值 > 0，立即获取并继续执行，如果信号量值 = 0，线程会阻塞等待，直到有连接被释放*/
    lock.lock();
    con = connList.front();
    connList.pop_front();
    --m_FreeConn;
    ++m_CurConn;
    lock.unlock();
    return con;
}
/*线程 A 请求连接 → 信号量 wait() → 获取锁 → 操作连接池 → 释放锁 → 返回连接
  线程 B 请求连接 → 信号量 wait() → 阻塞等待 → 线程 A 释放连接 → 信号量 post() → 线程 B 继续*/
//释放当前使用的连接
bool connection_pool::ReleaseConnection(MYSQL *con) {
    if (NULL == con)
        return false;
    lock.lock();
    connList.push_back(con);
    ++m_FreeConn;
    --m_CurConn;
    lock.unlock();
    reserve.post();//释放后回到连接池，又可用了
    return true;
}
//销毁数据库连接池
void connection_pool::DestroyPool() {
    lock.lock();
    if (connList.size() > 0) {
        list<MYSQL *>::iterator it;//迭代器遍历
        for (it = connList.begin(); it != connList.end(); ++it) {
            MYSQL *con = *it;
            mysql_close(con);//逐个释放
        }
        m_CurConn = 0;
        m_FreeConn = 0;
        connList.clear();//清空容器
    }
    lock.unlock();
}
//返回当前空闲的连接数
int connection_pool::GetFreeConn() {
    return this->m_FreeConn;
}
//析构函数：摧毁连接池
connection_pool::~connection_pool() {
    DestroyPool();
}
//设计模式的实现
connectionRAII::connectionRAII(MYSQL **SQL, connection_pool *connPool){
    //MYSQL**SQL：二级指针，用于返回获取的数据库连接
    connection_pool *connPool：连接池对象指针
    *SQL = connPool->GetConnection();//从连接池获取连接
    conRAII = *SQL;//保存连接指针
    poolRAII = connPool;//保存连接池指针
}//功能：从连接池获取一个数据库连接，并保存相关指针
connectionRAII::~connectionRAII(){
    poolRAII->ReleaseConnection(conRAII);
}//功能：自动将数据库连接释放回连接池

Log

block_queue.h

#ifndef BLOCK_QUEUE_H
#define BLOCK_QUEUE_H
#include <iostream>
#include <stdlib.h>
#include <pthread.h>
#include <sys/time.h>
#include "../lock/locker.h"
//使用队列实现异步模式
template <class T>
class block_queue {
private:
    locker m_mutex;//互斥锁
    cond m_cond;//条件变量
    T* m_array;//循环数组
    int m_size;//当前元素数量
    int m_max_size;//队列最大容量
    int m_front;//队首索引
    int m_back;//队尾索引
public:
    block_queue(int max_size = 1000) {
        if (max_size <= 0)//检查传入的队列大小是否合法
        {
            exit(-1);
        }
        //成员变量初始化
        m_max_size = max_size;//设置队列最大容量
        m_array = new T[max_size];//动态分配数组内存
        m_size = 0;//当前元素个数为 0
        m_front = -1;
        m_back = -1;//表示队列为空 还没有元素
    }
    void clear() {
        m_mutex.lock();
        m_size = 0;
        m_front = -1;
        m_back = -1;
        m_mutex.unlock();
    }
    ~block_queue()//释放数组
    {
        m_mutex.lock();
        if (m_array != NULL)
            delete [] m_array;
        m_mutex.unlock();
    }
    //判断队列是否满了
    bool full() {
        m_mutex.lock();
        if (m_size >= m_max_size) {
            m_mutex.unlock();
            return true;
        }
        m_mutex.unlock();
        return false;
    }
    //判断队列是否为空
    bool empty() {
        m_mutex.lock();
        if (0 == m_size) {
            m_mutex.unlock();
            return true;
        }
        m_mutex.unlock();
        return false;
    }
    //返回队首元素
    bool front(T &value) {
        m_mutex.lock();
        if (0 == m_size) {
            m_mutex.unlock();
            return false;
        }
        value = m_array[m_front];
        m_mutex.unlock();
        return true;
    }
    //返回队尾元素
    bool back(T &value) {
        m_mutex.lock();
        if (0 == m_size) {
            m_mutex.unlock();
            return false;
        }
        value = m_array[m_back];
        m_mutex.unlock();
        return true;
    }
    int size() {
        int tmp = 0;
        m_mutex.lock();
        tmp = m_size;
        m_mutex.unlock();
        return tmp;
    }
    int max_size() {
        int tmp = 0;
        m_mutex.lock();
        tmp = m_max_size;
        m_mutex.unlock();
        return tmp;
    }
    //往队列添加元素，需要将所有使用队列的线程先唤醒
    //当有元素 push 进队列，相当于生产者生产了一个元素
    //若当前没有线程等待条件变量，则唤醒无意义
    bool push(const T &item) {
        m_mutex.lock();
        if (m_size >= m_max_size)//队列满时
        {
            m_cond.broadcast();//调用 m_cond.broadcast() 唤醒所有等待的消费者线程 让他们去消费
            m_mutex.unlock();
            return false;
        }
        m_back = (m_back + 1) % m_max_size;//移动队尾指针
        m_array[m_back] = item;
        m_size++;
        m_cond.broadcast();//通知所有等待的消费者线程有新数据可用
        m_mutex.unlock();
        return true;
    }
    //pop 时，如果当前队列没有元素，将会等待条件变量
    //消费者：从队列取出日志
    bool pop(T &item) //T&item：用于存储弹出的元素
    {
        m_mutex.lock();
        //队列空时等待
        while (m_size <= 0)//使用 while 而不是 if 是为了防止虚假唤醒
        {
            if (!m_cond.wait(m_mutex.get()))// 等待条件满足（其中 wait 等待前，会先释放锁，然后等待，最后等待成功会重新获取锁）
            {
                m_mutex.unlock();// 等待失败，显式释放锁（安全措施，确保锁在任何情况都能被释放）
                return false;
            }
        }
        m_front = (m_front + 1) % m_max_size;//循环队列，移动头指针
        item = m_array[m_front];
        m_size--;
        m_mutex.unlock();
        return true;
    }
    //增加了超时处理（队列没有可用的元素，就等待，直到超时）
    bool pop(T &item, int ms_timeout) //T&item：用于存储弹出的元素
    int ms_timeout:超时时间（毫秒）
    {
        struct timespec t = {0, 0};//秒 纳秒
        struct timeval now = {0, 0};//秒 毫秒
        gettimeofday(&now, NULL);//获取当前系统时间
        m_mutex.lock();
        if (m_size <= 0)//队列为空
        {
            t.tv_sec = now.tv_sec + ms_timeout / 1000;//秒数 = 当前秒数 + 超时毫秒数 / 1000
            t.tv_nsec = (ms_timeout % 1000) * 1000;//纳秒数 = (超时毫秒数 % 1000) * 1000
            if (!m_cond.timewait(m_mutex.get(), t)) //带超时的条件等待
            {
                m_mutex.unlock();
                return false;
            }
        }
        if (m_size <= 0) //即使被唤醒，队列也可能为空 防止虚假唤醒
        {
            m_mutex.unlock();
            return false;
        }
        m_front = (m_front + 1) % m_max_size;//循环队列，移动头指针
        item = m_array[m_front];
        m_size--;
        m_mutex.unlock();
        return true;
    }
};
#endif

log.h

#ifndef LOG_H
#define LOG_H
#include <stdio.h>
#include <iostream>
#include <string>
#include <stdarg.h>
#include <pthread.h>
#include "block_queue.h"
class Log {
public:
    //C++11 以后，使用局部变量懒汉不用加锁 (懒汉模式：首次调用时创建实例)
    //单例模式实现 整个程序只有一个日志实例
    static Log *get_instance()//单例模式实现
    {
        static Log instance;
        return &instance;
    }
    static void *flush_log_thread(void *args)//异步内容
    {
        Log::get_instance()->async_write_log();
    }
    bool init(const char *file_name, int close_log, int log_buf_size = 8192, int split_lines = 5000000, int max_queue_size = 0);
    void write_log(int level, const char *format, ...);//核心写入函数
    void flush(void);//手动刷新缓冲区
private:
    Log();
    virtual ~Log();
    //异步日志机制
    void *async_write_log() {
        string single_log;
        while (m_log_queue->pop(single_log))// 从阻塞队列消费日志
        {
            m_mutex.lock();
            fputs(single_log.c_str(), m_fp);//将日志字符串写入文件
            m_mutex.unlock();
        }
    }
private:
    //文件操作相关
    char dir_name[128]; //日志目录
    char log_name[128]; //log 文件名
    int m_split_lines; //日志分隔行数
    int m_log_buf_size; //日志缓冲区大小
    long long m_count; //日志行数计数
    int m_today; //因为按天分类，记录当前时间是那一天
    //同步机制
    locker m_mutex;
    FILE *m_fp; //打开 log 的文件指针
    char *m_buf; //格式化缓冲区
    //异步相关
    block_queue<string> *m_log_queue; //阻塞队列
    bool m_is_async; //是否同步标志位
    int m_close_log; //是否关闭日志
};
#define LOG_DEBUG(format, ...) if(0 == m_close_log) {Log::get_instance()->write_log(0, format, ##__VA_ARGS__); Log::get_instance()->flush();}
#define LOG_INFO(format, ...) if(0 == m_close_log) {Log::get_instance()->write_log(1, format, ##__VA_ARGS__); Log::get_instance()->flush();}
#define LOG_WARN(format, ...) if(0 == m_close_log) {Log::get_instance()->write_log(2, format, ##__VA_ARGS__); Log::get_instance()->flush();}
#define LOG_ERROR(format, ...) if(0 == m_close_log) {Log::get_instance()->write_log(3, format, ##__VA_ARGS__); Log::get_instance()->flush();}
/*
 * 宏定义结构分析
 * #define 宏名 (参数，...) 条件 { 操作; 操作; }
 * 条件判断：0==close_log 开启日志
 * 变参宏：(format, ...) ...表示可变参数
 * ##__VA_ARGS__用来处理可变参数
 * 日志级别：0-调试 1-信息 2-警告 3-错误
 */
#endif

log.cpp

参数说明**thread** (输出参数)类型: pthread_t *作用: 指向 pthread_t 类型变量的指针。函数成功返回后，该变量会被填充为新创建的线程标识符（Thread ID）。这个 ID 在后面其他线程函数（如 pthread_join, pthread_cancel）中用于引用这个特定的线程。attr (输入参数)类型: pthread_attr_t *作用: 用于设置新线程的属性，如栈大小、调度策略、分离状态等。特殊值:如果传入 NULL，线程将使用默认属性创建。在大多数情况下，我们使用默认属性就足够了。如果需要自定义属性，必须先使用 pthread_attr_init 初始化一个属性对象，设置好所需属性后传入。start_routine (输入参数)类型: void *(*)(void *)作用: 这是一个函数指针，指向新线程将要执行的函数。这个函数必须具有特定的签名：返回类型是 void * 接收一个 void * 类型的参数**arg** (输入参数)类型: void *作用: 传递给 start_routine 函数的参数。它是一个泛型指针，你可以传递任何数据的地址（如一个变量的地址、一个结构体的地址等）。如果不需要传递参数，可以传入 NULL。

返回值****成功: 返回 0。失败: 返回一个错误代码（非零值），而不是设置 errno。常见的错误代码有：EAGAIN: 系统资源不足，无法创建另一个线程，或线程数量超过了系统的限制。EINVAL: 参数 attr 无效。EPERM: 没有权限设置调度策略和参数。

#include <string.h>
#include <time.h>
#include <sys/time.h>
#include <stdarg.h>
#include "log.h"
#include <pthread.h>
Log::Log()//构造初始化
{
    m_count = 0;// 日志行数计数清零
    m_is_async = false;// 默认同步模式
}
Log::~Log() {
    if (m_fp != NULL) {
        fclose(m_fp); // 关闭日志文件
    }
}
//init 主要是：1.异步设置 2.智能为日记添加日期 3.初始化参数 然后开始追加文件
bool Log::init(const char *file_name, int close_log, int log_buf_size, int split_lines, int max_queue_size) {
    //如果设置了 max_queue_size，则设置为异步模式
    if (max_queue_size >= 1) {
        m_is_async = true;
        m_log_queue = new block_queue<string>(max_queue_size);
        pthread_t tid;//创建线程来消费日志
        pthread_create(&tid, NULL, flush_log_thread, NULL);//参数 3 调用消费日志函数（pop）（将日志写入文件）
    }
    m_close_log = close_log;
    m_log_buf_size = log_buf_size;
    m_buf = new char[m_log_buf_size]; // 分配（格式化）缓冲区
    memset(m_buf, '\0', m_log_buf_size);// 清空缓冲区 全变成 0
    m_split_lines = split_lines;// 设置文件分割行数
    time_t t = time(NULL);
    struct tm *sys_tm = localtime(&t);
    struct tm my_tm = *sys_tm; //解引用*用以复制数据
    // 构造日志文件名：前缀_年_月_日.log
    char log_full_name[256] = {0};
    const char *p = strrchr(file_name, '/');// 在字符串 str 中从后向前查找字符/最后一次出现的位置 (找不到返回 null)
    if (p == NULL)// 没有目录路径，只有文件名
    {
        //年份 (上面的是按间隔算 (1900)、月份（0-11 变成 1-12）、日期 (1-31)，例如：2024_11_25_server.log
        snprintf(log_full_name, 255, "%d_%02d_%02d_%s", my_tm.tm_year + 1900, my_tm.tm_mon + 1, my_tm.tm_mday, file_name);
    }
    else // 包含目录路径
    {
        //假设 file_name = "/var/log/server.log"
        strcpy(log_name, p + 1);//复制文件名部分 (server.log)
        strncpy(dir_name, file_name, p - file_name + 1);//复制目录路径，其中 +1 是为了包含 '/' 本身
        snprintf(log_full_name, 255, "%s%d_%02d_%02d_%s", dir_name, my_tm.tm_year + 1900, my_tm.tm_mon + 1, my_tm.tm_mday, log_name);
        //"/var/log/2024_11_25_server.log"
    }
    m_today = my_tm.tm_mday;// 记录当前日期，用于按天分割
    m_fp = fopen(log_full_name, "a"); // 以追加模式打开文件
    if (m_fp == NULL)//打开失败
    {
        return false;
    }
    return true;
}
//初始化追加了 直接写
void Log::write_log(int level, const char *format, ...) {
    struct timeval now = {0, 0};//秒和微秒
    timeval(time_t、suseconds_t)
    gettimeofday(&now, NULL);
    time_t t = now.tv_sec;//提取秒数
    struct tm *sys_tm = localtime(&t);
    struct tm my_tm = *sys_tm;//深拷贝时间结构
    char s[16] = {0};//日志级别标识
    switch (level) {
    case 0: strcpy(s, "[debug]:");//向字符数组加入相对应的标识
        break;
    case 1: strcpy(s, "[info]:");
        break;
    case 2: strcpy(s, "[warn]:");
        break;
    case 3: strcpy(s, "[erro]:");
        break;
    default: strcpy(s, "[info]:");
        break;
    }
    m_mutex.lock();
    m_count++;//增加行数计数
    // 检查是否需要分割文件：如果日期变化或达到最大行数则需要分隔文件
    //日志轮转机制
    if (m_today != my_tm.tm_mday || m_count % m_split_lines == 0) {
        //需要写下一个日志了
        char new_log[256] = {0};
        fflush(m_fp); //将标准 I/O 库缓冲区中的数据强制写入到底层文件中。
        fclose(m_fp);//关闭当前文件
        char tail[16] = {0};
        snprintf(tail, 16, "%d_%02d_%02d_", my_tm.tm_year + 1900, my_tm.tm_mon + 1, my_tm.tm_mday);
        //分割文件的两种情况分别讨论
        if (m_today != my_tm.tm_mday)//日期变化
        {
            snprintf(new_log, 255, "%s%s%s", dir_name, tail, log_name);//分别记录了不变的值（dir_name,log_name）只用修改要改的值 (tail)
            m_today = my_tm.tm_mday;//更新日期
            m_count = 0;//重置计数器
        }
        else//行数达到限制
        {
            snprintf(new_log, 255, "%s%s%s.%lld", dir_name, tail, log_name, m_count / m_split_lines);
        }
        /*/var/log/myapp/2024_01_15_app.log.1 /var/log/myapp/2024_01_15_app.log.2*/
        m_fp = fopen(new_log, "a");//创建新文件
    }
    m_mutex.unlock();
    //写入内容
    va_list valst;
    va_start(valst, format);// 初始化可变参数列表
    string log_str;
    m_mutex.lock();
    // 格式化时间戳和日志级别
    // "2024-12-25 14:30:45.123456 INFO "
    int n = snprintf(m_buf, 48, "%d-%02d-%02d %02d:%02d:%02d.%06ld %s ", my_tm.tm_year + 1900, my_tm.tm_mon + 1, my_tm.tm_mday, my_tm.tm_hour, my_tm.tm_min, my_tm.tm_sec, now.tv_usec, s);//格式化用户内容
    //写入核心内容
    int m = vsnprintf(m_buf + n, m_log_buf_size - n - 1, format, valst);//-1 是留给\0 的
    m_buf[n + m] = '\n'; // 添加换行
    m_buf[n + m + 1] = '\0';
    log_str = m_buf; // 转为 string 格式
    m_mutex.unlock();
    //写入策略选择
    if (m_is_async && !m_log_queue->full())// 异步模式且队列未满
    {
        m_log_queue->push(log_str); // 放入队列，立即返回
    }
    else// 同步模式或队列已满
    //确保日志不丢
    {
        m_mutex.lock();
        fputs(log_str.c_str(), m_fp);// 直接写入文件里
        m_mutex.unlock();
    }
    va_end(valst);// 清理可变参数
}
void Log::flush(void) {
    m_mutex.lock();
    //强制刷新写入流缓冲区
    fflush(m_fp); //强制把数据从缓存推到磁盘 (不然可能会丢失)
    m_mutex.unlock();
}

Lock

#ifndef LOCKER_H
#define LOCKER_H
//多线程同步，确保任一时刻只能有一个线程能进入关键代码段
/* =>信号量 =>互斥锁 =>条件变量 */
#include <exception>
#include <pthread.h>
#include <semaphore.h>
//sem 类是一个信号量封装类
/* 信号量是一种同步机制，用于控制多个线程之间的访问顺序。通常情况下，
  当多个线程需要共享一个资源时，需要使用信号量来确保每个线程按照一定的顺序访问该资源，从而避免出现竞争条件和数据不一致等问题 */
class sem {
public:
    sem() {
        /*sem_init 是一个用于初始化信号量的函数，它有三个参数，分别是：
         sem：指向要初始化的信号量的指针。
         pshared：指定信号量是在进程间共享还是在线程间共享的标志。如果 pshared 为 0，则表示信号量将在同一进程内的线程之间共享；如果 pshared 为非 0 值，则表示信号量可以在多个进程之间共享。
         value：指定信号量的初始值
         return 0 表示成功 */
        if (sem_init(&m_sem, 0, 0) != 0) {
            throw std::exception();//信号量初始化失败时，抛出一个 std::exception 对象，安全地中止当前操作并将错误状态通知给调用者
        }
    }
    sem(int num) {
        if (sem_init(&m_sem, 0, num) != 0)//创建多个信号量
        {
            throw std::exception();
        }
    }
    ~sem() {
        //毁信号量对象，释放资源
        sem_destroy(&m_sem);
    }
    bool wait() //该方法会对信号量进行等待操作，如果信号量的值为 0，则该方法会阻塞当前线程，直到有其他线程通过 post() 方法将信号量的值增加至大于 0，才会唤醒该线程
    {
        return sem_wait(&m_sem) == 0;
    }
    bool post() {
        //sem_post 核心作用是增加（解锁）一个信号量的值。成功返回 0，失败返回 -1
        return sem_post(&m_sem) == 0;
    }
private:
    sem_t m_sem;// 初始化一个名为 m_sem 的信号量
};
/* 在多线程程序中，使用互斥锁可以避免多个线程同时访问共享资源而导致的数据竞争问题。
  这里的 lock() 和 unlock() 方法就是为了控制对共享资源的访问，
  只有获得了互斥锁的线程才能访问共享资源，其他线程则必须等待锁被释放才能获取它。 */
class locker {
public:
    locker() {
        if (pthread_mutex_init(&m_mutex, NULL) != 0) {
            throw std::exception();
        }
    }
    ~locker() {
        pthread_mutex_destroy(&m_mutex);
    }
    bool lock() {
        return pthread_mutex_lock(&m_mutex) == 0;
    }
    bool unlock() {
        return pthread_mutex_unlock(&m_mutex) == 0;
    }
    pthread_mutex_t *get() {
        return &m_mutex;// 返回互斥锁的指针
    }
private:
    pthread_mutex_t m_mutex;
};
/* 多用于生产者消费者模型，只有符合条件变量才可以生产或者是进行消费 */
class cond {
public:
    cond() {
        if (pthread_cond_init(&m_cond, NULL) != 0) {
            //pthread_mutex_destroy(&m_mutex);
            throw std::exception();//抛出异常
        }
    }
    ~cond() {
        pthread_cond_destroy(&m_cond);
    }
    bool wait(pthread_mutex_t *m_mutex)//调用前必须已经获得 m_mutex 锁
    {
        int ret = 0;
        //pthread_mutex_lock(&m_mutex);
        ret = pthread_cond_wait(&m_cond, m_mutex);
        //pthread_mutex_unlock(&m_mutex);
        /* 原子地释放锁并进入等待
           被唤醒时重新获取锁
           返回时线程持有锁 */
        return ret == 0;
    }
    bool timewait(pthread_mutex_t *m_mutex, struct timespec t) {
        int ret = 0;
        //pthread_mutex_lock(&m_mutex);
        ret = pthread_cond_timedwait(&m_cond, m_mutex, &t);
        //pthread_mutex_unlock(&m_mutex);
        return ret == 0;
    }
    bool signal() {
        return pthread_cond_signal(&m_cond) == 0;//唤醒一个等待该条件变量的线程
    }
    bool broadcast() {
        return pthread_cond_broadcast(&m_cond) == 0;//唤醒所有等待该条件变量的线程
    }
private:
    //static pthread_mutex_t m_mutex;
    pthread_cond_t m_cond;
};
#endif

Http

http_conn.h

#ifndef HTTPCONNECTION_H
#define HTTPCONNECTION_H
#include <unistd.h>
#include <signal.h>
#include <sys/types.h>
#include <sys/epoll.h>
#include <fcntl.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <assert.h>
#include <sys/stat.h>
#include <string.h>
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/mman.h>
#include <stdarg.h>
#include <errno.h>
#include <sys/wait.h>
#include <sys/uio.h>
#include <map>
#include "../lock/locker.h"
#include "../CGImysql/sql_connection_pool.h"
#include "../timer/lst_timer.h"
#include "../log/log.h"
class http_conn //存在于客户端和服务器相交流之间，客户端发起请求，服务器返回一个响应
{
    // 客户端：请求行、请求头部、空行、和请求体
    //HTTP 响应也由四个部分组成：分别是：状态行、响应头、空行、响应体
public:
    //静态常量定义
    static const int FILENAME_LEN = 200;//文件名的最大长度
    static const int READ_BUFFER_SIZE = 2048;//读缓冲区的大小
    static const int WRITE_BUFFER_SIZE = 1024;//写缓冲区的大小
    //枚举类型
    enum METHOD {
        GET = 0,//GET 请求
        POST,//POST 请求
        HEAD,//HEAD 请求
        PUT,//PUT
        DELETE,//DELETE
        TRACE,//TRACE
        OPTIONS,//OPTIONS
        CONNECT,//CONNECT
        PATH//PATH
    };
    //解析状态枚举 服务器端
    enum CHECK_STATE {
        CHECK_STATE_REQUESTLINE = 0,//正在解析请求行
        CHECK_STATE_HEADER,//正在解析请求头
        CHECK_STATE_CONTENT//正在解析请求体
    };
    // HTTP 处理结果枚举
    enum HTTP_CODE {
        NO_REQUEST,//请求不完整，需要继续读取客户数据
        GET_REQUEST,//获得了完整的客户请求
        BAD_REQUEST,//客户请求有语法错误
        NO_RESOURCE,//没有资源
        FORBIDDEN_REQUEST,//客户对资源没有足够的访问权限
        FILE_REQUEST,//文件请求
        INTERNAL_ERROR,//服务器内部错误
        CLOSED_CONNECTION//客户端已经关闭连接
    };
    //行解析状态枚举 (辅助解析内容)
    enum LINE_STATUS {
        LINE_OK = 0,//读取到完整行
        LINE_BAD,//行格式出错
        LINE_OPEN//行数据尚且不完整，需要继续读取
    };
public:
    http_conn() {}
    ~http_conn() {}
public:
    //初始化 HTTP 连接
    void init(int sockfd, const sockaddr_in& addr, char*, int, int, string user, string passwd, string sqlname);
    void close_conn(bool real_close = true);
    void process();//处理 HTTP 请求
    bool read_once();//一次性读取所有可用的数据到读缓冲区
    bool write();//将响应数据写入套接字
    sockaddr_in *get_address() {
        return &m_address;//获取客户端地址信息
    }
    void initmysql_result(connection_pool *connPool);//从数据库连接池初始化用户数据
    int timer_flag;
    int improv;
private:
    void init();//初始化连接的各种状态变量
    HTTP_CODE process_read();//http 请求解析的主状态机 返回的是 HTTP_CODE
    bool process_write(HTTP_CODE ret);//响应生成
    HTTP_CODE parse_request_line(char *text);//请求行解析
    HTTP_CODE parse_headers(char *text);//请求头解析
    HTTP_CODE parse_content(char *text);//请求体解析
    HTTP_CODE do_request();//业务逻辑处理
    //辅助工具函数
    //行处理相关
    char *get_line() {
        return m_read_buf + m_start_line;
    };//返回当前要解析的行起始位置
    LINE_STATUS parse_line();//在读取缓冲区中查找完整的行（以 \r\n 结尾）
    //内存管理
    void unmap();//取消文件的内存映射 释放资源
    //响应构建函数
    //响应组件构建
    bool add_response(const char *format, ...);//可变参数函数，格式化字符串到写缓冲区
    bool add_status_line(int status, const char *title);//添加状态行，如 HTTP/1.1 200 OK
    bool add_headers(int content_length);//添加完整的响应头
    bool add_content(const char *content);//添加响应体内容
    //响应头字段
    bool add_content_type();
    bool add_content_length(int content_length);
    bool add_linger();
    bool add_blank_line();
public:
    static int m_epollfd; //所有对象共享的 epoll 文件描述符
    static int m_user_count;//当前连接的用户数 (HTTP 连接数量)
    MYSQL* mysql;//数据库连接指针
    int m_state; //连接状态：读为 0，写为 1
private:
    //包含了 HTTP 连接处理的所有状态和数据
    //套接字和地址
    int m_sockfd;//client
    sockaddr_in m_address; //读缓冲区管理
    char m_read_buf[READ_BUFFER_SIZE];//读缓冲区（2048 字节）
    long m_read_idx;// 当前已读取数据的末尾位置
    long m_checked_idx;// 当前已解析数据的位置
    int m_start_line; // 当前解析行的起始位置
    //m_read_buf: [已解析数据 | 待解析数据 | 空闲空间]
    //↑ ↑ ↑
    //m_start_line m_checked_idx m_read_idx
    //写缓冲区管理
    char m_write_buf[WRITE_BUFFER_SIZE];// 写缓冲区（1024 字节）
    int m_write_idx;// 写缓冲区当前写入位置
    //解析状态机
    CHECK_STATE m_check_state;// 当前解析状态（请求行/头部/内容）
    METHOD m_method;// HTTP 方法（GET/POST 等）
    //请求信息
    char *m_url;// 请求的 URL
    char *m_version;// HTTP 版本
    char *m_host;// 主机名
    long m_content_length;// 内容长度（POST 请求）
    bool m_linger; // 是否保持连接
    char *m_string; //存储请求头数据
    int cgi; //是否启用的 POST 处理
    //文件操作
    char m_real_file[FILENAME_LEN];// 实际文件路径（200 字节）
    char *m_file_address; // 文件内存映射地址
    struct stat m_file_stat;//文件状态信息
    struct iovec m_iv[2];//分散写结构数组
    int m_iv_count;//分散写向量数量
    /* m_iv[0]: 指向 HTTP 响应头（m_write_buf）
       m_iv[1]: 指向文件内容（m_file_address）
    */
    int bytes_to_send;// 剩余要发送的字节数
    int bytes_have_send;// 已发送的字节数
    //服务器配置
    char* doc_root; // 文档根目录
    int m_TRIGMode; // 触发模式（ET/LT）
    int m_close_log; // 日志开关
    map<string, string> m_users; // 用户缓存（用户名 - 密码）
    char sql_user[100]; // 数据库用户名
    char sql_passwd[100]; // 数据库密码
    char sql_name[100]; // 数据库名
};
#endif

http_conn.cpp

**strpbrk(char *str1, char *str2)**在 str1 中查找 str2 中任意字符的第一次出现示例：strpbrk("GET /", " \t") 返回指向空格的指针

**strspn(char *str1, char *str2)**返回 str1 开头连续包含 str2 中字符的个数示例：strspn(" /index", " \t") 返回 3（3 个空格）

**strcasecmp / strncasecmp**不区分大小写的字符串比较 strncasecmp 只比较前 n 个字符

#include "http_conn.h"
#include <mysql/mysql.h>
#include <fstream>
//定义 http 响应的一些状态信息
const char *ok_200_title = "OK";
const char *error_400_title = "Bad Request";
const char *error_400_form = "Your request has bad syntax or is inherently impossible to staisfy.\n";
const char *error_403_title = "Forbidden";
const char *error_403_form = "You do not have permission to get file form this server.\n";
const char *error_404_title = "Not Found";
const char *error_404_form = "The requested file was not found on this server.\n";
const char *error_500_title = "Internal Error";
const char *error_500_form = "There was an unusual problem serving the request file.\n";
locker m_lock;
map<string, string> users;//存储 user 数据（姓名：密码）
void http_conn::initmysql_result(connection_pool *connPool) {
    MYSQL *mysql = NULL;
    connectionRAII mysqlcon(&mysql, connPool);//使用 connectionRAII 函数获取连接同时自动管理释放
    //在 user 表中检索 username，passwd 数据
    if (mysql_query(mysql, "SELECT username,passwd FROM user"))//执行 sql 查询
    {
        LOG_ERROR("SELECT error:%s\n", mysql_error(mysql));
    }
    //从表中检索完整的结果集
    MYSQL_RES *result = mysql_store_result(mysql);
    //返回结果集中的列数
    int num_fields = mysql_num_fields(result);
    //返回所有字段结构的数组
    MYSQL_FIELD *fields = mysql_fetch_fields(result);
    //从结果集中获取下一行，将对应的用户名和密码，存入 map 中
    while (MYSQL_ROW row = mysql_fetch_row(result)) {
        string temp1(row[0]);
        string temp2(row[1]);
        users[temp1] = temp2;
    }
}
//对文件描述符设置非阻塞（lst_timer）
int setnonblocking(int fd) {
    int old_option = fcntl(fd, F_GETFL);// 获取当前文件状态标志
    int new_option = old_option | O_NONBLOCK;
    fcntl(fd, F_SETFL, new_option);// 设置新的文件状态标志
    return old_option;// 返回原始状态（用于后续恢复）
}
//lst.timer 已实现
void addfd(int epollfd, int fd, bool one_shot, int TRIGMode) {
    epoll_event event;
    event.data.fd = fd;
    if (1 == TRIGMode)//ET
    {
        event.events = EPOLLIN | EPOLLET | EPOLLRDHUP;
    }
    else //LT
    {
        event.events = EPOLLIN | EPOLLRDHUP;
    }
    if (one_shot)
    {
        event.events |= EPOLLONESHOT;
    }
    epoll_ctl(epollfd, EPOLL_CTL_ADD, fd, &event);
    setnonblocking(fd);
}
//从内核时间表删除描述符
void removefd(int epollfd, int fd) {
    epoll_ctl(epollfd, EPOLL_CTL_DEL, fd, 0);
    close(fd);
}
//将事件重置为 ET/LT
void modfd(int epollfd, int fd, int ev, int TRIGMode) {
    epoll_event event;
    event.data.fd = fd;
    if (1 == TRIGMode)
    {
        event.events = ev | EPOLLET | EPOLLONESHOT | EPOLLRDHUP;
    }
    else
    {
        event.events = ev | EPOLLONESHOT | EPOLLRDHUP;
    }
    epoll_ctl(epollfd, EPOLL_CTL_MOD, fd, &event);//修改
}
int http_conn::m_user_count = 0;
int http_conn::m_epollfd = -1;
//关闭连接，关闭一个 sockfd 连接，客户总量减一
void http_conn::close_conn(bool real_close) {
    if (real_close && (m_sockfd != -1))//只有当需要真正关闭且 socket 有效时才执行
    {
        printf("close %d\n", m_sockfd);
        removefd(m_epollfd, m_sockfd); // 从 epoll 中移除监控
        m_sockfd = -1; // 标记 socket 为无效
        m_user_count--; // 减少用户计数
    }
}
//初始化连接，外部调用（接收配置参数，建立基础连接）
void http_conn::init(int sockfd, const sockaddr_in &addr, char *root, int TRIGMode, int close_log, string user, string passwd, string sqlname) {
    m_sockfd = sockfd;//客户端文件描述符
    m_address = addr;//客户端地址结构
    addfd(m_epollfd, sockfd, true, m_TRIGMode);// 将 socket 添加到 epoll 监控（启用 EPOLLONESHOT）
    m_user_count++;
    doc_root = root;
    m_TRIGMode = TRIGMode;
    m_close_log = close_log;
    strcpy(sql_user, user.c_str());
    strcpy(sql_passwd, passwd.c_str());
    strcpy(sql_name, sqlname.c_str());
    init();//内部调用 （重置会话状态，准备处理请求）
}
//初始化新接受的连接
//check_state 默认为分析请求行状态
void http_conn::init() {
    mysql = NULL; // MySQL 连接指针，初始为 NULL
    //解析状态相关
    m_check_state = CHECK_STATE_REQUESTLINE;//解析请求行
    m_start_line = 0;//当前解析行的起始位置
    m_checked_idx = 0;//当前已解析的数据位置
    m_read_idx = 0;//当前已读取的末尾位置
    //数据传输相关
    bytes_to_send = 0; // 待发送字节数清零
    bytes_have_send = 0; // 已发送字节数清零
    m_write_idx = 0; // 写缓冲区位置重置
    //HTTP 请求相关
    m_linger = false;//是否保持连接
    m_method = GET;//http 方法
    m_url = 0;//请求的 url
    m_version = 0;//http 版本
    m_host = 0;//主机名
    m_content_length = 0;//内容长度
    cgi = 0; //是否启用 post 处理
    // m_state = 0;//连接状态
    timer_flag = 0;//定时器标志
    improv = 0;//是否 improv
    //缓冲区管理
    memset(m_read_buf, '\0', READ_BUFFER_SIZE); // 清空读缓冲区
    memset(m_write_buf, '\0', WRITE_BUFFER_SIZE); // 清空写缓冲区
    memset(m_real_file, '\0', FILENAME_LEN); // 清空文件路径缓冲区;
}
//行解析 查找\r\n分隔符
http_conn::LINE_STATUS http_conn::parse_line() {
    char temp;
    for (; m_checked_idx < m_read_idx; ++m_checked_idx) {
        temp = m_read_buf[m_checked_idx];
        if (temp == '\r') {
            if ((m_checked_idx + 1) == m_read_idx)
                return LINE_OPEN;// 数据不完整：只有\r，没有\n，LINE_OPEN - 数据不完整，需要继续读取
            else if (m_read_buf[m_checked_idx + 1] == '\n') {
                m_read_buf[m_checked_idx++] = '\0'; // 将\r替换为字符串结束符\0
                m_read_buf[m_checked_idx++] = '\0'; // 将\n替换为字符串结束符\0
                return LINE_OK;//表示成功解析一行
            }
            return LINE_BAD;// 格式错误：\r后面不是\n
        }
        else if (temp == '\n') {
            if (m_checked_idx > 1 && m_read_buf[m_checked_idx - 1] == '\r') {
                m_read_buf[m_checked_idx - 1] = '\0';
                m_read_buf[m_checked_idx++] = '\0';
                return LINE_OK;
            }
            return LINE_BAD; // 格式错误：\n前面不是\r
        }
    }
    return LINE_OPEN;//否则返回数据不完整
}
/* m_read_buf (缓冲区起始地址) │ ▼ [ 已处理数据 | 待处理数据 | 空闲空间 ] ↑ ↑ ↑ 0 m_start_line m_read_idx */
//读取客户数据
bool http_conn::read_once() {
    if (m_read_idx >= READ_BUFFER_SIZE) //防止缓冲区溢出
    {
        return false;
    }
    int bytes_read = 0;
    //LT 读取数据
    if (0 == m_TRIGMode) {
        bytes_read = recv(m_sockfd, m_read_buf + m_read_idx, READ_BUFFER_SIZE - m_read_idx, 0);//m_read_buf 读取缓冲区的起始地址，m_read_idx 当前已存储数据的偏移量，组合起来指向缓冲区中下一个可写入位置，len：缓冲区剩余空间，返回值为实际接收到的字节数
        m_read_idx += bytes_read;//更新缓冲区已读到位置指针
        if (bytes_read <= 0) //<0 读取出错，==0 对端关闭连接
        {
            return false;
        }
        return true;
    }
    //ET 读数据
    else {
        while (true)//得一次性读完
        {
            bytes_read = recv(m_sockfd, m_read_buf + m_read_idx, READ_BUFFER_SIZE - m_read_idx, 0);
            if (bytes_read == -1) //读取错误
            {
                if (errno == EAGAIN || errno == EWOULDBLOCK)
                    break;
                return false;
            }
            else if (bytes_read == 0)//连接关闭
            {
                return false;
            }
            m_read_idx += bytes_read;
        }
        return true;
    }
}
//请求行解析：获得请求方法，目标 url 及 http 版本号 例如：GET /index.html HTTP/1.1
http_conn::HTTP_CODE http_conn::parse_request_line(char *text) {
    m_url = strpbrk(text, " \t");//查找第一个空行或制表符
    if (!m_url) {
        return BAD_REQUEST;
    }
    *m_url++ = '\0';//空格替换为\0，*是解引用获取内存地址的值
    char *method = text;//method 指向 text
    //text="GET\0"
    //m_url="/index.html HTTP/1.1"
    if (strcasecmp(method, "GET") == 0)
        m_method = GET;
    else if (strcasecmp(method, "POST") == 0)
    {
        m_method = POST;
        cgi = 1;// 标记需要 CGI 处理
    }
    else
        return BAD_REQUEST;//不支持的方法
    //分离 url 和版本号
    m_url += strspn(m_url, " \t");//跳过空白字符 指向 URL 真正开始位置
    m_version = strpbrk(m_url, " \t");//查找 url 后的的空格
    if (!m_version)
        return BAD_REQUEST;
    *m_version++ = '\0';
    m_version += strspn(m_version, " \t");
    if (strcasecmp(m_version, "HTTP/1.1") != 0)//只支持 HTTP/1.1
        return BAD_REQUEST;
    if (strncasecmp(m_url, "http://", 7) == 0)//处理 http：//开头的 URL
    {
        m_url += 7;//跳过"http://"
        m_url = strchr(m_url, '/');//找到主机名后的第一个'/'
    }
    if (strncasecmp(m_url, "https://", 8) == 0) {
        m_url += 8;
        m_url = strchr(m_url, '/');
    }
    if (!m_url || m_url[0] != '/')
        return BAD_REQUEST;
    //默认页面处理
    if (strlen(m_url) == 1)//如果只是'/'，默认显示 judge.html
        strcat(m_url, "judge.html");
    m_check_state = CHECK_STATE_HEADER;//下一步解析请求头
    return NO_REQUEST;//请求还未完整解析（还有别的要解析）
}
//解析 http 请求头，处理 Connection、Content-length、Host 等重要头部字段
http_conn::HTTP_CODE http_conn::parse_headers(char *text) {
    if (text[0] == '\0')//表示遇到空行，HTTP 头部结束
    {
        if (m_content_length != 0) //说明后面还有请求体，切换到内容解析状态
        {
            m_check_state = CHECK_STATE_CONTENT
            return NO_REQUEST;//还有请求体需要解析
        }
        return GET_REQUEST; //没有请求体，表示请求解析完成
    }
    //connection 头部
    else if (strncasecmp(text, "Connection:", 11) == 0)//处理连接保持设置
    {
        text += 11;
        text += strspn(text, " \t");// 跳过空白字符
        if (strcasecmp(text, "keep-alive") == 0) {
            m_linger = true;//设置长连接标志
        }
    }
    //connection-length 头部
    else if (strncasecmp(text, "Content-length:", 15) == 0) //获取请求头长度
    {
        text += 15;
        text += strspn(text, " \t");
        m_content_length = atol(text);//atol(text) 将字符串转为长整型
    }
    else if (strncasecmp(text, "Host:", 5) == 0)//获取目标主机名
    {
        text += 5;
        text += strspn(text, " \t");
        m_host = text;//直接保存指针
    }
    else {
        LOG_INFO("oop!unknow header: %s", text);//对于不认识的头部字段，记录日志但继续解析
    }
    return NO_REQUEST;
}
//这个函数负责检查 POST 请求的请求体受否被完全接收
http_conn::HTTP_CODE http_conn::parse_content(char *text) {
    // 检查是否已经读取了完整的消息体
    if (m_read_idx >= (m_content_length + m_checked_idx))//已接收数据量 >= 期望的请求体长度 + 已解析位置（未解析的数据长度 = m_read_idx - m_checked_idx）
    {
        text[m_content_length] = '\0';// 在消息体末尾添加字符串结束符
        m_string = text;//保存消息体内容
        return GET_REQUEST;//返回完整请求
    }
    return NO_REQUEST;//需要继续读取
}
//这是一个 HTTP 请求处理的主状态机函数，负责协调整个 HTTP 请求的解析过程。
http_conn::HTTP_CODE http_conn::process_read() {
    LINE_STATUS line_status = LINE_OK;// 行解析状态
    HTTP_CODE ret = NO_REQUEST;//HTTP 解析结果
    char *text = 0;// 当前正在处理的行数据
    //m_check_state: 主解析状态（请求行、头部、内容）
    while ((m_check_state == CHECK_STATE_CONTENT && line_status == LINE_OK) || ((line_status = parse_line()) == LINE_OK))//正在解析请求体（直接进入内容处理）和按行解析模式（调用 parse_line（）先解析一行数据后继续处理）
    {
        text = get_line(); //get_line()：返回当前解析行的指针
        m_start_line = m_checked_idx; // 更新起始行位置，用于下一轮解析
        LOG_INFO("%s", text); // 记录日志
        switch (m_check_state) {
        case CHECK_STATE_REQUESTLINE: //解析请求行
        {
            ret = parse_request_line(text);
            if (ret == BAD_REQUEST)
                return BAD_REQUEST;
            break;
        }
        case CHECK_STATE_HEADER://解析头
        {
            ret = parse_headers(text); // 解析各个头部字段：Connection、Content-Length、Host 等头部
            if (ret == BAD_REQUEST)
                return BAD_REQUEST;
            else if (ret == GET_REQUEST) // 头部解析完成且无请求体
            {
                return do_request(); // 处理请求
            }
            break;
        }
        case CHECK_STATE_CONTENT://解析请求体
        {
            ret = parse_content(text); // 检查消息体是否完整
            if (ret == GET_REQUEST) // 消息体接收完整
                return do_request(); // 处理请求
            line_status = LINE_OPEN; // 否则设置为打开状态，继续读取
            break;
        }
        default:
            return INTERNAL_ERROR;
        }
    }
    return NO_REQUEST;
}
//HTTP 请求处理的核心业务逻辑
http_conn::HTTP_CODE http_conn::do_request() {
    //基础路径设置
    strcpy(m_real_file, doc_root);// 设置网站根目录
    int len = strlen(doc_root);
    const char *p = strrchr(m_url, '/'); // 找到最后一个斜杠
    //处理 cgi 登录或注册
    if (cgi == 1 && (*(p + 1) == '2' || *(p + 1) == '3')) //其中/2 登录 /3 注册
    {
        //根据标志判断是登录检测还是注册检测
        char flag = m_url[1];
        //构建真实文件路径
        char *m_url_real = (char *)malloc(sizeof(char) * 200);
        strcpy(m_url_real, "/");
        strcat(m_url_real, m_url + 2);
        strncpy(m_real_file + len, m_url_real, FILENAME_LEN - len - 1);
        free(m_url_real);
        //解析用户名和密码
        //user=123&passwd=123
        char name[100], password[100];
        int i;
        for (i = 5; m_string[i] != '&'; ++i)
            name[i - 5] = m_string[i];
        name[i - 5] = '\0';
        int j = 0;
        for (i = i + 10; m_string[i] != '\0'; ++i, ++j)
            password[j] = m_string[i];
        password[j] = '\0';
        if (*(p + 1) == '3') {
            //如果是注册，先检测数据库中是否有重名的
            //没有重名的，进行增加数据
            char *sql_insert = (char *)malloc(sizeof(char) * 200);
            strcpy(sql_insert, "INSERT INTO user(username, passwd) VALUES(");
            strcat(sql_insert, "'");
            strcat(sql_insert, name);
            strcat(sql_insert, "', '");
            strcat(sql_insert, password);
            strcat(sql_insert, ")'");
            if (users.find(name) == users.end())// 检查用户名是否已存在
            {
                m_lock.lock();
                int res = mysql_query(mysql, sql_insert);//插入数据库
                users.insert(pair<string, string>(name, password));/更新缓存
                m_lock.unlock();
                if (!res)
                    strcpy(m_url, "/log.html"); // 注册成功
                else
                    strcpy(m_url, "/registerError.html");// 数据库错误
            }
            else
                strcpy(m_url, "/registerError.html");// 用户名已存在
        }
        //如果是登录，直接判断
        //若浏览器端输入的用户名和密码在表中可以查找到，返回 1，否则返回 0
        else if (*(p + 1) == '2') {
            if (users.find(name) != users.end() && users[name] == password)
                strcpy(m_url, "/welcome.html");// 登录成功
            else
                strcpy(m_url, "/logError.html");//登录失败
        }
    }
    // 根据 URL 数字路由到不同页面
    if (*(p + 1) == '0') {
        char *m_url_real = (char *)malloc(sizeof(char) * 200);
        strcpy(m_url_real, "/register.html");
        strncpy(m_real_file + len, m_url_real, strlen(m_url_real));
        free(m_url_real);
    }
    else if (*(p + 1) == '1') {
        char *m_url_real = (char *)malloc(sizeof(char) * 200);
        strcpy(m_url_real, "/log.html");
        strncpy(m_real_file + len, m_url_real, strlen(m_url_real));
        free(m_url_real);
    }
    else if (*(p + 1) == '5') {
        char *m_url_real = (char *)malloc(sizeof(char) * 200);
        strcpy(m_url_real, "/picture.html");
        strncpy(m_real_file + len, m_url_real, strlen(m_url_real));
        free(m_url_real);
    }
    else if (*(p + 1) == '6') {
        char *m_url_real = (char *)malloc(sizeof(char) * 200);
        strcpy(m_url_real, "/video.html");
        strncpy(m_real_file + len, m_url_real, strlen(m_url_real));
        free(m_url_real);
    }
    else if (*(p + 1) == '7') {
        char *m_url_real = (char *)malloc(sizeof(char) * 200);
        strcpy(m_url_real, "/fans.html");
        strncpy(m_real_file + len, m_url_real, strlen(m_url_real));
        free(m_url_real);
    }
    else
        strncpy(m_real_file + len, m_url, FILENAME_LEN - len - 1);//直接访问
    // 检查文件状态
    if (stat(m_real_file, &m_file_stat) < 0)
        return NO_RESOURCE; // 文件不存在
    if (!(m_file_stat.st_mode & S_IROTH))
        return FORBIDDEN_REQUEST; // 无读取权限
    if (S_ISDIR(m_file_stat.st_mode))
        return BAD_REQUEST; // 不能访问目录
    // 使用内存映射提高文件读取性能
    int fd = open(m_real_file, O_RDONLY);
    m_file_address = (char*)mmap(0, m_file_stat.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
    close(fd);
    return FILE_REQUEST;
}
//这是一个内存映射清理函数，用于释放之前通过 mmap 创建的内存映射。
void http_conn::unmap() {
    if (m_file_address) {
        munmap(m_file_address, m_file_stat.st_size);
        m_file_address = 0;
    }
}
//HTTP 响应数据发送函数，使用了 writev 系统调用来实现高性能的分散写操作。
bool http_conn::write() {
    int temp = 0;
    if (bytes_to_send == 0) {
        modfd(m_epollfd, m_sockfd, EPOLLIN, m_TRIGMode); //重新监听读事件
        //初始化连接状态
        init();
        return true;
    }
    while (1) {
        temp = writev(m_sockfd, m_iv, m_iv_count); //使用 writev 系统调用一次性发送多个缓冲区的数据。
        if (temp < 0) {
            if (errno == EAGAIN)//写缓冲区满，注册写事件等待下次可写
            {
                modfd(m_epollfd, m_sockfd, EPOLLOUT, m_TRIGMode);
                return true;
            }
            //清理资源并关闭连接
            unmap();
            return false;
        }
        //更新发送状态
        bytes_have_send += temp;
        bytes_to_send -= temp;
        if (bytes_have_send >= m_iv[0].iov_len) {
            // 情况 1：第一个缓冲区已发送完
            m_iv[0].iov_len = 0;
            m_iv[1].iov_base = m_file_address + (bytes_have_send - m_write_idx);
            m_iv[1].iov_len = bytes_to_send;
        }
        else {
            // 情况 2：第一个缓冲区未发送完
            m_iv[0].iov_base = m_write_buf + bytes_have_send;
            m_iv[0].iov_len = m_iv[0].iov_len - bytes_have_send;
        }
        if (bytes_to_send <= 0) {
            unmap();
            modfd(m_epollfd, m_sockfd, EPOLLIN, m_TRIGMode);
            if (m_linger) {
                init();
                return true;
            }
            else {
                return false;
            }
        }
    }
}
//这是一个可变参数响应构建函数，用于格式化并添加 HTTP 响应数据到写缓冲区。
bool http_conn::add_response(const char *format, ...) {
    if (m_write_idx >= WRITE_BUFFER_SIZE)
        return false;
    va_list arg_list;
    va_start(arg_list, format);
    int len = vsnprintf(m_write_buf + m_write_idx, WRITE_BUFFER_SIZE - 1 - m_write_idx, format, arg_list);
    if (len >= (WRITE_BUFFER_SIZE - 1 - m_write_idx)) {
        va_end(arg_list);
        return false;
    }
    m_write_idx += len;
    va_end(arg_list);
    LOG_INFO("request:%s", m_write_buf);
    return true;
}
bool http_conn::add_status_line(int status, const char *title) {
    return add_response("%s %d %s\r\n", "HTTP/1.1", status, title);
}
bool http_conn::add_headers(int content_len) {
    return add_content_length(content_len) && add_linger() && add_blank_line();
}
bool http_conn::add_content_length(int content_len) {
    return add_response("Content-Length:%d\r\n", content_len);
}
bool http_conn::add_content_type() {
    return add_response("Content-Type:%s\r\n", "text/html");
}
bool http_conn::add_linger() {
    return add_response("Connection:%s\r\n", (m_linger == true) ? "keep-alive" : "close");
}
bool http_conn::add_blank_line() {
    return add_response("%s", "\r\n");
}
bool http_conn::add_content(const char *content) {
    return add_response("%s", content);
}
bool http_conn::process_write(HTTP_CODE ret) {
    switch (ret) {
    case INTERNAL_ERROR://内部服务器错误 (500)
    {
        add_status_line(500, error_500_title);
        add_headers(strlen(error_500_form));
        if (!add_content(error_500_form))
            return false;
        break;
    }
    case BAD_REQUEST:
    {
        add_status_line(404, error_404_title);
        add_headers(strlen(error_404_form));
        if (!add_content(error_404_form))
            return false;
        break;
    }
    case FORBIDDEN_REQUEST:
    {
        add_status_line(403, error_403_title);
        add_headers(strlen(error_403_form));
        if (!add_content(error_403_form))
            return false;
        break;
    }
    case FILE_REQUEST:
    {
        add_status_line(200, ok_200_title);
        if (m_file_stat.st_size != 0) {
            add_headers(m_file_stat.st_size);
            m_iv[0].iov_base = m_write_buf;
            m_iv[0].iov_len = m_write_idx;
            m_iv[1].iov_base = m_file_address;
            m_iv[1].iov_len = m_file_stat.st_size;
            m_iv_count = 2;
            bytes_to_send = m_write_idx + m_file_stat.st_size;
            return true;
        }
        else {
            const char *ok_string = "<html><body></body></html>";
            add_headers(strlen(ok_string));
            if (!add_content(ok_string))
                return false;
        }
    }
    default:
        return false;
    }
    m_iv[0].iov_base = m_write_buf;
    m_iv[0].iov_len = m_write_idx;
    m_iv_count = 1;
    bytes_to_send = m_write_idx;
    return true;
}
//这是一个 HTTP 连接处理的主流程函数，负责协调整个 HTTP 请求的处理过程。
void http_conn::process() {
    HTTP_CODE read_ret = process_read();
    if (read_ret == NO_REQUEST) {
        modfd(m_epollfd, m_sockfd, EPOLLIN, m_TRIGMode);
        return;
    }
    bool write_ret = process_write(read_ret);
    if (!write_ret) {
        close_conn();
    }
    modfd(m_epollfd, m_sockfd, EPOLLOUT, m_TRIGMode);
}

Config

config.h 和 config.cpp 主要是对一些参数赋初值以及解析参数，以此就不过多讲解