【项目】 ：C++ - 仿mudou库one thread one loop式并发服务器实现(代码实现)

上一个项目中我实现了日志系统，因此本项目的日志模块我便使用了该系统。
日志系统博客
日志代码仓库

不过在本项目中使用日志系统模块似乎有点大了，这里有个比较简便的日志宏的实现：

#define INF 0
#define DBG 1
#define ERR 2

// 默认日志级别
#define DEFAULT_LOG_LEVEL DBG

// 通用日志宏
#define LOG(level, format, ...) { \
    if (level >= DEFAULT_LOG_LEVEL) { \
        time_t t = time(NULL); \
        struct tm *m = localtime(&t); \
        char ts[32] = {0}; \
        strftime(ts, 31, "%H:%M:%S", m); \
        fprintf(stdout, "[%p %s %s:%d] " format "\n", \
                (void*)pthread_self(), ts, __FILE__, __LINE__, ##__VA_ARGS__); \
    } \
}

// 不同级别日志宏
#define INF_LOG(format, ...) LOG(INF, format, ##__VA_ARGS__);
#define DBG_LOG(format, ...) LOG(DBG, format, ##__VA_ARGS__);
#define ERR_LOG(format, ...) LOG(ERR, format, ##__VA_ARGS__);

一、SERVER模块

缓存区 Buffer 类

Buffer 类用于实现用户态缓冲区，提供数据存储、读取和管理等功能。

#define BUFF_DEFAULT_SIZE 1024
class Buffer
{
private:
    std::vector<char> _buffer; // 缓冲区
    uint64_t _read_idx;        // 读偏移
    uint64_t _write_idx;       // 写偏移

public:
    char *Begin() { return &*_buffer.begin(); }
    // 获取读写位置起始地址
    char *WritePosition() { return Begin() + _write_idx; }
    char *ReadPosition() { return Begin() + _read_idx; }

    // 获取当前缓冲区中 前后缓冲区位置大小
    uint64_t TailFreeSpace() { return _buffer.size() - _write_idx; }
    uint64_t HeadFreeSpace() { return _read_idx; }

    // 获取可读数据大小
    uint64_t ReadAbleSize() { return _write_idx - _read_idx; }

    // 读写idx 向后移动
    void MoveReadOffset(uint64_t len)
    {
        if (len == 0)
            return;
        assert(len <= ReadAbleSize());
        _read_idx += len;
    }
    void MoveWriteOffset(uint64_t len)
    {
        if (len == 0)
            return;
        assert(len <= TailFreeSpace());
        _write_idx += len;
    }

    void EnsureWriteSpace(uint64_t len)
    {
        if (len <= TailFreeSpace())
            return;
        /*如果len 是小于等于缓冲区中所有空闲位置大小，那么将数据往前移动*/
        if (len <= TailFreeSpace() + HeadFreeSpace())
        {
            uint64_t res = ReadAbleSize();
            std::copy(ReadPosition(), ReadPosition() + res, Begin());
            _read_idx = 0;
            _write_idx = res;
        }
        else // 缓冲区的空间不足，进行扩容
        {
            Log::DEBUG("RESIZE %ld", _write_idx + len);
            _buffer.resize(_write_idx + len);
        }
    }

public:
    Buffer() : _buffer(BUFF_DEFAULT_SIZE), _read_idx(0), _write_idx(0) {}

    // write接口
    void Write(const char *data, uint64_t len)
    {
        if (len == 0)
            return;
        EnsureWriteSpace(len);
        std::copy(data, data + len, WritePosition());
    }
    void WriteAndPush(const char *data, uint64_t len)
    {
        if (len == 0)
            return;
        Write(data, len);
        MoveWriteOffset(len);
    }

    void WriteString(const std::string &data)
    {
        Write(data.c_str(), data.size());
    }
    void WriteStringAndPush(const std::string &data)
    {
        WriteString(data);
        MoveWriteOffset(data.size());
    }

    void WriteBuffer(Buffer &buf)
    {
        Write(buf.ReadPosition(), buf.ReadAbleSize());
    }
    void WriteBufferAndPush(Buffer &buf)
    {
        WriteBuffer(buf);
        MoveWriteOffset(buf.ReadAbleSize());
    }

    // read接口
    void Read(char *buf, uint64_t len)
    {
        if (len == 0)
            return;
        assert(len <= ReadAbleSize());
        std::copy(ReadPosition(), ReadPosition() + len, buf);
    }
    void ReadAndPop(char *buf, uint64_t len)
    {
        Read(buf, len);
        MoveReadOffset(len);
    }

    std::string ReadAsString(uint64_t len)
    {
        assert(len <= ReadAbleSize());
        std::string str;
        str.resize(len);
        Read(&str[0], len);
        return str;
    }
    std::string ReadAsStringAndPop(uint64_t len)
    {
        assert(len <= ReadAbleSize());
        std::string str = ReadAsString(len);
        MoveReadOffset(len);
        return str;
    }
    // 这里我们就不需要再写一个ReadBuffer了 因为使用WriteBuffer可以实现同样的功能

    std::string GetLine()
    {
        char *pos = (char *)memchr(ReadPosition(), '\n', ReadAbleSize());
        if (pos == NULL)
        {
            return "";
        }
        //  +1是为了把换行字符也取出来。读取出\n
        return ReadAsString(pos - ReadPosition() + 1);
    }
    std::string GetLineAndPop()
    {
        std::string str = GetLine();
        MoveReadOffset(str.size());
        return str;
    }

    void Clear()
    {
        _write_idx = 0;
        _read_idx = 0;
    }
};

套接字Socket类

封装套接字操作。

class Socket
{
private:
    int _sockfd;

public:
    Socket() : _sockfd(-1) {}
    Socket(int fd) : _sockfd(fd) {}
    ~Socket() { Close(); }

    int GetFd() { return _sockfd; }
    // 创建套接字
    bool CreateSock()
    {
        _sockfd = socket(AF_INET, SOCK_STREAM, 0);
        if (_sockfd < 0)
        {
            Log::ERROR("%s", "Create socket false");
            return false;
        }
        return true;
    }

    // fd绑定ip port
    bool Bind(const std::string &ip, uint16_t port)
    {
        struct sockaddr_in addr;
        addr.sin_family = AF_INET;
        addr.sin_port = htons(port);
        addr.sin_addr.s_addr = inet_addr(ip.c_str());

        int n = bind(_sockfd, (const sockaddr *)&addr, sizeof(addr));
        if (n < 0)
        {
            Log::ERROR("%s", "SOCKET bind false");
            return false;
        }
        return true;
    }

    // 监听
    bool Listen(int backlog = 15)
    {
        int ret = listen(_sockfd, backlog);
        if (ret < 0)
        {
            Log::ERROR("%s", "SOCKET listen false");
            return false;
        }
        return true;
    }

    // 客户端连接服务器
    bool Connect(const std::string &ip, uint16_t port)
    {
        struct sockaddr_in addr;
        addr.sin_family = AF_INET;
        addr.sin_port = htons(port);
        addr.sin_addr.s_addr = inet_addr(ip.c_str());

        int n = connect(_sockfd, (const sockaddr *)&addr, sizeof(addr));
        if (n < 0)
        {
            Log::ERROR("%s", "SOCKET Connect false");
            return false;
        }
        return true;
    }

    // 监听 接受新连接
    int Accept()
    {
        // 这里我不需要知道ip 和port 所以我设置了 null
        int newfd = accept(_sockfd, NULL, NULL);
        if (newfd < 0)
        {
            Log::ERROR("%s", "SOCKET accept false");
            return -1;
        }
        Log::DEBUG("%s", "get a link");
        return newfd;
    }

    // flag == MSG_DONTWAIT 表示当前接收为非阻塞。
    ssize_t Recv(void *buff, size_t len, int nonblock_flag = 0)
    {
        ssize_t n = recv(_sockfd, buff, len, nonblock_flag);
        if (n <= 0)
        {
            // EAGAIN 当前socket的接收缓冲区中没有数据了，在非阻塞的情况下才会有这个错误
            // EINTR  表示当前socket的阻塞等待，被信号打断了，
            if (errno == EAGAIN || errno == EINTR)
                return 0; // 表示这次接收没有接收到数据

            Log::ERROR("%s", "SOCKET recv false");
            return -1;
        }
        return n;
    }

    ssize_t NonBlockRecv(void *buff, size_t len)
    {
        return Recv(buff, len, MSG_DONTWAIT);
    }

    ssize_t Send(const void *buff, size_t len, int nonblock_flag = 0)
    {
        ssize_t n = send(_sockfd, buff, len, nonblock_flag);
        if (n <= 0)
        {
            // EAGAIN 当前socket的接收缓冲区中没有数据了，在非阻塞的情况下才会有这个错误
            // EINTR  表示当前socket的阻塞等待，被信号打断了，
            if (errno == EAGAIN || errno == EINTR)
                return 0; // 表示这次接收没有接收到数据

            Log::ERROR("%s", "SOCKET send false");
            return -1;
        }
        return n;
    }

    ssize_t NonBlockSend(const void *buff, size_t len)
    {
        return Send(buff, len, MSG_DONTWAIT);
    }

    // 关闭套接字
    void Close()
    {
        if (_sockfd != -1)
        {
            close(_sockfd);
            _sockfd = -1;
        }
    }

    // 设置非堵塞
    void SetNonBlock()
    {
        int flag = fcntl(_sockfd, F_GETFL, 0);
        fcntl(_sockfd, F_SETFL, flag | O_NONBLOCK);
    }

    // 设置套接字选项---开启地址端口重用
    void ReuseAddress()
    {
        // int setsockopt(int fd, int leve, int optname, void *val, int vallen)
        int val = 1;
        setsockopt(_sockfd, SOL_SOCKET, SO_REUSEADDR, (void *)&val, sizeof(int));
        val = 1;
        setsockopt(_sockfd, SOL_SOCKET, SO_REUSEPORT, (void *)&val, sizeof(int));
    }

    // 创建一个服务端
    bool CreateServer(uint16_t port, const std::string &ip = "0.0.0.0", bool nonblock_flag = false, int backlog = 15)
    {
        // 1. 创建套接字，2. 设置非阻塞，3. 启动地址重用 ，4.绑定地址 ，5. 开始监听
        if (CreateSock() == false)
            return false;
        if (nonblock_flag == true)
            SetNonBlock();
        ReuseAddress();
        if (Bind(ip, port) == false)
            return false;
        if (Listen(backlog) == false)
            return false;

        Log::INFO("%s", "create server success");
        return true;
    }

    bool CreateClient(uint16_t port, const std::string &ip)
    {
        // 1. 创建套接字。bind(对于客户端可以忽略)  2. 连接服务器
        if (CreateSock() == false)
            return false;
        if (Connect(ip, port) == false)
            return false;
        Log::INFO("%s", "create client success");
        return true;
    }
};

事件管理Channel类

管理描述符的 I/O 事件（读、写、错误等）。
与 Poller 配合，触发事件时回调相应处理函数。

class Poller;
class EventLoop;
// Channel 实现单个 描述符与事件的管理
class Channel
{
    using EventCallback = std::function<void()>;

private:
    int _fd;
    EventLoop *_loop;
    uint32_t _events;  // 监控的事件
    uint32_t _revents; // 已就绪的事件
    EventCallback _read_callback;
    EventCallback _write_callback;
    EventCallback _error_callback;
    EventCallback _close_callback; // 连接断开触发的回调函数
    EventCallback _event_callback; // 事件触发后调整活跃度
public:
    Channel(EventLoop *loop, int fd) : _loop(loop), _fd(fd), _events(0), _revents(0) {}
    void SetREvents(uint32_t events) { _revents = events; } // 设置实际就绪的事件
    void SetReadCallback(const EventCallback &cb) { _read_callback = cb; }
    void SetWriteCallback(const EventCallback &cb) { _write_callback = cb; }
    void SetErrorCallback(const EventCallback &cb) { _error_callback = cb; }
    void SetCloseCallback(const EventCallback &cb) { _close_callback = cb; }
    void SetEventCallback(const EventCallback &cb) { _event_callback = cb; }

    int GetFd() { return _fd; }
    uint32_t Events() { return _events; } // 获取需要监控的事件

    // 判断当前是否监控了可读事件 或者可写事件
    bool ReadAble() { return _events & EPOLLIN; }
    bool WriteAble() { return _events & EPOLLOUT; }

    // 启动读写事件监控
    void EnableRead()
    {
        _events |= EPOLLIN;
        Update();
    }
    void EnableWrite()
    {
        _events |= EPOLLOUT;
        Update();
    }

    // 关闭读写事件监控
    void DisableRead()
    {
        _events &= ~EPOLLIN;
        Update();
    }
    void DisableWrite()
    {
        _events &= ~EPOLLOUT;
        Update();
    }
    // 关闭所有事件监控
    void DisableAll() { _events = 0; }

    // 直接移除在epoll的监控, 因为需要调用poller的接口，所以类外定义
    void Remove();
    void Update();

    void HandleEvent()
    {
        // 读事件就绪 | 对端断开 |
        if ((_revents & EPOLLIN) || (_revents & EPOLLRDHUP) || (_revents & EPOLLPRI))
        {
   
            if (_read_callback)
                _read_callback();
        }

        // EPOLLOUT < EPOLLERR < EPOLLHUP 如果出错了，就别处理写；如果挂掉了，就别处理写/错。
        if (_revents & EPOLLHUP)
        {
         
            if (_close_callback)
                _close_callback();
            return;
        }
        else if (_revents & EPOLLERR)
        {
           
            if (_error_callback)
                _error_callback();
            return;
        }
        else if (_revents & EPOLLOUT)
        {

            if (_write_callback)
                _write_callback();
        }

        if (_event_callback)
            _event_callback(); // 调整事件的活跃度
    }
};

描述符事件监控Poller类

#define MAX_EPOLLEVENTS 100
class Poller
{
private:
    int _epfd; // epoll句柄
    struct epoll_event _evs[MAX_EPOLLEVENTS];
    std::unordered_map<int, Channel *> _channels; // fd和事件管理的映射
private:
    // 对epoll中的红黑树事件进行管理
    void Updata(Channel *channel, int op)
    {
        int fd = channel->GetFd();
        struct epoll_event ev;
        ev.data.fd = fd;
        ev.events = channel->Events();
        int ret = epoll_ctl(_epfd, op, fd, &ev);
        if (ret < 0)
        {
            Log::ERROR("%s", "epoll_ctl false");
        }
        return;
    }

    // 判断channel 是否已经添加到了事件管理中
    bool HasChannel(Channel *channel)
    {
        int fd = channel->GetFd();
        auto it = _channels.find(fd);
        if (it == _channels.end())
            return false;

        return true;
    }

public:
    Poller()
    {
        _epfd = epoll_create(MAX_EPOLLEVENTS);
        if (_epfd < 0)
        {
            Log::ERROR("epoll_create false");
            abort(); // 退出程序
        }
    }

    // 修改事件
    void UpdateEvent(Channel *channel)
    {
        // 判断channel 是否存在 事件管理中
        bool ret = HasChannel(channel);
        if (ret == false)
        {
            _channels.insert(std::make_pair(channel->GetFd(), channel));
            Updata(channel, EPOLL_CTL_ADD);
            return;
        }
        Updata(channel, EPOLL_CTL_MOD);
        return;
    }

    void RemoveEvent(Channel *channel)
    {
        auto it = _channels.find(channel->GetFd());
        if (it == _channels.end())
            return;
        // 在hash中删除
        _channels.erase(it);
        // 在epoll红黑树中删除
        Updata(channel, EPOLL_CTL_DEL);
    }

    // 开始监控，返回活跃连接
    void Poll(std::vector<Channel *> *active)
    {
        int nfds = epoll_wait(_epfd, _evs, MAX_EPOLLEVENTS, -1); // 永久堵塞
        if (nfds < 0)
        {
            // EINTR  表示当前socket的阻塞等待，被信号打断了，
            if (errno == EINTR) // 信号打断
                return;

            Log::ERROR("EPOLL WAIT ERROR:%s", strerror(errno));
            return;
        }

        for (int i = 0; i < nfds; i++)
        {
            auto it = _channels.find(_evs[i].data.fd);
            assert(it != _channels.end());
            it->second->SetREvents(_evs[i].events); // 设置就绪事件
            active->push_back(it->second);          // 输出型参数
        }
        return;
    }
};

定时任务管理TimerWheel类

using TaskFunc = std::function<void()>;
using ReleaseFunc = std::function<void()>;
class TimerTask
{

private:
    uint64_t _id;          // 定时器任务ID
    uint32_t _timeout;     // 定时任务超时事件
    bool _canceled;        // 取消定时任务,false-表示没有被取消， true-表示被取消
    TaskFunc _task_cb;     // 定时器对象要执行的定时任务
    ReleaseFunc _relea_cb; // 用于删除TimerWheel中保存的定时器对象信息
public:
    TimerTask(uint64_t id, uint32_t timeout, const TaskFunc &cb) : _id(id), _timeout(timeout), _canceled(false), _task_cb(cb) {}
    ~TimerTask()
    {
        if (_canceled == false)
            _task_cb();
        _relea_cb();
    }

    void Cancel() { _canceled = true; }
    void SetRelease(const ReleaseFunc &cb) { _relea_cb = cb; }
    uint32_t GetTimeout() { return _timeout; }
};

class TimerWheel
{
    using WeakTask = std::weak_ptr<TimerTask>;
    using ShareTask = std::shared_ptr<TimerTask>;

private:
    int _tick;                                      // 当前的秒针，走到哪里释放哪里，释放哪里，就相当于执行哪里的任务
    int _capacity;                                  // 表盘最大数量---其实就是最大延迟时间
    std::unordered_map<uint64_t, WeakTask> _timers; //_timers 的作用只是 快速查找任务（通过 id 找对应的任务）。它本身并不想延长任务的生命周期。
    std::vector<std::vector<ShareTask>> _wheel;

    // timefd
    EventLoop *_loop;
    int _timerfd; // 定时器描述符--可读事件回调就是读取计数器，执行定时任务
    std::unique_ptr<Channel> _timer_channel;

private:
    void RemoveTimer(uint64_t id)
    {
        auto it = _timers.find(id);
        if (it != _timers.end())
        {
            _timers.erase(it);
        }
    }

    static int CreateTimerfd()
    {
        int timerfd = timerfd_create(CLOCK_MONOTONIC, 0);
        if (timerfd < 0)
        {
            Log::ERROR("timerfd create false");
            abort();
        }
        struct itimerspec itime;
        itime.it_value.tv_sec = 1; // 第一次超时时间为1s后
        itime.it_value.tv_nsec = 0;
        itime.it_interval.tv_sec = 1; // 第一次超时后，每次超时的间隔时
        itime.it_interval.tv_nsec = 0;
        timerfd_settime(timerfd, 0, &itime, NULL);
        return timerfd;
    }

    // 跑动时间轮
    void RunWheel()
    {
        _tick = (_tick + 1) % _capacity;
        _wheel[_tick].clear(); // 清空指定位置的数组，就会把数组中保存的所有管理定时器对象的shared_ptr释放掉
    }

    int ReadTimefd()
    {
        uint64_t times;
        // 有可能因为其他描述符的事件处理花费事件比较长，然后在处理定时器描述符事件的时候，有可能就已经超时了很多次
        // read读取到的数据times就是从上一次read之后超时的次数
        int ret = read(_timerfd, &times, 8);
        if (ret < 0)
        {
            Log::ERROR("read Timerfd false");
            abort();
        }
        return times;
    }

    // 通过timerfd read来跑动时间轮
    void OnTime()
    {
        int times = ReadTimefd();
        for (int i = 0; i < times; i++)
        {
            RunWheel();
        }
    }

    void TimerAddInLoop(uint64_t id, uint32_t timeout, const TaskFunc &cb)
    {
        ShareTask ptr(new TimerTask(id, timeout, cb));
        ptr->SetRelease(std::bind(&TimerWheel::RemoveTimer, this, id));
        // 添加到timer 中
        _timers[id] = WeakTask(ptr);
        int pos = (_tick + timeout) % _capacity;
        _wheel[pos].push_back(ptr);
    }

    // 刷新/延迟定时任务
    void TimerRefreshInLoop(uint64_t id)
    {

        // 通过保存的定时器对象的weak_ptr构造一个shared_ptr出来，添加到轮子中
        auto it = _timers.find(id);
        if (it == _timers.end())
        {
            return; // 定时任务没有找到
        }
        ShareTask ptr = it->second.lock(); // lock获取weak_ptr管理的对象对应的shared_ptr
        // 由于是shared_ptr，所以我们只需要将一个新的shared_ptr插入到_wheel中即可达到延迟的目的
        int timeout = ptr->GetTimeout();
        int pos = (_tick + timeout) %_capacity;
        _wheel[pos].push_back(ptr);
    }

    // 将定时任务的任务取消
    void TaskCancelInLoop(uint64_t id)
    {
        auto it = _timers.find(id);
        if (it == _timers.end())
        {
            return;
        }

        ShareTask ptr = it->second.lock();
        if (ptr)
            ptr->Cancel();
    }

public:
    TimerWheel(EventLoop *loop) : _tick(0), _capacity(60), _wheel(_capacity), _loop(loop),
                                  _timerfd(CreateTimerfd()), _timer_channel(new Channel(_loop, _timerfd))
    {
        _timer_channel->SetReadCallback(std::bind(&TimerWheel::OnTime, this));
        _timer_channel->EnableRead();
    }

    void TimerAdd(uint64_t id, uint32_t timeout, const TaskFunc &cb);
    void TimerRefresh(uint64_t id);
    void TimerCancel(uint64_t id);

    /*这个接口存在线程安全问题--这个接口实际上不能被外界使用者调用，只能在模块内，在对应的EventLoop线程内执行*/
    bool HasTimer(uint64_t id)
    {
        auto it = _timers.find(id);
        if (it == _timers.end())
        {
            return false;
        }
        return true;
    }
};

Reactor-EventLoop线程池类

using Functor = std::function<void()>;
class EventLoop
{
private:
    std::mutex _mutex;                       // 给任务池上锁
    std::vector<Functor> _tasks;             // 任务池
    std::thread::id _thread_id;              // 每一个Evenetloop都由一个线程池来管理
    int _event_fd;                           // eventfd唤醒IO事件监控有可能导致的阻塞
    std::unique_ptr<Channel> _event_channel; // eventfd的Channel
    Poller _poller;                          // 当前Loop下所有描述符的事件监控
    TimerWheel _timer_wheel;                 // 定时器模块
public:
    // 执行任务池中的任务
    void RunAllTask()
    {
        std::vector<Functor> tmp;
        {
            std::unique_lock<std::mutex> _lock(_mutex);
            _tasks.swap(tmp);
        }
        for (auto &f : tmp)
        {
            f();
        }
        return;
    }

    // 创造一个 eventfd , readEvent , WeakUpEventfd
    static int CreateEvent()
    {
        int efd = eventfd(0, EFD_CLOEXEC | EFD_NONBLOCK);
        if (efd < 0)
        {
            Log::ERROR("create eventfd false");
            abort(); // 关闭程序
        }
        return efd;
    }
    void ReadEventfd()
    {
        uint64_t ret = 0;
        int n = read(_event_fd, &ret, sizeof(ret));
        if (n < 0)
        {
            // EINTR -- 被信号打断；   EAGAIN -- 表示无数据可读
            if (errno == EINTR || errno == EAGAIN)
            {
                return;
            }
            Log::ERROR("read eventfd false");
            abort();
        }
        return;
    }
    void WakeUpEventfd()
    {
        uint64_t ret = 1;
        int n = write(_event_fd, &ret, sizeof(ret));
        if (n < 0)
        {
            // EINTR -- 被信号打断；   EAGAIN -- 表示无数据可读
            if (errno == EINTR || errno == EAGAIN)
            {
                return;
            }
            Log::ERROR("write eventfd false");
            abort();
        }
        return;
    }

public:
    EventLoop() : _thread_id(std::this_thread::get_id()),
                  _event_fd(CreateEvent()),
                  _event_channel(new Channel(this, _event_fd)),
                  _timer_wheel(this)
    {
        // 给 evetfd设置可读回调
        _event_channel->SetReadCallback(std::bind(&EventLoop::ReadEventfd, this));
        // 启动读事件监控
        _event_channel->EnableRead();
    }

    // 事件监控->就绪事件处理->执行任务池中任务
    void Start()
    {
        while (1)
        {
            std::vector<Channel *> actives;
            _poller.Poll(&actives);
            for (auto &channel : actives)
            {
                channel->HandleEvent();
            }
            RunAllTask();
        }
    }

    // 判断当前线程是否是EventLoop对应的线程
    bool IsInloop() { return _thread_id == std::this_thread::get_id(); }

    void AssertInloop() { assert(_thread_id == std::this_thread::get_id()); }
    // 判断将要执行的任务是否处于当前线程中，如果是则执行，不是则压入队列。
    void RunInLoop(const Functor &cb)
    {
        // 如果是eventloop线程内部直接执行
        if (IsInloop() == true)
        {
            cb();
            return;
        }
        QueueInLoop(cb);
    }

    // 将操作压入任务池
    void QueueInLoop(const Functor &cb)
    {
        // 涉及任务池的操作都要加锁
        {
            std::unique_lock<std::mutex> _lock(_mutex);
            _tasks.push_back(cb);
        }

        // 压入任务池的操作，代表任务池中存在数据，而start需要处理就绪事件
        // 如果没有就绪事件则导致epol_wait会堵塞
        // 所以我们需要通过给eventfd写入一个数据，eventfd就会触发可读事件
        WakeUpEventfd();
    }

    // 添加/修改描述符的事件监控
    void UpdateEvent(Channel *channel) { _poller.UpdateEvent(channel); }
    // 移除描述符的监控
    void RemoveEvent(Channel *channel) { _poller.RemoveEvent(channel); }

    // 定时器模块接口
    void TimerAdd(uint64_t id, uint32_t timeout, const TaskFunc &cb) { _timer_wheel.TimerAdd(id, timeout, cb); }
    void TimerRefresh(uint64_t id) { _timer_wheel.TimerRefresh(id); }
    void TimerCancel(uint64_t id) { _timer_wheel.TimerCancel(id); }
    bool HasTimer(uint64_t id) { return _timer_wheel.HasTimer(id); }
};

void Channel::Remove() { _loop->RemoveEvent(this); }
void Channel::Update() { _loop->UpdateEvent(this); }

void TimerWheel::TimerAdd(uint64_t id, uint32_t timeout, const TaskFunc &cb)
{
    _loop->RunInLoop(std::bind(&TimerWheel::TimerAddInLoop, this, id, timeout, cb));
}

// 刷新/延迟定时任务
void TimerWheel::TimerRefresh(uint64_t id)
{
    _loop->RunInLoop(std::bind(&TimerWheel::TimerRefreshInLoop, this, id));
}
void TimerWheel::TimerCancel(uint64_t id)
{
    _loop->RunInLoop(std::bind(&TimerWheel::TaskCancelInLoop, this, id));
}

class LoopThread
{
private:
    /*互斥锁和条件变量用于实现_loop获取的同步关系，避免线程创建了，但是_loop还没有实例化之前去获取_loop*/
    std::mutex _mutex;             // 互斥锁
    std::condition_variable _cond; // 条件变量
    EventLoop *_loop;              // 由线程实例化一个对象
    std::thread _thread;           // Loop所在的线程
private:
    void ThreadEntry()
    { /*这里创造一个对象而不是new，是为了保持_loop的生命周期与线程的一致*/
        EventLoop loop;
        {
            std::unique_lock<std::mutex> lock(_mutex);
            _loop = &loop;
            _cond.notify_all();
        }
        _loop->Start(); // 循坏
    }

public:
    LoopThread() : _loop(nullptr), _thread(std::thread(&LoopThread::ThreadEntry, this)) {}

    EventLoop *GetLoop()
    {
        EventLoop *loop = nullptr;
        {
            std::unique_lock<std::mutex> lock(_mutex);
            _cond.wait(lock, [&]()
                       { return _loop != nullptr; });
            loop = _loop;
        }
        return loop;
    }
};

class LoopThreadPool
{
private:
    int _thread_count;                  // 从属线程数量
    int _loops_idx;                     //_loops下标
    EventLoop *_base_loop;              // 主线程
    std::vector<LoopThread *> _threads; // 从属线程
    std::vector<EventLoop *> _loops;    // 从属线程的eventloop
public:
    LoopThreadPool(EventLoop *base_loop, int thread_count = 0) : _thread_count(thread_count), _loops_idx(0), _base_loop(base_loop) {}
    void SetThreadCount(int count) { _thread_count = count; }
    void CreateThread()
    {
        if (_thread_count > 0)
        {
            _threads.resize(_thread_count);
            _loops.resize(_thread_count);
            for (int i = 0; i < _thread_count; i++)
            {
                _threads[i] = new LoopThread();
                _loops[i] = _threads[i]->GetLoop();
            }
        }
    }

    EventLoop *NextLoop()
    {
        if (_thread_count == 0)
        {
            return _base_loop;
        }
        EventLoop* loop = _loops[_loops_idx];
        _loops_idx = (_loops_idx + 1) % _thread_count;
        return loop;
    }
};

通用类型Any类

class Any
{
private:
    class holder
    {
    public:
        virtual ~holder() {}
        virtual const std::type_info &type() = 0;
        virtual holder *clone() = 0;
    };

    template <class T>
    class placeholder : public holder
    {
    public:
        T _val;

    public:
        placeholder(const T &val) : _val(val) {}
        // 获取对象保存的数据类型
        const std::type_info &type() override { return typeid(T); }
        holder *clone() override { return new placeholder(_val); }
    };

private:
    holder *_content;

public:
    Any() : _content(nullptr) {}
    template <class T>
    Any(const T &val) : _content(new placeholder<T>(val)) {}
    Any(const Any &other) : _content(other._content ? other._content->clone() : nullptr) {}
    ~Any() { delete _content; }

    Any &swap(Any &other)
    {
        std::swap(_content, other._content);
        return *this;
    }

    template <class T>
    Any &operator=(const T &val)
    {
        // 构造一个临时对象
        Any(val).swap(*this);
        return *this;
    }

    Any &operator=(const Any &other)
    {
        // 构造一个临时对象
        Any(other).swap(*this);
        return *this;
    }

    template <class T>
    T &GetContent()
    {
        assert(_content != nullptr);
        assert(typeid(T) == _content->type());

        auto p = dynamic_cast<placeholder<T> *>(_content);
        assert(p != nullptr);
        return p->_val;
    }
};

通信连接管理Connection类

class Connection;
typedef enum
{
    DISCONNECTED, // 连接关闭状态
    CONNECTING,   // 连接建立成功-待处理状态
    CONNECTED,    // 连接建立完成，各种设置已完成，可以通信的状态
    DISCONNECTING // 待关闭状态
} ConnStatus;

using PtrConnection = std::shared_ptr<Connection>;
// Connection 实现 单个套接字连接管理
class Connection : public std::enable_shared_from_this<Connection>
{
    using ConnectedCallback = std::function<void(const PtrConnection &)>;
    // 消息处理
    using MessageCallback = std::function<void(const PtrConnection &, Buffer *)>;
    using ClosedCallback = std::function<void(const PtrConnection &)>;
    using AnyEventCallback = std::function<void(const PtrConnection &)>;

private:
    EventLoop *_loop;  // 连接锁管理的loop
    uint64_t _conn_id; // 连接的唯一ID，便于连接的管理和查找
    // uint64_t _timer_id;   //定时器ID，必须是唯一的，这块为了简化操作使用conn_id作为定时器ID
    int _sockfd;                   // 连接关联的文件描述符
    Socket _socket;                // 套接字操作管理
    Channel _channel;              // 连接的事件管理
    Buffer _in_buffer;             // 输入缓冲区---存放从socket中读取到的数据
    Buffer _out_buffer;            // 输出缓冲区---存放要发送给对端的数据
    ConnStatus _statu;             // 连接状态
    bool _enable_inactive_release; // 连接是否启动非活跃销毁的判断标志，默认为false

    Any _context; // 请求的接收处理上下文
    ConnectedCallback _connected_callback;
    MessageCallback _message_callback;
    ClosedCallback _closed_callback;
    AnyEventCallback _event_callback;
    ClosedCallback _server_closed_callback;

private:
    void HandleRead() // 描述符可读事件
    {
        char buffer[65536];
        // 1.接受socket套接字中的数据
        ssize_t ret = _socket.NonBlockRecv(buffer, 65535);
        if (ret < 0)
        { // recv出错
            ShutdownInLoop();
            return;
        }
        else if (ret == 0)
            return;
        // 将读到的数据放入缓冲区中
        _in_buffer.WriteAndPush(buffer, ret);
        if (_in_buffer.ReadAbleSize() > 0)
        { // shared_from_this--从当前对象自身获取自身的shared_ptr管理对象
            if (_message_callback)
                _message_callback(shared_from_this(), &_in_buffer);
        }
    }

    void HandleWrite() // 描述符可写事件
    {
        ssize_t ret = _socket.NonBlockSend(_out_buffer.ReadPosition(), _out_buffer.ReadAbleSize());
        if (ret < 0)
        { // send出错，即使发送失败、连接马上要释放，这部分已经读到的数据 还没被应用层处理。如果直接释放连接，这些数据就丢了。
            // 所以在释放前调用 _message_callback，可以让业务层先处理掉已经收到的数据，避免数据丢失。

            if (_in_buffer.ReadAbleSize() > 0)
            { // shared_from_this--从当前对象自身获取自身的shared_ptr管理对象
                if (_message_callback)
                    _message_callback(shared_from_this(), &_in_buffer);
            }
            return Release();
        }
        else if (ret == 0)
            return;

        _out_buffer.MoveReadOffset(ret); // 千万不要忘了，将读偏移向后移动
        if (_out_buffer.ReadAbleSize() == 0)
        {
            // 如果输出缓冲区没有可读数据，则关闭可写事件的监控
            _channel.DisableWrite();
            if (_statu == DISCONNECTING)
                Release();
        }
        return;
    }
    void HandleClose() // 描述符触发挂断事件
    {
        if (_in_buffer.ReadAbleSize() > 0)
        { // shared_from_this--从当前对象自身获取自身的shared_ptr管理对象
            if (_message_callback)
                _message_callback(shared_from_this(), &_in_buffer);
        }
        // 输出缓冲 _out_buffer 里的数据是 准备发给对端的。
        // 但既然挂断了，对端已经不再接收，所以发也没用，只会出错。
        Release();
    }
    // 描述符触发出错事件
    void HandleError() { HandleClose(); }
    // 描述符触发任意事件
    void HandleEvent()
    {
        // 刷新活跃度
        if (_enable_inactive_release == true)
        {
            _loop->TimerRefresh(_conn_id);
        }
        if (_event_callback)
            _event_callback(shared_from_this());
    }

    // 非活跃的销毁任务
    void EnableInactiveReleaseInLoop(int sec)
    {
        _enable_inactive_release = true;
        if (_loop->HasTimer(_conn_id))
        {
            _loop->TimerRefresh(_conn_id);
            return;
        }

        _loop->TimerAdd(_conn_id, sec, std::bind(&Connection::Release, this));
    }
    void CancelInactiveReleaseInLoop()
    {
        _enable_inactive_release = false;
        if (_loop->HasTimer(_conn_id))
        {
            _loop->TimerCancel(_conn_id);
        }
    }

    void EstablishedInLoop()
    {
        assert(_statu == CONNECTING); // 连接中
        _statu = CONNECTED;
        _channel.EnableRead();
        if (_connected_callback)
            _connected_callback(shared_from_this());
        //_statu = CONNECTED;
    }
    void SendInLoop(Buffer &buf)
    {
        if (_statu == DISCONNECTED)
            return;
        _out_buffer.WriteBufferAndPush(buf);
        // 启动可写事件监控
        if (_channel.WriteAble() == false)
        {
            _channel.EnableWrite();
        }
    }

    void ReleaseInLoop() // 实际的释放接口
    {
        _statu = DISCONNECTED;
        // 将channel 从loop的管理中移除
        _channel.Remove();
        _socket.Close();

        // loop中的定时任务器可能存在任务，我们要销毁非活跃任务
        if (_loop->HasTimer(_conn_id))
            CancelInactiveReleaseInLoop();

        // 组件使用者先关闭设置的回调函数
        if (_closed_callback)
            _closed_callback(shared_from_this());
        // 移除服务器内部管理的连接信息
        if (_server_closed_callback)
            _server_closed_callback(shared_from_this());
    }

    void ShutdownInLoop() // shutdown判断发送缓冲区中是否有数据,然后调用ReleaseInLoop
    {
        _statu = DISCONNECTING;
        if (_in_buffer.ReadAbleSize() > 0)
        {
            if (_message_callback)
                _message_callback(shared_from_this(), &_in_buffer);
        }

        if (_out_buffer.ReadAbleSize() > 0)
        {
            if (_channel.WriteAble() == false)
                _channel.EnableWrite();
        }

        if (_out_buffer.ReadAbleSize() == 0)
        {
            Release();
        }
    }

    void UpgradeInLoop(const Any &context, const ConnectedCallback &conn,
                       const MessageCallback &msg, const ClosedCallback &closed, const AnyEventCallback &event)
    {
        _context = context;
        _connected_callback = conn;
        _message_callback = msg;
        _closed_callback = closed;
        _event_callback = event;
    }

public:
    Connection(EventLoop *loop, uint64_t conn_id, int sockfd) : _loop(loop), _conn_id(conn_id), _sockfd(sockfd), _socket(_sockfd),
                                                                _channel(_loop, _sockfd), _statu(CONNECTING), _enable_inactive_release(false)
    {
        _channel.SetReadCallback(std::bind(&Connection::HandleRead, this));
        _channel.SetWriteCallback(std::bind(&Connection::HandleWrite, this));
        _channel.SetCloseCallback(std::bind(&Connection::HandleClose, this));
        _channel.SetErrorCallback(std::bind(&Connection::HandleError, this));
        _channel.SetEventCallback(std::bind(&Connection::HandleEvent, this));
        // 一旦启动读事件监控就有可能会立即触发读事件，如果这时候启动了非活跃连接销毁就会产生问题
    }
    ~Connection() { Log::DEBUG("realse Connection:%p", this); }

    // 获取连接id
    uint64_t GetConnid() { return _conn_id; }
    // 获取sockfd
    int GetSockfd() { return _sockfd; }

    // 获取上下文
    Any *GetContext() { return &_context; }
    // 是否Connected状态
    bool IsConnected() { return _statu == CONNECTED; }

    /*这四个回调函数，是让服务器模块来设置的(即组件的使用者设置)*/
    void SetConnectedCallback(const ConnectedCallback &cb) { _connected_callback = cb; }
    void SetMessageedCallback(const MessageCallback &cb) { _message_callback = cb; }
    void SetClosedCallback(const ClosedCallback &cb) { _closed_callback = cb; }
    void SetAnyEventCallback(const AnyEventCallback &cb) { _event_callback = cb; }
    void SetSrvClosedCallback(const ClosedCallback &cb) { _server_closed_callback = cb; }

    // 设置上下文，连接处理后会调用
    void SetContext(const Any &context) { _context = context; }
    // 启动非活跃销毁
    void EnableInactiveRelease(int sec)
    {
        _loop->RunInLoop(std::bind(&Connection::EnableInactiveReleaseInLoop, this, sec));
    }
    // 关闭非活跃销毁
    void CancelInactiveRelease()
    {
        _loop->RunInLoop(std::bind(&Connection::CancelInactiveRelease, this));
    }
    // 启动监控调用 _connected_callback
    void Established()
    {
        _loop->RunInLoop(std::bind(&Connection::EstablishedInLoop, this));
    }
    // 发送数据到缓冲区
    void Send(const char *data, size_t len)
    {
        Buffer buf;
        buf.WriteAndPush(data, len);
        // 这个操作是压入任务池，可能调用的时候临时变量已经释放，所以需要创造一个buff保存数据
        _loop->RunInLoop(std::bind(&Connection::SendInLoop, this, std::move(buf)));
    }
    // 关闭连接 提供给组件使用者-在关闭前需要判断发送缓冲区中是否有数据
    void Shutdown()
    {
        _loop->RunInLoop(std::bind(&Connection::ShutdownInLoop, this));
    }

    void Release()
    {
        _loop->QueueInLoop(std::bind(&Connection::ReleaseInLoop, this));
    }

    // 切换协议，设置相关的回调函数
    void Upgrade(const Any &context, const ConnectedCallback &conn,
                 const MessageCallback &msg, const ClosedCallback &closed, const AnyEventCallback &event)
    {
        // 该接口必须在本线程中执行
        // 防备新的事件触发后，处理的时候，切换任务还没有被执行--会导致数据使用原协议处理了。
        _loop->AssertInloop();
        _loop->RunInLoop(std::bind(&Connection::UpgradeInLoop, this, context, conn, msg, closed, event));
    }
};

监听描述符管理Acceptor类

class Acceptor
{
    using AcceptCallback = std::function<void(int)>;

private:
    Socket _lis_sock; // 监听套接字
    EventLoop *_loop;
    Channel _channel;

    AcceptCallback _accept_callback;

private:
    void HandleRead()
    {
        int newfd = _lis_sock.Accept();
        if (newfd < 0)
            return;
        if (_accept_callback)
            _accept_callback(newfd);
    }

    // 创造监听套接字
    int CreateServer(int port)
    {
        bool ret = _lis_sock.CreateServer(port);
        assert(ret == true);
        return _lis_sock.GetFd();
    }

public:
    Acceptor(EventLoop *loop, int port) : _lis_sock(CreateServer(port)), _loop(loop), _channel(_loop, _lis_sock.GetFd())
    {
        _channel.SetReadCallback(std::bind(&Acceptor::HandleRead, this));
        /*不能将启动读事件监控，放到构造函数中，必须在设置回调函数后，再去启动*/
        /*否则有可能造成启动监控后，立即有事件，处理的时候，回调函数还没设置：新连接得不到处理，且资源泄漏*/
    }

    void SetAcceptCallback(const AcceptCallback &cb) { _accept_callback = cb; }
    void SetLisEnableRead() { _channel.EnableRead(); }
};

服务器TcpServer类

class TcpServer
{
    using ConnectedCallback = std::function<void(const PtrConnection &)>;
    // 消息处理
    using MessageCallback = std::function<void(const PtrConnection &, Buffer *)>;
    using ClosedCallback = std::function<void(const PtrConnection &)>;
    using AnyEventCallback = std::function<void(const PtrConnection &)>;

private:
    int _port;                                          // 端口号
    uint64_t _next_id;                                  // 自增长的连接id
    int _timeout;                                       // 非活跃连接时间
    bool _enable_inactive_release;                      // 非活跃销毁启动标志F
    EventLoop _base_loop;                               // 主线程的Eventloop对象,负责监听处理
    Acceptor _acceptor;                                 // 这是监听套接字
    LoopThreadPool _thread_poll;                        // 从属线程池
    std::unordered_map<uint64_t, PtrConnection> _conns; // 保存管理所有连接对应的shared_ptr对象

    ConnectedCallback _connected_callback;
    MessageCallback _message_callback;
    ClosedCallback _closed_callback;
    AnyEventCallback _event_callback;

private:
    void NewConnection(int newfd) // 为新连接构造一个Connection进行管理
    {
        _next_id++;
        PtrConnection conn(new Connection(_thread_poll.NextLoop(), _next_id, newfd));
        conn->SetConnectedCallback(_connected_callback);
        conn->SetMessageedCallback(_message_callback);
        conn->SetClosedCallback(_closed_callback);
        conn->SetAnyEventCallback(_event_callback);
        conn->SetSrvClosedCallback(std::bind(&TcpServer::RemoveConnection, this, std::placeholders::_1));
        if (_enable_inactive_release == true)
            conn->EnableInactiveRelease(10);
        conn->Established();
        _conns.insert(std::make_pair(_next_id, conn));
    }

    void RemoveConnectionInLoop(const PtrConnection &conn)
    {
        uint64_t id = conn->GetConnid();
        auto it = _conns.find(id);
        if (it != _conns.end())
        {
            _conns.erase(it);
        }
    }

    void RemoveConnection(const PtrConnection &conn) // 删除_conns中保存的对象，这里删除才是真正的删除
    {
        _base_loop.RunInLoop(std::bind(&TcpServer::RemoveConnectionInLoop, this, conn));
    }

    void TaskRunAfterInLoop(const Functor &task, int delay)
    {
        _next_id++;
        _base_loop.TimerAdd(_next_id, delay, task);
    }

public:
    TcpServer(int port) : _port(port), _next_id(0), _enable_inactive_release(false),
                          _acceptor(&_base_loop, _port), _thread_poll(&_base_loop)
    {
        _acceptor.SetAcceptCallback(std::bind(&TcpServer::NewConnection, this, std::placeholders::_1));
        _acceptor.SetLisEnableRead();
    }

    void SetThreadCount(int count) { _thread_poll.SetThreadCount(count); }

    void SetConnectedCallback(const ConnectedCallback &cb) { _connected_callback = cb; }
    void SetMessageedCallback(const MessageCallback &cb) { _message_callback = cb; }
    void SetClosedCallback(const ClosedCallback &cb) { _closed_callback = cb; }
    void SetAnyEventCallback(const AnyEventCallback &cb) { _event_callback = cb; }

    void EnableInactiveRelease(int timeout)
    {
        _timeout = timeout;
        _enable_inactive_release = true;
    }

    // 用于添加定时任务
    void TaskRunAfter(const Functor &task, int delay)
    {
        _base_loop.RunInLoop(std::bind(&TcpServer::TaskRunAfterInLoop, this, task, delay));
    }

    void Start()
    {
        _thread_poll.CreateThread();
        _base_loop.Start();
    }
};

class NetWork
{
public:
    NetWork()
    {
        Log::DEBUG("SIGPIPE INIT");
        signal(SIGPIPE, SIG_IGN);
    }
};
static NetWork nw;

二、HTTP协议模块

Util实用工具类

std::unordered_map<int, std::string> _status_msg = {
    {100, "Continue"},
    {101, "Switching Protocol"},
    {102, "Processing"},
    {103, "Early Hints"},
    {200, "OK"},
    {201, "Created"},
    {202, "Accepted"},
    {203, "Non-Authoritative Information"},
    {204, "No Content"},
    {205, "Reset Content"},
    {206, "Partial Content"},
    {207, "Multi-Status"},
    {208, "Already Reported"},
    {226, "IM Used"},
    {300, "Multiple Choice"},
    {301, "Moved Permanently"},
    {302, "Found"},
    {303, "See Other"},
    {304, "Not Modified"},
    {305, "Use Proxy"},
    {306, "unused"},
    {307, "Temporary Redirect"},
    {308, "Permanent Redirect"},
    {400, "Bad Request"},
    {401, "Unauthorized"},
    {402, "Payment Required"},
    {403, "Forbidden"},
    {404, "Not Found"},
    {405, "Method Not Allowed"},
    {406, "Not Acceptable"},
    {407, "Proxy Authentication Required"},
    {408, "Request Timeout"},
    {409, "Conflict"},
    {410, "Gone"},
    {411, "Length Required"},
    {412, "Precondition Failed"},
    {413, "Payload Too Large"},
    {414, "URI Too Long"},
    {415, "Unsupported Media Type"},
    {416, "Range Not Satisfiable"},
    {417, "Expectation Failed"},
    {418, "I'm a teapot"},
    {421, "Misdirected Request"},
    {422, "Unprocessable Entity"},
    {423, "Locked"},
    {424, "Failed Dependency"},
    {425, "Too Early"},
    {426, "Upgrade Required"},
    {428, "Precondition Required"},
    {429, "Too Many Requests"},
    {431, "Request Header Fields Too Large"},
    {451, "Unavailable For Legal Reasons"},
    {501, "Not Implemented"},
    {502, "Bad Gateway"},
    {503, "Service Unavailable"},
    {504, "Gateway Timeout"},
    {505, "HTTP Version Not Supported"},
    {506, "Variant Also Negotiates"},
    {507, "Insufficient Storage"},
    {508, "Loop Detected"},
    {510, "Not Extended"},
    {511, "Network Authentication Required"}};

std::unordered_map<std::string, std::string> _mime_msg = {
    {".aac", "audio/aac"},
    {".abw", "application/x-abiword"},
    {".arc", "application/x-freearc"},
    {".avi", "video/x-msvideo"},
    {".azw", "application/vnd.amazon.ebook"},
    {".bin", "application/octet-stream"},
    {".bmp", "image/bmp"},
    {".bz", "application/x-bzip"},
    {".bz2", "application/x-bzip2"},
    {".csh", "application/x-csh"},
    {".css", "text/css"},
    {".csv", "text/csv"},
    {".doc", "application/msword"},
    {".docx", "application/vnd.openxmlformats-officedocument.wordprocessingml.document"},
    {".eot", "application/vnd.ms-fontobject"},
    {".epub", "application/epub+zip"},
    {".gif", "image/gif"},
    {".htm", "text/html"},
    {".html", "text/html"},
    {".ico", "image/vnd.microsoft.icon"},
    {".ics", "text/calendar"},
    {".jar", "application/java-archive"},
    {".jpeg", "image/jpeg"},
    {".jpg", "image/jpeg"},
    {".js", "text/javascript"},
    {".json", "application/json"},
    {".jsonld", "application/ld+json"},
    {".mid", "audio/midi"},
    {".midi", "audio/x-midi"},
    {".mjs", "text/javascript"},
    {".mp3", "audio/mpeg"},
    {".mpeg", "video/mpeg"},
    {".mpkg", "application/vnd.apple.installer+xml"},
    {".odp", "application/vnd.oasis.opendocument.presentation"},
    {".ods", "application/vnd.oasis.opendocument.spreadsheet"},
    {".odt", "application/vnd.oasis.opendocument.text"},
    {".oga", "audio/ogg"},
    {".ogv", "video/ogg"},
    {".ogx", "application/ogg"},
    {".otf", "font/otf"},
    {".png", "image/png"},
    {".pdf", "application/pdf"},
    {".ppt", "application/vnd.ms-powerpoint"},
    {".pptx", "application/vnd.openxmlformats-officedocument.presentationml.presentation"},
    {".rar", "application/x-rar-compressed"},
    {".rtf", "application/rtf"},
    {".sh", "application/x-sh"},
    {".svg", "image/svg+xml"},
    {".swf", "application/x-shockwave-flash"},
    {".tar", "application/x-tar"},
    {".tif", "image/tiff"},
    {".tiff", "image/tiff"},
    {".ttf", "font/ttf"},
    {".txt", "text/plain"},
    {".vsd", "application/vnd.visio"},
    {".wav", "audio/wav"},
    {".weba", "audio/webm"},
    {".webm", "video/webm"},
    {".webp", "image/webp"},
    {".woff", "font/woff"},
    {".woff2", "font/woff2"},
    {".xhtml", "application/xhtml+xml"},
    {".xls", "application/vnd.ms-excel"},
    {".xlsx", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"},
    {".xml", "application/xml"},
    {".xul", "application/vnd.mozilla.xul+xml"},
    {".zip", "application/zip"},
    {".3gp", "video/3gpp"},
    {".3g2", "video/3gpp2"},
    {".7z", "application/x-7z-compressed"}};

class Util
{
public:
    // 字符串分割
    static size_t Split(const std::string &str, const std::string &seq, std::vector<std::string> *arry)
    {
        int offset = 0;
        while (offset < str.size())
        {
            // abc....bcd.aaa.
            size_t pos = str.find(seq, offset);
            if (pos == std::string::npos) // 如果没找到则表示要截取最后一个字符串
            {
                arry->push_back(str.substr(offset));
                return arry->size();
            }
            // 找到则pos指向【.】的下标
            if (pos == offset) // 代表存在多个【.】，截取的字符没有任何意义
            {
                offset = pos + seq.size();
                continue;
            }
            arry->push_back(str.substr(offset, pos - offset));
            offset = pos + seq.size();
        }
        return arry->size();
    }

    // 读取字符串内容
    static bool ReadFile(const std::string &filename, std::string *buf)
    {
        std::ifstream ifs(filename, std::ios::binary);
        if (ifs.is_open() == false)
        {
            Log::ERROR("open %s false", filename.c_str());
            return false;
        }
        size_t fsize = 0;
        ifs.seekg(0, ifs.end); // 跳转到文件末尾
        fsize = ifs.tellg();   // 获取当前读写位置相对于起始位置的偏移量，从末尾偏移刚好就是文件大小
        ifs.seekg(0, ifs.beg); // 跳转到文件起始位置

        buf->resize(fsize);
        ifs.read(&(*buf)[0], fsize);
        if (ifs.good() == false)
        {
            Log::ERROR("read %s false", filename.c_str());
            ifs.close();
            return false;
        }

        ifs.close();
        return true;
    }

    // 向文件写入数据
    static bool WriteFile(const std::string &filename, const std::string &buf)
    {
        std::ofstream ofs(filename, std::ios::binary | std::ios::trunc); // 在打开文件时，把已有内容全部清空（truncate to zero length）
        if (ofs.is_open() == false)
        {
            Log::ERROR("open %s false", filename.c_str());
            return false;
        }
        ofs.write(buf.c_str(), buf.size());
        if (ofs.good() == false)
        {
            Log::ERROR("read %s false", filename.c_str());
            ofs.close();
            return false;
        }

        ofs.close();
        return true;
    }

    // URL 编码
    static std::string UrlEncode(const std::string &url, bool convert_space_to_plus)
    {
        std::string res;
        for (unsigned char c : url)
        {
            if (c == '.' || c == '-' || c == '_' || c == '~' || isalnum(c))
            {
                res += c;
            }
            else if (c == ' ' && convert_space_to_plus)
            {
                res += '+';
            }
            else
            {
                char tmp[4] = {0};
                snprintf(tmp, 4, "%%%02X", c);
                res += tmp;
            }
        }
        return res;
    }

    // %2B == 43
    // 只支持 '0'-'9' 和 'A'-'F'
    static int CtoInt(char c)
    {
        if (c >= '0' && c <= '9')
            return c - '0';
        if (c >= 'A' && c <= 'F')
            return c - 'A' + 10;

        // 非法字符直接返回 -1（也可以选择抛异常或忽略）
        return -1;
    }

    // URL 解码
    static std::string UrlDecode(const std::string &url, bool convert_plus_to_space)
    {
        std::string res;
        for (int i = 0; i < url.size(); i++)
        {
            if (url[i] == '%')
            {
                if (i + 2 < url.size())
                {
                    int c1 = CtoInt(url[i + 1]);
                    int c2 = CtoInt(url[i + 2]);
                    if (c1 != -1 && c2 != -1)
                    {
                        res += static_cast<char>(c1 * 16 + c2);
                        i += 2;
                        continue;
                    }
                }
                // 如果不是有效的 %xx，直接保留 %
                res += '%';
            }
            else if (url[i] == '+' && convert_plus_to_space)
            {
                res += ' ';
            }
            else
                res += url[i];
        }
        return res;
    }

    // 响应状态码的描述信息获取
    static std::string StatusDesc(int status)
    {

        auto it = _status_msg.find(status);
        if (it != _status_msg.end())
        {
            return it->second;
        }
        return "Unknow status";
    }
    // 根据文件后缀名获取文件mine
    static std::string GetMimeTypeFromExtension(const std::string &filename)
    {

        // 获取文件扩展名 a.txt
        size_t pos = filename.find_last_of('.');
        if (pos == std::string::npos)
        {
            return "application/octet-stream";
        }
        std::string ext = filename.substr(pos);
        // 通过扩展名获取mime
        auto it = _mime_msg.find(ext);
        if (it != _mime_msg.end())
        {
            return it->second;
        }
        return "application/octet-stream";
    }

    // 判断一个文件是否是目录
    static bool IsDirectory(const std::string &filename)
    {
        struct stat st;
        int ret = stat(filename.c_str(), &st);
        if (ret < 0)
        {
            return false;
        }
        return S_ISDIR(st.st_mode);
    }
    // 判断一个文件是否是普通文件
    static bool IsRegularFile(const std::string &filename)
    {
        struct stat st;
        int ret = stat(filename.c_str(), &st);
        if (ret < 0)
        {
            return false;
        }
        return S_ISREG(st.st_mode);
    }
    // http请求路径是否有效
    static bool ValidPath(const std::string &path)
    {
        std::vector<std::string> sub;
        Split(path, "/", &sub);
        int level = 0;
        for (auto &s : sub)
        {
            if (s == "..")
            {
                level--;
                if (level < 0)
                    return false;
                continue;
            }

            if (s != ".")
                level++;
        }
        return true;
    }
};

HttpRequest请求类

class HttpRequest
{
public:
    std::string _method;                                   // 请求方法
    std::string _path;                                     // 资源路径
    std::string _version;                                  // 协议版本
    std::string _body;                                     // 请求正文
    std::smatch _matches;                                  // 资源路径的正则提取数据
    std::unordered_map<std::string, std::string> _headers; // http头部字段
    std::unordered_map<std::string, std::string> _params;  // 查询字符串
public:
    HttpRequest() : _version("HTTP/1.1") {}
    void ReSet()
    {
        _method.clear();
        _path.clear();
        _version = "HTTP/1.1";
        _body.clear();
        std::smatch matches;
        _matches.swap(matches);
        _headers.clear();
        _params.clear();
    }
    // 插入头部字段
    void SetHeader(const std::string &key, const std::string &val)
    {
        _headers.insert(std::make_pair(key, val));
    }
    // 判断是否存在指定的头部字段
    bool HasHeader(const std::string &key) const
    {
        auto it = _headers.find(key);
        if (it == _headers.end())
        {
            return false;
        }
        return true;
    }
    // 获取指定头部字段的值
    std::string GetHeader(const std::string &key) const
    {
        auto it = _headers.find(key);
        if (it == _headers.end())
        {
            return "";
        }
        return it->second;
    }

    // 插入查询字符串
    void SetParam(const std::string &key, const std::string &val)
    {
        _params.insert(std::make_pair(key, val));
    }
    // 判断是否有指定的查询字符串
    bool HasParam(const std::string &key)
    {
        auto it = _params.find(key);
        if (it == _params.end())
        {
            return false;
        }
        return true;
    }
    // 获取指定的查询字符串
    std::string GetParam(const std::string &key) const
    {
        auto it = _params.find(key);
        if (it == _params.end())
        {
            return "";
        }
        return it->second;
    }

    // 获取正文长度
    size_t ContentLength() const
    {
        if (HasHeader("Content-Length") == false)
        {
            return 0;
        }
        std::string content = GetHeader("Content-Length");
        return std::stol(content);
    }
    // 判断是否是短连接
    bool Close() const
    {
        if (HasHeader("Connection") == true && GetHeader("Connection") == "keep-alive")
        {
            
            return false;
        }

        //Log::DEBUG("长连接");
        return true;
    }
};

HttpResponse响应类

class HttpResponse
{
public:
    int _status;                                           // 状态码
    bool _redirect_flag;                                   // 重定向标志
    std::string _redirect_url;                             // 重定向路径
    std::unordered_map<std::string, std::string> _headers; // http头部字段
    std::string _body;                                     // 回复正文
public:
    HttpResponse() : _status(200), _redirect_flag(false) {}
    HttpResponse(int status) : _status(status), _redirect_flag(false) {}

    void ReSet()
    {
        _status = 200;
        _redirect_flag = false;
        _redirect_url.clear();
        _headers.clear();
        _body.clear();
    }

    // 插入头部字段
    void SetHeader(const std::string &key, const std::string &val)
    {
        // std::cout << "插入的键值对是： " << key << ": " << val << std::endl;
        _headers.insert(std::make_pair(key, val));
    }
    // 判断是否存在指定的头部字段
    bool HasHeader(const std::string &key)
    {
        auto it = _headers.find(key);
        if (it == _headers.end())
        {
            return false;
        }
        return true;
    }
    // 获取指定头部字段的值
    std::string GetHeader(const std::string &key)
    {
        auto it = _headers.find(key);
        if (it == _headers.end())
        {
            return "";
        }
        return it->second;
    }

    void SetContent(const std::string &body, const std::string &type = "text/html")
    {
        _body = body;
        SetHeader("Content-Type", type);
    }

    void SetRedirect(const std::string &url, int status = 302)
    {
        _status = status;
        _redirect_flag = true;
        _redirect_url = url;
    }

    // 判断是否是短连接
    bool Close()
    {
        if (HasHeader("Connection") == true && GetHeader("Connection") == "keep-alive")
        {
            return false;
        }
        return true;
    }
};