![\"\"](\"https:\/\/www.wsisp.com\/helps\/wp-content\/uploads\/2025\/04\/20250418125914-68024ca28ccf6.png\")
<\/p>\n\u6e90\u7801：\u7530\u67d0super\/moduo<\/p>\n<\/p>\n
\u76ee\u5f55<\/p>\n
SERVER\u6a21\u5757：<\/p>\n
Buffer\u6a21\u5757：<\/p>\n
Socket\u6a21\u5757：<\/p>\n
Channel\u6a21\u5757：<\/p>\n
Connection\u6a21\u5757：<\/p>\n
Acceptor\u6a21\u5757：<\/p>\n
TimerQueue\u6a21\u5757：<\/p>\n
Poller\u6a21\u5757：<\/p>\n
EventLoop\u6a21\u5757：<\/p>\n
TcpServer\u6a21\u5757：<\/p>\n
HTTP\u534f\u8bae\u7ec4\u4ef6\u6a21\u5757：<\/p>\n
Util\u6a21\u5757：<\/p>\n
HttpRequest\u6a21\u5757：<\/p>\n
HttpContext\u6a21\u5757：<\/p>\n
HttpServer\u6a21\u5757：<\/p>\n
\u901a\u8fc7\u54b1\u4eec\u5b9e\u73b0\u7684\u2fbc\u5e76\u53d1\u670d\u52a1\u5668\u7ec4\u4ef6，\u53ef\u4ee5\u7b80\u6d01\u5feb\u901f\u7684\u5b8c\u6210\u2f00\u4e2a\u2fbc\u6027\u80fd\u7684\u670d\u52a1\u5668\u642d\u5efa\u3002 \u5e76\u4e14，\u901a\u8fc7\u7ec4\u4ef6\u5185\u63d0\u4f9b\u7684\u4e0d\u540c\u5e94\u2f64\u5c42\u534f\u8bae\u2f40\u6301，\u4e5f\u53ef\u4ee5\u5feb\u901f\u5b8c\u6210\u2f00\u4e2a\u2fbc\u6027\u80fd\u5e94\u2f64\u670d\u52a1\u5668\u7684\u642d\u5efa（\u5f53\u524d ，\u4e3a\u4e86\u4fbf\u4e8e\u9879\u2f6c\u7684\u6f14\u2f70，\u9879\u2f6c\u4e2d\u63d0\u4f9bHTTP\u534f\u8bae\u7ec4\u4ef6\u7684\u2f40\u6301）\u3002 \u5728\u8fd9\u2fa5，\u8981\u660e\u786e\u7684\u662f\u54b1\u4eec\u8981\u5b9e\u73b0\u7684\u662f\u2f00\u4e2a\u2fbc\u5e76\u53d1\u670d\u52a1\u5668\u7ec4\u4ef6，\u56e0\u6b64\u5f53\u524d\u7684\u9879\u2f6c\u4e2d\u5e76\u4e0d\u5305\u542b\u5b9e\u9645\u7684\u4e1a\u52a1\u5185\u5bb9\u3002<\/p>\n
<\/p>\n
\u56fe\u7247\u6765\u6e90：\u00a0\u56fe\u89e3one loop per thread：\u4f7f\u7528muduo\u7f51\u7edc\u5e93\u5b9e\u73b0web\u670d\u52a1\u5668_znzxc\u7684\u535a\u5ba2-CSDN\u535a\u5ba2<\/p>\n
\u672c\u9879\u76ee\u603b\u5171\u5206\u4e3a\u4e24\u5927\u6a21\u5757\u5206\u522b\u4e3aServer\u548cHTTP\u6a21\u5757\u3002<\/p>\n
SERVER\u6a21\u5757\u5c31\u662f\u5bf9\u6240\u6709\u7684\u8fde\u63a5\u4ee5\u53ca\u7ebf\u7a0b\u8fdb\u2f8f\u7ba1\u7406，\u8ba9\u5b83\u4eec\u5404\u53f8\u5176\u804c，\u5728\u5408\u9002\u7684\u65f6\u5019\u505a\u5408\u9002\u7684\u4e8b，\u6700\u7ec8\u5b8c\u6210\u2fbc\u6027\u80fd\u670d\u52a1\u5668\u7ec4\u4ef6\u7684\u5b9e\u73b0\u3002<\/p>\n
\u7ba1\u7406\u2f45\u2faf： \u76d1\u542c\u8fde\u63a5\u7ba1\u7406：\u5bf9\u76d1\u542c\u8fde\u63a5\u8fdb\u2f8f\u7ba1\u7406 \u901a\u4fe1\u8fde\u63a5\u7ba1\u7406：\u5bf9\u901a\u4fe1\u8fde\u63a5\u8fdb\u2f8f\u7ba1\u7406 \u8d85\u65f6\u8fde\u63a5\u7ba1\u7406：\u5bf9\u8d85\u65f6\u8fde\u63a5\u8fdb\u2f8f\u7ba1\u7406 \u57fa\u4e8e\u4ee5\u4e0a\u53ef\u4ee5\u5c06\u5176\u5206\u4e3a\u591a\u4e2a\u5b50\u6a21\u5757：<\/p>\n
\u2f64\u4e8e\u5b9e\u73b0\u7528\u6237\u6001\u7f13\u51b2\u533a，\u63d0\u4f9b\u6570\u636e\u7f13\u51b2，\u53d6\u51fa\u7b49\u529f\u80fd\u3002<\/p>\n
class Buffer {
\n private:
\n std::vector<char> _buffer; \/\/\u4f7f\u7528vector\u8fdb\u884c\u5185\u5b58\u7a7a\u95f4\u7ba1\u7406
\n uint64_t _reader_idx; \/\/\u8bfb\u504f\u79fb
\n uint64_t _writer_idx; \/\/\u5199\u504f\u79fb
\n public:
\n Buffer():_reader_idx(0), _writer_idx(0), _buffer(BUFFER_DEFAULT_SIZE){}
\n char *Begin() { return &*_buffer.begin(); }
\n \/\/\u83b7\u53d6\u5f53\u524d\u5199\u5165\u8d77\u59cb\u5730\u5740, _buffer\u7684\u7a7a\u95f4\u8d77\u59cb\u5730\u5740，\u52a0\u4e0a\u5199\u504f\u79fb\u91cf
\n char *WritePosition() { return Begin() + _writer_idx; }
\n \/\/\u83b7\u53d6\u5f53\u524d\u8bfb\u53d6\u8d77\u59cb\u5730\u5740
\n char *ReadPosition() { return Begin() + _reader_idx; }
\n \/\/\u83b7\u53d6\u7f13\u51b2\u533a\u672b\u5c3e\u7a7a\u95f2\u7a7a\u95f4\u5927\u5c0f–\u5199\u504f\u79fb\u4e4b\u540e\u7684\u7a7a\u95f2\u7a7a\u95f4, \u603b\u4f53\u7a7a\u95f4\u5927\u5c0f\u51cf\u53bb\u5199\u504f\u79fb
\n uint64_t TailIdleSize() { return _buffer.size() – _writer_idx; }
\n \/\/\u83b7\u53d6\u7f13\u51b2\u533a\u8d77\u59cb\u7a7a\u95f2\u7a7a\u95f4\u5927\u5c0f–\u8bfb\u504f\u79fb\u4e4b\u524d\u7684\u7a7a\u95f2\u7a7a\u95f4
\n uint64_t HeadIdleSize() { return _reader_idx; }
\n \/\/\u83b7\u53d6\u53ef\u8bfb\u6570\u636e\u5927\u5c0f = \u5199\u504f\u79fb – \u8bfb\u504f\u79fb
\n uint64_t ReadAbleSize() { return _writer_idx – _reader_idx; }
\n \/\/\u5c06\u8bfb\u504f\u79fb\u5411\u540e\u79fb\u52a8
\n void MoveReadOffset(uint64_t len) {
\n if (len == 0) return;
\n \/\/\u5411\u540e\u79fb\u52a8\u7684\u5927\u5c0f，\u5fc5\u987b\u5c0f\u4e8e\u53ef\u8bfb\u6570\u636e\u5927\u5c0f
\n assert(len <= ReadAbleSize());
\n _reader_idx += len;
\n }
\n \/\/\u5c06\u5199\u504f\u79fb\u5411\u540e\u79fb\u52a8
\n void MoveWriteOffset(uint64_t len) {
\n \/\/\u5411\u540e\u79fb\u52a8\u7684\u5927\u5c0f，\u5fc5\u987b\u5c0f\u4e8e\u5f53\u524d\u540e\u8fb9\u7684\u7a7a\u95f2\u7a7a\u95f4\u5927\u5c0f
\n assert(len <= TailIdleSize());
\n _writer_idx += len;
\n }
\n \/\/\u786e\u4fdd\u53ef\u5199\u7a7a\u95f4\u8db3\u591f（\u6574\u4f53\u7a7a\u95f2\u7a7a\u95f4\u591f\u4e86\u5c31\u79fb\u52a8\u6570\u636e，\u5426\u5219\u5c31\u6269\u5bb9）
\n void EnsureWriteSpace(uint64_t len) {
\n \/\/\u5982\u679c\u672b\u5c3e\u7a7a\u95f2\u7a7a\u95f4\u5927\u5c0f\u8db3\u591f，\u76f4\u63a5\u8fd4\u56de
\n if (TailIdleSize() >= len) { return; }
\n \/\/\u672b\u5c3e\u7a7a\u95f2\u7a7a\u95f4\u4e0d\u591f，\u5219\u5224\u65ad\u52a0\u4e0a\u8d77\u59cb\u4f4d\u7f6e\u7684\u7a7a\u95f2\u7a7a\u95f4\u5927\u5c0f\u662f\u5426\u8db3\u591f, \u591f\u4e86\u5c31\u5c06\u6570\u636e\u79fb\u52a8\u5230\u8d77\u59cb\u4f4d\u7f6e
\n if (len <= TailIdleSize() + HeadIdleSize()) {
\n \/\/\u5c06\u6570\u636e\u79fb\u52a8\u5230\u8d77\u59cb\u4f4d\u7f6e
\n uint64_t rsz = ReadAbleSize();\/\/\u628a\u5f53\u524d\u6570\u636e\u5927\u5c0f\u5148\u4fdd\u5b58\u8d77\u6765
\n std::copy(ReadPosition(), ReadPosition() + rsz, Begin());\/\/\u628a\u53ef\u8bfb\u6570\u636e\u62f7\u8d1d\u5230\u8d77\u59cb\u4f4d\u7f6e
\n _reader_idx = 0; \/\/\u5c06\u8bfb\u504f\u79fb\u5f520
\n _writer_idx = rsz; \/\/\u5c06\u5199\u4f4d\u7f6e\u7f6e\u4e3a\u53ef\u8bfb\u6570\u636e\u5927\u5c0f， \u56e0\u4e3a\u5f53\u524d\u7684\u53ef\u8bfb\u6570\u636e\u5927\u5c0f\u5c31\u662f\u5199\u504f\u79fb\u91cf
\n }else {
\n \/\/\u603b\u4f53\u7a7a\u95f4\u4e0d\u591f，\u5219\u9700\u8981\u6269\u5bb9，\u4e0d\u79fb\u52a8\u6570\u636e，\u76f4\u63a5\u7ed9\u5199\u504f\u79fb\u4e4b\u540e\u6269\u5bb9\u8db3\u591f\u7a7a\u95f4\u5373\u53ef
\n DBG_LOG("RESIZE %ld", _writer_idx + len);
\n _buffer.resize(_writer_idx + len);
\n }
\n }
\n \/\/\u5199\u5165\u6570\u636e
\n void Write(const void *data, uint64_t len) {
\n \/\/1. \u4fdd\u8bc1\u6709\u8db3\u591f\u7a7a\u95f4，2. \u62f7\u8d1d\u6570\u636e\u8fdb\u53bb
\n if (len == 0) return;
\n EnsureWriteSpace(len);
\n const char *d = (const char *)data;
\n std::copy(d, d + len, WritePosition());
\n }
\n void WriteAndPush(const void *data, uint64_t len) {
\n Write(data, len);
\n MoveWriteOffset(len);
\n }
\n void WriteString(const std::string &data) {
\n return Write(data.c_str(), data.size());
\n }
\n void WriteStringAndPush(const std::string &data) {
\n WriteString(data);
\n MoveWriteOffset(data.size());
\n }
\n void WriteBuffer(Buffer &data) {
\n return Write(data.ReadPosition(), data.ReadAbleSize());
\n }
\n void WriteBufferAndPush(Buffer &data) {
\n WriteBuffer(data);
\n MoveWriteOffset(data.ReadAbleSize());
\n }
\n \/\/\u8bfb\u53d6\u6570\u636e
\n void Read(void *buf, uint64_t len) {
\n \/\/\u8981\u6c42\u8981\u83b7\u53d6\u7684\u6570\u636e\u5927\u5c0f\u5fc5\u987b\u5c0f\u4e8e\u53ef\u8bfb\u6570\u636e\u5927\u5c0f
\n assert(len <= ReadAbleSize());
\n std::copy(ReadPosition(), ReadPosition() + len, (char*)buf);
\n }
\n void ReadAndPop(void *buf, uint64_t len) {
\n Read(buf, len);
\n MoveReadOffset(len);
\n }
\n std::string ReadAsString(uint64_t len) {
\n \/\/\u8981\u6c42\u8981\u83b7\u53d6\u7684\u6570\u636e\u5927\u5c0f\u5fc5\u987b\u5c0f\u4e8e\u53ef\u8bfb\u6570\u636e\u5927\u5c0f
\n assert(len <= ReadAbleSize());
\n std::string str;
\n str.resize(len);
\n Read(&str[0], len);
\n return str;
\n }
\n std::string ReadAsStringAndPop(uint64_t len) {
\n assert(len <= ReadAbleSize());
\n std::string str = ReadAsString(len);
\n MoveReadOffset(len);
\n return str;
\n }
\n char *FindCRLF() {
\n char *res = (char*)memchr(ReadPosition(), '\\\\n', ReadAbleSize());
\n return res;
\n }
\n \/*\u901a\u5e38\u83b7\u53d6\u4e00\u884c\u6570\u636e，\u8fd9\u79cd\u60c5\u51b5\u9488\u5bf9\u662f*\/
\n std::string GetLine() {
\n char *pos = FindCRLF();
\n if (pos == NULL) {
\n return "";
\n }
\n \/\/ +1\u662f\u4e3a\u4e86\u628a\u6362\u884c\u5b57\u7b26\u4e5f\u53d6\u51fa\u6765\u3002
\n return ReadAsString(pos – ReadPosition() + 1);
\n }
\n std::string GetLineAndPop() {
\n std::string str = GetLine();
\n MoveReadOffset(str.size());
\n return str;
\n }
\n \/\/\u6e05\u7a7a\u7f13\u51b2\u533a
\n void Clear() {
\n \/\/\u53ea\u9700\u8981\u5c06\u504f\u79fb\u91cf\u5f520\u5373\u53ef
\n _reader_idx = 0;
\n _writer_idx = 0;
\n }
\n}; <\/p>\n
\u5c01\u88c5\u5957\u63a5\u5b57<\/p>\n
class Socket {
\n private:
\n int _sockfd;
\n public:
\n Socket():_sockfd(-1) {}
\n Socket(int fd): _sockfd(fd) {}
\n ~Socket() { Close(); }
\n int Fd() { return _sockfd; }
\n \/\/\u521b\u5efa\u5957\u63a5\u5b57
\n bool Create() {
\n \/\/ int socket(int domain, int type, int protocol)
\n _sockfd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
\n if (_sockfd < 0) {
\n ERR_LOG("CREATE SOCKET FAILED!!");
\n return false;
\n }
\n return true;
\n }
\n \/\/\u7ed1\u5b9a\u5730\u5740\u4fe1\u606f
\n bool Bind(const std::string &ip, uint16_t port) {
\n struct sockaddr_in addr;
\n addr.sin_family = AF_INET;
\n addr.sin_port = htons(port);
\n addr.sin_addr.s_addr = inet_addr(ip.c_str());
\n socklen_t len = sizeof(struct sockaddr_in);
\n \/\/ int bind(int sockfd, struct sockaddr*addr, socklen_t len);
\n int ret = bind(_sockfd, (struct sockaddr*)&addr, len);
\n if (ret < 0) {
\n ERR_LOG("BIND ADDRESS FAILED!");
\n return false;
\n }
\n return true;
\n }
\n \/\/\u5f00\u59cb\u76d1\u542c
\n bool Listen(int backlog = MAX_LISTEN) {
\n \/\/ int listen(int backlog)
\n int ret = listen(_sockfd, backlog);
\n if (ret < 0) {
\n ERR_LOG("SOCKET LISTEN FAILED!");
\n return false;
\n }
\n return true;
\n }
\n \/\/\u5411\u670d\u52a1\u5668\u53d1\u8d77\u8fde\u63a5
\n bool Connect(const std::string &ip, uint16_t port) {
\n struct sockaddr_in addr;
\n addr.sin_family = AF_INET;
\n addr.sin_port = htons(port);
\n addr.sin_addr.s_addr = inet_addr(ip.c_str());
\n socklen_t len = sizeof(struct sockaddr_in);
\n \/\/ int connect(int sockfd, struct sockaddr*addr, socklen_t len);
\n int ret = connect(_sockfd, (struct sockaddr*)&addr, len);
\n if (ret < 0) {
\n ERR_LOG("CONNECT SERVER FAILED!");
\n return false;
\n }
\n return true;
\n }
\n \/\/\u83b7\u53d6\u65b0\u8fde\u63a5
\n int Accept() {
\n \/\/ int accept(int sockfd, struct sockaddr *addr, socklen_t *len);
\n int newfd = accept(_sockfd, NULL, NULL);
\n if (newfd < 0) {
\n ERR_LOG("SOCKET ACCEPT FAILED!");
\n return -1;
\n }
\n return newfd;
\n }
\n \/\/\u63a5\u6536\u6570\u636e
\n ssize_t Recv(void *buf, size_t len, int flag = 0) {
\n \/\/ ssize_t recv(int sockfd, void *buf, size_t len, int flag);
\n ssize_t ret = recv(_sockfd, buf, len, flag);
\n if (ret <= 0) {
\n \/\/EAGAIN \u5f53\u524dsocket\u7684\u63a5\u6536\u7f13\u51b2\u533a\u4e2d\u6ca1\u6709\u6570\u636e\u4e86，\u5728\u975e\u963b\u585e\u7684\u60c5\u51b5\u4e0b\u624d\u4f1a\u6709\u8fd9\u4e2a\u9519\u8bef
\n \/\/EINTR \u8868\u793a\u5f53\u524dsocket\u7684\u963b\u585e\u7b49\u5f85，\u88ab\u4fe1\u53f7\u6253\u65ad\u4e86，
\n if (errno == EAGAIN || errno == EINTR) {
\n return 0;\/\/\u8868\u793a\u8fd9\u6b21\u63a5\u6536\u6ca1\u6709\u63a5\u6536\u5230\u6570\u636e
\n }
\n ERR_LOG("SOCKET RECV FAILED!!");
\n return -1;
\n }
\n return ret; \/\/\u5b9e\u9645\u63a5\u6536\u7684\u6570\u636e\u957f\u5ea6
\n }
\n ssize_t NonBlockRecv(void *buf, size_t len) {
\n return Recv(buf, len, MSG_DONTWAIT); \/\/ MSG_DONTWAIT \u8868\u793a\u5f53\u524d\u63a5\u6536\u4e3a\u975e\u963b\u585e\u3002
\n }
\n \/\/\u53d1\u9001\u6570\u636e
\n ssize_t Send(const void *buf, size_t len, int flag = 0) {
\n \/\/ ssize_t send(int sockfd, void *data, size_t len, int flag);
\n ssize_t ret = send(_sockfd, buf, len, flag);
\n if (ret < 0) {
\n if (errno == EAGAIN || errno == EINTR) {
\n return 0;
\n }
\n ERR_LOG("SOCKET SEND FAILED!!");
\n return -1;
\n }
\n return ret;\/\/\u5b9e\u9645\u53d1\u9001\u7684\u6570\u636e\u957f\u5ea6
\n }
\n ssize_t NonBlockSend(void *buf, size_t len) {
\n if (len == 0) return 0;
\n return Send(buf, len, MSG_DONTWAIT); \/\/ MSG_DONTWAIT \u8868\u793a\u5f53\u524d\u53d1\u9001\u4e3a\u975e\u963b\u585e\u3002
\n }
\n \/\/\u5173\u95ed\u5957\u63a5\u5b57
\n void Close() {
\n if (_sockfd != -1) {
\n close(_sockfd);
\n _sockfd = -1;
\n }
\n }
\n \/\/\u521b\u5efa\u4e00\u4e2a\u670d\u52a1\u7aef\u8fde\u63a5
\n bool CreateServer(uint16_t port, const std::string &ip = "0.0.0.0", bool block_flag = false) {
\n \/\/1. \u521b\u5efa\u5957\u63a5\u5b57，2. \u7ed1\u5b9a\u5730\u5740，3. \u5f00\u59cb\u76d1\u542c，4. \u8bbe\u7f6e\u975e\u963b\u585e， 5. \u542f\u52a8\u5730\u5740\u91cd\u7528
\n if (Create() == false) return false;
\n if (block_flag) NonBlock();
\n if (Bind(ip, port) == false) return false;
\n if (Listen() == false) return false;
\n ReuseAddress();
\n return true;
\n }
\n \/\/\u521b\u5efa\u4e00\u4e2a\u5ba2\u6237\u7aef\u8fde\u63a5
\n bool CreateClient(uint16_t port, const std::string &ip) {
\n \/\/1. \u521b\u5efa\u5957\u63a5\u5b57，2.\u6307\u5411\u8fde\u63a5\u670d\u52a1\u5668
\n if (Create() == false) return false;
\n if (Connect(ip, port) == false) return false;
\n return true;
\n }
\n \/\/\u8bbe\u7f6e\u5957\u63a5\u5b57\u9009\u9879—\u5f00\u542f\u5730\u5740\u7aef\u53e3\u91cd\u7528
\n void ReuseAddress() {
\n \/\/ int setsockopt(int fd, int leve, int optname, void *val, int vallen)
\n int val = 1;
\n setsockopt(_sockfd, SOL_SOCKET, SO_REUSEADDR, (void*)&val, sizeof(int));
\n val = 1;
\n setsockopt(_sockfd, SOL_SOCKET, SO_REUSEPORT, (void*)&val, sizeof(int));
\n }
\n \/\/\u8bbe\u7f6e\u5957\u63a5\u5b57\u963b\u585e\u5c5e\u6027– \u8bbe\u7f6e\u4e3a\u975e\u963b\u585e
\n void NonBlock() {
\n \/\/int fcntl(int fd, int cmd, … \/* arg *\/ );
\n int flag = fcntl(_sockfd, F_GETFL, 0);
\n fcntl(_sockfd, F_SETFL, flag | O_NONBLOCK);
\n }
\n}; <\/p>\n
Channel\u6a21\u5757\u662f\u5bf9\u2f00\u4e2a\u63cf\u8ff0\u7b26\u9700\u8981\u8fdb\u2f8f\u7684IO\u4e8b\u4ef6\u7ba1\u7406\u7684\u6a21\u5757，\u5b9e\u73b0\u5bf9\u63cf\u8ff0\u7b26\u53ef\u8bfb，\u53ef\u5199，\u9519\u8bef…\u4e8b\u4ef6\u7684\u7ba1\u7406\u64cd\u4f5c，\u4ee5\u53caPoller\u6a21\u5757\u5bf9\u63cf\u8ff0\u7b26\u8fdb\u2f8fIO\u4e8b\u4ef6\u76d1\u63a7\u5c31\u7eea\u540e，\u6839\u636e\u4e0d\u540c\u7684\u4e8b\u4ef6，\u56de\u8c03\u4e0d\u540c\u7684\u5904\u7406\u51fd\u6570\u529f\u80fd\u3002<\/p>\n
class Channel {
\n private:
\n int _fd;
\n EventLoop *_loop;
\n uint32_t _events; \/\/ \u5f53\u524d\u9700\u8981\u76d1\u63a7\u7684\u4e8b\u4ef6
\n uint32_t _revents; \/\/ \u5f53\u524d\u8fde\u63a5\u89e6\u53d1\u7684\u4e8b\u4ef6
\n using EventCallback = std::function<void()>;
\n EventCallback _read_callback; \/\/\u53ef\u8bfb\u4e8b\u4ef6\u88ab\u89e6\u53d1\u7684\u56de\u8c03\u51fd\u6570
\n EventCallback _write_callback; \/\/\u53ef\u5199\u4e8b\u4ef6\u88ab\u89e6\u53d1\u7684\u56de\u8c03\u51fd\u6570
\n EventCallback _error_callback; \/\/\u9519\u8bef\u4e8b\u4ef6\u88ab\u89e6\u53d1\u7684\u56de\u8c03\u51fd\u6570
\n EventCallback _close_callback; \/\/\u8fde\u63a5\u65ad\u5f00\u4e8b\u4ef6\u88ab\u89e6\u53d1\u7684\u56de\u8c03\u51fd\u6570
\n EventCallback _event_callback; \/\/\u4efb\u610f\u4e8b\u4ef6\u88ab\u89e6\u53d1\u7684\u56de\u8c03\u51fd\u6570
\n public:
\n Channel(EventLoop *loop, int fd):_fd(fd), _events(0), _revents(0), _loop(loop) {}
\n int Fd() { return _fd; }
\n uint32_t Events() { return _events; }\/\/\u83b7\u53d6\u60f3\u8981\u76d1\u63a7\u7684\u4e8b\u4ef6
\n void SetREvents(uint32_t events) { _revents = events; }\/\/\u8bbe\u7f6e\u5b9e\u9645\u5c31\u7eea\u7684\u4e8b\u4ef6
\n void SetReadCallback(const EventCallback &cb) { _read_callback = cb; }
\n void SetWriteCallback(const EventCallback &cb) { _write_callback = cb; }
\n void SetErrorCallback(const EventCallback &cb) { _error_callback = cb; }
\n void SetCloseCallback(const EventCallback &cb) { _close_callback = cb; }
\n void SetEventCallback(const EventCallback &cb) { _event_callback = cb; }
\n \/\/\u5f53\u524d\u662f\u5426\u76d1\u63a7\u4e86\u53ef\u8bfb
\n bool ReadAble() { return (_events & EPOLLIN); }
\n \/\/\u5f53\u524d\u662f\u5426\u76d1\u63a7\u4e86\u53ef\u5199
\n bool WriteAble() { return (_events & EPOLLOUT); }
\n \/\/\u542f\u52a8\u8bfb\u4e8b\u4ef6\u76d1\u63a7
\n void EnableRead() { _events |= EPOLLIN; Update(); }
\n \/\/\u542f\u52a8\u5199\u4e8b\u4ef6\u76d1\u63a7
\n void EnableWrite() { _events |= EPOLLOUT; Update(); }
\n \/\/\u5173\u95ed\u8bfb\u4e8b\u4ef6\u76d1\u63a7
\n void DisableRead() { _events &= ~EPOLLIN; Update(); }
\n \/\/\u5173\u95ed\u5199\u4e8b\u4ef6\u76d1\u63a7
\n void DisableWrite() { _events &= ~EPOLLOUT; Update(); }
\n \/\/\u5173\u95ed\u6240\u6709\u4e8b\u4ef6\u76d1\u63a7
\n void DisableAll() { _events = 0; Update(); }
\n \/\/\u79fb\u9664\u76d1\u63a7
\n void Remove();
\n void Update();
\n \/\/\u4e8b\u4ef6\u5904\u7406，\u4e00\u65e6\u8fde\u63a5\u89e6\u53d1\u4e86\u4e8b\u4ef6，\u5c31\u8c03\u7528\u8fd9\u4e2a\u51fd\u6570，\u81ea\u5df1\u89e6\u53d1\u4e86\u4ec0\u4e48\u4e8b\u4ef6\u5982\u4f55\u5904\u7406\u81ea\u5df1\u51b3\u5b9a
\n void HandleEvent() {
\n if ((_revents & EPOLLIN) || (_revents & EPOLLRDHUP) || (_revents & EPOLLPRI)) {
\n \/*\u4e0d\u7ba1\u4efb\u4f55\u4e8b\u4ef6，\u90fd\u8c03\u7528\u7684\u56de\u8c03\u51fd\u6570*\/
\n if (_read_callback) _read_callback();
\n }
\n \/*\u6709\u53ef\u80fd\u4f1a\u91ca\u653e\u8fde\u63a5\u7684\u64cd\u4f5c\u4e8b\u4ef6，\u4e00\u6b21\u53ea\u5904\u7406\u4e00\u4e2a*\/
\n if (_revents & EPOLLOUT) {
\n if (_write_callback) _write_callback();
\n }else if (_revents & EPOLLERR) {
\n if (_error_callback) _error_callback();\/\/\u4e00\u65e6\u51fa\u9519，\u5c31\u4f1a\u91ca\u653e\u8fde\u63a5，\u56e0\u6b64\u8981\u653e\u5230\u524d\u8fb9\u8c03\u7528\u4efb\u610f\u56de\u8c03
\n }else if (_revents & EPOLLHUP) {
\n if (_close_callback) _close_callback();
\n }
\n if (_event_callback) _event_callback();
\n }
\n}; <\/p>\n
Connection\u6a21\u5757\u662f\u5bf9Buffer\u6a21\u5757，Socket\u6a21\u5757，Channel\u6a21\u5757\u7684\u2f00\u4e2a\u6574\u4f53\u5c01\u88c5，\u5b9e\u73b0\u4e86\u5bf9\u2f00\u4e2a\u901a\u4fe1\u5957\u63a5\u5b57\u7684\u6574\u4f53\u7684\u7ba1\u7406，\u6bcf\u2f00\u4e2a\u8fdb\u2f8f\u6570\u636e\u901a\u4fe1\u7684\u5957\u63a5\u5b57（\u4e5f\u5c31\u662faccept\u83b7\u53d6\u5230\u7684\u65b0\u8fde\u63a5）\u90fd\u4f1a\u4f7f\u2f64 Connection\u8fdb\u2f8f\u7ba1\u7406\u3002<\/p>\n
class Connection : public std::enable_shared_from_this<Connection> {
\n private:
\n uint64_t _conn_id; \/\/ \u8fde\u63a5\u7684\u552f\u4e00ID，\u4fbf\u4e8e\u8fde\u63a5\u7684\u7ba1\u7406\u548c\u67e5\u627e
\n \/\/uint64_t _timer_id; \/\/\u5b9a\u65f6\u5668ID，\u5fc5\u987b\u662f\u552f\u4e00\u7684，\u8fd9\u5757\u4e3a\u4e86\u7b80\u5316\u64cd\u4f5c\u4f7f\u7528conn_id\u4f5c\u4e3a\u5b9a\u65f6\u5668ID
\n int _sockfd; \/\/ \u8fde\u63a5\u5173\u8054\u7684\u6587\u4ef6\u63cf\u8ff0\u7b26
\n bool _enable_inactive_release; \/\/ \u8fde\u63a5\u662f\u5426\u542f\u52a8\u975e\u6d3b\u8dc3\u9500\u6bc1\u7684\u5224\u65ad\u6807\u5fd7，\u9ed8\u8ba4\u4e3afalse
\n EventLoop *_loop; \/\/ \u8fde\u63a5\u6240\u5173\u8054\u7684\u4e00\u4e2aEventLoop
\n ConnStatu _statu; \/\/ \u8fde\u63a5\u72b6\u6001
\n Socket _socket; \/\/ \u5957\u63a5\u5b57\u64cd\u4f5c\u7ba1\u7406
\n Channel _channel; \/\/ \u8fde\u63a5\u7684\u4e8b\u4ef6\u7ba1\u7406
\n Buffer _in_buffer; \/\/ \u8f93\u5165\u7f13\u51b2\u533a—\u5b58\u653e\u4ecesocket\u4e2d\u8bfb\u53d6\u5230\u7684\u6570\u636e
\n Buffer _out_buffer; \/\/ \u8f93\u51fa\u7f13\u51b2\u533a—\u5b58\u653e\u8981\u53d1\u9001\u7ed9\u5bf9\u7aef\u7684\u6570\u636e
\n Any _context; \/\/ \u8bf7\u6c42\u7684\u63a5\u6536\u5904\u7406\u4e0a\u4e0b\u6587<\/p>\n
\/*\u8fd9\u56db\u4e2a\u56de\u8c03\u51fd\u6570，\u662f\u8ba9\u670d\u52a1\u5668\u6a21\u5757\u6765\u8bbe\u7f6e\u7684（\u5176\u5b9e\u670d\u52a1\u5668\u6a21\u5757\u7684\u5904\u7406\u56de\u8c03\u4e5f\u662f\u7ec4\u4ef6\u4f7f\u7528\u8005\u8bbe\u7f6e\u7684）*\/
\n \/*\u6362\u53e5\u8bdd\u8bf4，\u8fd9\u51e0\u4e2a\u56de\u8c03\u90fd\u662f\u7ec4\u4ef6\u4f7f\u7528\u8005\u4f7f\u7528\u7684*\/
\n using ConnectedCallback = std::function<void(const PtrConnection&)>;
\n using MessageCallback = std::function<void(const PtrConnection&, Buffer *)>;
\n using ClosedCallback = std::function<void(const PtrConnection&)>;
\n using AnyEventCallback = std::function<void(const PtrConnection&)>;
\n ConnectedCallback _connected_callback;
\n MessageCallback _message_callback;
\n ClosedCallback _closed_callback;
\n AnyEventCallback _event_callback;
\n \/*\u7ec4\u4ef6\u5185\u7684\u8fde\u63a5\u5173\u95ed\u56de\u8c03–\u7ec4\u4ef6\u5185\u8bbe\u7f6e\u7684，\u56e0\u4e3a\u670d\u52a1\u5668\u7ec4\u4ef6\u5185\u4f1a\u628a\u6240\u6709\u7684\u8fde\u63a5\u7ba1\u7406\u8d77\u6765，\u4e00\u65e6\u67d0\u4e2a\u8fde\u63a5\u8981\u5173\u95ed*\/
\n \/*\u5c31\u5e94\u8be5\u4ece\u7ba1\u7406\u7684\u5730\u65b9\u79fb\u9664\u6389\u81ea\u5df1\u7684\u4fe1\u606f*\/
\n ClosedCallback _server_closed_callback;
\n private:
\n \/*\u4e94\u4e2achannel\u7684\u4e8b\u4ef6\u56de\u8c03\u51fd\u6570*\/
\n \/\/\u63cf\u8ff0\u7b26\u53ef\u8bfb\u4e8b\u4ef6\u89e6\u53d1\u540e\u8c03\u7528\u7684\u51fd\u6570，\u63a5\u6536socket\u6570\u636e\u653e\u5230\u63a5\u6536\u7f13\u51b2\u533a\u4e2d，\u7136\u540e\u8c03\u7528_message_callback
\n void HandleRead() {
\n \/\/1. \u63a5\u6536socket\u7684\u6570\u636e，\u653e\u5230\u7f13\u51b2\u533a
\n char buf[65536];
\n ssize_t ret = _socket.NonBlockRecv(buf, 65535);
\n if (ret < 0) {
\n \/\/\u51fa\u9519\u4e86,\u4e0d\u80fd\u76f4\u63a5\u5173\u95ed\u8fde\u63a5
\n return ShutdownInLoop();
\n }
\n \/\/\u8fd9\u91cc\u7684\u7b49\u4e8e0\u8868\u793a\u7684\u662f\u6ca1\u6709\u8bfb\u53d6\u5230\u6570\u636e，\u800c\u5e76\u4e0d\u662f\u8fde\u63a5\u65ad\u5f00\u4e86，\u8fde\u63a5\u65ad\u5f00\u8fd4\u56de\u7684\u662f-1
\n \/\/\u5c06\u6570\u636e\u653e\u5165\u8f93\u5165\u7f13\u51b2\u533a,\u5199\u5165\u4e4b\u540e\u987a\u4fbf\u5c06\u5199\u504f\u79fb\u5411\u540e\u79fb\u52a8
\n _in_buffer.WriteAndPush(buf, ret);
\n \/\/2. \u8c03\u7528message_callback\u8fdb\u884c\u4e1a\u52a1\u5904\u7406
\n if (_in_buffer.ReadAbleSize() > 0) {
\n \/\/shared_from_this–\u4ece\u5f53\u524d\u5bf9\u8c61\u81ea\u8eab\u83b7\u53d6\u81ea\u8eab\u7684shared_ptr\u7ba1\u7406\u5bf9\u8c61
\n return _message_callback(shared_from_this(), &_in_buffer);
\n }
\n }
\n \/\/\u63cf\u8ff0\u7b26\u53ef\u5199\u4e8b\u4ef6\u89e6\u53d1\u540e\u8c03\u7528\u7684\u51fd\u6570，\u5c06\u53d1\u9001\u7f13\u51b2\u533a\u4e2d\u7684\u6570\u636e\u8fdb\u884c\u53d1\u9001
\n void HandleWrite() {
\n \/\/_out_buffer\u4e2d\u4fdd\u5b58\u7684\u6570\u636e\u5c31\u662f\u8981\u53d1\u9001\u7684\u6570\u636e
\n ssize_t ret = _socket.NonBlockSend(_out_buffer.ReadPosition(), _out_buffer.ReadAbleSize());
\n if (ret < 0) {
\n \/\/\u53d1\u9001\u9519\u8bef\u5c31\u8be5\u5173\u95ed\u8fde\u63a5\u4e86，
\n if (_in_buffer.ReadAbleSize() > 0) {
\n _message_callback(shared_from_this(), &_in_buffer);
\n }
\n return Release();\/\/\u8fd9\u65f6\u5019\u5c31\u662f\u5b9e\u9645\u7684\u5173\u95ed\u91ca\u653e\u64cd\u4f5c\u4e86\u3002
\n }
\n _out_buffer.MoveReadOffset(ret);\/\/\u5343\u4e07\u4e0d\u8981\u5fd8\u4e86，\u5c06\u8bfb\u504f\u79fb\u5411\u540e\u79fb\u52a8
\n if (_out_buffer.ReadAbleSize() == 0) {
\n _channel.DisableWrite();\/\/ \u6ca1\u6709\u6570\u636e\u5f85\u53d1\u9001\u4e86，\u5173\u95ed\u5199\u4e8b\u4ef6\u76d1\u63a7
\n \/\/\u5982\u679c\u5f53\u524d\u662f\u8fde\u63a5\u5f85\u5173\u95ed\u72b6\u6001，\u5219\u6709\u6570\u636e，\u53d1\u9001\u5b8c\u6570\u636e\u91ca\u653e\u8fde\u63a5，\u6ca1\u6709\u6570\u636e\u5219\u76f4\u63a5\u91ca\u653e
\n if (_statu == DISCONNECTING) {
\n return Release();
\n }
\n }
\n return;
\n }
\n \/\/\u63cf\u8ff0\u7b26\u89e6\u53d1\u6302\u65ad\u4e8b\u4ef6
\n void HandleClose() {
\n \/*\u4e00\u65e6\u8fde\u63a5\u6302\u65ad\u4e86，\u5957\u63a5\u5b57\u5c31\u4ec0\u4e48\u90fd\u5e72\u4e0d\u4e86\u4e86，\u56e0\u6b64\u6709\u6570\u636e\u5f85\u5904\u7406\u5c31\u5904\u7406\u4e00\u4e0b，\u5b8c\u6bd5\u5173\u95ed\u8fde\u63a5*\/
\n if (_in_buffer.ReadAbleSize() > 0) {
\n _message_callback(shared_from_this(), &_in_buffer);
\n }
\n return Release();
\n }
\n \/\/\u63cf\u8ff0\u7b26\u89e6\u53d1\u51fa\u9519\u4e8b\u4ef6
\n void HandleError() {
\n return HandleClose();
\n }
\n \/\/\u63cf\u8ff0\u7b26\u89e6\u53d1\u4efb\u610f\u4e8b\u4ef6: 1. \u5237\u65b0\u8fde\u63a5\u7684\u6d3b\u8dc3\u5ea6–\u5ef6\u8fdf\u5b9a\u65f6\u9500\u6bc1\u4efb\u52a1； 2. \u8c03\u7528\u7ec4\u4ef6\u4f7f\u7528\u8005\u7684\u4efb\u610f\u4e8b\u4ef6\u56de\u8c03
\n void HandleEvent() {
\n if (_enable_inactive_release == true) { _loop->TimerRefresh(_conn_id); }
\n if (_event_callback) { _event_callback(shared_from_this()); }
\n }
\n \/\/\u8fde\u63a5\u83b7\u53d6\u4e4b\u540e，\u6240\u5904\u7684\u72b6\u6001\u4e0b\u8981\u8fdb\u884c\u5404\u79cd\u8bbe\u7f6e（\u542f\u52a8\u8bfb\u76d1\u63a7,\u8c03\u7528\u56de\u8c03\u51fd\u6570）
\n void EstablishedInLoop() {
\n \/\/ 1. \u4fee\u6539\u8fde\u63a5\u72b6\u6001； 2. \u542f\u52a8\u8bfb\u4e8b\u4ef6\u76d1\u63a7； 3. \u8c03\u7528\u56de\u8c03\u51fd\u6570
\n assert(_statu == CONNECTING);\/\/\u5f53\u524d\u7684\u72b6\u6001\u5fc5\u987b\u4e00\u5b9a\u662f\u4e0a\u5c42\u7684\u534a\u8fde\u63a5\u72b6\u6001
\n _statu = CONNECTED;\/\/\u5f53\u524d\u51fd\u6570\u6267\u884c\u5b8c\u6bd5，\u5219\u8fde\u63a5\u8fdb\u5165\u5df2\u5b8c\u6210\u8fde\u63a5\u72b6\u6001
\n \/\/ \u4e00\u65e6\u542f\u52a8\u8bfb\u4e8b\u4ef6\u76d1\u63a7\u5c31\u6709\u53ef\u80fd\u4f1a\u7acb\u5373\u89e6\u53d1\u8bfb\u4e8b\u4ef6，\u5982\u679c\u8fd9\u65f6\u5019\u542f\u52a8\u4e86\u975e\u6d3b\u8dc3\u8fde\u63a5\u9500\u6bc1
\n _channel.EnableRead();
\n if (_connected_callback) _connected_callback(shared_from_this());
\n }
\n \/\/\u8fd9\u4e2a\u63a5\u53e3\u624d\u662f\u5b9e\u9645\u7684\u91ca\u653e\u63a5\u53e3
\n void ReleaseInLoop() {
\n \/\/1. \u4fee\u6539\u8fde\u63a5\u72b6\u6001，\u5c06\u5176\u7f6e\u4e3aDISCONNECTED
\n _statu = DISCONNECTED;
\n \/\/2. \u79fb\u9664\u8fde\u63a5\u7684\u4e8b\u4ef6\u76d1\u63a7
\n _channel.Remove();
\n \/\/3. \u5173\u95ed\u63cf\u8ff0\u7b26
\n _socket.Close();
\n \/\/4. \u5982\u679c\u5f53\u524d\u5b9a\u65f6\u5668\u961f\u5217\u4e2d\u8fd8\u6709\u5b9a\u65f6\u9500\u6bc1\u4efb\u52a1，\u5219\u53d6\u6d88\u4efb\u52a1
\n if (_loop->HasTimer(_conn_id)) CancelInactiveReleaseInLoop();
\n \/\/5. \u8c03\u7528\u5173\u95ed\u56de\u8c03\u51fd\u6570，\u907f\u514d\u5148\u79fb\u9664\u670d\u52a1\u5668\u7ba1\u7406\u7684\u8fde\u63a5\u4fe1\u606f\u5bfc\u81f4Connection\u88ab\u91ca\u653e，\u518d\u53bb\u5904\u7406\u4f1a\u51fa\u9519，\u56e0\u6b64\u5148\u8c03\u7528\u7528\u6237\u7684\u56de\u8c03\u51fd\u6570
\n if (_closed_callback) _closed_callback(shared_from_this());
\n \/\/\u79fb\u9664\u670d\u52a1\u5668\u5185\u90e8\u7ba1\u7406\u7684\u8fde\u63a5\u4fe1\u606f
\n if (_server_closed_callback) _server_closed_callback(shared_from_this());
\n }
\n \/\/\u8fd9\u4e2a\u63a5\u53e3\u5e76\u4e0d\u662f\u5b9e\u9645\u7684\u53d1\u9001\u63a5\u53e3，\u800c\u53ea\u662f\u628a\u6570\u636e\u653e\u5230\u4e86\u53d1\u9001\u7f13\u51b2\u533a，\u542f\u52a8\u4e86\u53ef\u5199\u4e8b\u4ef6\u76d1\u63a7
\n void SendInLoop(Buffer &buf) {
\n if (_statu == DISCONNECTED) return ;
\n _out_buffer.WriteBufferAndPush(buf);
\n if (_channel.WriteAble() == false) {
\n _channel.EnableWrite();
\n }
\n }
\n \/\/\u8fd9\u4e2a\u5173\u95ed\u64cd\u4f5c\u5e76\u975e\u5b9e\u9645\u7684\u8fde\u63a5\u91ca\u653e\u64cd\u4f5c，\u9700\u8981\u5224\u65ad\u8fd8\u6709\u6ca1\u6709\u6570\u636e\u5f85\u5904\u7406，\u5f85\u53d1\u9001
\n void ShutdownInLoop() {
\n _statu = DISCONNECTING;\/\/ \u8bbe\u7f6e\u8fde\u63a5\u4e3a\u534a\u5173\u95ed\u72b6\u6001
\n if (_in_buffer.ReadAbleSize() > 0) {
\n if (_message_callback) _message_callback(shared_from_this(), &_in_buffer);
\n }
\n \/\/\u8981\u4e48\u5c31\u662f\u5199\u5165\u6570\u636e\u7684\u65f6\u5019\u51fa\u9519\u5173\u95ed，\u8981\u4e48\u5c31\u662f\u6ca1\u6709\u5f85\u53d1\u9001\u6570\u636e，\u76f4\u63a5\u5173\u95ed
\n if (_out_buffer.ReadAbleSize() > 0) {
\n if (_channel.WriteAble() == false) {
\n _channel.EnableWrite();
\n }
\n }
\n if (_out_buffer.ReadAbleSize() == 0) {
\n Release();
\n }
\n }
\n \/\/\u542f\u52a8\u975e\u6d3b\u8dc3\u8fde\u63a5\u8d85\u65f6\u91ca\u653e\u89c4\u5219
\n void EnableInactiveReleaseInLoop(int sec) {
\n \/\/1. \u5c06\u5224\u65ad\u6807\u5fd7 _enable_inactive_release \u7f6e\u4e3atrue
\n _enable_inactive_release = true;
\n \/\/2. \u5982\u679c\u5f53\u524d\u5b9a\u65f6\u9500\u6bc1\u4efb\u52a1\u5df2\u7ecf\u5b58\u5728，\u90a3\u5c31\u5237\u65b0\u5ef6\u8fdf\u4e00\u4e0b\u5373\u53ef
\n if (_loop->HasTimer(_conn_id)) {
\n return _loop->TimerRefresh(_conn_id);
\n }
\n \/\/3. \u5982\u679c\u4e0d\u5b58\u5728\u5b9a\u65f6\u9500\u6bc1\u4efb\u52a1，\u5219\u65b0\u589e
\n _loop->TimerAdd(_conn_id, sec, std::bind(&Connection::Release, this));
\n }
\n void CancelInactiveReleaseInLoop() {
\n _enable_inactive_release = false;
\n if (_loop->HasTimer(_conn_id)) {
\n _loop->TimerCancel(_conn_id);
\n }
\n }
\n void UpgradeInLoop(const Any &context,
\n const ConnectedCallback &conn,
\n const MessageCallback &msg,
\n const ClosedCallback &closed,
\n const AnyEventCallback &event) {
\n _context = context;
\n _connected_callback = conn;
\n _message_callback = msg;
\n _closed_callback = closed;
\n _event_callback = event;
\n }
\n public:
\n Connection(EventLoop *loop, uint64_t conn_id, int sockfd):_conn_id(conn_id), _sockfd(sockfd),
\n _enable_inactive_release(false), _loop(loop), _statu(CONNECTING), _socket(_sockfd),
\n _channel(loop, _sockfd) {
\n _channel.SetCloseCallback(std::bind(&Connection::HandleClose, this));
\n _channel.SetEventCallback(std::bind(&Connection::HandleEvent, this));
\n _channel.SetReadCallback(std::bind(&Connection::HandleRead, this));
\n _channel.SetWriteCallback(std::bind(&Connection::HandleWrite, this));
\n _channel.SetErrorCallback(std::bind(&Connection::HandleError, this));
\n }
\n ~Connection() { DBG_LOG("RELEASE CONNECTION:%p", this); }
\n \/\/\u83b7\u53d6\u7ba1\u7406\u7684\u6587\u4ef6\u63cf\u8ff0\u7b26
\n int Fd() { return _sockfd; }
\n \/\/\u83b7\u53d6\u8fde\u63a5ID
\n int Id() { return _conn_id; }
\n \/\/\u662f\u5426\u5904\u4e8eCONNECTED\u72b6\u6001
\n bool Connected() { return (_statu == CONNECTED); }
\n \/\/\u8bbe\u7f6e\u4e0a\u4e0b\u6587–\u8fde\u63a5\u5efa\u7acb\u5b8c\u6210\u65f6\u8fdb\u884c\u8c03\u7528
\n void SetContext(const Any &context) { _context = context; }
\n \/\/\u83b7\u53d6\u4e0a\u4e0b\u6587，\u8fd4\u56de\u7684\u662f\u6307\u9488
\n Any *GetContext() { return &_context; }
\n void SetConnectedCallback(const ConnectedCallback&cb) { _connected_callback = cb; }
\n void SetMessageCallback(const MessageCallback&cb) { _message_callback = cb; }
\n void SetClosedCallback(const ClosedCallback&cb) { _closed_callback = cb; }
\n void SetAnyEventCallback(const AnyEventCallback&cb) { _event_callback = cb; }
\n void SetSrvClosedCallback(const ClosedCallback&cb) { _server_closed_callback = cb; }
\n \/\/\u8fde\u63a5\u5efa\u7acb\u5c31\u7eea\u540e，\u8fdb\u884cchannel\u56de\u8c03\u8bbe\u7f6e，\u542f\u52a8\u8bfb\u76d1\u63a7，\u8c03\u7528_connected_callback
\n void Established() {
\n _loop->RunInLoop(std::bind(&Connection::EstablishedInLoop, this));
\n }
\n \/\/\u53d1\u9001\u6570\u636e，\u5c06\u6570\u636e\u653e\u5230\u53d1\u9001\u7f13\u51b2\u533a，\u542f\u52a8\u5199\u4e8b\u4ef6\u76d1\u63a7
\n void Send(const char *data, size_t len) {
\n \/\/\u5916\u754c\u4f20\u5165\u7684data，\u53ef\u80fd\u662f\u4e2a\u4e34\u65f6\u7684\u7a7a\u95f4，\u6211\u4eec\u73b0\u5728\u53ea\u662f\u628a\u53d1\u9001\u64cd\u4f5c\u538b\u5165\u4e86\u4efb\u52a1\u6c60，\u6709\u53ef\u80fd\u5e76\u6ca1\u6709\u88ab\u7acb\u5373\u6267\u884c
\n \/\/\u56e0\u6b64\u6709\u53ef\u80fd\u6267\u884c\u7684\u65f6\u5019，data\u6307\u5411\u7684\u7a7a\u95f4\u6709\u53ef\u80fd\u5df2\u7ecf\u88ab\u91ca\u653e\u4e86\u3002
\n Buffer buf;
\n buf.WriteAndPush(data, len);
\n _loop->RunInLoop(std::bind(&Connection::SendInLoop, this, std::move(buf)));
\n }
\n \/\/\u63d0\u4f9b\u7ed9\u7ec4\u4ef6\u4f7f\u7528\u8005\u7684\u5173\u95ed\u63a5\u53e3–\u5e76\u4e0d\u5b9e\u9645\u5173\u95ed，\u9700\u8981\u5224\u65ad\u6709\u6ca1\u6709\u6570\u636e\u5f85\u5904\u7406
\n void Shutdown() {
\n _loop->RunInLoop(std::bind(&Connection::ShutdownInLoop, this));
\n }
\n void Release() {
\n _loop->QueueInLoop(std::bind(&Connection::ReleaseInLoop, this));
\n }
\n \/\/\u542f\u52a8\u975e\u6d3b\u8dc3\u9500\u6bc1，\u5e76\u5b9a\u4e49\u591a\u957f\u65f6\u95f4\u65e0\u901a\u4fe1\u5c31\u662f\u975e\u6d3b\u8dc3，\u6dfb\u52a0\u5b9a\u65f6\u4efb\u52a1
\n void EnableInactiveRelease(int sec) {
\n _loop->RunInLoop(std::bind(&Connection::EnableInactiveReleaseInLoop, this, sec));
\n }
\n \/\/\u53d6\u6d88\u975e\u6d3b\u8dc3\u9500\u6bc1
\n void CancelInactiveRelease() {
\n _loop->RunInLoop(std::bind(&Connection::CancelInactiveReleaseInLoop, this));
\n }
\n \/\/\u5207\u6362\u534f\u8bae—\u91cd\u7f6e\u4e0a\u4e0b\u6587\u4ee5\u53ca\u9636\u6bb5\u6027\u56de\u8c03\u5904\u7406\u51fd\u6570 — \u800c\u662f\u8fd9\u4e2a\u63a5\u53e3\u5fc5\u987b\u5728EventLoop\u7ebf\u7a0b\u4e2d\u7acb\u5373\u6267\u884c
\n \/\/\u9632\u5907\u65b0\u7684\u4e8b\u4ef6\u89e6\u53d1\u540e，\u5904\u7406\u7684\u65f6\u5019，\u5207\u6362\u4efb\u52a1\u8fd8\u6ca1\u6709\u88ab\u6267\u884c–\u4f1a\u5bfc\u81f4\u6570\u636e\u4f7f\u7528\u539f\u534f\u8bae\u5904\u7406\u4e86\u3002
\n void Upgrade(const Any &context, const ConnectedCallback &conn, const MessageCallback &msg,
\n const ClosedCallback &closed, const AnyEventCallback &event) {
\n _loop->AssertInLoop();
\n _loop->RunInLoop(std::bind(&Connection::UpgradeInLoop, this, context, conn, msg, closed, event));
\n }
\n}; <\/p>\n
Acceptor\u6a21\u5757\u662f\u5bf9Socket\u6a21\u5757，Channel\u6a21\u5757\u7684\u2f00\u4e2a\u6574\u4f53\u5c01\u88c5，\u5b9e\u73b0\u4e86\u5bf9\u2f00\u4e2a\u76d1\u542c\u5957\u63a5\u5b57\u7684\u6574\u4f53\u7684\u7ba1\u7406\u3002<\/p>\n
class Acceptor {
\n private:
\n Socket _socket;\/\/\u7528\u4e8e\u521b\u5efa\u76d1\u542c\u5957\u63a5\u5b57
\n EventLoop *_loop; \/\/\u7528\u4e8e\u5bf9\u76d1\u542c\u5957\u63a5\u5b57\u8fdb\u884c\u4e8b\u4ef6\u76d1\u63a7
\n Channel _channel; \/\/\u7528\u4e8e\u5bf9\u76d1\u542c\u5957\u63a5\u5b57\u8fdb\u884c\u4e8b\u4ef6\u7ba1\u7406<\/p>\n
using AcceptCallback = std::function<void(int)>;
\n AcceptCallback _accept_callback;
\n private:
\n \/*\u76d1\u542c\u5957\u63a5\u5b57\u7684\u8bfb\u4e8b\u4ef6\u56de\u8c03\u5904\u7406\u51fd\u6570—\u83b7\u53d6\u65b0\u8fde\u63a5，\u8c03\u7528_accept_callback\u51fd\u6570\u8fdb\u884c\u65b0\u8fde\u63a5\u5904\u7406*\/
\n void HandleRead() {
\n int newfd = _socket.Accept();
\n if (newfd < 0) {
\n return ;
\n }
\n if (_accept_callback) _accept_callback(newfd);
\n }
\n int CreateServer(int port) {
\n bool ret = _socket.CreateServer(port);
\n assert(ret == true);
\n return _socket.Fd();
\n }
\n public:
\n \/*\u4e0d\u80fd\u5c06\u542f\u52a8\u8bfb\u4e8b\u4ef6\u76d1\u63a7，\u653e\u5230\u6784\u9020\u51fd\u6570\u4e2d，\u5fc5\u987b\u5728\u8bbe\u7f6e\u56de\u8c03\u51fd\u6570\u540e，\u518d\u53bb\u542f\u52a8*\/
\n \/*\u5426\u5219\u6709\u53ef\u80fd\u9020\u6210\u542f\u52a8\u76d1\u63a7\u540e，\u7acb\u5373\u6709\u4e8b\u4ef6，\u5904\u7406\u7684\u65f6\u5019，\u56de\u8c03\u51fd\u6570\u8fd8\u6ca1\u8bbe\u7f6e：\u65b0\u8fde\u63a5\u5f97\u4e0d\u5230\u5904\u7406，\u4e14\u8d44\u6e90\u6cc4\u6f0f*\/
\n Acceptor(EventLoop *loop, int port): _socket(CreateServer(port)), _loop(loop),
\n _channel(loop, _socket.Fd()) {
\n _channel.SetReadCallback(std::bind(&Acceptor::HandleRead, this));
\n }
\n void SetAcceptCallback(const AcceptCallback &cb) { _accept_callback = cb; }
\n void Listen() { _channel.EnableRead(); }
\n}; <\/p>\n
TimerQueue\u6a21\u5757\u662f\u5b9e\u73b0\u56fa\u5b9a\u65f6\u95f4\u5b9a\u65f6\u4efb\u52a1\u7684\u6a21\u5757，\u53ef\u4ee5\u7406\u89e3\u5c31\u662f\u8981\u7ed9\u5b9a\u65f6\u4efb\u52a1\u7ba1\u7406\u5668，\u5411\u5b9a\u65f6\u4efb\u52a1\u7ba1\u7406\u5668\u4e2d\u6dfb\u52a0\u2f00\u4e2a\u4efb\u52a1，\u4efb\u52a1\u5c06\u5728\u56fa\u5b9a\u65f6\u95f4\u540e\u88ab\u6267\u2f8f，\u540c\u65f6\u4e5f\u53ef\u4ee5\u901a\u8fc7\u5237\u65b0\u5b9a\u65f6\u4efb\u52a1\u6765\u5ef6\u8fdf\u4efb\u52a1\u7684\u6267\u2f8f\u3002<\/p>\n
using TaskFunc = std::function<void()>;
\nusing ReleaseFunc = std::function<void()>;
\nclass TimerTask{
\n private:
\n uint64_t _id; \/\/ \u5b9a\u65f6\u5668\u4efb\u52a1\u5bf9\u8c61ID
\n uint32_t _timeout; \/\/\u5b9a\u65f6\u4efb\u52a1\u7684\u8d85\u65f6\u65f6\u95f4
\n bool _canceled; \/\/ false-\u8868\u793a\u6ca1\u6709\u88ab\u53d6\u6d88， true-\u8868\u793a\u88ab\u53d6\u6d88
\n TaskFunc _task_cb; \/\/\u5b9a\u65f6\u5668\u5bf9\u8c61\u8981\u6267\u884c\u7684\u5b9a\u65f6\u4efb\u52a1
\n ReleaseFunc _release; \/\/\u7528\u4e8e\u5220\u9664TimerWheel\u4e2d\u4fdd\u5b58\u7684\u5b9a\u65f6\u5668\u5bf9\u8c61\u4fe1\u606f
\n public:
\n TimerTask(uint64_t id, uint32_t delay, const TaskFunc &cb):
\n _id(id), _timeout(delay), _task_cb(cb), _canceled(false) {}
\n ~TimerTask() {
\n if (_canceled == false) _task_cb();
\n _release();
\n }
\n void Cancel() { _canceled = true; }
\n void SetRelease(const ReleaseFunc &cb) { _release = cb; }
\n uint32_t DelayTime() { return _timeout; }
\n};<\/p>\n
class TimerWheel {
\n private:
\n using WeakTask = std::weak_ptr<TimerTask>;
\n using PtrTask = std::shared_ptr<TimerTask>;
\n int _tick; \/\/\u5f53\u524d\u7684\u79d2\u9488，\u8d70\u5230\u54ea\u91cc\u91ca\u653e\u54ea\u91cc，\u91ca\u653e\u54ea\u91cc，\u5c31\u76f8\u5f53\u4e8e\u6267\u884c\u54ea\u91cc\u7684\u4efb\u52a1
\n int _capacity; \/\/\u8868\u76d8\u6700\u5927\u6570\u91cf—\u5176\u5b9e\u5c31\u662f\u6700\u5927\u5ef6\u8fdf\u65f6\u95f4
\n std::vector<std::vector<PtrTask>> _wheel;
\n std::unordered_map<uint64_t, WeakTask> _timers;<\/p>\n
EventLoop *_loop;
\n int _timerfd;\/\/\u5b9a\u65f6\u5668\u63cf\u8ff0\u7b26–\u53ef\u8bfb\u4e8b\u4ef6\u56de\u8c03\u5c31\u662f\u8bfb\u53d6\u8ba1\u6570\u5668，\u6267\u884c\u5b9a\u65f6\u4efb\u52a1
\n std::unique_ptr<Channel> _timer_channel;
\n private:
\n void RemoveTimer(uint64_t id) {
\n auto it = _timers.find(id);
\n if (it != _timers.end()) {
\n _timers.erase(it);
\n }
\n }
\n static int CreateTimerfd() {
\n int timerfd = timerfd_create(CLOCK_MONOTONIC, 0);
\n if (timerfd < 0) {
\n ERR_LOG("TIMERFD CREATE FAILED!");
\n abort();
\n }
\n \/\/int timerfd_settime(int fd, int flags, struct itimerspec *new, struct itimerspec *old);
\n struct itimerspec itime;
\n itime.it_value.tv_sec = 1;
\n itime.it_value.tv_nsec = 0;\/\/\u7b2c\u4e00\u6b21\u8d85\u65f6\u65f6\u95f4\u4e3a1s\u540e
\n itime.it_interval.tv_sec = 1;
\n itime.it_interval.tv_nsec = 0; \/\/\u7b2c\u4e00\u6b21\u8d85\u65f6\u540e，\u6bcf\u6b21\u8d85\u65f6\u7684\u95f4\u9694\u65f6
\n timerfd_settime(timerfd, 0, &itime, NULL);
\n return timerfd;
\n }
\n int ReadTimefd() {
\n uint64_t times;
\n \/\/\u6709\u53ef\u80fd\u56e0\u4e3a\u5176\u4ed6\u63cf\u8ff0\u7b26\u7684\u4e8b\u4ef6\u5904\u7406\u82b1\u8d39\u4e8b\u4ef6\u6bd4\u8f83\u957f，\u7136\u540e\u5728\u5904\u7406\u5b9a\u65f6\u5668\u63cf\u8ff0\u7b26\u4e8b\u4ef6\u7684\u65f6\u5019，\u6709\u53ef\u80fd\u5c31\u5df2\u7ecf\u8d85\u65f6\u4e86\u5f88\u591a\u6b21
\n \/\/read\u8bfb\u53d6\u5230\u7684\u6570\u636etimes\u5c31\u662f\u4ece\u4e0a\u4e00\u6b21read\u4e4b\u540e\u8d85\u65f6\u7684\u6b21\u6570
\n int ret = read(_timerfd, ×, 8);
\n if (ret < 0) {
\n ERR_LOG("READ TIMEFD FAILED!");
\n abort();
\n }
\n return times;
\n }
\n \/\/\u8fd9\u4e2a\u51fd\u6570\u5e94\u8be5\u6bcf\u79d2\u949f\u88ab\u6267\u884c\u4e00\u6b21，\u76f8\u5f53\u4e8e\u79d2\u9488\u5411\u540e\u8d70\u4e86\u4e00\u6b65
\n void RunTimerTask() {
\n _tick = (_tick + 1) % _capacity;
\n _wheel[_tick].clear();\/\/\u6e05\u7a7a\u6307\u5b9a\u4f4d\u7f6e\u7684\u6570\u7ec4，\u5c31\u4f1a\u628a\u6570\u7ec4\u4e2d\u4fdd\u5b58\u7684\u6240\u6709\u7ba1\u7406\u5b9a\u65f6\u5668\u5bf9\u8c61\u7684shared_ptr\u91ca\u653e\u6389
\n }
\n void OnTime() {
\n \/\/\u6839\u636e\u5b9e\u9645\u8d85\u65f6\u7684\u6b21\u6570，\u6267\u884c\u5bf9\u5e94\u7684\u8d85\u65f6\u4efb\u52a1
\n int times = ReadTimefd();
\n for (int i = 0; i < times; i++) {
\n RunTimerTask();
\n }
\n }
\n void TimerAddInLoop(uint64_t id, uint32_t delay, const TaskFunc &cb) {
\n PtrTask pt(new TimerTask(id, delay, cb));
\n pt->SetRelease(std::bind(&TimerWheel::RemoveTimer, this, id));
\n int pos = (_tick + delay) % _capacity;
\n _wheel[pos].push_back(pt);
\n _timers[id] = WeakTask(pt);
\n }
\n void TimerRefreshInLoop(uint64_t id) {
\n \/\/\u901a\u8fc7\u4fdd\u5b58\u7684\u5b9a\u65f6\u5668\u5bf9\u8c61\u7684weak_ptr\u6784\u9020\u4e00\u4e2ashared_ptr\u51fa\u6765，\u6dfb\u52a0\u5230\u8f6e\u5b50\u4e2d
\n auto it = _timers.find(id);
\n if (it == _timers.end()) {
\n return;\/\/\u6ca1\u627e\u7740\u5b9a\u65f6\u4efb\u52a1，\u6ca1\u6cd5\u5237\u65b0，\u6ca1\u6cd5\u5ef6\u8fdf
\n }
\n PtrTask pt = it->second.lock();\/\/lock\u83b7\u53d6weak_ptr\u7ba1\u7406\u7684\u5bf9\u8c61\u5bf9\u5e94\u7684shared_ptr
\n int delay = pt->DelayTime();
\n int pos = (_tick + delay) % _capacity;
\n _wheel[pos].push_back(pt);
\n }
\n void TimerCancelInLoop(uint64_t id) {
\n auto it = _timers.find(id);
\n if (it == _timers.end()) {
\n return;\/\/\u6ca1\u627e\u7740\u5b9a\u65f6\u4efb\u52a1，\u6ca1\u6cd5\u5237\u65b0，\u6ca1\u6cd5\u5ef6\u8fdf
\n }
\n PtrTask pt = it->second.lock();
\n if (pt) pt->Cancel();
\n }
\n public:
\n TimerWheel(EventLoop *loop):_capacity(60), _tick(0), _wheel(_capacity), _loop(loop),
\n _timerfd(CreateTimerfd()), _timer_channel(new Channel(_loop, _timerfd)) {
\n _timer_channel->SetReadCallback(std::bind(&TimerWheel::OnTime, this));
\n _timer_channel->EnableRead();\/\/\u542f\u52a8\u8bfb\u4e8b\u4ef6\u76d1\u63a7
\n }
\n \/*\u5b9a\u65f6\u5668\u4e2d\u6709\u4e2a_timers\u6210\u5458，\u5b9a\u65f6\u5668\u4fe1\u606f\u7684\u64cd\u4f5c\u6709\u53ef\u80fd\u5728\u591a\u7ebf\u7a0b\u4e2d\u8fdb\u884c，\u56e0\u6b64\u9700\u8981\u8003\u8651\u7ebf\u7a0b\u5b89\u5168\u95ee\u9898*\/
\n \/*\u5982\u679c\u4e0d\u60f3\u52a0\u9501，\u90a3\u5c31\u628a\u5bf9\u5b9a\u671f\u7684\u6240\u6709\u64cd\u4f5c，\u90fd\u653e\u5230\u4e00\u4e2a\u7ebf\u7a0b\u4e2d\u8fdb\u884c*\/
\n void TimerAdd(uint64_t id, uint32_t delay, const TaskFunc &cb);
\n \/\/\u5237\u65b0\/\u5ef6\u8fdf\u5b9a\u65f6\u4efb\u52a1
\n void TimerRefresh(uint64_t id);
\n void TimerCancel(uint64_t id);
\n \/*\u8fd9\u4e2a\u63a5\u53e3\u5b58\u5728\u7ebf\u7a0b\u5b89\u5168\u95ee\u9898–\u8fd9\u4e2a\u63a5\u53e3\u5b9e\u9645\u4e0a\u4e0d\u80fd\u88ab\u5916\u754c\u4f7f\u7528\u8005\u8c03\u7528，\u53ea\u80fd\u5728\u6a21\u5757\u5185，\u5728\u5bf9\u5e94\u7684EventLoop\u7ebf\u7a0b\u5185\u6267\u884c*\/
\n bool HasTimer(uint64_t id) {
\n auto it = _timers.find(id);
\n if (it == _timers.end()) {
\n return false;
\n }
\n return true;
\n }
\n}; <\/p>\n
Poller\u6a21\u5757\u662f\u5bf9epoll\u8fdb\u2f8f\u5c01\u88c5\u7684\u2f00\u4e2a\u6a21\u5757，\u4e3b\u8981\u5b9e\u73b0epoll\u7684IO\u4e8b\u4ef6\u6dfb\u52a0，\u4fee\u6539，\u79fb\u9664，\u83b7\u53d6\u6d3b\u8dc3\u8fde\u63a5\u529f\u80fd\u3002<\/p>\n
class Poller {
\n private:
\n int _epfd;
\n struct epoll_event _evs[MAX_EPOLLEVENTS];
\n std::unordered_map<int, Channel *> _channels;
\n private:
\n \/\/\u5bf9epoll\u7684\u76f4\u63a5\u64cd\u4f5c
\n void Update(Channel *channel, int op) {
\n \/\/ int epoll_ctl(int epfd, int op, int fd, struct epoll_event *ev);
\n int fd = channel->Fd();
\n struct epoll_event ev;
\n ev.data.fd = fd;
\n ev.events = channel->Events();
\n int ret = epoll_ctl(_epfd, op, fd, &ev);
\n if (ret < 0) {
\n ERR_LOG("EPOLLCTL FAILED!");
\n }
\n return;
\n }
\n \/\/\u5224\u65ad\u4e00\u4e2aChannel\u662f\u5426\u5df2\u7ecf\u6dfb\u52a0\u4e86\u4e8b\u4ef6\u76d1\u63a7
\n bool HasChannel(Channel *channel) {
\n auto it = _channels.find(channel->Fd());
\n if (it == _channels.end()) {
\n return false;
\n }
\n return true;
\n }
\n public:
\n Poller() {
\n _epfd = epoll_create(MAX_EPOLLEVENTS);
\n if (_epfd < 0) {
\n ERR_LOG("EPOLL CREATE FAILED!!");
\n abort();\/\/\u9000\u51fa\u7a0b\u5e8f
\n }
\n }
\n \/\/\u6dfb\u52a0\u6216\u4fee\u6539\u76d1\u63a7\u4e8b\u4ef6
\n void UpdateEvent(Channel *channel) {
\n bool ret = HasChannel(channel);
\n if (ret == false) {
\n \/\/\u4e0d\u5b58\u5728\u5219\u6dfb\u52a0
\n _channels.insert(std::make_pair(channel->Fd(), channel));
\n return Update(channel, EPOLL_CTL_ADD);
\n }
\n return Update(channel, EPOLL_CTL_MOD);
\n }
\n \/\/\u79fb\u9664\u76d1\u63a7
\n void RemoveEvent(Channel *channel) {
\n auto it = _channels.find(channel->Fd());
\n if (it != _channels.end()) {
\n _channels.erase(it);
\n }
\n Update(channel, EPOLL_CTL_DEL);
\n }
\n \/\/\u5f00\u59cb\u76d1\u63a7，\u8fd4\u56de\u6d3b\u8dc3\u8fde\u63a5
\n void Poll(std::vector<Channel*> *active) {
\n \/\/ int epoll_wait(int epfd, struct epoll_event *evs, int maxevents, int timeout)
\n int nfds = epoll_wait(_epfd, _evs, MAX_EPOLLEVENTS, -1);
\n if (nfds < 0) {
\n if (errno == EINTR) {
\n return ;
\n }
\n ERR_LOG("EPOLL WAIT ERROR:%s\\\\n", strerror(errno));
\n abort();\/\/\u9000\u51fa\u7a0b\u5e8f
\n }
\n for (int i = 0; i < nfds; i++) {
\n auto it = _channels.find(_evs[i].data.fd);
\n assert(it != _channels.end());
\n it->second->SetREvents(_evs[i].events);\/\/\u8bbe\u7f6e\u5b9e\u9645\u5c31\u7eea\u7684\u4e8b\u4ef6
\n active->push_back(it->second);
\n }
\n return;
\n }
\n}; <\/p>\n
EventLoop\u6a21\u5757\u53ef\u4ee5\u7406\u89e3\u5c31\u662f\u6211\u4eec\u4e0a\u8fb9\u6240\u8bf4\u7684Reactor\u6a21\u5757，\u5b83\u662f\u5bf9Poller\u6a21\u5757，TimerQueue\u6a21\u5757，Socket\u6a21\u5757\u7684\u2f00\u4e2a\u6574\u4f53\u5c01\u88c5，\u8fdb\u2f8f\u6240\u6709\u63cf\u8ff0\u7b26\u7684\u4e8b\u4ef6\u76d1\u63a7\u3002 EventLoop\u6a21\u5757\u5fc5\u7136\u662f\u2f00\u4e2a\u5bf9\u8c61\u5bf9\u5e94\u2f00\u4e2a\u7ebf\u7a0b\u7684\u6a21\u5757，\u7ebf\u7a0b\u5185\u90e8\u7684\u2f6c\u7684\u5c31\u662f\u8fd0\u2f8fEventLoop\u7684\u542f\u52a8\u51fd\u6570\u3002<\/p>\n
class EventLoop {
\n private:
\n using Functor = std::function<void()>;
\n std::thread::id _thread_id;\/\/\u7ebf\u7a0bID
\n int _event_fd;\/\/eventfd\u5524\u9192IO\u4e8b\u4ef6\u76d1\u63a7\u6709\u53ef\u80fd\u5bfc\u81f4\u7684\u963b\u585e
\n std::unique_ptr<Channel> _event_channel;
\n Poller _poller;\/\/\u8fdb\u884c\u6240\u6709\u63cf\u8ff0\u7b26\u7684\u4e8b\u4ef6\u76d1\u63a7
\n std::vector<Functor> _tasks;\/\/\u4efb\u52a1\u6c60
\n std::mutex _mutex;\/\/\u5b9e\u73b0\u4efb\u52a1\u6c60\u64cd\u4f5c\u7684\u7ebf\u7a0b\u5b89\u5168
\n TimerWheel _timer_wheel;\/\/\u5b9a\u65f6\u5668\u6a21\u5757
\n public:
\n \/\/\u6267\u884c\u4efb\u52a1\u6c60\u4e2d\u7684\u6240\u6709\u4efb\u52a1
\n void RunAllTask() {
\n std::vector<Functor> functor;
\n {
\n std::unique_lock<std::mutex> _lock(_mutex);
\n _tasks.swap(functor);
\n }
\n for (auto &f : functor) {
\n f();
\n }
\n return ;
\n }
\n static int CreateEventFd() {
\n int efd = eventfd(0, EFD_CLOEXEC | EFD_NONBLOCK);
\n if (efd < 0) {
\n ERR_LOG("CREATE EVENTFD FAILED!!");
\n abort();\/\/\u8ba9\u7a0b\u5e8f\u5f02\u5e38\u9000\u51fa
\n }
\n return efd;
\n }
\n void ReadEventfd() {
\n uint64_t res = 0;
\n int ret = read(_event_fd, &res, sizeof(res));
\n if (ret < 0) {
\n \/\/EINTR — \u88ab\u4fe1\u53f7\u6253\u65ad； EAGAIN — \u8868\u793a\u65e0\u6570\u636e\u53ef\u8bfb
\n if (errno == EINTR || errno == EAGAIN) {
\n return;
\n }
\n ERR_LOG("READ EVENTFD FAILED!");
\n abort();
\n }
\n return ;
\n }
\n void WeakUpEventFd() {
\n uint64_t val = 1;
\n int ret = write(_event_fd, &val, sizeof(val));
\n if (ret < 0) {
\n if (errno == EINTR) {
\n return;
\n }
\n ERR_LOG("READ EVENTFD FAILED!");
\n abort();
\n }
\n return ;
\n }
\n public:
\n EventLoop():_thread_id(std::this_thread::get_id()),
\n _event_fd(CreateEventFd()),
\n _event_channel(new Channel(this, _event_fd)),
\n _timer_wheel(this) {
\n \/\/\u7ed9eventfd\u6dfb\u52a0\u53ef\u8bfb\u4e8b\u4ef6\u56de\u8c03\u51fd\u6570，\u8bfb\u53d6eventfd\u4e8b\u4ef6\u901a\u77e5\u6b21\u6570
\n _event_channel->SetReadCallback(std::bind(&EventLoop::ReadEventfd, this));
\n \/\/\u542f\u52a8eventfd\u7684\u8bfb\u4e8b\u4ef6\u76d1\u63a7
\n _event_channel->EnableRead();
\n }
\n \/\/\u4e09\u6b65\u8d70–\u4e8b\u4ef6\u76d1\u63a7-\u300b\u5c31\u7eea\u4e8b\u4ef6\u5904\u7406-\u300b\u6267\u884c\u4efb\u52a1
\n void Start() {
\n while(1) {
\n \/\/1. \u4e8b\u4ef6\u76d1\u63a7，
\n std::vector<Channel *> actives;
\n _poller.Poll(&actives);
\n \/\/2. \u4e8b\u4ef6\u5904\u7406\u3002
\n for (auto &channel : actives) {
\n channel->HandleEvent();
\n }
\n \/\/3. \u6267\u884c\u4efb\u52a1
\n RunAllTask();
\n }
\n }
\n \/\/\u7528\u4e8e\u5224\u65ad\u5f53\u524d\u7ebf\u7a0b\u662f\u5426\u662fEventLoop\u5bf9\u5e94\u7684\u7ebf\u7a0b；
\n bool IsInLoop() {
\n return (_thread_id == std::this_thread::get_id());
\n }
\n void AssertInLoop() {
\n assert(_thread_id == std::this_thread::get_id());
\n }
\n \/\/\u5224\u65ad\u5c06\u8981\u6267\u884c\u7684\u4efb\u52a1\u662f\u5426\u5904\u4e8e\u5f53\u524d\u7ebf\u7a0b\u4e2d，\u5982\u679c\u662f\u5219\u6267\u884c，\u4e0d\u662f\u5219\u538b\u5165\u961f\u5217\u3002
\n void RunInLoop(const Functor &cb) {
\n if (IsInLoop()) {
\n return cb();
\n }
\n return QueueInLoop(cb);
\n }
\n \/\/\u5c06\u64cd\u4f5c\u538b\u5165\u4efb\u52a1\u6c60
\n void QueueInLoop(const Functor &cb) {
\n {
\n std::unique_lock<std::mutex> _lock(_mutex);
\n _tasks.push_back(cb);
\n }
\n \/\/\u5524\u9192\u6709\u53ef\u80fd\u56e0\u4e3a\u6ca1\u6709\u4e8b\u4ef6\u5c31\u7eea，\u800c\u5bfc\u81f4\u7684epoll\u963b\u585e；
\n \/\/\u5176\u5b9e\u5c31\u662f\u7ed9eventfd\u5199\u5165\u4e00\u4e2a\u6570\u636e，eventfd\u5c31\u4f1a\u89e6\u53d1\u53ef\u8bfb\u4e8b\u4ef6
\n WeakUpEventFd();
\n }
\n \/\/\u6dfb\u52a0\/\u4fee\u6539\u63cf\u8ff0\u7b26\u7684\u4e8b\u4ef6\u76d1\u63a7
\n void UpdateEvent(Channel *channel) { return _poller.UpdateEvent(channel); }
\n \/\/\u79fb\u9664\u63cf\u8ff0\u7b26\u7684\u76d1\u63a7
\n void RemoveEvent(Channel *channel) { return _poller.RemoveEvent(channel); }
\n void TimerAdd(uint64_t id, uint32_t delay, const TaskFunc &cb) { return _timer_wheel.TimerAdd(id, delay, cb); }
\n void TimerRefresh(uint64_t id) { return _timer_wheel.TimerRefresh(id); }
\n void TimerCancel(uint64_t id) { return _timer_wheel.TimerCancel(id); }
\n bool HasTimer(uint64_t id) { return _timer_wheel.HasTimer(id); }
\n}; <\/p>\n
\u8fd9\u4e2a\u6a21\u5757\u662f\u2f00\u4e2a\u6574\u4f53Tcp\u670d\u52a1\u5668\u6a21\u5757\u7684\u5c01\u88c5，\u5185\u90e8\u5c01\u88c5\u4e86Acceptor\u6a21\u5757，EventLoopThreadPool\u6a21<\/p>\n
\u5757\u3002<\/p>\n
class TcpServer {
\n private:
\n uint64_t _next_id; \/\/\u8fd9\u662f\u4e00\u4e2a\u81ea\u52a8\u589e\u957f\u7684\u8fde\u63a5ID，
\n int _port;
\n int _timeout; \/\/\u8fd9\u662f\u975e\u6d3b\u8dc3\u8fde\u63a5\u7684\u7edf\u8ba1\u65f6\u95f4—\u591a\u957f\u65f6\u95f4\u65e0\u901a\u4fe1\u5c31\u662f\u975e\u6d3b\u8dc3\u8fde\u63a5
\n bool _enable_inactive_release;\/\/\u662f\u5426\u542f\u52a8\u4e86\u975e\u6d3b\u8dc3\u8fde\u63a5\u8d85\u65f6\u9500\u6bc1\u7684\u5224\u65ad\u6807\u5fd7
\n EventLoop _baseloop; \/\/\u8fd9\u662f\u4e3b\u7ebf\u7a0b\u7684EventLoop\u5bf9\u8c61，\u8d1f\u8d23\u76d1\u542c\u4e8b\u4ef6\u7684\u5904\u7406
\n Acceptor _acceptor; \/\/\u8fd9\u662f\u76d1\u542c\u5957\u63a5\u5b57\u7684\u7ba1\u7406\u5bf9\u8c61
\n LoopThreadPool _pool; \/\/\u8fd9\u662f\u4ece\u5c5eEventLoop\u7ebf\u7a0b\u6c60
\n std::unordered_map<uint64_t, PtrConnection> _conns;\/\/\u4fdd\u5b58\u7ba1\u7406\u6240\u6709\u8fde\u63a5\u5bf9\u5e94\u7684shared_ptr\u5bf9\u8c61<\/p>\n
using ConnectedCallback = std::function<void(const PtrConnection&)>;
\n using MessageCallback = std::function<void(const PtrConnection&, Buffer *)>;
\n using ClosedCallback = std::function<void(const PtrConnection&)>;
\n using AnyEventCallback = std::function<void(const PtrConnection&)>;
\n using Functor = std::function<void()>;
\n ConnectedCallback _connected_callback;
\n MessageCallback _message_callback;
\n ClosedCallback _closed_callback;
\n AnyEventCallback _event_callback;
\n private:
\n void RunAfterInLoop(const Functor &task, int delay) {
\n _next_id++;
\n _baseloop.TimerAdd(_next_id, delay, task);
\n }
\n \/\/\u4e3a\u65b0\u8fde\u63a5\u6784\u9020\u4e00\u4e2aConnection\u8fdb\u884c\u7ba1\u7406
\n void NewConnection(int fd) {
\n _next_id++;
\n PtrConnection conn(new Connection(_pool.NextLoop(), _next_id, fd));
\n conn->SetMessageCallback(_message_callback);
\n conn->SetClosedCallback(_closed_callback);
\n conn->SetConnectedCallback(_connected_callback);
\n conn->SetAnyEventCallback(_event_callback);
\n conn->SetSrvClosedCallback(std::bind(&TcpServer::RemoveConnection, this, std::placeholders::_1));
\n if (_enable_inactive_release) conn->EnableInactiveRelease(_timeout);\/\/\u542f\u52a8\u975e\u6d3b\u8dc3\u8d85\u65f6\u9500\u6bc1
\n conn->Established();\/\/\u5c31\u7eea\u521d\u59cb\u5316
\n _conns.insert(std::make_pair(_next_id, conn));
\n }
\n void RemoveConnectionInLoop(const PtrConnection &conn) {
\n int id = conn->Id();
\n auto it = _conns.find(id);
\n if (it != _conns.end()) {
\n _conns.erase(it);
\n }
\n }
\n \/\/\u4ece\u7ba1\u7406Connection\u7684_conns\u4e2d\u79fb\u9664\u8fde\u63a5\u4fe1\u606f
\n void RemoveConnection(const PtrConnection &conn) {
\n _baseloop.RunInLoop(std::bind(&TcpServer::RemoveConnectionInLoop, this, conn));
\n }
\n public:
\n TcpServer(int port):
\n _port(port),
\n _next_id(0),
\n _enable_inactive_release(false),
\n _acceptor(&_baseloop, port),
\n _pool(&_baseloop) {
\n _acceptor.SetAcceptCallback(std::bind(&TcpServer::NewConnection, this, std::placeholders::_1));
\n _acceptor.Listen();\/\/\u5c06\u76d1\u542c\u5957\u63a5\u5b57\u6302\u5230baseloop\u4e0a
\n }
\n void SetThreadCount(int count) { return _pool.SetThreadCount(count); }
\n void SetConnectedCallback(const ConnectedCallback&cb) { _connected_callback = cb; }
\n void SetMessageCallback(const MessageCallback&cb) { _message_callback = cb; }
\n void SetClosedCallback(const ClosedCallback&cb) { _closed_callback = cb; }
\n void SetAnyEventCallback(const AnyEventCallback&cb) { _event_callback = cb; }
\n void EnableInactiveRelease(int timeout) { _timeout = timeout; _enable_inactive_release = true; }
\n \/\/\u7528\u4e8e\u6dfb\u52a0\u4e00\u4e2a\u5b9a\u65f6\u4efb\u52a1
\n void RunAfter(const Functor &task, int delay) {
\n _baseloop.RunInLoop(std::bind(&TcpServer::RunAfterInLoop, this, task, delay));
\n }
\n void Start() { _pool.Create(); _baseloop.Start(); }
\n};<\/p>\n
void Channel::Remove() { return _loop->RemoveEvent(this); }
\nvoid Channel::Update() { return _loop->UpdateEvent(this); }
\nvoid TimerWheel::TimerAdd(uint64_t id, uint32_t delay, const TaskFunc &cb) {
\n _loop->RunInLoop(std::bind(&TimerWheel::TimerAddInLoop, this, id, delay, cb));
\n}
\n\/\/\u5237\u65b0\/\u5ef6\u8fdf\u5b9a\u65f6\u4efb\u52a1
\nvoid TimerWheel::TimerRefresh(uint64_t id) {
\n _loop->RunInLoop(std::bind(&TimerWheel::TimerRefreshInLoop, this, id));
\n}
\nvoid TimerWheel::TimerCancel(uint64_t id) {
\n _loop->RunInLoop(std::bind(&TimerWheel::TimerCancelInLoop, this, id));
\n}<\/p>\n
class NetWork {
\n public:
\n NetWork() {
\n DBG_LOG("SIGPIPE INIT");
\n signal(SIGPIPE, SIG_IGN);
\n }
\n}; <\/p>\n
std::unordered_map<int, std::string> _statu_msg = {
\n {100, "Continue"},
\n {101, "Switching Protocol"},
\n {102, "Processing"},
\n {103, "Early Hints"},
\n {200, "OK"},
\n {201, "Created"},
\n {202, "Accepted"},
\n {203, "Non-Authoritative Information"},
\n {204, "No Content"},
\n {205, "Reset Content"},
\n {206, "Partial Content"},
\n {207, "Multi-Status"},
\n {208, "Already Reported"},
\n {226, "IM Used"},
\n {300, "Multiple Choice"},
\n {301, "Moved Permanently"},
\n {302, "Found"},
\n {303, "See Other"},
\n {304, "Not Modified"},
\n {305, "Use Proxy"},
\n {306, "unused"},
\n {307, "Temporary Redirect"},
\n {308, "Permanent Redirect"},
\n {400, "Bad Request"},
\n {401, "Unauthorized"},
\n {402, "Payment Required"},
\n {403, "Forbidden"},
\n {404, "Not Found"},
\n {405, "Method Not Allowed"},
\n {406, "Not Acceptable"},
\n {407, "Proxy Authentication Required"},
\n {408, "Request Timeout"},
\n {409, "Conflict"},
\n {410, "Gone"},
\n {411, "Length Required"},
\n {412, "Precondition Failed"},
\n {413, "Payload Too Large"},
\n {414, "URI Too Long"},
\n {415, "Unsupported Media Type"},
\n {416, "Range Not Satisfiable"},
\n {417, "Expectation Failed"},
\n {418, "I'm a teapot"},
\n {421, "Misdirected Request"},
\n {422, "Unprocessable Entity"},
\n {423, "Locked"},
\n {424, "Failed Dependency"},
\n {425, "Too Early"},
\n {426, "Upgrade Required"},
\n {428, "Precondition Required"},
\n {429, "Too Many Requests"},
\n {431, "Request Header Fields Too Large"},
\n {451, "Unavailable For Legal Reasons"},
\n {501, "Not Implemented"},
\n {502, "Bad Gateway"},
\n {503, "Service Unavailable"},
\n {504, "Gateway Timeout"},
\n {505, "HTTP Version Not Supported"},
\n {506, "Variant Also Negotiates"},
\n {507, "Insufficient Storage"},
\n {508, "Loop Detected"},
\n {510, "Not Extended"},
\n {511, "Network Authentication Required"}
\n};<\/p>\n
std::unordered_map<std::string, std::string> _mime_msg = {
\n {".aac", "audio\/aac"},
\n {".abw", "application\/x-abiword"},
\n {".arc", "application\/x-freearc"},
\n {".avi", "video\/x-msvideo"},
\n {".azw", "application\/vnd.amazon.ebook"},
\n {".bin", "application\/octet-stream"},
\n {".bmp", "image\/bmp"},
\n {".bz", "application\/x-bzip"},
\n {".bz2", "application\/x-bzip2"},
\n {".csh", "application\/x-csh"},
\n {".css", "text\/css"},
\n {".csv", "text\/csv"},
\n {".doc", "application\/msword"},
\n {".docx", "application\/vnd.openxmlformats-officedocument.wordprocessingml.document"},
\n {".eot", "application\/vnd.ms-fontobject"},
\n {".epub", "application\/epub+zip"},
\n {".gif", "image\/gif"},
\n {".htm", "text\/html"},
\n {".html", "text\/html"},
\n {".ico", "image\/vnd.microsoft.icon"},
\n {".ics", "text\/calendar"},
\n {".jar", "application\/java-archive"},
\n {".jpeg", "image\/jpeg"},
\n {".jpg", "image\/jpeg"},
\n {".js", "text\/javascript"},
\n {".json", "application\/json"},
\n {".jsonld", "application\/ld+json"},
\n {".mid", "audio\/midi"},
\n {".midi", "audio\/x-midi"},
\n {".mjs", "text\/javascript"},
\n {".mp3", "audio\/mpeg"},
\n {".mpeg", "video\/mpeg"},
\n {".mpkg", "application\/vnd.apple.installer+xml"},
\n {".odp", "application\/vnd.oasis.opendocument.presentation"},
\n {".ods", "application\/vnd.oasis.opendocument.spreadsheet"},
\n {".odt", "application\/vnd.oasis.opendocument.text"},
\n {".oga", "audio\/ogg"},
\n {".ogv", "video\/ogg"},
\n {".ogx", "application\/ogg"},
\n {".otf", "font\/otf"},
\n {".png", "image\/png"},
\n {".pdf", "application\/pdf"},
\n {".ppt", "application\/vnd.ms-powerpoint"},
\n {".pptx", "application\/vnd.openxmlformats-officedocument.presentationml.presentation"},
\n {".rar", "application\/x-rar-compressed"},
\n {".rtf", "application\/rtf"},
\n {".sh", "application\/x-sh"},
\n {".svg", "image\/svg+xml"},
\n {".swf", "application\/x-shockwave-flash"},
\n {".tar", "application\/x-tar"},
\n {".tif", "image\/tiff"},
\n {".tiff", "image\/tiff"},
\n {".ttf", "font\/ttf"},
\n {".txt", "text\/plain"},
\n {".vsd", "application\/vnd.visio"},
\n {".wav", "audio\/wav"},
\n {".weba", "audio\/webm"},
\n {".webm", "video\/webm"},
\n {".webp", "image\/webp"},
\n {".woff", "font\/woff"},
\n {".woff2", "font\/woff2"},
\n {".xhtml", "application\/xhtml+xml"},
\n {".xls", "application\/vnd.ms-excel"},
\n {".xlsx", "application\/vnd.openxmlformats-officedocument.spreadsheetml.sheet"},
\n {".xml", "application\/xml"},
\n {".xul", "application\/vnd.mozilla.xul+xml"},
\n {".zip", "application\/zip"},
\n {".3gp", "video\/3gpp"},
\n {".3g2", "video\/3gpp2"},
\n {".7z", "application\/x-7z-compressed"}
\n};<\/p>\n
class Util {
\n public:
\n \/\/\u5b57\u7b26\u4e32\u5206\u5272\u51fd\u6570,\u5c06src\u5b57\u7b26\u4e32\u6309\u7167sep\u5b57\u7b26\u8fdb\u884c\u5206\u5272，\u5f97\u5230\u7684\u5404\u4e2a\u5b57\u4e32\u653e\u5230arry\u4e2d，\u6700\u7ec8\u8fd4\u56de\u5b57\u4e32\u7684\u6570\u91cf
\n static size_t Split(const std::string &src, const std::string &sep, std::vector<std::string> *arry) {
\n size_t offset = 0;
\n \/\/ \u670910\u4e2a\u5b57\u7b26，offset\u662f\u67e5\u627e\u7684\u8d77\u59cb\u4f4d\u7f6e，\u8303\u56f4\u5e94\u8be5\u662f0~9，offset==10\u5c31\u4ee3\u8868\u5df2\u7ecf\u8d8a\u754c\u4e86
\n while(offset < src.size()) {
\n size_t pos = src.find(sep, offset);\/\/\u5728src\u5b57\u7b26\u4e32\u504f\u79fb\u91cfoffset\u5904，\u5f00\u59cb\u5411\u540e\u67e5\u627esep\u5b57\u7b26\/\u5b57\u4e32，\u8fd4\u56de\u67e5\u627e\u5230\u7684\u4f4d\u7f6e
\n if (pos == std::string::npos) {\/\/\u6ca1\u6709\u627e\u5230\u7279\u5b9a\u7684\u5b57\u7b26
\n \/\/\u5c06\u5269\u4f59\u7684\u90e8\u5206\u5f53\u4f5c\u4e00\u4e2a\u5b57\u4e32，\u653e\u5165arry\u4e2d
\n if(pos == src.size()) break;
\n arry->push_back(src.substr(offset));
\n return arry->size();
\n }
\n if (pos == offset) {
\n offset = pos + sep.size();
\n continue;\/\/\u5f53\u524d\u5b57\u4e32\u662f\u4e00\u4e2a\u7a7a\u7684，\u6ca1\u6709\u5185\u5bb9
\n }
\n arry->push_back(src.substr(offset, pos – offset));
\n offset = pos + sep.size();
\n }
\n return arry->size();
\n }
\n \/\/\u8bfb\u53d6\u6587\u4ef6\u7684\u6240\u6709\u5185\u5bb9，\u5c06\u8bfb\u53d6\u7684\u5185\u5bb9\u653e\u5230\u4e00\u4e2aBuffer\u4e2d
\n static bool ReadFile(const std::string &filename, std::string *buf) {
\n std::ifstream ifs(filename, std::ios::binary);
\n if (ifs.is_open() == false) {
\n printf("OPEN %s FILE FAILED!!", filename.c_str());
\n return false;
\n }
\n size_t fsize = 0;
\n ifs.seekg(0, ifs.end);\/\/\u8df3\u8f6c\u8bfb\u5199\u4f4d\u7f6e\u5230\u672b\u5c3e
\n fsize = ifs.tellg(); \/\/\u83b7\u53d6\u5f53\u524d\u8bfb\u5199\u4f4d\u7f6e\u76f8\u5bf9\u4e8e\u8d77\u59cb\u4f4d\u7f6e\u7684\u504f\u79fb\u91cf，\u4ece\u672b\u5c3e\u504f\u79fb\u521a\u597d\u5c31\u662f\u6587\u4ef6\u5927\u5c0f
\n ifs.seekg(0, ifs.beg);\/\/\u8df3\u8f6c\u5230\u8d77\u59cb\u4f4d\u7f6e
\n buf->resize(fsize); \/\/\u5f00\u8f9f\u6587\u4ef6\u5927\u5c0f\u7684\u7a7a\u95f4
\n ifs.read(&(*buf)[0], fsize);
\n if (ifs.good() == false) {
\n printf("READ %s FILE FAILED!!", filename.c_str());
\n ifs.close();
\n return false;
\n }
\n ifs.close();
\n return true;
\n }
\n \/\/\u5411\u6587\u4ef6\u5199\u5165\u6570\u636e
\n static bool WriteFile(const std::string &filename, const std::string &buf) {
\n std::ofstream ofs(filename, std::ios::binary | std::ios::trunc);
\n if (ofs.is_open() == false) {
\n printf("OPEN %s FILE FAILED!!", filename.c_str());
\n return false;
\n }
\n ofs.write(buf.c_str(), buf.size());
\n if (ofs.good() == false) {
\n ERR_LOG("WRITE %s FILE FAILED!", filename.c_str());
\n ofs.close();
\n return false;
\n }
\n ofs.close();
\n return true;
\n }
\n \/\/URL\u7f16\u7801，\u907f\u514dURL\u4e2d\u8d44\u6e90\u8def\u5f84\u4e0e\u67e5\u8be2\u5b57\u7b26\u4e32\u4e2d\u7684\u7279\u6b8a\u5b57\u7b26\u4e0eHTTP\u8bf7\u6c42\u4e2d\u7279\u6b8a\u5b57\u7b26\u4ea7\u751f\u6b67\u4e49
\n \/\/\u7f16\u7801\u683c\u5f0f：\u5c06\u7279\u6b8a\u5b57\u7b26\u7684ascii\u503c，\u8f6c\u6362\u4e3a\u4e24\u4e2a16\u8fdb\u5236\u5b57\u7b26，\u524d\u7f00% C++ -> C%2B%2B
\n \/\/ \u4e0d\u7f16\u7801\u7684\u7279\u6b8a\u5b57\u7b26： RFC3986\u6587\u6863\u89c4\u5b9a . – _ ~ \u5b57\u6bcd，\u6570\u5b57\u5c5e\u4e8e\u7edd\u5bf9\u4e0d\u7f16\u7801\u5b57\u7b26
\n \/\/RFC3986\u6587\u6863\u89c4\u5b9a，\u7f16\u7801\u683c\u5f0f %HH
\n \/\/W3C\u6807\u51c6\u4e2d\u89c4\u5b9a，\u67e5\u8be2\u5b57\u7b26\u4e32\u4e2d\u7684\u7a7a\u683c，\u9700\u8981\u7f16\u7801\u4e3a+， \u89e3\u7801\u5219\u662f+\u8f6c\u7a7a\u683c
\n static std::string UrlEncode(const std::string url, bool convert_space_to_plus) {
\n std::string res;
\n for (auto &c : url) {
\n if (c == '.' || c == '-' || c == '_' || c == '~' || isalnum(c)) {
\n res += c;
\n continue;
\n }
\n if (c == ' ' && convert_space_to_plus == true) {
\n res += '+';
\n continue;
\n }
\n \/\/\u5269\u4e0b\u7684\u5b57\u7b26\u90fd\u662f\u9700\u8981\u7f16\u7801\u6210\u4e3a %HH \u683c\u5f0f
\n char tmp[4] = {0};
\n \/\/snprintf \u4e0e printf\u6bd4\u8f83\u7c7b\u4f3c，\u90fd\u662f\u683c\u5f0f\u5316\u5b57\u7b26\u4e32，\u53ea\u4e0d\u8fc7\u4e00\u4e2a\u662f\u6253\u5370，\u4e00\u4e2a\u662f\u653e\u5230\u4e00\u5757\u7a7a\u95f4\u4e2d
\n snprintf(tmp, 4, "%%%02X", c);
\n res += tmp;
\n }
\n return res;
\n }
\n static char HEXTOI(char c) {
\n if (c >= '0' && c <= '9') {
\n return c – '0';
\n }else if (c >= 'a' && c <= 'z') {
\n return c – 'a' + 10;
\n }else if (c >= 'A' && c <= 'Z') {
\n return c – 'A' + 10;
\n }
\n return -1;
\n }
\n static std::string UrlDecode(const std::string url, bool convert_plus_to_space) {
\n \/\/\u9047\u5230\u4e86%，\u5219\u5c06\u7d27\u968f\u5176\u540e\u76842\u4e2a\u5b57\u7b26，\u8f6c\u6362\u4e3a\u6570\u5b57，\u7b2c\u4e00\u4e2a\u6570\u5b57\u5de6\u79fb4\u4f4d，\u7136\u540e\u52a0\u4e0a\u7b2c\u4e8c\u4e2a\u6570\u5b57 + -> 2b %2b->2 << 4 + 11
\n std::string res;
\n for (int i = 0; i < url.size(); i++) {
\n if (url[i] == '+' && convert_plus_to_space == true) {
\n res += ' ';
\n continue;
\n }
\n if (url[i] == '%' && (i + 2) < url.size()) {
\n char v1 = HEXTOI(url[i + 1]);
\n char v2 = HEXTOI(url[i + 2]);
\n char v = v1 * 16 + v2;
\n res += v;
\n i += 2;
\n continue;
\n }
\n res += url[i];
\n }
\n return res;
\n }
\n \/\/\u54cd\u5e94\u72b6\u6001\u7801\u7684\u63cf\u8ff0\u4fe1\u606f\u83b7\u53d6
\n static std::string StatuDesc(int statu) {<\/p>\n
auto it = _statu_msg.find(statu);
\n if (it != _statu_msg.end()) {
\n return it->second;
\n }
\n return "Unknow";
\n }
\n \/\/\u6839\u636e\u6587\u4ef6\u540e\u7f00\u540d\u83b7\u53d6\u6587\u4ef6mime
\n static std::string ExtMime(const std::string &filename) {<\/p>\n
\/\/ a.b.txt \u5148\u83b7\u53d6\u6587\u4ef6\u6269\u5c55\u540d
\n size_t pos = filename.find_last_of('.');
\n if (pos == std::string::npos) {
\n return "application\/octet-stream";
\n }
\n \/\/\u6839\u636e\u6269\u5c55\u540d，\u83b7\u53d6mime
\n std::string ext = filename.substr(pos);
\n auto it = _mime_msg.find(ext);
\n if (it == _mime_msg.end()) {
\n return "application\/octet-stream";
\n }
\n return it->second;
\n }
\n \/\/\u5224\u65ad\u4e00\u4e2a\u6587\u4ef6\u662f\u5426\u662f\u4e00\u4e2a\u76ee\u5f55
\n static bool IsDirectory(const std::string &filename) {
\n struct stat st;
\n int ret = stat(filename.c_str(), &st);
\n if (ret < 0) {
\n return false;
\n }
\n return S_ISDIR(st.st_mode);
\n }
\n \/\/\u5224\u65ad\u4e00\u4e2a\u6587\u4ef6\u662f\u5426\u662f\u4e00\u4e2a\u666e\u901a\u6587\u4ef6
\n static bool IsRegular(const std::string &filename) {
\n struct stat st;
\n int ret = stat(filename.c_str(), &st);
\n if (ret < 0) {
\n return false;
\n }
\n return S_ISREG(st.st_mode);
\n }
\n \/\/http\u8bf7\u6c42\u7684\u8d44\u6e90\u8def\u5f84\u6709\u6548\u6027\u5224\u65ad
\n \/\/ \/index.html — \u524d\u8fb9\u7684\/\u53eb\u505a\u76f8\u5bf9\u6839\u76ee\u5f55 \u6620\u5c04\u7684\u662f\u67d0\u4e2a\u670d\u52a1\u5668\u4e0a\u7684\u5b50\u76ee\u5f55
\n \/\/ \u60f3\u8868\u8fbe\u7684\u610f\u601d\u5c31\u662f，\u5ba2\u6237\u7aef\u53ea\u80fd\u8bf7\u6c42\u76f8\u5bf9\u6839\u76ee\u5f55\u4e2d\u7684\u8d44\u6e90，\u5176\u4ed6\u5730\u65b9\u7684\u8d44\u6e90\u90fd\u4e0d\u4e88\u7406\u4f1a
\n \/\/ \/..\/login, \u8fd9\u4e2a\u8def\u5f84\u4e2d\u7684..\u4f1a\u8ba9\u8def\u5f84\u7684\u67e5\u627e\u8dd1\u5230\u76f8\u5bf9\u6839\u76ee\u5f55\u4e4b\u5916，\u8fd9\u662f\u4e0d\u5408\u7406\u7684，\u4e0d\u5b89\u5168\u7684
\n static bool ValidPath(const std::string &path) {
\n \/\/\u601d\u60f3：\u6309\u7167\/\u8fdb\u884c\u8def\u5f84\u5206\u5272，\u6839\u636e\u6709\u591a\u5c11\u5b50\u76ee\u5f55，\u8ba1\u7b97\u76ee\u5f55\u6df1\u5ea6，\u6709\u591a\u5c11\u5c42，\u6df1\u5ea6\u4e0d\u80fd\u5c0f\u4e8e0
\n std::vector<std::string> subdir;
\n Split(path, "\/", &subdir);
\n int level = 0;
\n for (auto &dir : subdir) {
\n if (dir == "..") {
\n level–; \/\/\u4efb\u610f\u4e00\u5c42\u8d70\u51fa\u76f8\u5bf9\u6839\u76ee\u5f55，\u5c31\u8ba4\u4e3a\u6709\u95ee\u9898
\n if (level < 0) return false;
\n continue;
\n }
\n level++;
\n }
\n return true;
\n }
\n}; <\/p>\n
class HttpRequest {
\n public:
\n std::string _method; \/\/\u8bf7\u6c42\u65b9\u6cd5
\n std::string _path; \/\/\u8d44\u6e90\u8def\u5f84
\n std::string _version; \/\/\u534f\u8bae\u7248\u672c
\n std::string _body; \/\/\u8bf7\u6c42\u6b63\u6587
\n std::smatch _matches; \/\/\u8d44\u6e90\u8def\u5f84\u7684\u6b63\u5219\u63d0\u53d6\u6570\u636e
\n std::unordered_map<std::string, std::string> _headers; \/\/\u5934\u90e8\u5b57\u6bb5
\n std::unordered_map<std::string, std::string> _params; \/\/\u67e5\u8be2\u5b57\u7b26\u4e32
\n public:
\n HttpRequest():_version("HTTP\/1.1") {}
\n void ReSet() {
\n _method.clear();
\n _path.clear();
\n _version = "HTTP\/1.1";
\n _body.clear();
\n std::smatch match;
\n _matches.swap(match);
\n _headers.clear();
\n _params.clear();
\n }
\n \/\/\u63d2\u5165\u5934\u90e8\u5b57\u6bb5
\n void SetHeader(const std::string &key, const std::string &val) {
\n _headers.insert(std::make_pair(key, val));
\n }
\n \/\/\u5224\u65ad\u662f\u5426\u5b58\u5728\u6307\u5b9a\u5934\u90e8\u5b57\u6bb5
\n bool HasHeader(const std::string &key) const {
\n auto it = _headers.find(key);
\n if (it == _headers.end()) {
\n return false;
\n }
\n return true;
\n }
\n \/\/\u83b7\u53d6\u6307\u5b9a\u5934\u90e8\u5b57\u6bb5\u7684\u503c
\n std::string GetHeader(const std::string &key) const {
\n auto it = _headers.find(key);
\n if (it == _headers.end()) {
\n return "";
\n }
\n return it->second;
\n }
\n \/\/\u63d2\u5165\u67e5\u8be2\u5b57\u7b26\u4e32
\n void SetParam(const std::string &key, const std::string &val) {
\n _params.insert(std::make_pair(key, val));
\n }
\n \/\/\u5224\u65ad\u662f\u5426\u6709\u67d0\u4e2a\u6307\u5b9a\u7684\u67e5\u8be2\u5b57\u7b26\u4e32
\n bool HasParam(const std::string &key) const {
\n auto it = _params.find(key);
\n if (it == _params.end()) {
\n return false;
\n }
\n return true;
\n }
\n \/\/\u83b7\u53d6\u6307\u5b9a\u7684\u67e5\u8be2\u5b57\u7b26\u4e32
\n std::string GetParam(const std::string &key) const {
\n auto it = _params.find(key);
\n if (it == _params.end()) {
\n return "";
\n }
\n return it->second;
\n }
\n \/\/\u83b7\u53d6\u6b63\u6587\u957f\u5ea6
\n size_t ContentLength() const {
\n \/\/ Content-Length: 1234\\\\r\\\\n
\n bool ret = HasHeader("Content-Length");
\n if (ret == false) {
\n return 0;
\n }
\n std::string clen = GetHeader("Content-Length");
\n return std::stol(clen);
\n }
\n \/\/\u5224\u65ad\u662f\u5426\u662f\u77ed\u94fe\u63a5
\n bool Close() const {
\n \/\/ \u6ca1\u6709Connection\u5b57\u6bb5，\u6216\u8005\u6709Connection\u4f46\u662f\u503c\u662fclose，\u5219\u90fd\u662f\u77ed\u94fe\u63a5，\u5426\u5219\u5c31\u662f\u957f\u8fde\u63a5
\n if (HasHeader("Connection") == true && GetHeader("Connection") == "keep-alive") {
\n return false;
\n }
\n return true;
\n }
\n}; <\/p>\n
class HttpContext {
\n private:
\n int _resp_statu; \/\/\u54cd\u5e94\u72b6\u6001\u7801
\n HttpRecvStatu _recv_statu; \/\/\u5f53\u524d\u63a5\u6536\u53ca\u89e3\u6790\u7684\u9636\u6bb5\u72b6\u6001
\n HttpRequest _request; \/\/\u5df2\u7ecf\u89e3\u6790\u5f97\u5230\u7684\u8bf7\u6c42\u4fe1\u606f
\n private:
\n bool ParseHttpLine(const std::string &line) {
\n std::smatch matches;
\n std::regex e("(GET|HEAD|POST|PUT|DELETE) ([^?]*)(?:\\\\\\\\?(.*))? (HTTP\/1\\\\\\\\.[01])(?:\\\\n|\\\\r\\\\n)?", std::regex::icase);
\n bool ret = std::regex_match(line, matches, e);
\n if (ret == false) {
\n _recv_statu = RECV_HTTP_ERROR;
\n _resp_statu = 400;\/\/BAD REQUEST
\n return false;
\n }
\n \/\/0 : GET \/bitejiuyeke\/login?user=xiaoming&pass=123123 HTTP\/1.1
\n \/\/1 : GET
\n \/\/2 : \/bitejiuyeke\/login
\n \/\/3 : user=xiaoming&pass=123123
\n \/\/4 : HTTP\/1.1
\n \/\/\u8bf7\u6c42\u65b9\u6cd5\u7684\u83b7\u53d6
\n _request._method = matches[1];
\n std::transform(_request._method.begin(), _request._method.end(), _request._method.begin(), ::toupper);
\n \/\/\u8d44\u6e90\u8def\u5f84\u7684\u83b7\u53d6，\u9700\u8981\u8fdb\u884cURL\u89e3\u7801\u64cd\u4f5c，\u4f46\u662f\u4e0d\u9700\u8981+\u8f6c\u7a7a\u683c
\n _request._path = Util::UrlDecode(matches[2], false);
\n \/\/\u534f\u8bae\u7248\u672c\u7684\u83b7\u53d6
\n _request._version = matches[4];
\n \/\/\u67e5\u8be2\u5b57\u7b26\u4e32\u7684\u83b7\u53d6\u4e0e\u5904\u7406
\n std::vector<std::string> query_string_arry;
\n std::string query_string = matches[3];
\n \/\/\u67e5\u8be2\u5b57\u7b26\u4e32\u7684\u683c\u5f0f key=val&key=val….., \u5148\u4ee5 & \u7b26\u53f7\u8fdb\u884c\u5206\u5272，\u5f97\u5230\u5404\u4e2a\u5b57\u4e32
\n Util::Split(query_string, "&", &query_string_arry);
\n \/\/\u9488\u5bf9\u5404\u4e2a\u5b57\u4e32，\u4ee5 = \u7b26\u53f7\u8fdb\u884c\u5206\u5272，\u5f97\u5230key \u548cval， \u5f97\u5230\u4e4b\u540e\u4e5f\u9700\u8981\u8fdb\u884cURL\u89e3\u7801
\n for (auto &str : query_string_arry) {
\n size_t pos = str.find("=");
\n if (pos == std::string::npos) {
\n _recv_statu = RECV_HTTP_ERROR;
\n _resp_statu = 400;\/\/BAD REQUEST
\n return false;
\n }
\n std::string key = Util::UrlDecode(str.substr(0, pos), true);
\n std::string val = Util::UrlDecode(str.substr(pos + 1), true);
\n _request.SetParam(key, val);
\n }
\n return true;
\n }
\n bool RecvHttpLine(Buffer *buf) {
\n if (_recv_statu != RECV_HTTP_LINE) return false;
\n \/\/1. \u83b7\u53d6\u4e00\u884c\u6570\u636e，\u5e26\u6709\u672b\u5c3e\u7684\u6362\u884c
\n std::string line = buf->GetLineAndPop();
\n \/\/2. \u9700\u8981\u8003\u8651\u7684\u4e00\u4e9b\u8981\u7d20：\u7f13\u51b2\u533a\u4e2d\u7684\u6570\u636e\u4e0d\u8db3\u4e00\u884c， \u83b7\u53d6\u7684\u4e00\u884c\u6570\u636e\u8d85\u5927
\n if (line.size() == 0) {
\n \/\/\u7f13\u51b2\u533a\u4e2d\u7684\u6570\u636e\u4e0d\u8db3\u4e00\u884c，\u5219\u9700\u8981\u5224\u65ad\u7f13\u51b2\u533a\u7684\u53ef\u8bfb\u6570\u636e\u957f\u5ea6，\u5982\u679c\u5f88\u957f\u4e86\u90fd\u4e0d\u8db3\u4e00\u884c，\u8fd9\u662f\u6709\u95ee\u9898\u7684
\n if (buf->ReadAbleSize() > MAX_LINE) {
\n _recv_statu = RECV_HTTP_ERROR;
\n _resp_statu = 414;\/\/URI TOO LONG
\n return false;
\n }
\n \/\/\u7f13\u51b2\u533a\u4e2d\u6570\u636e\u4e0d\u8db3\u4e00\u884c，\u4f46\u662f\u4e5f\u4e0d\u591a，\u5c31\u7b49\u7b49\u65b0\u6570\u636e\u7684\u5230\u6765
\n return true;
\n }
\n if (line.size() > MAX_LINE) {
\n _recv_statu = RECV_HTTP_ERROR;
\n _resp_statu = 414;\/\/URI TOO LONG
\n return false;
\n }
\n bool ret = ParseHttpLine(line);
\n if (ret == false) {
\n return false;
\n }
\n \/\/\u9996\u884c\u5904\u7406\u5b8c\u6bd5，\u8fdb\u5165\u5934\u90e8\u83b7\u53d6\u9636\u6bb5
\n _recv_statu = RECV_HTTP_HEAD;
\n return true;
\n }
\n bool RecvHttpHead(Buffer *buf) {
\n if (_recv_statu != RECV_HTTP_HEAD) return false;
\n \/\/\u4e00\u884c\u4e00\u884c\u53d6\u51fa\u6570\u636e，\u76f4\u5230\u9047\u5230\u7a7a\u884c\u4e3a\u6b62， \u5934\u90e8\u7684\u683c\u5f0f key: val\\\\r\\\\nkey: val\\\\r\\\\n….
\n while(1){
\n std::string line = buf->GetLineAndPop();
\n \/\/2. \u9700\u8981\u8003\u8651\u7684\u4e00\u4e9b\u8981\u7d20：\u7f13\u51b2\u533a\u4e2d\u7684\u6570\u636e\u4e0d\u8db3\u4e00\u884c， \u83b7\u53d6\u7684\u4e00\u884c\u6570\u636e\u8d85\u5927
\n if (line.size() == 0) {
\n \/\/\u7f13\u51b2\u533a\u4e2d\u7684\u6570\u636e\u4e0d\u8db3\u4e00\u884c，\u5219\u9700\u8981\u5224\u65ad\u7f13\u51b2\u533a\u7684\u53ef\u8bfb\u6570\u636e\u957f\u5ea6，\u5982\u679c\u5f88\u957f\u4e86\u90fd\u4e0d\u8db3\u4e00\u884c，\u8fd9\u662f\u6709\u95ee\u9898\u7684
\n if (buf->ReadAbleSize() > MAX_LINE) {
\n _recv_statu = RECV_HTTP_ERROR;
\n _resp_statu = 414;\/\/URI TOO LONG
\n return false;
\n }
\n \/\/\u7f13\u51b2\u533a\u4e2d\u6570\u636e\u4e0d\u8db3\u4e00\u884c，\u4f46\u662f\u4e5f\u4e0d\u591a，\u5c31\u7b49\u7b49\u65b0\u6570\u636e\u7684\u5230\u6765
\n return true;
\n }
\n if (line.size() > MAX_LINE) {
\n _recv_statu = RECV_HTTP_ERROR;
\n _resp_statu = 414;\/\/URI TOO LONG
\n return false;
\n }
\n if (line == "\\\\n" || line == "\\\\r\\\\n") {
\n break;
\n }
\n bool ret = ParseHttpHead(line);
\n if (ret == false) {
\n return false;
\n }
\n }
\n \/\/\u5934\u90e8\u5904\u7406\u5b8c\u6bd5，\u8fdb\u5165\u6b63\u6587\u83b7\u53d6\u9636\u6bb5
\n _recv_statu = RECV_HTTP_BODY;
\n return true;
\n }
\n bool ParseHttpHead(std::string &line) {
\n \/\/key: val\\\\r\\\\nkey: val\\\\r\\\\n….
\n if (line.back() == '\\\\n') line.pop_back();\/\/\u672b\u5c3e\u662f\u6362\u884c\u5219\u53bb\u6389\u6362\u884c\u5b57\u7b26
\n if (line.back() == '\\\\r') line.pop_back();\/\/\u672b\u5c3e\u662f\u56de\u8f66\u5219\u53bb\u6389\u56de\u8f66\u5b57\u7b26
\n size_t pos = line.find(": ");
\n if (pos == std::string::npos) {
\n _recv_statu = RECV_HTTP_ERROR;
\n _resp_statu = 400;\/\/
\n return false;
\n }
\n std::string key = line.substr(0, pos);
\n std::string val = line.substr(pos + 2);
\n _request.SetHeader(key, val);
\n return true;
\n }
\n bool RecvHttpBody(Buffer *buf) {
\n if (_recv_statu != RECV_HTTP_BODY) return false;
\n \/\/1. \u83b7\u53d6\u6b63\u6587\u957f\u5ea6
\n size_t content_length = _request.ContentLength();
\n if (content_length == 0) {
\n \/\/\u6ca1\u6709\u6b63\u6587，\u5219\u8bf7\u6c42\u63a5\u6536\u89e3\u6790\u5b8c\u6bd5
\n _recv_statu = RECV_HTTP_OVER;
\n return true;
\n }
\n \/\/2. \u5f53\u524d\u5df2\u7ecf\u63a5\u6536\u4e86\u591a\u5c11\u6b63\u6587,\u5176\u5b9e\u5c31\u662f\u5f80 _request._body \u4e2d\u653e\u4e86\u591a\u5c11\u6570\u636e\u4e86
\n size_t real_len = content_length – _request._body.size();\/\/\u5b9e\u9645\u8fd8\u9700\u8981\u63a5\u6536\u7684\u6b63\u6587\u957f\u5ea6
\n \/\/3. \u63a5\u6536\u6b63\u6587\u653e\u5230body\u4e2d，\u4f46\u662f\u4e5f\u8981\u8003\u8651\u5f53\u524d\u7f13\u51b2\u533a\u4e2d\u7684\u6570\u636e，\u662f\u5426\u662f\u5168\u90e8\u7684\u6b63\u6587
\n \/\/ 3.1 \u7f13\u51b2\u533a\u4e2d\u6570\u636e，\u5305\u542b\u4e86\u5f53\u524d\u8bf7\u6c42\u7684\u6240\u6709\u6b63\u6587，\u5219\u53d6\u51fa\u6240\u9700\u7684\u6570\u636e
\n if (buf->ReadAbleSize() >= real_len) {
\n _request._body.append(buf->ReadPosition(), real_len);
\n buf->MoveReadOffset(real_len);
\n _recv_statu = RECV_HTTP_OVER;
\n return true;
\n }
\n \/\/ 3.2 \u7f13\u51b2\u533a\u4e2d\u6570\u636e，\u65e0\u6cd5\u6ee1\u8db3\u5f53\u524d\u6b63\u6587\u7684\u9700\u8981，\u6570\u636e\u4e0d\u8db3，\u53d6\u51fa\u6570\u636e，\u7136\u540e\u7b49\u5f85\u65b0\u6570\u636e\u5230\u6765
\n _request._body.append(buf->ReadPosition(), buf->ReadAbleSize());
\n buf->MoveReadOffset(buf->ReadAbleSize());
\n return true;
\n }
\n public:
\n HttpContext():_resp_statu(200), _recv_statu(RECV_HTTP_LINE) {}
\n void ReSet() {
\n _resp_statu = 200;
\n _recv_statu = RECV_HTTP_LINE;
\n _request.ReSet();
\n }
\n int RespStatu() { return _resp_statu; }
\n HttpRecvStatu RecvStatu() { return _recv_statu; }
\n HttpRequest &Request() { return _request; }
\n \/\/\u63a5\u6536\u5e76\u89e3\u6790HTTP\u8bf7\u6c42
\n void RecvHttpRequest(Buffer *buf) {
\n \/\/\u4e0d\u540c\u7684\u72b6\u6001，\u505a\u4e0d\u540c\u7684\u4e8b\u60c5，\u4f46\u662f\u8fd9\u91cc\u4e0d\u8981break， \u56e0\u4e3a\u5904\u7406\u5b8c\u8bf7\u6c42\u884c\u540e，\u5e94\u8be5\u7acb\u5373\u5904\u7406\u5934\u90e8，\u800c\u4e0d\u662f\u9000\u51fa\u7b49\u65b0\u6570\u636e
\n switch(_recv_statu) {
\n case RECV_HTTP_LINE: RecvHttpLine(buf);
\n case RECV_HTTP_HEAD: RecvHttpHead(buf);
\n case RECV_HTTP_BODY: RecvHttpBody(buf);
\n }
\n return;
\n }
\n}; <\/p>\n
class HttpServer {
\n private:
\n using Handler = std::function<void(const HttpRequest &, HttpResponse *)>;
\n using Handlers = std::vector<std::pair<std::regex, Handler>>;
\n Handlers _get_route;
\n Handlers _post_route;
\n Handlers _put_route;
\n Handlers _delete_route;
\n std::string _basedir; \/\/\u9759\u6001\u8d44\u6e90\u6839\u76ee\u5f55
\n TcpServer _server;
\n private:
\n void ErrorHandler(const HttpRequest &req, HttpResponse *rsp) {
\n \/\/1. \u7ec4\u7ec7\u4e00\u4e2a\u9519\u8bef\u5c55\u793a\u9875\u9762
\n std::string body;
\n body += "<html>";
\n body += "<head>";
\n body += "<meta http-equiv='Content-Type' content='text\/html;charset=utf-8'>";
\n body += "<\/head>";
\n body += "<body>";
\n body += "<h1>";
\n body += std::to_string(rsp->_statu);
\n body += " ";
\n body += Util::StatuDesc(rsp->_statu);
\n body += "<\/h1>";
\n body += "<\/body>";
\n body += "<\/html>";
\n \/\/2. \u5c06\u9875\u9762\u6570\u636e，\u5f53\u4f5c\u54cd\u5e94\u6b63\u6587，\u653e\u5165rsp\u4e2d
\n rsp->SetContent(body, "text\/html");
\n }
\n \/\/\u5c06HttpResponse\u4e2d\u7684\u8981\u7d20\u6309\u7167http\u534f\u8bae\u683c\u5f0f\u8fdb\u884c\u7ec4\u7ec7，\u53d1\u9001
\n void WriteReponse(const PtrConnection &conn, const HttpRequest &req, HttpResponse &rsp) {
\n \/\/1. \u5148\u5b8c\u5584\u5934\u90e8\u5b57\u6bb5
\n if (req.Close() == true) {
\n rsp.SetHeader("Connection", "close");
\n }else {
\n rsp.SetHeader("Connection", "keep-alive");
\n }
\n if (rsp._body.empty() == false && rsp.HasHeader("Content-Length") == false) {
\n rsp.SetHeader("Content-Length", std::to_string(rsp._body.size()));
\n }
\n if (rsp._body.empty() == false && rsp.HasHeader("Content-Type") == false) {
\n rsp.SetHeader("Content-Type", "application\/octet-stream");
\n }
\n if (rsp._redirect_flag == true) {
\n rsp.SetHeader("Location", rsp._redirect_url);
\n }
\n \/\/2. \u5c06rsp\u4e2d\u7684\u8981\u7d20，\u6309\u7167http\u534f\u8bae\u683c\u5f0f\u8fdb\u884c\u7ec4\u7ec7
\n std::stringstream rsp_str;
\n rsp_str << req._version << " " << std::to_string(rsp._statu) << " " << Util::StatuDesc(rsp._statu) << "\\\\r\\\\n";
\n for (auto &head : rsp._headers) {
\n rsp_str << head.first << ": " << head.second << "\\\\r\\\\n";
\n }
\n rsp_str << "\\\\r\\\\n";
\n rsp_str << rsp._body;
\n \/\/3. \u53d1\u9001\u6570\u636e
\n conn->Send(rsp_str.str().c_str(), rsp_str.str().size());
\n }
\n bool IsFileHandler(const HttpRequest &req) {
\n \/\/ 1. \u5fc5\u987b\u8bbe\u7f6e\u4e86\u9759\u6001\u8d44\u6e90\u6839\u76ee\u5f55
\n if (_basedir.empty()) {
\n return false;
\n }
\n \/\/ 2. \u8bf7\u6c42\u65b9\u6cd5，\u5fc5\u987b\u662fGET \/ HEAD\u8bf7\u6c42\u65b9\u6cd5
\n if (req._method != "GET" && req._method != "HEAD") {
\n return false;
\n }
\n \/\/ 3. \u8bf7\u6c42\u7684\u8d44\u6e90\u8def\u5f84\u5fc5\u987b\u662f\u4e00\u4e2a\u5408\u6cd5\u8def\u5f84
\n if (Util::ValidPath(req._path) == false) {
\n return false;
\n }
\n \/\/ 4. \u8bf7\u6c42\u7684\u8d44\u6e90\u5fc5\u987b\u5b58\u5728,\u4e14\u662f\u4e00\u4e2a\u666e\u901a\u6587\u4ef6
\n \/\/ \u6709\u4e00\u79cd\u8bf7\u6c42\u6bd4\u8f83\u7279\u6b8a — \u76ee\u5f55：\/, \/image\/， \u8fd9\u79cd\u60c5\u51b5\u7ed9\u540e\u8fb9\u9ed8\u8ba4\u8ffd\u52a0\u4e00\u4e2a index.html
\n \/\/ index.html \/image\/a.png
\n \/\/ \u4e0d\u8981\u5fd8\u4e86\u524d\u7f00\u7684\u76f8\u5bf9\u6839\u76ee\u5f55,\u4e5f\u5c31\u662f\u5c06\u8bf7\u6c42\u8def\u5f84\u8f6c\u6362\u4e3a\u5b9e\u9645\u5b58\u5728\u7684\u8def\u5f84 \/image\/a.png -> .\/wwwroot\/image\/a.png
\n std::string req_path = _basedir + req._path;\/\/\u4e3a\u4e86\u907f\u514d\u76f4\u63a5\u4fee\u6539\u8bf7\u6c42\u7684\u8d44\u6e90\u8def\u5f84，\u56e0\u6b64\u5b9a\u4e49\u4e00\u4e2a\u4e34\u65f6\u5bf9\u8c61
\n if (req._path.back() == '\/') {
\n req_path += "index.html";
\n }
\n if (Util::IsRegular(req_path) == false) {
\n return false;
\n }
\n return true;
\n }
\n \/\/\u9759\u6001\u8d44\u6e90\u7684\u8bf7\u6c42\u5904\u7406 — \u5c06\u9759\u6001\u8d44\u6e90\u6587\u4ef6\u7684\u6570\u636e\u8bfb\u53d6\u51fa\u6765，\u653e\u5230rsp\u7684_body\u4e2d, \u5e76\u8bbe\u7f6emime
\n void FileHandler(const HttpRequest &req, HttpResponse *rsp) {
\n std::string req_path = _basedir + req._path;
\n if (req._path.back() == '\/') {
\n req_path += "index.html";
\n }
\n bool ret = Util::ReadFile(req_path, &rsp->_body);
\n if (ret == false) {
\n return;
\n }
\n std::string mime = Util::ExtMime(req_path);
\n rsp->SetHeader("Content-Type", mime);
\n return;
\n }
\n \/\/\u529f\u80fd\u6027\u8bf7\u6c42\u7684\u5206\u7c7b\u5904\u7406
\n void Dispatcher(HttpRequest &req, HttpResponse *rsp, Handlers &handlers) {
\n \/\/\u5728\u5bf9\u5e94\u8bf7\u6c42\u65b9\u6cd5\u7684\u8def\u7531\u8868\u4e2d，\u67e5\u627e\u662f\u5426\u542b\u6709\u5bf9\u5e94\u8d44\u6e90\u8bf7\u6c42\u7684\u5904\u7406\u51fd\u6570，\u6709\u5219\u8c03\u7528，\u6ca1\u6709\u5219\u53d1\u6325404
\n \/\/\u601d\u60f3：\u8def\u7531\u8868\u5b58\u50a8\u7684\u65f6\u952e\u503c\u5bf9 — \u6b63\u5219\u8868\u8fbe\u5f0f & \u5904\u7406\u51fd\u6570
\n \/\/\u4f7f\u7528\u6b63\u5219\u8868\u8fbe\u5f0f，\u5bf9\u8bf7\u6c42\u7684\u8d44\u6e90\u8def\u5f84\u8fdb\u884c\u6b63\u5219\u5339\u914d，\u5339\u914d\u6210\u529f\u5c31\u4f7f\u7528\u5bf9\u5e94\u51fd\u6570\u8fdb\u884c\u5904\u7406
\n \/\/ \/numbers\/(\\\\d+) \/numbers\/12345
\n for (auto &handler : handlers) {
\n const std::regex &re = handler.first;
\n const Handler &functor = handler.second;
\n bool ret = std::regex_match(req._path, req._matches, re);
\n if (ret == false) {
\n continue;
\n }
\n return functor(req, rsp);\/\/\u4f20\u5165\u8bf7\u6c42\u4fe1\u606f，\u548c\u7a7a\u7684rsp，\u6267\u884c\u5904\u7406\u51fd\u6570
\n }
\n rsp->_statu = 404;
\n }
\n void Route(HttpRequest &req, HttpResponse *rsp) {
\n \/\/1. \u5bf9\u8bf7\u6c42\u8fdb\u884c\u5206\u8fa8，\u662f\u4e00\u4e2a\u9759\u6001\u8d44\u6e90\u8bf7\u6c42，\u8fd8\u662f\u4e00\u4e2a\u529f\u80fd\u6027\u8bf7\u6c42
\n \/\/ \u9759\u6001\u8d44\u6e90\u8bf7\u6c42，\u5219\u8fdb\u884c\u9759\u6001\u8d44\u6e90\u7684\u5904\u7406
\n \/\/ \u529f\u80fd\u6027\u8bf7\u6c42，\u5219\u9700\u8981\u901a\u8fc7\u51e0\u4e2a\u8bf7\u6c42\u8def\u7531\u8868\u6765\u786e\u5b9a\u662f\u5426\u6709\u5904\u7406\u51fd\u6570
\n \/\/ \u65e2\u4e0d\u662f\u9759\u6001\u8d44\u6e90\u8bf7\u6c42，\u4e5f\u6ca1\u6709\u8bbe\u7f6e\u5bf9\u5e94\u7684\u529f\u80fd\u6027\u8bf7\u6c42\u5904\u7406\u51fd\u6570，\u5c31\u8fd4\u56de405
\n if (IsFileHandler(req) == true) {
\n \/\/\u662f\u4e00\u4e2a\u9759\u6001\u8d44\u6e90\u8bf7\u6c42, \u5219\u8fdb\u884c\u9759\u6001\u8d44\u6e90\u8bf7\u6c42\u7684\u5904\u7406
\n return FileHandler(req, rsp);
\n }
\n if (req._method == "GET" || req._method == "HEAD") {
\n return Dispatcher(req, rsp, _get_route);
\n }else if (req._method == "POST") {
\n return Dispatcher(req, rsp, _post_route);
\n }else if (req._method == "PUT") {
\n return Dispatcher(req, rsp, _put_route);
\n }else if (req._method == "DELETE") {
\n return Dispatcher(req, rsp, _delete_route);
\n }
\n rsp->_statu = 405;\/\/ Method Not Allowed
\n return ;
\n }
\n \/\/\u8bbe\u7f6e\u4e0a\u4e0b\u6587
\n void OnConnected(const PtrConnection &conn) {
\n conn->SetContext(HttpContext());
\n DBG_LOG("NEW CONNECTION %p", conn.get());
\n }
\n \/\/\u7f13\u51b2\u533a\u6570\u636e\u89e3\u6790+\u5904\u7406
\n void OnMessage(const PtrConnection &conn, Buffer *buffer) {
\n while(buffer->ReadAbleSize() > 0){
\n \/\/1. \u83b7\u53d6\u4e0a\u4e0b\u6587
\n HttpContext *context = conn->GetContext()->get<HttpContext>();
\n \/\/2. \u901a\u8fc7\u4e0a\u4e0b\u6587\u5bf9\u7f13\u51b2\u533a\u6570\u636e\u8fdb\u884c\u89e3\u6790，\u5f97\u5230HttpRequest\u5bf9\u8c61
\n \/\/ 1. \u5982\u679c\u7f13\u51b2\u533a\u7684\u6570\u636e\u89e3\u6790\u51fa\u9519，\u5c31\u76f4\u63a5\u56de\u590d\u51fa\u9519\u54cd\u5e94
\n \/\/ 2. \u5982\u679c\u89e3\u6790\u6b63\u5e38，\u4e14\u8bf7\u6c42\u5df2\u7ecf\u83b7\u53d6\u5b8c\u6bd5，\u624d\u5f00\u59cb\u53bb\u8fdb\u884c\u5904\u7406
\n context->RecvHttpRequest(buffer);
\n HttpRequest &req = context->Request();
\n HttpResponse rsp(context->RespStatu());
\n if (context->RespStatu() >= 400) {
\n \/\/\u8fdb\u884c\u9519\u8bef\u54cd\u5e94，\u5173\u95ed\u8fde\u63a5
\n ErrorHandler(req, &rsp);\/\/\u586b\u5145\u4e00\u4e2a\u9519\u8bef\u663e\u793a\u9875\u9762\u6570\u636e\u5230rsp\u4e2d
\n WriteReponse(conn, req, rsp);\/\/\u7ec4\u7ec7\u54cd\u5e94\u53d1\u9001\u7ed9\u5ba2\u6237\u7aef
\n context->ReSet();
\n buffer->MoveReadOffset(buffer->ReadAbleSize());\/\/\u51fa\u9519\u4e86\u5c31\u628a\u7f13\u51b2\u533a\u6570\u636e\u6e05\u7a7a
\n conn->Shutdown();\/\/\u5173\u95ed\u8fde\u63a5
\n return;
\n }
\n if (context->RecvStatu() != RECV_HTTP_OVER) {
\n \/\/\u5f53\u524d\u8bf7\u6c42\u8fd8\u6ca1\u6709\u63a5\u6536\u5b8c\u6574,\u5219\u9000\u51fa，\u7b49\u65b0\u6570\u636e\u5230\u6765\u518d\u91cd\u65b0\u7ee7\u7eed\u5904\u7406
\n return;
\n }
\n \/\/3. \u8bf7\u6c42\u8def\u7531 + \u4e1a\u52a1\u5904\u7406
\n Route(req, &rsp);
\n \/\/4. \u5bf9HttpResponse\u8fdb\u884c\u7ec4\u7ec7\u53d1\u9001
\n WriteReponse(conn, req, rsp);
\n \/\/5. \u91cd\u7f6e\u4e0a\u4e0b\u6587
\n context->ReSet();
\n \/\/6. \u6839\u636e\u957f\u77ed\u8fde\u63a5\u5224\u65ad\u662f\u5426\u5173\u95ed\u8fde\u63a5\u6216\u8005\u7ee7\u7eed\u5904\u7406
\n if (rsp.Close() == true) conn->Shutdown();\/\/\u77ed\u94fe\u63a5\u5219\u76f4\u63a5\u5173\u95ed
\n }
\n return;
\n }
\n public:
\n HttpServer(int port, int timeout = DEFALT_TIMEOUT):_server(port) {
\n _server.EnableInactiveRelease(timeout);
\n _server.SetConnectedCallback(std::bind(&HttpServer::OnConnected, this, std::placeholders::_1));
\n _server.SetMessageCallback(std::bind(&HttpServer::OnMessage, this, std::placeholders::_1, std::placeholders::_2));
\n }
\n void SetBaseDir(const std::string &path) {
\n assert(Util::IsDirectory(path) == true);
\n _basedir = path;
\n }
\n \/*\u8bbe\u7f6e\/\u6dfb\u52a0，\u8bf7\u6c42（\u8bf7\u6c42\u7684\u6b63\u5219\u8868\u8fbe）\u4e0e\u5904\u7406\u51fd\u6570\u7684\u6620\u5c04\u5173\u7cfb*\/
\n void Get(const std::string &pattern, const Handler &handler) {
\n _get_route.push_back(std::make_pair(std::regex(pattern), handler));
\n }
\n void Post(const std::string &pattern, const Handler &handler) {
\n _post_route.push_back(std::make_pair(std::regex(pattern), handler));
\n }
\n void Put(const std::string &pattern, const Handler &handler) {
\n _put_route.push_back(std::make_pair(std::regex(pattern), handler));
\n }
\n void Delete(const std::string &pattern, const Handler &handler) {
\n _delete_route.push_back(std::make_pair(std::regex(pattern), handler));
\n }
\n void SetThreadCount(int count) {
\n _server.SetThreadCount(count);
\n }
\n void Listen() {
\n _server.Start();
\n }
\n}; <\/p>\n","protected":false},"excerpt":{"rendered":"
\u6587\u7ae0\u6d4f\u89c8\u9605\u8bfb919\u6b21\uff0c\u70b9\u8d5e9\u6b21\uff0c\u6536\u85cf9\u6b21\u3002\u901a\u8fc7\u54b1\u4eec\u5b9e\u73b0\u7684\u2fbc\u5e76\u53d1\u670d\u52a1\u5668\u7ec4\u4ef6\uff0c\u53ef\u4ee5\u7b80\u6d01\u5feb\u901f\u7684\u5b8c\u6210\u2f00\u4e2a\u2fbc\u6027\u80fd\u7684\u670d\u52a1\u5668\u642d\u5efa\u3002\u5e76\u4e14\uff0c\u901a\u8fc7\u7ec4\u4ef6\u5185\u63d0\u4f9b\u7684\u4e0d\u540c\u5e94\u2f64\u5c42\u534f\u8bae\u2f40\u6301\uff0c\u4e5f\u53ef\u4ee5\u5feb\u901f\u5b8c\u6210\u2f00\u4e2a\u2fbc\u6027\u80fd\u5e94\u2f64\u670d\u52a1\u5668\u7684\u642d\u5efa\uff08\u5f53\u524d \uff0c\u4e3a\u4e86\u4fbf\u4e8e\u9879\u2f6c\u7684\u6f14\u2f70\uff0c\u9879\u2f6c\u4e2d\u63d0\u4f9bHTTP\u534f\u8bae\u7ec4\u4ef6\u7684\u2f40\u6301\uff09\u3002\u5728\u8fd9\u2fa5\uff0c\u8981\u660e\u786e\u7684\u662f\u54b1\u4eec\u8981\u5b9e\u73b0\u7684\u662f\u2f00\u4e2a\u2fbc\u5e76\u53d1\u670d\u52a1\u5668\u7ec4\u4ef6\uff0c\u56e0\u6b64\u5f53\u524d\u7684\u9879\u2f6c\u4e2d\u5e76\u4e0d\u5305\u542b\u5b9e\u9645\u7684\u4e1a\u52a1\u5185\u5bb9\u3002\u56fe\u7247\u6765\u6e90\uff1a\u672c\u9879\u76ee\u603b\u5171\u5206\u4e3a\u4e24\u5927\u6a21\u5757\u5206\u522b\u4e3aServer\u548cHTTP\u6a21\u5757\u3002_\u4effmuduo\u5e93one-thread-one-loop\u5f0f\u5e76\u53d1\u670d\u52a1\u5668<\/p>\n","protected":false},"author":2,"featured_media":14199,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[1],"tags":[43,44],"topic":[],"class_list":["post-14200","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-server","tag-43","tag-44"],"yoast_head":"\n