{"id":15670,"date":"2025-04-18T22:12:55","date_gmt":"2025-04-18T14:12:55","guid":{"rendered":"https:\/\/www.wsisp.com\/helps\/15670.html"},"modified":"2025-04-18T22:12:55","modified_gmt":"2025-04-18T14:12:55","slug":"%e4%bb%bfmudou%e5%ba%93one-thread-oneloop%e5%bc%8f%e5%b9%b6%e5%8f%91%e6%9c%8d%e5%8a%a1%e5%99%a8","status":"publish","type":"post","link":"https:\/\/www.wsisp.com\/helps\/15670.html","title":{"rendered":"\u4effmudou\u5e93one thread oneloop\u5f0f\u5e76\u53d1\u670d\u52a1\u5668"},"content":{"rendered":"

\u9879\u76eegitee：\u4effmuduo: \u4effmuduo<\/h2>\n

\u4e00：\u9879\u76ee\u76ee\u7684<\/h2>\n

1.1\u9879\u76ee\u7b80\u4ecb<\/h3>\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 <\/span> <\/p>\n

\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\u9879\u2f6c\u4e2d\u63d0\u4f9bHTTP\u534f\u8bae\u7ec4\u4ef6\u7684\u2f40\u6301）\u3002 <\/span> <\/p>\n

\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\u5bb9\u3002 <\/span> <\/p>\n

1.2HTTP\u670d\u52a1\u5668<\/span><\/h3>\n

\u6982\u5ff5： <\/span> <\/p>\n

HTTP（Hyper Text Transfer Protocol），\u8d85\u2f42\u672c\u4f20\u8f93\u534f\u8bae\u662f\u5e94\u2f64\u5c42\u534f\u8bae，\u662f\u2f00\u79cd\u7b80\u5355\u7684\u8bf7\u6c42-\u54cd\u5e94\u534f \u8bae（\u5ba2\u2f3e\u7aef\u6839\u636e\u2f83\u2f30\u7684\u9700\u8981\u5411\u670d\u52a1\u5668\u53d1\u9001\u8bf7\u6c42，\u670d\u52a1\u5668\u9488\u5bf9\u8bf7\u6c42\u63d0\u4f9b\u670d\u52a1，\u5b8c\u6bd5\u540e\u901a\u4fe1\u7ed3\u675f）\u3002 \u534f\u8bae\u7ec6\u8282\u5728\u4e4b\u524d\u7684\u535a\u5ba2\u4e0a\u5df2\u7ecf\u8bb2\u8fc7，\u8fd9\u2fa5\u4e0d\u518d\u8d58\u8ff0\u3002\u4f46\u662f\u9700\u8981\u6ce8\u610f\u7684\u662fHTTP\u534f\u8bae\u662f\u2f00\u4e2a\u8fd0\u2f8f\u5728TCP\u534f\u8bae\u4e4b\u4e0a \u7684\u5e94\u2f64\u5c42\u534f\u8bae，\u8fd9\u2f00\u70b9\u672c\u8d28\u4e0a\u662f\u544a\u8bc9\u6211\u4eec，HTTP\u670d\u52a1\u5668\u5176\u5b9e\u5c31\u662f\u4e2aTCP\u670d\u52a1\u5668，\u53ea\u4e0d\u8fc7\u5728\u5e94\u2f64\u5c42\u57fa\u4e8e HTTP\u534f\u8bae\u683c\u5f0f\u8fdb\u2f8f\u6570\u636e\u7684\u7ec4\u7ec7\u548c\u89e3\u6790\u6765\u660e\u786e\u5ba2\u2f3e\u7aef\u7684\u8bf7\u6c42\u5e76\u5b8c\u6210\u4e1a\u52a1\u5904\u7406\u3002 <\/span> <\/p>\n

\u56e0\u6b64\u5b9e\u73b0HTTP\u670d\u52a1\u5668\u7b80\u5355\u7406\u89e3，\u53ea\u9700\u8981\u4ee5\u4e0b\u2f0f\u6b65\u5373\u53ef <\/span> <\/p>\n

1. <\/span>
\n \u642d\u5efa\u2f00\u4e2aTCP\u670d\u52a1\u5668，\u63a5\u6536\u5ba2\u2f3e\u7aef\u8bf7\u6c42\u3002 <\/span> <\/p>\n

2. <\/span>
\n \u4ee5HTTP\u534f\u8bae\u683c\u5f0f\u8fdb\u2f8f\u89e3\u6790\u8bf7\u6c42\u6570\u636e，\u660e\u786e\u5ba2\u2f3e\u7aef\u2f6c\u7684\u3002 <\/span> <\/p>\n

3. <\/span>
\n \u660e\u786e\u5ba2\u2f3e\u7aef\u8bf7\u6c42\u2f6c\u7684\u540e\u63d0\u4f9b\u5bf9\u5e94\u670d\u52a1\u3002 <\/span> <\/p>\n

4. <\/span>
\n \u5c06\u670d\u52a1\u7ed3\u679c\u2f00HTTP\u534f\u8bae\u683c\u5f0f\u8fdb\u2f8f\u7ec4\u7ec7，\u53d1\u9001\u7ed9\u5ba2\u2f3e\u7aef<\/span> <\/p>\n

\u5b9e\u73b0\u2f00\u4e2aHTTP\u670d\u52a1\u5668\u5f88\u7b80\u5355，\u4f46\u662f\u5b9e\u73b0\u2f00\u4e2a\u2fbc\u6027\u80fd\u7684\u670d\u52a1\u5668\u5e76\u4e0d\u7b80\u5355，\u8fd9\u4e2a\u5355\u5143\u4e2d\u5c06\u8bb2\u89e3\u57fa\u4e8e <\/span> <\/p>\n

Reactor\u6a21\u5f0f\u7684\u2fbc\u6027\u80fd\u670d\u52a1\u5668\u5b9e\u73b0\u3002 <\/span> <\/p>\n

\u5f53\u7136\u51c6\u786e\u6765\u8bf4，\u56e0\u4e3a\u6211\u4eec\u8981\u5b9e\u73b0\u7684\u670d\u52a1\u5668\u672c\u2f9d\u5e76\u4e0d\u5b58\u5728\u4e1a\u52a1，\u54b1\u4eec\u8981\u5b9e\u73b0\u7684\u5e94\u8be5\u7b97\u662f\u2f00\u4e2a\u2fbc\u6027\u80fd\u670d\u52a1 \u5668\u57fa\u7840\u5e93，\u662f\u2f00\u4e2a\u57fa\u7840\u7ec4\u4ef6\u3002<\/span> <\/p>\n

1.3Reactor\u6a21\u578b：<\/span><\/h3>\n

\u6982\u5ff5 <\/span> <\/p>\n

Reactor \u6a21\u5f0f，\u662f\u6307\u901a\u8fc7\u2f00\u4e2a\u6216\u591a\u4e2a\u8f93\u2f0a\u540c\u65f6\u4f20\u9012\u7ed9\u670d\u52a1\u5668\u8fdb\u2f8f\u8bf7\u6c42\u5904\u7406\u65f6\u7684\u4e8b\u4ef6\u9a71\u52a8\u5904\u7406\u6a21\u5f0f\u3002 <\/span> <\/p>\n

\u670d\u52a1\u7aef\u7a0b\u5e8f\u5904\u7406\u4f20\u2f0a\u591a\u8def\u8bf7\u6c42，\u5e76\u5c06\u5b83\u4eec\u540c\u6b65\u5206\u6d3e\u7ed9\u8bf7\u6c42\u5bf9\u5e94\u7684\u5904\u7406\u7ebf\u7a0b，Reactor \u6a21\u5f0f\u4e5f\u53eb <\/span> <\/p>\n

Dispatcher \u6a21\u5f0f\u3002 <\/span> <\/p>\n

\u7b80\u5355\u7406\u89e3\u5c31\u662f\u4f7f\u2f64 <\/span>
\n I\/O<\/span>
\n \u591a\u8def\u590d\u2f64 \u7edf\u2f00\u76d1\u542c\u4e8b\u4ef6，\u6536\u5230\u4e8b\u4ef6\u540e\u5206\u53d1\u7ed9\u5904\u7406\u8fdb\u7a0b\u6216\u7ebf\u7a0b，\u662f\u7f16\u5199\u2fbc\u6027\u80fd <\/span> <\/p>\n

\u2f79\u7edc\u670d\u52a1\u5668\u7684\u5fc5\u5907\u6280\u672f\u4e4b\u2f00\u3002<\/span> <\/p>\n

\u5206\u7c7b： <\/span> <\/p>\n

\u5355Reactor\u5355\u7ebf\u7a0b：\u5355I\/O\u591a\u8def\u590d\u2f64+\u4e1a\u52a1\u5904\u7406 <\/span><\/h4>\n

1. <\/span>
\n \u901a\u8fc7IO\u591a\u8def\u590d\u2f64\u6a21\u578b\u8fdb\u2f8f\u5ba2\u2f3e\u7aef\u8bf7\u6c42\u76d1\u63a7 <\/span> <\/p>\n

2. <\/span>
\n \u89e6\u53d1\u4e8b\u4ef6\u540e，\u8fdb\u2f8f\u4e8b\u4ef6\u5904\u7406 <\/span> <\/p>\n

a. <\/span>
\n \u5982\u679c\u662f\u65b0\u5efa\u8fde\u63a5\u8bf7\u6c42，\u5219\u83b7\u53d6\u65b0\u5efa\u8fde\u63a5，\u5e76\u6dfb\u52a0\u2f84\u591a\u8def\u590d\u2f64\u6a21\u578b\u8fdb\u2f8f\u4e8b\u4ef6\u76d1\u63a7\u3002 <\/span> <\/p>\n

b. <\/span>
\n \u5982\u679c\u662f\u6570\u636e\u901a\u4fe1\u8bf7\u6c42，\u5219\u8fdb\u2f8f\u5bf9\u5e94\u6570\u636e\u5904\u7406（\u63a5\u6536\u6570\u636e，\u5904\u7406\u6570\u636e，\u53d1\u9001\u54cd\u5e94）\u3002 <\/span> <\/p>\n

\u4f18\u70b9：\u6240\u6709\u64cd\u4f5c\u5747\u5728\u540c\u2f00\u7ebf\u7a0b\u4e2d\u5b8c\u6210，\u601d\u60f3\u6d41\u7a0b\u8f83\u4e3a\u7b80\u5355，\u4e0d\u6d89\u53ca\u8fdb\u7a0b\/\u7ebf\u7a0b\u95f4\u901a\u4fe1\u53ca\u8d44\u6e90\u4e89\u62a2\u95ee\u9898\u3002 <\/span> <\/p>\n

\u7f3a\u70b9：\u2f46\u6cd5\u6709\u6548\u5229\u2f64CPU\u591a\u6838\u8d44\u6e90，\u5f88\u5bb9\u6613\u8fbe\u5230\u6027\u80fd\u74f6\u9888\u3002 <\/span> <\/p>\n

\u9002\u2f64\u573a\u666f：\u9002\u2f64\u4e8e\u5ba2\u2f3e\u7aef\u6570\u91cf\u8f83\u5c11，\u4e14\u5904\u7406\u901f\u5ea6\u8f83\u4e3a\u5feb\u901f\u7684\u573a\u666f\u3002（\u5904\u7406\u8f83\u6162\u6216\u6d3b\u8dc3\u8fde\u63a5\u8f83\u591a，\u4f1a\u5bfc <\/span> <\/p>\n

\u81f4\u4e32\u2f8f\u5904\u7406\u7684\u60c5\u51b5\u4e0b，\u540e\u5904\u7406\u7684\u8fde\u63a5\u2ed3\u65f6\u95f4\u2f46\u6cd5\u5f97\u5230\u54cd\u5e94）\u3002 <\/span> <\/p>\n

\u5355Reactor\u591a\u7ebf\u7a0b：\u5355I\/O\u591a\u8def\u590d\u2f64+\u7ebf\u7a0b\u6c60（\u4e1a\u52a1\u5904\u7406） <\/span><\/h4>\n

1. <\/span>
\n Reactor\u7ebf\u7a0b\u901a\u8fc7I\/O\u591a\u8def\u590d\u2f64\u6a21\u578b\u8fdb\u2f8f\u5ba2\u2f3e\u7aef\u8bf7\u6c42\u76d1\u63a7 <\/span> <\/p>\n

2. <\/span>
\n \u89e6\u53d1\u4e8b\u4ef6\u540e，\u8fdb\u2f8f\u4e8b\u4ef6\u5904\u7406 <\/span> <\/p>\n

a. <\/span>
\n \u5982\u679c\u662f\u65b0\u5efa\u8fde\u63a5\u8bf7\u6c42，\u5219\u83b7\u53d6\u65b0\u5efa\u8fde\u63a5，\u5e76\u6dfb\u52a0\u2f84\u591a\u8def\u590d\u2f64\u6a21\u578b\u8fdb\u2f8f\u4e8b\u4ef6\u76d1\u63a7\u3002 <\/span> <\/p>\n

b. <\/span>
\n \u5982\u679c\u662f\u6570\u636e\u901a\u4fe1\u8bf7\u6c42，\u5219\u63a5\u6536\u6570\u636e\u540e\u5206\u53d1\u7ed9Worker\u7ebf\u7a0b\u6c60\u8fdb\u2f8f\u4e1a\u52a1\u5904\u7406\u3002 <\/span> <\/p>\n

c. <\/span>
\n \u2f2f\u4f5c\u7ebf\u7a0b\u5904\u7406\u5b8c\u6bd5\u540e，\u5c06\u54cd\u5e94\u4ea4\u7ed9Reactor\u7ebf\u7a0b\u8fdb\u2f8f\u6570\u636e\u54cd\u5e94 <\/span> <\/p>\n

\u4f18\u70b9：\u5145\u5206\u5229\u2f64CPU\u591a\u6838\u8d44\u6e90 <\/span> <\/p>\n

\u7f3a\u70b9：\u591a\u7ebf\u7a0b\u95f4\u7684\u6570\u636e\u5171\u4eab\u8bbf\u95ee\u63a7\u5236\u8f83\u4e3a\u590d\u6742，\u5355\u4e2aReactor \u627f\u62c5\u6240\u6709\u4e8b\u4ef6\u7684\u76d1\u542c\u548c\u54cd\u5e94，\u5728\u5355\u7ebf\u7a0b\u4e2d <\/span> <\/p>\n

\u8fd0\u2f8f，\u2fbc\u5e76\u53d1\u573a\u666f\u4e0b\u5bb9\u6613\u6210\u4e3a\u6027\u80fd\u74f6\u9888\u3002 <\/span> <\/p>\n

\u591aReactor\u591a\u7ebf\u7a0b：\u591aI\/O\u591a\u8def\u590d\u2f64+\u7ebf\u7a0b\u6c60（\u4e1a\u52a1\u5904\u7406） <\/span><\/h4>\n

1. <\/span>
\n \u5728\u4e3bReactor\u4e2d\u5904\u7406\u65b0\u8fde\u63a5\u8bf7\u6c42\u4e8b\u4ef6，\u6709\u65b0\u8fde\u63a5\u5230\u6765\u5219\u5206\u53d1\u5230\u2f26Reactor\u4e2d\u76d1\u63a7 <\/span> <\/p>\n

2. <\/span>
\n \u5728\u2f26Reactor\u4e2d\u8fdb\u2f8f\u5ba2\u2f3e\u7aef\u901a\u4fe1\u76d1\u63a7，\u6709\u4e8b\u4ef6\u89e6\u53d1，\u5219\u63a5\u6536\u6570\u636e\u5206\u53d1\u7ed9Worker\u7ebf\u7a0b\u6c60 <\/span> <\/p>\n

3. <\/span>
\n Worker\u7ebf\u7a0b\u6c60\u5206\u914d\u72ec\u2f74\u7684\u7ebf\u7a0b\u8fdb\u2f8f\u5177\u4f53\u7684\u4e1a\u52a1\u5904\u7406 <\/span> <\/p>\n

a. <\/span>
\n \u2f2f\u4f5c\u7ebf\u7a0b\u5904\u7406\u5b8c\u6bd5\u540e，\u5c06\u54cd\u5e94\u4ea4\u7ed9\u2f26Reactor\u7ebf\u7a0b\u8fdb\u2f8f\u6570\u636e\u54cd\u5e94 <\/span> <\/p>\n

\u4f18\u70b9：\u5145\u5206\u5229\u2f64CPU\u591a\u6838\u8d44\u6e90，\u4e3b\u4eceReactor\u5404\u53f8\u5176\u804c<\/span> <\/p>\n

1.4\u2f6c\u6807\u5b9a\u4f4d：<\/span><\/h3>\n

One Thread One Loop\u4e3b\u4eceReactor\u6a21\u578b\u2fbc\u5e76\u53d1\u670d\u52a1\u5668 <\/span> <\/p>\n

\u54b1\u4eec\u8981\u5b9e\u73b0\u7684\u662f\u4e3b\u4eceReactor\u6a21\u578b\u670d\u52a1\u5668，\u4e5f\u5c31\u662f\u4e3bReactor\u7ebf\u7a0b\u4ec5\u4ec5\u76d1\u63a7\u76d1\u542c\u63cf\u8ff0\u7b26，\u83b7\u53d6\u65b0\u5efa\u8fde <\/span> <\/p>\n

\u63a5，\u4fdd\u8bc1\u83b7\u53d6\u65b0\u8fde\u63a5\u7684\u2fbc\u6548\u6027，\u63d0\u2fbc\u670d\u52a1\u5668\u7684\u5e76\u53d1\u6027\u80fd\u3002 <\/span> <\/p>\n

\u4e3bReactor\u83b7\u53d6\u5230\u65b0\u8fde\u63a5\u540e\u5206\u53d1\u7ed9\u2f26Reactor\u8fdb\u2f8f\u901a\u4fe1\u4e8b\u4ef6\u76d1\u63a7\u3002\u2f7d\u2f26Reactor\u7ebf\u7a0b\u76d1\u63a7\u5404\u2f83\u7684\u63cf\u8ff0\u7b26\u7684 \u8bfb\u5199\u4e8b\u4ef6\u8fdb\u2f8f\u6570\u636e\u8bfb\u5199\u4ee5\u53ca\u4e1a\u52a1\u5904\u7406\u3002<\/span> <\/p>\n

One Thread One Loop\u7684\u601d\u60f3\u5c31\u662f\u628a\u6240\u6709\u7684\u64cd\u4f5c\u90fd\u653e\u5230\u2f00\u4e2a\u7ebf\u7a0b\u4e2d\u8fdb\u2f8f，\u2f00\u4e2a\u7ebf\u7a0b\u5bf9\u5e94\u2f00\u4e2a\u4e8b\u4ef6\u5904\u7406 \u7684\u5faa\u73af\u3002 \u5f53\u524d\u5b9e\u73b0\u4e2d，\u56e0\u4e3a\u5e76\u4e0d\u786e\u5b9a\u7ec4\u4ef6\u4f7f\u2f64\u8005\u7684\u4f7f\u2f64\u610f\u5411，\u56e0\u6b64\u5e76\u4e0d\u63d0\u4f9b\u4e1a\u52a1\u5c42\u2f2f\u4f5c\u7ebf\u7a0b\u6c60\u7684\u5b9e\u73b0，\u53ea\u73b0 \u4e3b\u4eceReactor，\u2f7dWorker\u2f2f\u4f5c\u7ebf\u7a0b\u6c60，\u53ef\u7531\u7ec4\u4ef6\u5e93\u7684\u4f7f\u2f64\u8005\u7684\u9700\u8981\u2f83\u2f8f\u51b3\u5b9a\u662f\u5426\u4f7f\u2f64\u548c\u5b9e\u73b0\u3002<\/span> <\/p>\n

\u4e8c：\u529f\u80fd\u6a21\u5757\u5212\u5206： <\/span><\/h2>\n

\u57fa\u4e8e\u4ee5\u4e0a\u7684\u7406\u89e3，\u6211\u4eec\u8981\u5b9e\u73b0\u7684\u662f\u2f00\u4e2a\u5e26\u6709\u534f\u8bae\u2f40\u6301\u7684Reactor\u6a21\u578b\u2fbc\u6027\u80fd\u670d\u52a1\u5668，\u56e0\u6b64\u5c06\u6574\u4e2a\u9879\u2f6c\u7684 \u5b9e\u73b0\u5212\u5206\u4e3a\u4e24\u4e2a\u2f24\u7684\u6a21\u5757： <\/span> <\/p>\n

\u2022 <\/span>
\n SERVER\u6a21\u5757：\u5b9e\u73b0Reactor\u6a21\u578b\u7684TCP\u670d\u52a1\u5668； <\/span> <\/p>\n

\u2022 <\/span>
\n \u534f\u8bae\u6a21\u5757：\u5bf9\u5f53\u524d\u7684Reactor\u6a21\u578b\u670d\u52a1\u5668\u63d0\u4f9b\u5e94\u2f64\u5c42\u534f\u8bae\u2f40\u6301\u3002 <\/span> <\/p>\n

SERVER\u6a21\u5757： <\/span><\/h3>\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 <\/span> <\/p>\n

\u2f7d\u5177\u4f53\u7684\u7ba1\u7406\u4e5f\u5206\u4e3a\u4e09\u4e2a\u2f45\u2faf： <\/span> <\/p>\n

\u2022 <\/span>
\n \u76d1\u542c\u8fde\u63a5\u7ba1\u7406：\u5bf9\u76d1\u542c\u8fde\u63a5\u8fdb\u2f8f\u7ba1\u7406\u3002 <\/span> <\/p>\n

\u2022 <\/span>
\n \u901a\u4fe1\u8fde\u63a5\u7ba1\u7406：\u5bf9\u901a\u4fe1\u8fde\u63a5\u8fdb\u2f8f\u7ba1\u7406\u3002 <\/span> <\/p>\n

\u2022 <\/span>
\n \u8d85\u65f6\u8fde\u63a5\u7ba1\u7406：\u5bf9\u8d85\u65f6\u8fde\u63a5\u8fdb\u2f8f\u7ba1\u7406\u3002 <\/span> <\/p>\n

\u57fa\u4e8e\u4ee5\u4e0a\u7684\u7ba1\u7406\u601d\u60f3，\u5c06\u8fd9\u4e2a\u6a21\u5757\u8fdb\u2f8f\u7ec6\u81f4\u7684\u5212\u5206\u2f1c\u53ef\u4ee5\u5212\u5206\u4e3a\u4ee5\u4e0b\u591a\u4e2a\u2f26\u6a21\u5757：<\/span> <\/p>\n

Buffer\u6a21\u5757： <\/span><\/h4>\n

Buffer\u6a21\u5757\u662f\u2f00\u4e2a\u7f13\u51b2\u533a\u6a21\u5757，\u2f64\u4e8e\u5b9e\u73b0\u901a\u4fe1\u4e2d\u2f64\u2f3e\u6001\u7684\u63a5\u6536\u7f13\u51b2\u533a\u548c\u53d1\u9001\u7f13\u51b2\u533a\u529f\u80fd <\/span> <\/p>\n

\"\" <\/p>\n

Socket\u6a21\u5757： <\/span><\/h4>\n

Socket\u6a21\u5757\u662f\u5bf9\u5957\u63a5\u5b57\u64cd\u4f5c\u5c01\u88c5\u7684\u2f00\u4e2a\u6a21\u5757，\u4e3b\u8981\u5b9e\u73b0\u7684socket\u7684\u5404\u9879\u64cd\u4f5c\u3002 <\/span> <\/p>\n

\"\" <\/p>\n

Channel\u6a21\u5757： <\/span><\/h4>\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 <\/span> <\/p>\n

\"\" <\/p>\n

Connection\u6a21\u5757 <\/span><\/h4>\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 <\/span> <\/p>\n

Connection\u8fdb\u2f8f\u7ba1\u7406\u3002 <\/span> <\/p>\n

\u2022 <\/span>
\n Connection\u6a21\u5757\u5185\u90e8\u5305\u542b\u6709\u4e09\u4e2a\u7531\u7ec4\u4ef6\u4f7f\u2f64\u8005\u4f20\u2f0a\u7684\u56de\u8c03\u51fd\u6570：\u8fde\u63a5\u5efa\u2f74\u5b8c\u6210\u56de\u8c03，\u4e8b\u4ef6\u56de\u8c03， <\/span> <\/p>\n

\u65b0\u6570\u636e\u56de\u8c03，\u5173\u95ed\u56de\u8c03\u3002<\/span> <\/p>\n

\u2022 <\/span>
\n Connection\u6a21\u5757\u5185\u90e8\u5305\u542b\u6709\u4e24\u4e2a\u7ec4\u4ef6\u4f7f\u2f64\u8005\u63d0\u4f9b\u7684\u63a5\u2f1d：\u6570\u636e\u53d1\u9001\u63a5\u2f1d，\u8fde\u63a5\u5173\u95ed\u63a5\u2f1d <\/span> <\/p>\n

\u2022 <\/span>
\n Connection\u6a21\u5757\u5185\u90e8\u5305\u542b\u6709\u4e24\u4e2a\u2f64\u2f3e\u6001\u7f13\u51b2\u533a：\u2f64\u2f3e\u6001\u63a5\u6536\u7f13\u51b2\u533a，\u2f64\u2f3e\u6001\u53d1\u9001\u7f13\u51b2\u533a <\/span> <\/p>\n

\u2022 <\/span>
\n Connection\u6a21\u5757\u5185\u90e8\u5305\u542b\u6709\u2f00\u4e2aSocket\u5bf9\u8c61：\u5b8c\u6210\u63cf\u8ff0\u7b26\u2faf\u5411\u7cfb\u7edf\u7684IO\u64cd\u4f5c <\/span> <\/p>\n

\u2022 <\/span>
\n Connection\u6a21\u5757\u5185\u90e8\u5305\u542b\u6709\u2f00\u4e2aChannel\u5bf9\u8c61：\u5b8c\u6210\u63cf\u8ff0\u7b26IO\u4e8b\u4ef6\u5c31\u7eea\u7684\u5904\u7406 <\/span> <\/p>\n

\u5177\u4f53\u5904\u7406\u6d41\u7a0b\u5982\u4e0b： <\/span> <\/p>\n

1. <\/span>
\n \u5b9e\u73b0\u5411Channel\u63d0\u4f9b\u53ef\u8bfb，\u53ef\u5199，\u9519\u8bef\u7b49\u4e0d\u540c\u4e8b\u4ef6\u7684IO\u4e8b\u4ef6\u56de\u8c03\u51fd\u6570，\u7136\u540e\u5c06Channel\u548c\u5bf9\u5e94\u7684\u63cf \u8ff0\u7b26\u6dfb\u52a0\u5230Poller\u4e8b\u4ef6\u76d1\u63a7\u4e2d\u3002 <\/span> <\/p>\n

2. <\/span>
\n \u5f53\u63cf\u8ff0\u7b26\u5728Poller\u6a21\u5757\u4e2d\u5c31\u7eea\u4e86IO\u53ef\u8bfb\u4e8b\u4ef6，\u5219\u8c03\u2f64\u63cf\u8ff0\u7b26\u5bf9\u5e94Channel\u4e2d\u4fdd\u5b58\u7684\u8bfb\u4e8b\u4ef6\u5904\u7406\u51fd <\/span> <\/p>\n

\u6570，\u8fdb\u2f8f\u6570\u636e\u8bfb\u53d6，\u5c06socket\u63a5\u6536\u7f13\u51b2\u533a\u5168\u90e8\u8bfb\u53d6\u5230Connection\u7ba1\u7406\u7684\u2f64\u2f3e\u6001\u63a5\u6536\u7f13\u51b2\u533a\u4e2d\u3002\u7136 <\/span> <\/p>\n

\u540e\u8c03\u2f64\u7531\u7ec4\u4ef6\u4f7f\u2f64\u8005\u4f20\u2f0a\u7684\u65b0\u6570\u636e\u5230\u6765\u56de\u8c03\u51fd\u6570\u8fdb\u2f8f\u5904\u7406\u3002 <\/span> <\/p>\n

3. <\/span>
\n \u7ec4\u4ef6\u4f7f\u2f64\u8005\u8fdb\u2f8f\u6570\u636e\u7684\u4e1a\u52a1\u5904\u7406\u5b8c\u6bd5\u540e，\u901a\u8fc7Connection\u5411\u4f7f\u2f64\u8005\u63d0\u4f9b\u7684\u6570\u636e\u53d1\u9001\u63a5\u2f1d，\u5c06\u6570\u636e \u5199\u2f0aConnection\u7684\u53d1\u9001\u7f13\u51b2\u533a\u4e2d\u3002 <\/span> <\/p>\n

4. <\/span>
\n \u542f\u52a8\u63cf\u8ff0\u7b26\u5728Poll\u6a21\u5757\u4e2d\u7684IO\u5199\u4e8b\u4ef6\u76d1\u63a7，\u5c31\u7eea\u540e，\u8c03\u2f64Channel\u4e2d\u4fdd\u5b58\u7684\u5199\u4e8b\u4ef6\u5904\u7406\u51fd\u6570，\u5c06\u53d1 \u9001\u7f13\u51b2\u533a\u4e2d\u7684\u6570\u636e\u901a\u8fc7Socket\u8fdb\u2f8f\u2faf\u5411\u7cfb\u7edf\u7684\u5b9e\u9645\u6570\u636e\u53d1\u9001\u3002<\/span> <\/p>\n

\"\" <\/p>\n

Acceptor\u6a21\u5757： <\/span><\/h4>\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 <\/span> <\/p>\n

\u2022 <\/span>
\n Acceptor\u6a21\u5757\u5185\u90e8\u5305\u542b\u6709\u2f00\u4e2aSocket\u5bf9\u8c61：\u5b9e\u73b0\u76d1\u542c\u5957\u63a5\u5b57\u7684\u64cd\u4f5c <\/span> <\/p>\n

\u2022 <\/span>
\n Acceptor\u6a21\u5757\u5185\u90e8\u5305\u542b\u6709\u2f00\u4e2aChannel\u5bf9\u8c61：\u5b9e\u73b0\u76d1\u542c\u5957\u63a5\u5b57IO\u4e8b\u4ef6\u5c31\u7eea\u7684\u5904\u7406 <\/span> <\/p>\n

\u5177\u4f53\u5904\u7406\u6d41\u7a0b\u5982\u4e0b： <\/span> <\/p>\n

1. <\/span>
\n \u5b9e\u73b0\u5411Channel\u63d0\u4f9b\u53ef\u8bfb\u4e8b\u4ef6\u7684IO\u4e8b\u4ef6\u5904\u7406\u56de\u8c03\u51fd\u6570，\u51fd\u6570\u7684\u529f\u80fd\u5176\u5b9e\u4e5f\u5c31\u662f\u83b7\u53d6\u65b0\u8fde\u63a5 <\/span> <\/p>\n

2. <\/span>
\n \u4e3a\u65b0\u8fde\u63a5\u6784\u5efa\u2f00\u4e2aConnection\u5bf9\u8c61\u51fa\u6765\u3002 <\/span> <\/p>\n

\"\" <\/p>\n

TimerQueue\u6a21\u5757： <\/span><\/h4>\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 <\/span> <\/p>\n

\u8fd9\u4e2a\u6a21\u5757\u4e3b\u8981\u662f\u5bf9Connection\u5bf9\u8c61\u7684\u2f63\u547d\u5468\u671f\u7ba1\u7406，\u5bf9\u2fae\u6d3b\u8dc3\u8fde\u63a5\u8fdb\u2f8f\u8d85\u65f6\u540e\u7684\u91ca\u653e\u529f\u80fd\u3002 <\/span> <\/p>\n

TimerQueue\u6a21\u5757\u5185\u90e8\u5305\u542b\u6709\u2f00\u4e2atimerfd：linux\u7cfb\u7edf\u63d0\u4f9b\u7684\u5b9a\u65f6\u5668\u3002 <\/span> <\/p>\n

TimerQueue\u6a21\u5757\u5185\u90e8\u5305\u542b\u6709\u2f00\u4e2aChannel\u5bf9\u8c61：\u5b9e\u73b0\u5bf9timerfd\u7684IO\u65f6\u95f4\u5c31\u7eea\u56de\u8c03\u5904\u7406<\/span> <\/p>\n

\"\" <\/p>\n

Poller\u6a21\u5757： <\/span><\/h4>\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<\/span> <\/p>\n

\"\" <\/p>\n

EventLoop\u6a21\u5757： <\/span><\/h4>\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 <\/span> <\/p>\n

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 <\/span> <\/p>\n

EventLoop\u6a21\u5757\u4e3a\u4e86\u4fdd\u8bc1\u6574\u4e2a\u670d\u52a1\u5668\u7684\u7ebf\u7a0b\u5b89\u5168\u95ee\u9898，\u56e0\u6b64\u8981\u6c42\u4f7f\u2f64\u8005\u5bf9\u4e8eConnection\u7684\u6240\u6709\u64cd\u4f5c\u2f00 \u5b9a\u8981\u5728\u5176\u5bf9\u5e94\u7684EventLoop\u7ebf\u7a0b\u5185\u5b8c\u6210，\u4e0d\u80fd\u5728\u5176\u4ed6\u7ebf\u7a0b\u4e2d\u8fdb\u2f8f（\u2f50\u5982\u7ec4\u4ef6\u4f7f\u2f64\u8005\u4f7f\u2f64Connection\u53d1 \u9001\u6570\u636e，\u4ee5\u53ca\u5173\u95ed\u8fde\u63a5\u8fd9\u79cd\u64cd\u4f5c）\u3002 <\/span> <\/p>\n

EventLoop\u6a21\u5757\u4fdd\u8bc1\u2f83\u2f30\u5185\u90e8\u6240\u76d1\u63a7\u7684\u6240\u6709\u63cf\u8ff0\u7b26，\u90fd\u8981\u662f\u6d3b\u8dc3\u8fde\u63a5，\u2fae\u6d3b\u8dc3\u8fde\u63a5\u5c31\u8981\u53ca\u65f6\u91ca\u653e\u907f\u514d \u8d44\u6e90\u6d6a\u8d39\u3002 <\/span> <\/p>\n

\u2022 <\/span>
\n EventLoop\u6a21\u5757\u5185\u90e8\u5305\u542b\u6709\u2f00\u4e2aeventfd：eventfd\u5176\u5b9e\u5c31\u662flinux\u5185\u6838\u63d0\u4f9b\u7684\u2f00\u4e2a\u4e8b\u4ef6fd，\u4e13\u2ed4\u2f64\u4e8e <\/span> <\/p>\n

\u4e8b\u4ef6\u901a\u77e5\u3002 <\/span> <\/p>\n

\u2022 <\/span>
\n EventLoop\u6a21\u5757\u5185\u90e8\u5305\u542b\u6709\u2f00\u4e2aPoller\u5bf9\u8c61：\u2f64\u4e8e\u8fdb\u2f8f\u63cf\u8ff0\u7b26\u7684IO\u4e8b\u4ef6\u76d1\u63a7\u3002 <\/span> <\/p>\n

\u2022 <\/span>
\n EventLoop\u6a21\u5757\u5185\u90e8\u5305\u542b\u6709\u2f00\u4e2aTimerQueue\u5bf9\u8c61：\u2f64\u4e8e\u8fdb\u2f8f\u5b9a\u65f6\u4efb\u52a1\u7684\u7ba1\u7406\u3002 <\/span> <\/p>\n

\u2022 <\/span>
\n EventLoop\u6a21\u5757\u5185\u90e8\u5305\u542b\u6709\u2f00\u4e2aPendingTask\u961f\u5217：\u7ec4\u4ef6\u4f7f\u2f64\u8005\u5c06\u5bf9Connection\u8fdb\u2f8f\u7684\u6240\u6709\u64cd\u4f5c， \u90fd\u52a0\u2f0a\u5230\u4efb\u52a1\u961f\u5217\u4e2d，\u7531EventLoop\u6a21\u5757\u8fdb\u2f8f\u7ba1\u7406，\u5e76\u5728EventLoop\u5bf9\u5e94\u7684\u7ebf\u7a0b\u4e2d\u8fdb\u2f8f\u6267\u2f8f\u3002 <\/span> <\/p>\n

\u2022 <\/span>
\n \u6bcf\u2f00\u4e2aConnection\u5bf9\u8c61\u90fd\u4f1a\u7ed1\u5b9a\u5230\u2f00\u4e2aEventLoop\u4e0a，\u8fd9\u6837\u80fd\u4fdd\u8bc1\u5bf9\u8fd9\u4e2a\u8fde\u63a5\u7684\u6240\u6709\u64cd\u4f5c\u90fd\u662f\u5728 <\/span> <\/p>\n

\u2f00\u4e2a\u7ebf\u7a0b\u4e2d\u5b8c\u6210\u7684\u3002 <\/span> <\/p>\n

\u5177\u4f53\u64cd\u4f5c\u6d41\u7a0b： <\/span> <\/p>\n

1. <\/span>
\n \u901a\u8fc7Poller\u6a21\u5757\u5bf9\u5f53\u524d\u6a21\u5757\u7ba1\u7406\u5185\u7684\u6240\u6709\u63cf\u8ff0\u7b26\u8fdb\u2f8fIO\u4e8b\u4ef6\u76d1\u63a7，\u6709\u63cf\u8ff0\u7b26\u4e8b\u4ef6\u5c31\u7eea\u540e，\u901a\u8fc7\u63cf\u8ff0 \u7b26\u5bf9\u5e94\u7684Channel\u8fdb\u2f8f\u4e8b\u4ef6\u5904\u7406\u3002 <\/span> <\/p>\n

2. <\/span>
\n \u6240\u6709\u5c31\u7eea\u7684\u63cf\u8ff0\u7b26IO\u4e8b\u4ef6\u5904\u7406\u5b8c\u6bd5\u540e，\u5bf9\u4efb\u52a1\u961f\u5217\u4e2d\u7684\u6240\u6709\u64cd\u4f5c\u987a\u5e8f\u8fdb\u2f8f\u6267\u2f8f\u3002 <\/span> <\/p>\n

3. <\/span>
\n \u7531\u4e8eepoll\u7684\u4e8b\u4ef6\u76d1\u63a7，\u6709\u53ef\u80fd\u4f1a\u56e0\u4e3a\u6ca1\u6709\u4e8b\u4ef6\u5230\u6765\u2f7d\u6301\u7eed\u963b\u585e，\u5bfc\u81f4\u4efb\u52a1\u961f\u5217\u4e2d\u7684\u4efb\u52a1\u4e0d\u80fd\u53ca\u65f6\u5f97 \u5230\u6267\u2f8f，\u56e0\u6b64\u521b\u5efa\u4e86eventfd，\u6dfb\u52a0\u5230Poller\u7684\u4e8b\u4ef6\u76d1\u63a7\u4e2d，\u2f64\u4e8e\u5b9e\u73b0\u6bcf\u6b21\u5411\u4efb\u52a1\u961f\u5217\u6dfb\u52a0\u4efb\u52a1\u7684\u65f6 \u5019，\u901a\u8fc7\u5411eventfd\u5199\u2f0a\u6570\u636e\u6765\u5524\u9192epoll\u7684\u963b\u585e\u3002 <\/span> <\/p>\n

\"\" <\/p>\n

TcpServer\u6a21\u5757： <\/span><\/h4>\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 <\/span> <\/p>\n

\u5757\u3002 <\/span> <\/p>\n

\u2022 <\/span>
\n TcpServer\u4e2d\u5305\u542b\u6709\u2f00\u4e2aEventLoop\u5bf9\u8c61：\u4ee5\u5907\u5728\u8d85\u8f7b\u91cf\u4f7f\u2f64\u573a\u666f\u4e2d\u4e0d\u9700\u8981EventLoop\u7ebf\u7a0b\u6c60，\u53ea <\/span> <\/p>\n

\u9700\u8981\u5728\u4e3b\u7ebf\u7a0b\u4e2d\u5b8c\u6210\u6240\u6709\u64cd\u4f5c\u7684\u60c5\u51b5\u3002 <\/span> <\/p>\n

\u2022 <\/span>
\n TcpServer\u6a21\u5757\u5185\u90e8\u5305\u542b\u6709\u2f00\u4e2aEventLoopThreadPool\u5bf9\u8c61：\u5176\u5b9e\u5c31\u662fEventLoop\u7ebf\u7a0b\u6c60，\u4e5f\u5c31\u662f <\/span> <\/p>\n

\u2f26Reactor\u7ebf\u7a0b\u6c60 <\/span> <\/p>\n

\u2022 <\/span>
\n TcpServer\u6a21\u5757\u5185\u90e8\u5305\u542b\u6709\u2f00\u4e2aAcceptor\u5bf9\u8c61：\u2f00\u4e2aTcpServer\u670d\u52a1\u5668，\u5fc5\u7136\u5bf9\u5e94\u6709\u2f00\u4e2a\u76d1\u542c\u5957\u63a5 <\/span> <\/p>\n

\u5b57，\u80fd\u591f\u5b8c\u6210\u83b7\u53d6\u5ba2\u2f3e\u7aef\u65b0\u8fde\u63a5，\u5e76\u5904\u7406\u7684\u4efb\u52a1\u3002 <\/span> <\/p>\n

\u2022 <\/span>
\n TcpServer\u6a21\u5757\u5185\u90e8\u5305\u542b\u6709\u2f00\u4e2astd::shared_ptr<Connection>\u7684hash\u8868：\u4fdd\u5b58\u4e86\u6240\u6709\u7684\u65b0\u5efa\u8fde\u63a5 <\/span> <\/p>\n

\u5bf9\u5e94\u7684Connection，\u6ce8\u610f，\u6240\u6709\u7684Connection\u4f7f\u2f64shared_ptr\u8fdb\u2f8f\u7ba1\u7406，\u8fd9\u6837\u80fd\u591f\u4fdd\u8bc1\u5728hash\u8868 <\/span> <\/p>\n

\u4e2d\u5220\u9664\u4e86Connection\u4fe1\u606f\u540e，\u5728shared_ptr\u8ba1\u6570\u5668\u4e3a0\u7684\u60c5\u51b5\u4e0b\u5b8c\u6210\u5bf9Connection\u8d44\u6e90\u7684\u91ca\u653e\u64cd <\/span> <\/p>\n

\u4f5c\u3002 <\/span> <\/p>\n

\u5177\u4f53\u64cd\u4f5c\u6d41\u7a0b\u5982\u4e0b： <\/span> <\/p>\n

1. <\/span>
\n \u5728\u5b9e\u4f8b\u5316TcpServer\u5bf9\u8c61\u8fc7\u7a0b\u4e2d，\u5b8c\u6210BaseLoop\u7684\u8bbe\u7f6e，Acceptor\u5bf9\u8c61\u7684\u5b9e\u4f8b\u5316，\u4ee5\u53caEventLoop <\/span> <\/p>\n

\u7ebf\u7a0b\u6c60\u7684\u5b9e\u4f8b\u5316，\u4ee5\u53castd::shared_ptr<Connection>\u7684hash\u8868\u7684\u5b9e\u4f8b\u5316\u3002 <\/span> <\/p>\n

2. <\/span>
\n \u4e3aAcceptor\u5bf9\u8c61\u8bbe\u7f6e\u56de\u8c03\u51fd\u6570：\u83b7\u53d6\u5230\u65b0\u8fde\u63a5\u540e，\u4e3a\u65b0\u8fde\u63a5\u6784\u5efaConnection\u5bf9\u8c61，\u8bbe\u7f6e <\/span> <\/p>\n

Connection\u7684\u5404\u9879\u56de\u8c03，\u5e76\u4f7f\u2f64shared_ptr\u8fdb\u2f8f\u7ba1\u7406，\u5e76\u6dfb\u52a0\u5230hash\u8868\u4e2d\u8fdb\u2f8f\u7ba1\u7406，\u5e76\u4e3a <\/span> <\/p>\n

Connection\u9009\u62e9\u2f00\u4e2aEventLoop\u7ebf\u7a0b，\u4e3aConnection\u6dfb\u52a0\u2f00\u4e2a\u5b9a\u65f6\u9500\u6bc1\u4efb\u52a1，\u4e3aConnection\u6dfb\u52a0 <\/span> <\/p>\n

\u4e8b\u4ef6\u76d1\u63a7， <\/span> <\/p>\n

3. <\/span>
\n \u542f\u52a8BaseLoop\u3002<\/span> <\/p>\n

\"\" <\/p>\n

\u4e0b\u9762\u662f\u6a21\u5757\u4e4b\u95f4\u7684\u5173\u7cfb\u56fe <\/p>\n

\u6a21\u5757\u5173\u7cfb\u56fe<\/h3>\n

\"\" <\/p>\n

\u65f6\u95f4\u8f6e\u601d\u60f3： <\/span><\/h3>\n

\u4e0a\u8ff0\u7684\u4f8b\u2f26，\u5b58\u5728\u2f00\u4e2a\u5f88\u2f24\u7684\u95ee\u9898，\u6bcf\u6b21\u8d85\u65f6\u90fd\u8981\u5c06\u6240\u6709\u7684\u8fde\u63a5\u904d\u5386\u2f00\u904d，\u5982\u679c\u6709\u4e0a\u4e07\u4e2a\u8fde\u63a5，\u6548\u7387 \u2f46\u7591\u662f\u8f83\u4e3a\u4f4e\u4e0b\u7684\u3002 <\/span> <\/p>\n

\u8fd9\u65f6\u5019\u2f24\u5bb6\u5c31\u4f1a\u60f3\u5230，\u6211\u4eec\u53ef\u4ee5\u9488\u5bf9\u6240\u6709\u7684\u8fde\u63a5，\u6839\u636e\u6bcf\u4e2a\u8fde\u63a5\u6700\u8fd1\u2f00\u6b21\u901a\u4fe1\u7684\u7cfb\u7edf\u65f6\u95f4\u5efa\u2f74\u2f00\u4e2a\u2f29 \u6839\u5806，\u8fd9\u6837\u53ea\u9700\u8981\u6bcf\u6b21\u9488\u5bf9\u5806\u9876\u90e8\u5206\u7684\u8fde\u63a5\u9010\u4e2a\u91ca\u653e，\u76f4\u5230\u6ca1\u6709\u8d85\u65f6\u7684\u8fde\u63a5\u4e3a\u2f4c，\u8fd9\u6837\u4e5f\u53ef\u4ee5\u2f24\u2f24\u63d0 \u2fbc\u5904\u7406\u7684\u6548\u7387\u3002 <\/span> <\/p>\n

\u4e0a\u8ff0\u2f45\u6cd5\u53ef\u4ee5\u5b9e\u73b0\u5b9a\u65f6\u4efb\u52a1，\u4f46\u662f\u8fd9\u2fa5\u7ed9\u2f24\u5bb6\u4ecb\u7ecd\u53e6\u2f00\u79cd\u2f45\u6848：\u65f6\u95f4\u8f6e <\/span> <\/p>\n

\u65f6\u95f4\u8f6e\u7684\u601d\u60f3\u6765\u6e90\u4e8e\u949f\u8868，\u5982\u679c\u6211\u4eec\u5b9a\u4e86\u2f00\u4e2a3\u70b9\u949f\u7684\u95f9\u94c3，\u5219\u5f53\u65f6\u9488\u2f9b\u52303\u7684\u65f6\u5019，\u5c31\u4ee3\u8868\u65f6\u95f4\u5230 <\/span> <\/p>\n

\u4e86\u3002 \u540c\u6837\u7684\u9053\u7406，\u5982\u679c\u6211\u4eec\u5b9a\u4e49\u4e86\u2f00\u4e2a\u6570\u7ec4，\u5e76\u4e14\u6709\u2f00\u4e2a\u6307\u9488，\u6307\u5411\u6570\u7ec4\u8d77\u59cb\u4f4d\u7f6e，\u8fd9\u4e2a\u6307\u9488\u6bcf\u79d2\u949f\u5411\u540e \u2f9b\u52a8\u2f00\u6b65，\u2f9b\u5230\u54ea\u2fa5，\u5219\u4ee3\u8868\u54ea\u2fa5\u7684\u4efb\u52a1\u8be5\u88ab\u6267\u2f8f\u4e86，\u90a3\u4e48\u5982\u679c\u6211\u4eec\u60f3\u8981\u5b9a\u2f00\u4e2a3s\u540e\u7684\u4efb\u52a1，\u5219\u53ea\u9700 \u8981\u5c06\u4efb\u52a1\u6dfb\u52a0\u5230tick+3\u4f4d\u7f6e，\u5219\u6bcf\u79d2\u4e2d\u2f9b\u2f00\u6b65，\u4e09\u79d2\u949f\u540etick\u2f9b\u5230\u5bf9\u5e94\u4f4d\u7f6e，\u8fd9\u65f6\u5019\u6267\u2f8f\u5bf9\u5e94\u4f4d\u7f6e\u7684\u4efb \u52a1\u5373\u53ef<\/span>
\n \u4f46\u662f，\u540c\u2f00\u65f6\u95f4\u53ef\u80fd\u4f1a\u6709\u2f24\u6279\u91cf\u7684\u5b9a\u65f6\u4efb\u52a1，\u56e0\u6b64\u6211\u4eec\u53ef\u4ee5\u7ed9\u6570\u7ec4\u5bf9\u5e94\u4f4d\u7f6e\u4e0b\u62c9\u2f00\u4e2a\u6570\u7ec4，\u8fd9\u6837\u5c31\u53ef<\/span>
\n \u4ee5\u5728\u540c\u2f00\u4e2a\u65f6\u523b\u4e0a\u6dfb\u52a0\u591a\u4e2a\u5b9a\u65f6\u4efb\u52a1\u4e86\u3002<\/span> <\/p>\n

\"\" <\/p>\n

\u5f53\u7136，\u4e0a\u8ff0\u64cd\u4f5c\u4e5f\u6709\u2f00\u4e9b\u7f3a\u9677，\u2f50\u5982\u6211\u4eec\u5982\u679c\u8981\u5b9a\u4e49\u2f00\u4e2a60s\u540e\u7684\u4efb\u52a1，\u5219\u9700\u8981\u5c06\u6570\u7ec4\u7684\u5143\u7d20\u4e2a\u6570\u8bbe\u7f6e \u4e3a60\u624d\u53ef\u4ee5，\u5982\u679c\u8bbe\u7f6e\u2f00\u2f29\u65f6\u540e\u7684\u5b9a\u65f6\u4efb\u52a1，\u5219\u9700\u8981\u5b9a\u4e493600\u4e2a\u5143\u7d20\u7684\u6570\u7ec4，\u8fd9\u6837\u2f46\u7591\u662f\u2f50\u8f83\u2fc7\u70e6 \u7684\u3002 <\/span> <\/p>\n

\u56e0\u6b64，\u53ef\u4ee5\u91c7\u2f64\u591a\u5c42\u7ea7\u7684\u65f6\u95f4\u8f6e，\u6709\u79d2\u9488\u8f6e，\u5206\u9488\u8f6e，\u65f6\u9488\u8f6e， 60<time<3600\u5219time\/60\u5c31\u662f\u5206\u9488\u8f6e \u5bf9\u5e94\u5b58\u50a8\u7684\u4f4d\u7f6e，\u5f53tick\/3600\u7b49\u4e8e\u5bf9\u5e94\u4f4d\u7f6e\u7684\u65f6\u5019，\u5c06\u5176\u4f4d\u7f6e\u7684\u4efb\u52a1\u5411\u5206\u9488，\u79d2\u9488\u8f6e\u8fdb\u2f8f\u79fb\u52a8\u3002 \u56e0\u4e3a\u5f53\u524d\u6211\u4eec\u7684\u5e94\u2f64\u4e2d，\u5012\u662f\u4e0d\u2f64\u8bbe\u8ba1\u7684\u8fd9\u4e48\u2fc7\u70e6，\u56e0\u4e3a\u6211\u4eec\u7684\u5b9a\u65f6\u4efb\u52a1\u901a\u5e38\u8bbe\u7f6e\u768430s\u4ee5\u5185，\u6240\u4ee5\u7b80 \u5355\u7684\u5355\u5c42\u65f6\u95f4\u8f6e\u5c31\u591f\u2f64\u4e86\u3002 <\/span> <\/p>\n

\u4f46\u662f，\u6211\u4eec\u4e5f\u5f97\u8003\u8651\u2f00\u4e2a\u95ee\u9898，\u5f53\u524d\u7684\u8bbe\u8ba1\u662f\u65f6\u95f4\u5230\u4e86，\u5219\u4e3b\u52a8\u53bb\u6267\u2f8f\u5b9a\u65f6\u4efb\u52a1，\u91ca\u653e\u8fde\u63a5，\u90a3\u80fd\u4e0d \u80fd\u5728\u65f6\u95f4\u5230\u4e86\u540e，\u2f83\u52a8\u6267\u2f8f\u5b9a\u65f6\u4efb\u52a1\u5462，\u8fd9\u65f6\u5019\u6211\u4eec\u5c31\u60f3\u5230\u2f00\u4e2a\u64cd\u4f5c-\u7c7b\u7684\u6790\u6784\u51fd\u6570\u3002 <\/span> <\/p>\n

\u2f00\u4e2a\u7c7b\u7684\u6790\u6784\u51fd\u6570，\u5728\u5bf9\u8c61\u88ab\u91ca\u653e\u65f6\u4f1a\u2f83\u52a8\u88ab\u6267\u2f8f，\u90a3\u4e48\u6211\u4eec\u5982\u679c\u5c06\u2f00\u4e2a\u5b9a\u65f6\u4efb\u52a1\u4f5c\u4e3a\u2f00\u4e2a\u7c7b\u7684\u6790\u6784 \u51fd\u6570\u5185\u7684\u64cd\u4f5c，\u5219\u8fd9\u4e2a\u5b9a\u65f6\u4efb\u52a1\u5728\u5bf9\u8c61\u88ab\u91ca\u653e\u7684\u65f6\u5019\u5c31\u4f1a\u6267\u2f8f\u3002 <\/span> <\/p>\n

\u4f46\u662f\u4ec5\u4ec5\u4e3a\u4e86\u8fd9\u4e2a\u2f6c\u7684，\u2f7d\u8bbe\u8ba1\u2f00\u4e2a\u989d\u5916\u7684\u4efb\u52a1\u7c7b，\u597d\u50cf\u6709\u4e9b\u4e0d\u5212\u7b97，\u4f46\u662f，\u8fd9\u2fa5\u6211\u4eec\u2f1c\u8981\u8003\u8651\u53e6\u2f00 \u4e2a\u95ee\u9898，\u90a3\u5c31\u662f\u5047\u5982\u6709\u2f00\u4e2a\u8fde\u63a5\u5efa\u2f74\u6210\u529f\u4e86，\u6211\u4eec\u7ed9\u8fd9\u4e2a\u8fde\u63a5\u8bbe\u7f6e\u4e86\u2f00\u4e2a30s\u540e\u7684\u5b9a\u65f6\u9500\u6bc1\u4efb\u52a1，\u4f46\u662f <\/span> <\/p>\n

\u5728\u7b2c10s\u7684\u65f6\u5019，\u8fd9\u4e2a\u8fde\u63a5\u8fdb\u2f8f\u4e86\u2f00\u6b21\u901a\u4fe1，\u90a3\u4e48\u6211\u4eec\u5e94\u8be5\u65f6\u5728\u7b2c30s\u7684\u65f6\u5019\u5173\u95ed，\u8fd8\u662f\u7b2c40s\u7684\u65f6\u5019\u5173 \u95ed\u5462？\u2f46\u7591\u5e94\u8be5\u662f\u7b2c40s\u7684\u65f6\u5019\u3002\u4e5f\u5c31\u662f\u8bf4，\u8fd9\u65f6\u5019，\u6211\u4eec\u9700\u8981\u8ba9\u8fd9\u4e2a\u7b2c30s\u7684\u4efb\u52a1\u5931\u6548，\u4f46\u662f\u6211\u4eec\u8be5 \u5982\u4f55\u5b9e\u73b0\u8fd9\u4e2a\u64cd\u4f5c\u5462？ <\/span> <\/p>\n

\u8fd9\u2fa5，\u6211\u4eec\u5c31\u2f64\u5230\u4e86\u667a\u80fd\u6307\u9488shared_ptr，shared_ptr\u6709\u4e2a\u8ba1\u6570\u5668，\u5f53\u8ba1\u6570\u4e3a0\u7684\u65f6\u5019，\u624d\u4f1a\u771f\u6b63\u91ca\u653e \u2f00\u4e2a\u5bf9\u8c61，\u90a3\u4e48\u5982\u679c\u8fde\u63a5\u5728\u7b2c10s\u8fdb\u2f8f\u4e86\u2f00\u6b21\u901a\u4fe1，\u5219\u6211\u4eec\u7ee7\u7eed\u5411\u5b9a\u65f6\u4efb\u52a1\u4e2d，\u6dfb\u52a0\u2f00\u4e2a30s\u540e（\u4e5f\u5c31 <\/span> <\/p>\n

\u662f\u7b2c40s）\u7684\u4efb\u52a1\u7c7b\u5bf9\u8c61\u7684shared_ptr，\u5219\u8fd9\u65f6\u5019\u4e24\u4e2a\u4efb\u52a1shared_ptr\u8ba1\u6570\u4e3a2，\u5219\u7b2c30s\u7684\u5b9a\u65f6\u4efb\u52a1 \u88ab\u91ca\u653e\u7684\u65f6\u5019，\u8ba1\u6570-1，\u53d8\u4e3a1，\u5e76\u4e0d\u4e3a0，\u5219\u5e76\u4e0d\u4f1a\u6267\u2f8f\u5b9e\u9645\u7684\u6790\u6784\u51fd\u6570，\u90a3\u4e48\u5c31\u76f8\u5f53\u4e8e\u8fd9\u4e2a\u7b2c30s\u7684 \u4efb\u52a1\u5931\u6548\u4e86，\u53ea\u6709\u5728\u7b2c40s\u7684\u65f6\u5019，\u8fd9\u4e2a\u4efb\u52a1\u624d\u4f1a\u88ab\u771f\u6b63\u91ca\u653e\u3002 <\/span> <\/p>\n

\u4e0a\u8ff0\u8fc7\u7a0b\u5c31\u662f\u65f6\u95f4\u8f6e\u5b9a\u65f6\u4efb\u52a1\u7684\u601d\u60f3\u4e86，\u5f53\u7136\u8fd9\u2fa5\u4e3a\u4e86\u66f4\u52a0\u7b80\u4fbf\u7684\u5b9e\u73b0，\u8fdb\u2f8f\u4e86\u2f00\u4e9b\u2f29\u2f29\u7684\u8c03\u6574\u5b9e <\/span> <\/p>\n

\u73b0\u3002<\/span> <\/p>\n

\u5177\u4f53\u6a21\u5757\u5b9e\u73b0\u4ee3\u7801\u5982\u4e0b<\/span> <\/p>\n

#include <iostream>
\n#include <vector>
\n#include <unordered_map>
\n#include <functional>
\n#include <cstdint>
\n#include <memory>
\n#include <unistd.h><\/p>\n

using TaskFunc = std::function<void()>;
\nusing ReleaseFunc = std::function<void()>;
\nclass TimerTask
\n{
\n uint64_t _id; \/\/ \u5b9a\u65f6\u5668\u7684ID
\n uint64_t _timeout; \/\/ \u8d85\u65f6\u65f6\u95f4
\n bool _canceled; \/\/\u53d6\u6d88\u5b9a\u65f6\u4efb\u52a1
\n TaskFunc _task_cb; \/\/ \u56de\u8c03\u51fd\u6570\u7684\u4efb\u52a1
\n ReleaseFunc _release; \/\/ \u6e05\u695a\u65f6\u95f4\u8f6e\u4e2d\u7684\u8bb0\u5f55<\/p>\n

public:
\n TimerTask(uint64_t id, uint64_t timeout, TaskFunc cb)
\n : _id(id),
\n _timeout(timeout),
\n _task_cb(cb),
\n _canceled(false)
\n {
\n }<\/p>\n

void SetRelease(ReleaseFunc release)
\n {
\n _release = release;
\n }<\/p>\n

~TimerTask()
\n {
\n if(!_canceled)
\n _task_cb();
\n _release();
\n }<\/p>\n

void Cancel()
\n {
\n _canceled=true;
\n }<\/p>\n

uint32_t DelayTime()
\n {
\n return _timeout;
\n }
\n};<\/p>\n

class TimeWheel
\n{
\nprivate:
\n using WeakTask = std::weak_ptr<TimerTask>;
\n using PtrTask = std::shared_ptr<TimerTask>;
\n int _tick; \/\/ \u79d2\u9488
\n int _capacity; \/\/ \u6700\u5927\u5b9a\u65f6\u65f6\u95f4
\n std::vector<std::vector<PtrTask>> _timeWheel; \/\/ \u65f6\u95f4\u8f6e
\n std::unordered_map<uint32_t, WeakTask> _timers; \/\/ \u7528\u6765\u4fdd\u5b58\u5b9a\u65f6\u5668\u7684\u4fe1\u606f
\nprivate:
\n void RemoveTimer(uint64_t id)
\n {
\n auto it = _timers.find(id);
\n if (it != _timers.end())
\n {
\n _timers.erase(it);
\n }
\n }<\/p>\n

public:
\n TimeWheel()
\n : _tick(0),
\n _capacity(60),
\n _timeWheel(_capacity)
\n {
\n }<\/p>\n

void TimerAdd(uint64_t id, uint64_t timeout, TaskFunc cb)
\n {
\n PtrTask pt(new TimerTask(id, timeout, cb)); \/\/ \u521b\u5efa\u4efb\u52a1<\/p>\n

pt->SetRelease(std::bind(&TimeWheel::RemoveTimer, this, id)); \/\/ \u8bbe\u7f6e\u5220\u9664\u51fd\u6570\u56de\u8c03
\n int pos = (_tick + pt->DelayTime()) % _capacity; \/\/ \u627e\u5230\u8981\u63d2\u5165\u5230\u65f6\u95f4\u8f6e\u7684\u4f4d\u7f6e
\n _timeWheel[pos].push_back(pt); \/\/ \u63d2\u5165\u65f6\u95f4\u8f6e
\n _timers[id] = WeakTask(pt); \/\/ \u4fdd\u5b58\u5b9a\u65f6\u5668\u7684\u4fe1\u606f
\n }<\/p>\n

void TimerRefresh(uint64_t id)
\n {
\n auto it = _timers.find(id);
\n if (it == _timers.end())
\n {
\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 int pos = (_tick + pt->DelayTime()) % _capacity; \/\/ \u627e\u5230\u8981\u63d2\u5165\u5230\u65f6\u95f4\u8f6e\u7684\u4f4d\u7f6e
\n _timeWheel[pos].push_back(pt); \/\/ \u63d2\u5165\u65f6\u95f4\u8f6e
\n }<\/p>\n

void TimerCancel(uint64_t id)
\n {
\n auto it = _timers.find(id);
\n if (it == _timers.end())
\n {
\n return; \/\/ \u6ca1\u627e\u7740\u5b9a\u65f6\u4efb\u52a1，\u6ca1\u6cd5\u5237\u65b0，\u6ca1\u6cd5\u5ef6\u8fdf
\n }<\/p>\n

PtrTask pt=it->second.lock();
\n pt->Cancel();<\/p>\n

}<\/p>\n

void RunTimerTask()
\n {
\n _tick=(_tick+1)%_capacity;
\n _timeWheel[_tick].clear();
\n }
\n};<\/p>\n

\/\/\u6d4b\u8bd5\u4ee3\u7801
\n\/*
\nclass Test {
\n public:
\n Test() {std::cout << "\u6784\u9020" << std::endl;}
\n ~Test() {std::cout << "\u6790\u6784" << std::endl;}
\n};<\/p>\n

void DelTest(Test *t) {
\n delete t;
\n}<\/p>\n

int main()
\n{
\n TimeWheel tw;<\/p>\n

Test *t = new Test();
\n std::cout<<1<<std::endl;
\n tw.TimerAdd(888, 5, std::bind(DelTest, t));<\/p>\n

for(int i = 0; i < 5; i++) {
\n sleep(1);
\n \/\/std::cout<<1<<std::endl;
\n tw.TimerRefresh(888);\/\/\u5237\u65b0\u5b9a\u65f6\u4efb\u52a1
\n \/\/std::cout<<2<<std::endl;
\n tw.RunTimerTask();\/\/\u5411\u540e\u79fb\u52a8\u79d2\u9488<\/p>\n

std::cout << "\u5237\u65b0\u4e86\u4e00\u4e0b\u5b9a\u65f6\u4efb\u52a1，\u91cd\u65b0\u9700\u89815s\u4e2d\u540e\u624d\u4f1a\u9500\u6bc1\\\\n";
\n }
\n \/\/tw.TimerCancel(888);
\n while(1) {
\n sleep(1);
\n std::cout << "——————-\\\\n";
\n tw.RunTimerTask();\/\/\u5411\u540e\u79fb\u52a8\u79d2\u9488
\n }
\n return 0;
\n}*\/ <\/p>\n

\u6b63\u5219\u5e93\u7684\u7b80\u5355\u4f7f\u2f64： <\/span><\/h3>\n

\u6b63\u5219\u8868\u8fbe\u5f0f(regular expression)\u63cf\u8ff0\u4e86\u2f00\u79cd\u5b57\u7b26\u4e32\u5339\u914d\u7684\u6a21\u5f0f（pattern），\u53ef\u4ee5\u2f64\u6765\u68c0\u67e5\u2f00\u4e2a\u4e32\u662f\u5426 \u542b\u6709\u67d0\u79cd\u2f26\u4e32\u3001\u5c06\u5339\u914d\u7684\u2f26\u4e32\u66ff\u6362\u6216\u8005\u4ece\u67d0\u4e2a\u4e32\u4e2d\u53d6\u51fa\u7b26\u5408\u67d0\u4e2a\u6761\u4ef6\u7684\u2f26\u4e32\u7b49\u3002 <\/span> <\/p>\n

\u6b63\u5219\u8868\u8fbe\u5f0f\u7684\u4f7f\u2f64，\u53ef\u4ee5\u4f7f\u5f97HTTP\u8bf7\u6c42\u7684\u89e3\u6790\u66f4\u52a0\u7b80\u5355（\u8fd9\u2fa5\u6307\u7684\u65f6\u7a0b\u5e8f\u5458\u7684\u2f2f\u4f5c\u53d8\u5f97\u7684\u7b80\u5355，\u8fd9\u5e76 \u4e0d\u4ee3\u8868\u5904\u7406\u6548\u7387\u4f1a\u53d8\u2fbc，\u5b9e\u9645\u4e0a\u6548\u7387\u4e0a\u662f\u4f4e\u4e8e\u76f4\u63a5\u7684\u5b57\u7b26\u4e32\u5904\u7406\u7684），\u4f7f\u6211\u4eec\u5b9e\u73b0\u7684HTTP\u7ec4\u4ef6\u5e93\u4f7f\u2f64 \u8d77\u6765\u66f4\u52a0\u7075\u6d3b\u3002<\/span> <\/p>\n

\"\". <\/p>\n

\u4f8b\u5982\u4e0b\u56fe\u5c31\u662f\u4e00\u4e2a\u5173\u4e8e\u6b63\u5219\u8868\u8fbe\u5f0f\u4f7f\u7528\u7684\u6848\u4f8b，\u66f4\u591a\u7684\u89c4\u5219\u53ef\u4ee5\u6839\u636e\u9700\u6c42\u53bb\u67e5\u8be2\u3002 <\/p>\n

\"\" <\/p>\n

\u901a\u2f64\u7c7b\u578bany\u7c7b\u578b\u7684\u5b9e\u73b0： <\/span><\/h3>\n

\u6bcf\u2f00\u4e2aConnection\u5bf9\u8fde\u63a5\u8fdb\u2f8f\u7ba1\u7406，\u6700\u7ec8\u90fd\u4e0d\u53ef\u907f\u514d\u9700\u8981\u6d89\u53ca\u5230\u5e94\u2f64\u5c42\u534f\u8bae\u7684\u5904\u7406，\u56e0\u6b64\u5728 <\/span> <\/p>\n

Connection\u4e2d\u9700\u8981\u8bbe\u7f6e\u534f\u8bae\u5904\u7406\u7684\u4e0a\u4e0b\u2f42\u6765\u63a7\u5236\u5904\u7406\u8282\u594f\u3002\u4f46\u662f\u5e94\u2f64\u5c42\u534f\u8bae\u5343\u5343\u4e07，\u4e3a\u4e86\u964d\u4f4e\u8026\u5408 <\/span> <\/p>\n

\u5ea6，\u8fd9\u4e2a\u534f\u8bae\u63a5\u6536\u89e3\u6790\u4e0a\u4e0b\u2f42\u5c31\u4e0d\u80fd\u6709\u660e\u663e\u7684\u534f\u8bae\u503e\u5411，\u5b83\u53ef\u4ee5\u662f\u4efb\u610f\u534f\u8bae\u7684\u4e0a\u4e0b\u2f42\u4fe1\u606f，\u56e0\u6b64\u5c31\u9700 \u8981\u2f00\u4e2a\u901a\u2f64\u7684\u7c7b\u578b\u6765\u4fdd\u5b58\u5404\u79cd\u4e0d\u540c\u7684\u6570\u636e\u7ed3\u6784\u3002 <\/span> <\/p>\n

\u5728C\u8bed\u2f94\u4e2d，\u901a\u2f64\u7c7b\u578b\u53ef\u4ee5\u4f7f\u2f64void*\u6765\u7ba1\u7406，\u4f46\u662f\u5728C++\u4e2d，boost\u5e93\u548cC++17\u7ed9\u6211\u4eec\u63d0\u4f9b\u4e86\u2f00\u4e2a\u901a\u2f64 \u7c7b\u578bany\u6765\u7075\u6d3b\u4f7f\u2f64，\u5982\u679c\u8003\u8651\u589e\u52a0\u4ee3\u7801\u7684\u79fb\u690d\u6027，\u5c3d\u91cf\u51cf\u5c11\u7b2c\u4e09\u2f45\u5e93\u7684\u4f9d\u8d56，\u5219\u53ef\u4ee5\u4f7f\u2f64C++17\u7279\u6027\u4e2d\u7684any，\u6216\u8005\u2f83\u2f30\u6765\u5b9e\u73b0\u3002\u2f7d\u8fd9\u4e2aany\u901a\u2f64\u7c7b\u578b\u7c7b\u7684\u5b9e\u73b0\u5176\u5b9e\u5e76\u4e0d\u590d\u6742，\u4ee5\u4e0b\u662f\u7b80\u5355\u7684\u90e8\u5206\u5b9e\u73b0\u3002 <\/span> <\/p>\n

\u4e3b\u8981\u8bbe\u8ba1\u601d\u8def\u5982\u4e0b\u56fe<\/span> <\/p>\n

\"\" <\/p>\n

\u2fb8\u5148<\/span>Any<\/span>\u7c7b\u80af\u5b9a\u4e0d\u80fd\u662f\u2f00\u4e2a\u6a21\u677f\u7c7b，\u5426\u5219\u7f16\u8bd1\u7684\u65f6\u5019<\/span> Any<int> a, Any<float>b,<\/span>\u9700\u8981\u4f20\u7c7b\u578b\u4f5c <\/span> <\/p>\n

\u4e3a\u6a21\u677f\u53c2\u6570，\u4e5f\u5c31\u662f\u8bf4\u5728\u4f7f\u2f64\u7684\u65f6\u5019\u5c31\u8981\u786e\u5b9a\u5176\u7c7b\u578b<\/span> <\/p>\n

\u8fd9\u662f\u2f8f\u4e0d\u901a\u7684，\u56e0\u4e3a\u4fdd\u5b58\u5728<\/span>Content<\/span>\u4e2d\u7684\u534f\u8bae\u4e0a\u4e0b\u2f42，\u6211\u4eec\u5728\u5b9a\u4e49<\/span>any<\/span>\u5bf9\u8c61\u7684\u65f6\u5019\u662f\u4e0d\u77e5\u9053\u4ed6\u4eec\u7684\u534f <\/span>
\n \u8bae\u7c7b\u578b\u7684，\u56e0\u6b64\u2f46\u6cd5\u4f20\u9012\u7c7b\u578b\u4f5c\u4e3a\u6a21\u677f\u53c2\u6570<\/span> <\/p>\n

\u56e0\u6b64\u8003\u8651<\/span>Any<\/span>\u5185\u90e8\u8bbe\u8ba1\u2f00\u4e2a\u6a21\u677f\u5bb9\u5668<\/span>holder<\/span>\u7c7b，\u53ef\u4ee5\u4fdd\u5b58\u5404\u79cd\u7c7b\u578b\u6570\u636e<\/span> <\/p>\n

\u2f7d\u56e0\u4e3a\u5728<\/span>Any<\/span>\u7c7b\u4e2d\u2f46\u6cd5\u5b9a\u4e49\u8fd9\u4e2a<\/span>holder<\/span>\u5bf9\u8c61\u6216\u6307\u9488，\u56e0\u4e3a<\/span>any<\/span>\u4e5f\u4e0d\u77e5\u9053\u8fd9\u4e2a\u7c7b\u8981\u4fdd\u5b58\u4ec0\u4e48\u7c7b\u578b\u7684\u6570 <\/span> <\/p>\n

\u636e，\u56e0\u6b64\u2f46\u6cd5\u4f20\u9012\u7c7b\u578b\u53c2\u6570<\/span>
\n \u6240\u4ee5，\u5b9a\u4e49\u2f00\u4e2a\u57fa\u7c7b<\/span>placehoder<\/span>，\u8ba9<\/span>holder<\/span>\u7ee7\u627f\u4e8e<\/span>placeholde<\/span>，\u2f7d<\/span>Any<\/span>\u7c7b\u4fdd\u5b58\u2f57\u7c7b\u6307\u9488\u5373\u53ef<\/span>
\n \u5f53\u9700\u8981\u4fdd\u5b58\u6570\u636e\u65f6，\u5219<\/span>new<\/span>\u2f00\u4e2a\u5e26\u6709\u6a21\u677f\u53c2\u6570\u7684\u2f26\u7c7b<\/span>holder<\/span>\u5bf9\u8c61\u51fa\u6765\u4fdd\u5b58\u6570\u636e，\u7136\u540e\u8ba9<\/span>Any<\/span>\u7c7b\u4e2d\u7684\u2f57 <\/span>\u7c7b\u6307\u9488，\u6307\u5411\u8fd9\u4e2a\u2f26\u7c7b\u5bf9\u8c61\u5c31\u641e\u5b9a\u4e86<\/span> <\/p>\n

#include <iostream>
\n#include <typeinfo>
\n#include <string>
\nclass Any
\n{
\nprivate:
\n class holder
\n {
\n public:
\n holder(){}
\n virtual const std::type_info &type() = 0; \/\/ \u8fd4\u56de\u4fdd\u5b58\u6570\u636e\u7684\u7c7b\u578b
\n virtual holder *clone() = 0; \/\/ \u514b\u9686\u81ea\u8eab
\n };<\/p>\n

template <class T>
\n class placeHolder : public holder
\n {
\n public:
\n placeHolder(const T &val)
\n : _val(val)
\n {
\n }<\/p>\n

virtual const std::type_info &type()
\n {
\n return typeid(_val);
\n }<\/p>\n

virtual placeHolder *clone()
\n {
\n return new placeHolder(_val);
\n }<\/p>\n

T _val;
\n };
\n holder *_content;<\/p>\n

public:
\n \/\/\u65e0\u53c2\u6784\u9020
\n Any() : _content(nullptr) {}
\n \/\/\u6709\u53c2\u6784\u9020
\n template <class T>
\n Any(const T val)
\n : _content(new placeHolder<T>(val))
\n {
\n }<\/p>\n

\/\/\u514b\u9686\u51fd\u6570
\n Any(const Any &other)
\n : _content(other._content == nullptr ? nullptr : other._content->clone()) {} \/\/ \u8fd9\u4e2a\u5730\u65b9\u7528\u5230\u4e86\u591a\u6001，\u7236\u7c7b\u6307\u9488\u8c03\u7528\u5b50\u7c7b\u7684clone\u51fd\u6570<\/p>\n

\/\/\u6790\u6784
\n ~Any()
\n {
\n delete _content;
\n }<\/p>\n

\/\/\u4ea4\u6362\u81ea\u8eab\u548c\u4f20\u5165\u5bf9\u8c61\u4fdd\u5b58\u7684\u5185\u5bb9
\n Any &Swap(Any &other)
\n {
\n std::swap(_content, other._content);
\n return *this;
\n }<\/p>\n

template <class T>
\n T *get()
\n {
\n if (typeid(T) != _content->type())
\n return nullptr;
\n else
\n return &(((placeHolder<T>*)_content)->_val);
\n }<\/p>\n

Any &operator=(const Any &other)
\n {
\n \/\/ \u4e3aval\u6784\u9020\u4e00\u4e2a\u4e34\u65f6\u7684\u901a\u7528\u5bb9\u5668，\u7136\u540e\u4e0e\u5f53\u524d\u5bb9\u5668\u81ea\u8eab\u8fdb\u884c\u6307\u9488\u4ea4\u6362，\u4e34\u65f6\u5bf9\u8c61\u91ca\u653e\u7684\u65f6\u5019，\u539f\u5148\u4fdd\u5b58\u7684\u6570\u636e\u4e5f\u5c31\u88ab\u91ca\u653e
\n Any(other).Swap(*this);
\n return *this;
\n }
\n template <class T>
\n Any &operator=(const T val)
\n {
\n Any(val).Swap(*this);
\n return *this;
\n }
\n};<\/p>\n

\/\/\u6d4b\u8bd5\u7528\u4f8b
\n\/*
\nclass Test{
\n public:
\n Test() {std::cout << "\u6784\u9020" << std::endl;}
\n Test(const Test &t) {std::cout << "\u62f7\u8d1d" << std::endl;}
\n ~Test() {std::cout << "\u6790\u6784" << std::endl;}
\n};
\nint main()
\n{<\/p>\n

Any a;<\/p>\n

a = 10;
\n int *pa = a.get<int>();
\n std::cout << *pa << std::endl;
\n a = std::string("nihao");
\n std::string *ps = a.get<std::string>();
\n std::cout << *ps << std::endl;<\/p>\n

return 0;
\n}*\/ <\/p>\n

<\/h3>\n

HTTP\u534f\u8bae\u6a21\u5757： <\/span><\/h3>\n

HTTP\u534f\u8bae\u6a21\u5757\u2f64\u4e8e\u5bf9\u2fbc\u5e76\u53d1\u670d\u52a1\u5668\u6a21\u5757\u8fdb\u2f8f\u534f\u8bae\u2f40\u6301，\u57fa\u4e8e\u63d0\u4f9b\u7684\u534f\u8bae\u2f40\u6301\u80fd\u591f\u66f4\u2f45\u4fbf\u7684\u5b8c\u6210\u6307\u5b9a\u534f \u8bae\u670d\u52a1\u5668\u7684\u642d\u5efa\u3002 <\/span> <\/p>\n

\u2f7dHTTP\u534f\u8bae\u2f40\u6301\u6a21\u5757\u7684\u5b9e\u73b0，\u53ef\u4ee5\u7ec6\u5206\u4e3a\u4ee5\u4e0b\u2f0f\u4e2a\u6a21\u5757\u3002 <\/span> <\/p>\n

Util\u6a21\u5757： <\/span><\/h4>\n

\u8fd9\u4e2a\u6a21\u5757\u662f\u2f00\u4e2a\u2f2f\u5177\u6a21\u5757，\u4e3b\u8981\u63d0\u4f9bHTTP\u534f\u8bae\u6a21\u5757\u6240\u2f64\u5230\u7684\u2f00\u4e9b\u2f2f\u5177\u51fd\u6570，\u2f50\u5982url\u7f16\u89e3\u7801，\u2f42\u4ef6\u8bfb \u5199….\u7b49\u3002 HttpRequest\u6a21\u5757： <\/span> <\/p>\n

\u8fd9\u4e2a\u6a21\u5757\u662fHTTP\u8bf7\u6c42\u6570\u636e\u6a21\u5757，\u2f64\u4e8e\u4fdd\u5b58HTTP\u8bf7\u6c42\u6570\u636e\u88ab\u89e3\u6790\u540e\u7684\u5404\u9879\u8bf7\u6c42\u5143\u7d20\u4fe1\u606f\u3002 <\/span> <\/p>\n

HttpResponse\u6a21\u5757： <\/span><\/h4>\n

\u8fd9\u4e2a\u6a21\u5757\u662fHTTP\u54cd\u5e94\u6570\u636e\u6a21\u5757，\u2f64\u4e8e\u4e1a\u52a1\u5904\u7406\u540e\u8bbe\u7f6e\u5e76\u4fdd\u5b58HTTP\u54cd\u5e94\u6570\u636e\u7684\u7684\u5404\u9879\u5143\u7d20\u4fe1\u606f，\u6700\u7ec8 \u4f1a\u88ab\u6309\u7167HTTP\u534f\u8bae\u54cd\u5e94\u683c\u5f0f\u7ec4\u7ec7\u6210\u4e3a\u54cd\u5e94\u4fe1\u606f\u53d1\u9001\u7ed9\u5ba2\u2f3e\u7aef\u3002<\/span> <\/p>\n

HttpContext\u6a21\u5757： <\/span><\/h4>\n

\u8fd9\u4e2a\u6a21\u5757\u662f\u2f00\u4e2aHTTP\u8bf7\u6c42\u63a5\u6536\u7684\u4e0a\u4e0b\u2f42\u6a21\u5757，\u4e3b\u8981\u662f\u4e3a\u4e86\u9632\u2f4c\u5728\u2f00\u6b21\u63a5\u6536\u7684\u6570\u636e\u4e2d，\u4e0d\u662f\u2f00\u4e2a\u5b8c\u6574\u7684 HTTP\u8bf7\u6c42，\u5219\u89e3\u6790\u8fc7\u7a0b\u5e76\u672a\u5b8c\u6210，\u2f46\u6cd5\u8fdb\u2f8f\u5b8c\u6574\u7684\u8bf7\u6c42\u5904\u7406，\u9700\u8981\u5728\u4e0b\u6b21\u63a5\u6536\u5230\u65b0\u6570\u636e\u540e\u7ee7\u7eed\u6839\u636e\u4e0a \u4e0b\u2f42\u8fdb\u2f8f\u89e3\u6790，\u6700\u7ec8\u5f97\u5230\u2f00\u4e2aHttpRequest\u8bf7\u6c42\u4fe1\u606f\u5bf9\u8c61，\u56e0\u6b64\u5728\u8bf7\u6c42\u6570\u636e\u7684\u63a5\u6536\u4ee5\u53ca\u89e3\u6790\u90e8\u5206\u9700\u8981\u2f00 \u4e2a\u4e0a\u4e0b\u2f42\u6765\u8fdb\u2f8f\u63a7\u5236\u63a5\u6536\u548c\u5904\u7406\u8282\u594f\u3002 <\/span> <\/p>\n

HttpServer\u6a21\u5757： <\/span><\/h4>\n

\u8fd9\u4e2a\u6a21\u5757\u662f\u6700\u7ec8\u7ed9\u7ec4\u4ef6\u4f7f\u2f64\u8005\u63d0\u4f9b\u7684HTTP\u670d\u52a1\u5668\u6a21\u5757\u4e86，\u2f64\u4e8e\u4ee5\u7b80\u5355\u7684\u63a5\u2f1d\u5b9e\u73b0HTTP\u670d\u52a1\u5668\u7684\u642d \u5efa\u3002 <\/span> <\/p>\n

HttpServer\u6a21\u5757\u5185\u90e8\u5305\u542b\u6709\u2f00\u4e2aTcpServer\u5bf9\u8c61：TcpServer\u5bf9\u8c61\u5b9e\u73b0\u670d\u52a1\u5668\u7684\u642d\u5efa <\/span> <\/p>\n

HttpServer\u6a21\u5757\u5185\u90e8\u5305\u542b\u6709\u4e24\u4e2a\u63d0\u4f9b\u7ed9TcpServer\u5bf9\u8c61\u7684\u63a5\u2f1d：\u8fde\u63a5\u5efa\u2f74\u6210\u529f\u8bbe\u7f6e\u4e0a\u4e0b\u2f42\u63a5\u2f1d，\u6570\u636e\u5904 \u7406\u63a5\u2f1d\u3002 <\/span> <\/p>\n

HttpServer\u6a21\u5757\u5185\u90e8\u5305\u542b\u6709\u2f00\u4e2ahash-map\u8868\u5b58\u50a8\u8bf7\u6c42\u4e0e\u5904\u7406\u51fd\u6570\u7684\u6620\u5c04\u8868：\u7ec4\u4ef6\u4f7f\u2f64\u8005\u5411 <\/span> <\/p>\n

HttpServer\u8bbe\u7f6e\u54ea\u4e9b\u8bf7\u6c42\u5e94\u8be5\u4f7f\u2f64\u54ea\u4e9b\u51fd\u6570\u8fdb\u2f8f\u5904\u7406，\u7b49TcpServer\u6536\u5230\u5bf9\u5e94\u7684\u8bf7\u6c42\u5c31\u4f1a\u4f7f\u2f64\u5bf9\u5e94\u7684\u51fd \u6570\u8fdb\u2f8f\u5904\u7406\u3002<\/span> <\/p>\n

\u4e09：\u6a21\u5757\u5b9e\u73b0<\/h2>\n

SERVER\u670d\u52a1\u5668\u6a21\u5757\u5b9e\u73b0： <\/span><\/h3>\n

\u7f13\u51b2\u533aBuffer\u7c7b\u5b9e\u73b0： <\/span><\/h4>\n

Buffer\u7c7b\u2f64\u4e8e\u5b9e\u73b0\u2f64\u2f3e\u6001\u7f13\u51b2\u533a，\u63d0\u4f9b\u6570\u636e\u7f13\u51b2，\u53d6\u51fa\u7b49\u529f\u80fd\u3002 <\/span> <\/p>\n

\"\" <\/p>\n

\"\" <\/p>\n

class Buffer
\n{
\n#define BUFFER_DEFAULT_SIZE 1024
\nprivate:
\n std::vector<char> _buffer;
\n uint64_t _reader_idx;\/\/\u8bfb\u4f4d\u7f6e\u7d22\u5f15
\n uint64_t _writer_idx;\/\/\u5199\u4f4d\u7f6e\u7d22\u5f15<\/p>\n

public:
\n Buffer()
\n : _reader_idx(0),
\n _writer_idx(0),
\n _buffer(BUFFER_DEFAULT_SIZE)
\n {
\n }
\n \/\/ \u8fd4\u56de\u8d77\u59cb\u4f4d\u7f6e
\n char *Begin()
\n {
\n return &*_buffer.begin();
\n }<\/p>\n

\/\/ \u83b7\u53d6\u5199\u5165\u4f4d\u7f6e
\n char *WritePosition()
\n {
\n return Begin() + _writer_idx;
\n }
\n \/\/ \u83b7\u53d6\u8bfb\u53d6\u4f4d\u7f6e
\n char *ReadPosition()
\n {
\n return Begin() + _reader_idx;
\n }
\n \/\/ \u83b7\u53d6\u5934\u5269\u4f59\u7a7a\u95f4
\n uint64_t HeadIdleSize()
\n {
\n return _reader_idx;
\n }
\n \/\/ \u83b7\u53d6\u5c3e\u90e8\u5269\u4f59\u7a7a\u95f4
\n uint64_t TailIdleSize()
\n {
\n return _buffer.size() – _writer_idx;
\n }
\n \/\/ \u83b7\u53d6\u53ef\u8bfb\u6570\u636e\u5927\u5c0f
\n uint64_t ReadAbleSize()
\n {
\n return _writer_idx – _reader_idx;
\n }
\n \/\/ \u5c06\u8bfb\u504f\u79fb\u5411\u540e\u79fb\u52a8
\n void MoveReadOffset(uint64_t len)
\n {
\n if (len == 0)
\n return;
\n \/\/ \u5411\u540e\u79fb\u52a8\u7684\u5927\u5c0f，\u5fc5\u987b\u5c0f\u4e8e\u53ef\u8bfb\u6570\u636e\u5927\u5c0f
\n if(len <= ReadAbleSize())
\n _reader_idx += len;
\n else ERR_LOG("MoveReadOffset ERROR");
\n }
\n \/\/ \u5c06\u5199\u504f\u79fb\u5411\u540e\u79fb\u52a8
\n void MoveWriteOffset(uint64_t len)
\n {
\n \/\/ \u5411\u540e\u79fb\u52a8\u7684\u5927\u5c0f，\u5fc5\u987b\u5c0f\u4e8e\u5f53\u524d\u540e\u8fb9\u7684\u7a7a\u95f2\u7a7a\u95f4\u5927\u5c0f
\n if(len <= TailIdleSize())
\n _writer_idx += len;
\n else ERR_LOG("MoveWriteOffset ERROR");
\n }
\n \/\/ \u786e\u4fdd\u53ef\u4ee5\u7a7a\u95f4\u8db3\u591f，\u5426\u5219\u5c31\u6269\u5bb9
\n void EnsureWriteSpace(uint64_t len)
\n {
\n if (TailIdleSize() >= len)
\n {
\n return;
\n }
\n else
\n {
\n if (len <= HeadIdleSize() + TailIdleSize())
\n {
\n \/\/ \u5982\u679c\u5934\u5c3e\u7a7a\u95f4\u8db3\u591f，\u5c31\u5c3d\u91cf\u8282\u7ea6\u7a7a\u95f4\u4e0d\u6269\u5bb9，\u53ea\u5c06\u7f13\u51b2\u533a\u91cd\u65b0\u6574\u7406\u5373\u53ef
\n \/\/ \u5c06\u6570\u636e\u79fb\u52a8\u5230\u5934\u90e8，\u5c06\u5934\u90e8\u548c\u5c3e\u90e8\u5269\u4f59\u7a7a\u95f4\u7ed3\u5408
\n uint64_t rsz = ReadAbleSize();
\n std::copy(ReadPosition(), ReadPosition() + rsz, Begin());
\n _reader_idx = 0;
\n _writer_idx = rsz;
\n }
\n else
\n {
\n \/\/ \u603b\u4f53\u7a7a\u95f4\u4e0d\u591f\u5c31\u8fdb\u884c\u6269\u5bb9
\n _buffer.resize(_writer_idx + len);
\n }
\n }
\n }
\n \/\/ \u5199\u5165\u6570\u636e
\n void Write(const void *data, int len)
\n {
\n \/\/ 1.\u4fdd\u8bc1\u6709\u8db3\u591f\u7a7a\u95f4 2.\u5c06\u6570\u636e\u62f7\u5165\u7f13\u51b2\u533a
\n EnsureWriteSpace(len);
\n const char *d = (const char *)data;
\n std::copy(d, d + len, WritePosition());
\n }
\n void WriteAndPush(const void *data, int len)
\n {
\n Write(data, len);
\n MoveWriteOffset(len);
\n }
\n \/\/ \u5199\u5165\u5b57\u7b26\u4e32
\n void WriteString(std::string &data)
\n {
\n Write(data.c_str(), data.size());
\n }
\n void WriteStringAndPush(std::string &data)
\n {
\n WriteString(data);
\n MoveWriteOffset(data.size());
\n }
\n \/\/ \u4ece\u5176\u4ed6\u7f13\u51b2\u533a\u5199\u5165
\n void WriteBuffer(Buffer &buf)
\n {
\n Write((const void *)buf.ReadPosition(), buf.ReadAbleSize());
\n }
\n void WriteBufferAndPush(Buffer &buf)
\n {
\n Write((const void *)buf.ReadPosition(), buf.ReadAbleSize());
\n MoveWriteOffset(buf.ReadAbleSize());
\n }
\n \/\/ \u8bfb\u53d6\u6570\u636e
\n void Read(void *rec, int len)
\n {
\n if (len <= ReadAbleSize())
\n {
\n \/\/ std::copy(Begin() + _reader_size, Begin() + _writer_size, (char *)rec);
\n std::copy(ReadPosition(), ReadPosition() + len, (char*)rec);
\n }
\n else
\n {
\n ERR_LOG("\u8bfb\u53d6\u6570\u636e\u51fa\u9519");
\n }
\n }
\n void ReadAndPop(void *rec, int len)
\n {
\n if (len <= ReadAbleSize())
\n {
\n Read(rec, len);
\n MoveReadOffset(len);
\n }
\n else
\n {
\n ERR_LOG("ReadAndPop ERROR");
\n }
\n }
\n \/\/ \u4ee5\u5b57\u7b26\u4e32\u7684\u5f62\u5f0f\u8bfb\u53d6\u6570\u636e
\n std::string ReadAsString(int len)
\n {
\n if (len <= ReadAbleSize())
\n {
\n std::string str;
\n str.resize(len);
\n Read(&str[0], len);
\n return str;
\n }
\n return "";
\n }<\/p>\n

std::string ReadAsStringAndpop(int len)
\n {
\n if(len <= ReadAbleSize())
\n {
\n std::string ret = ReadAsString(len);
\n MoveReadOffset(len);
\n return ret;
\n }
\n else
\n {
\n ERR_LOG("ReadAsStringAndpop ERROR");
\n return "";
\n }
\n }
\n \/\/ \u67e5\u627e\u4e00\u884c\u6570\u636e
\n char *FindCRLF()
\n {
\n void *res = memchr((void *)ReadPosition(), '\\\\n', ReadAbleSize());
\n return (char *)res;
\n }
\n \/\/ \u4ee5\u5b57\u7b26\u4e32\u5f62\u5f0f\u83b7\u53d6\u4e00\u884c\u6570\u636e
\n std::string GetLine()
\n {
\n char *pos = FindCRLF();
\n if (pos == nullptr)
\n {
\n return "";
\n }
\n \/\/+1\u662f\u628a\u6362\u884c\u7b26\u4e5f\u53d6\u51fa\u6765，\u56e0\u4e3apos\u662f\u4e0b\u4e00\u4e2a\u884c\u7684\u8d77\u59cb\u5730\u5740
\n return ReadAsString(pos – ReadPosition() + 1);
\n }
\n std::string GetLineAndPop()
\n {
\n \/\/ \u8c03\u7528GetLine\u51fd\u6570\u83b7\u53d6\u4e00\u884c\u5b57\u7b26\u4e32
\n std::string ret = GetLine();
\n \/\/ \u6839\u636e\u83b7\u53d6\u7684\u5b57\u7b26\u4e32\u957f\u5ea6\u79fb\u52a8\u8bfb\u53d6\u504f\u79fb\u91cf
\n MoveReadOffset(ret.size());
\n \/\/ \u8fd4\u56de\u83b7\u53d6\u5230\u7684\u5b57\u7b26\u4e32
\n return ret;
\n }
\n \/\/ \u6e05\u7a7a\u6570\u636e
\n void Clear()
\n {
\n _writer_idx = 0;
\n _reader_idx = 0;
\n }
\n}; <\/p>\n

\u2f47\u5fd7\u5b8f\u7684\u5b9e\u73b0：<\/span><\/h4>\n

#define INF 0
\n#define DBG 1
\n#define ERR 2
\n#define LOG_LEVEL DBG<\/p>\n

#define LOG(level, format, …) do{\\\\
\n if (level < LOG_LEVEL) break;\\\\
\n time_t t = time(NULL);\\\\
\n struct tm *ltm = localtime(&t);\\\\
\n char tmp[32] = {0};\\\\
\n strftime(tmp, 31, "%H:%M:%S", ltm);\\\\
\n fprintf(stdout, "[%p %s %s:%d] " format "\\\\n", (void*)pthread_self(), tmp, __FILE__, __LINE__, ##__VA_ARGS__);\\\\
\n }while(0)<\/p>\n

#define INF_LOG(format, …) LOG(INF, format, ##__VA_ARGS__)
\n#define DBG_LOG(format, …) LOG(DBG, format, ##__VA_ARGS__)
\n#define ERR_LOG(format, …) LOG(ERR, format, ##__VA_ARGS__) <\/p>\n

\u5957\u63a5\u5b57Socket\u7c7b\u5b9e\u73b0：<\/span><\/h4>\n

#define MAX_LISEN 1024
\nclass Socket
\n{
\nprivate:
\n int _socketfd;<\/p>\n

public:
\n Socket() : _socketfd(-1) {}
\n Socket(int fd) : _socketfd(fd) {}
\n ~Socket() {}
\n int Fd()
\n {
\n return _socketfd;
\n }
\n \/\/ \u521b\u5efa\u5957\u63a5\u5b57
\n bool Create()
\n {
\n _socketfd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
\n if (_socketfd < 0)
\n {
\n ERR_LOG("CREATED SOCKET ERROR");
\n return false;
\n }
\n return true;
\n }
\n \/\/ \u7ed1\u5b9a\u7aef\u53e3\u53f7
\n bool Bind(const std::string &ip, uint16_t port)
\n {
\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 ret = bind(_socketfd, (struct sockaddr *)&addr, len);
\n if (ret < 0)
\n {
\n ERR_LOG("BIND ERROR");
\n return false;
\n }
\n return true;
\n }
\n \/\/ \u76d1\u542c\u5957\u63a5\u5b57
\n bool Listen(int backLog = MAX_LISEN)
\n {
\n int ret = listen(_socketfd, backLog);
\n if (ret < 0)
\n {
\n ERR_LOG("LISTEN ERROR");
\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 {
\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 ret = connect(_socketfd, (struct sockaddr *)&addr, len);
\n if (ret < 0)
\n {
\n ERR_LOG("CONNECT FAILED");
\n return false;
\n }
\n return true;
\n }
\n \/\/ \u83b7\u53d6\u65b0\u8fde\u63a5
\n int Accept()
\n {
\n int newfd = accept(_socketfd, nullptr, nullptr);
\n if (newfd < 0)
\n {
\n ERR_LOG("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 {
\n ssize_t ret = recv(_socketfd, buf, len, flag);
\n if (ret <= 0)
\n {
\n if (errno == EAGAIN || errno == EINTR)
\n {
\n ERR_LOG("RECEIVE AGAIN");
\n return 0;
\n }
\n ERR_LOG("RECEIVE FAILED:%d", errno);
\n return -1;
\n }<\/p>\n

return ret;
\n }
\n ssize_t NoBlockRecv(void *buf, size_t len)
\n {
\n \/\/ \u4f7f\u7528Recv\u51fd\u6570\u63a5\u6536\u6570\u636e，\u5e76\u8bbe\u7f6e\u6807\u5fd7\u4f4d\u4e3aMSG_DONTWAIT\u4ee5\u5b9e\u73b0\u975e\u963b\u585e\u63a5\u6536
\n return Recv(buf, len, MSG_DONTWAIT);
\n }
\n \/\/ \u53d1\u9001\u6570\u636e
\n int Send(const void *buf, size_t len, int flag = 0)
\n {
\n DBG_LOG("SEND:%ld", len);
\n ssize_t ret = send(_socketfd, buf, len, flag);
\n if (ret <= 0)
\n {
\n if (ret < 0)
\n {
\n if (errno == EAGAIN || errno == EINTR)
\n {
\n return 0;
\n }
\n }
\n ERR_LOG("SEND FAILED");
\n return -1;
\n }<\/p>\n

return ret;
\n }
\n ssize_t NoBlockSend(void *buf, size_t len)
\n {
\n return Send(buf, len, MSG_DONTWAIT);
\n }
\n \/\/ \u5173\u95ed\u5957\u63a5\u5b57
\n void Close()
\n {
\n if (_socketfd != -1)
\n {
\n close(_socketfd);
\n _socketfd = -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 {
\n if (Create() == false)
\n return false;
\n if (block_flag)
\n NoBlock();
\n if (Bind(ip, port) == false)
\n return false;
\n if (Listen() == false)
\n return false;
\n ReuseAdress();
\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 {
\n if (Create() == false)
\n return false;
\n if (Connect(ip, port) == false)
\n return false;
\n return true;
\n }
\n \/\/ \u5f00\u542f\u5730\u5740\u7aef\u53e3\u91cd\u7528
\n void ReuseAdress()
\n {
\n int val = 1;
\n \/\/ \u8bbe\u7f6e\u5957\u63a5\u5b57\u9009\u9879 SO_REUSEADDR，\u5141\u8bb8\u5730\u5740\u91cd\u7528
\n setsockopt(_socketfd, SOL_SOCKET, SO_REUSEADDR, (void*)&val, sizeof(int));<\/p>\n

val = 1;
\n \/\/ \u8bbe\u7f6e\u5957\u63a5\u5b57\u9009\u9879 SO_REUSEPORT，\u5141\u8bb8\u7aef\u53e3\u91cd\u7528
\n setsockopt(_socketfd, SOL_SOCKET, SO_REUSEPORT, (void*)&val, sizeof(int));
\n }
\n \/\/ \u5957\u63a5\u5b57\u8bbe\u7f6e\u4e3a\u975e\u963b\u585e
\n void NoBlock()
\n {
\n \/\/\u83b7\u53d6\u539f\u672c\u7684flag\u503c
\n int flag = fcntl(_socketfd, F_GETFL, 0);
\n fcntl(_socketfd, F_SETFL, flag | O_NONBLOCK);\/\/\u65b0\u589e\u975e\u963b\u585e
\n }
\n};<\/p>\n

\u4e8b\u4ef6\u7ba1\u7406Channel\u7c7b\u5b9e\u73b0：<\/span><\/h4>\n

\/*
\n\u4e00\u4e2achannel\u5bf9\u5e94\u4e00\u4e2afd，\u53bb\u76d1\u7ba1\u4e00\u4e2afd\u4e0a\u53d1\u751f\u7684\u6240\u6709\u4e8b\u4ef6
\npoller\u8d1f\u8d23\u76d1\u7ba1\u6240\u6709channel，poller\u624d\u5177\u6709\u5b9e\u9645\u7684epoll，poller\u624d\u662f\u5b9e\u9645\u7684\u76d1\u63a7\u8005，\u8d1f\u8d23\u76d1\u7ba1\u6240\u6709channel
\nchannel\u4fdd\u5b58\u4e00\u4e2aenvent\u8868\u548c\u76f8\u5e94\u7684\u56de\u8c03\u51fd\u6570,\u8fd9\u4e5fpoller\u624d\u53ef\u4ee5\u6839\u636echannel\u8fdb\u884c\u76f8\u5e94\u7684\u76d1\u63a7（\u6839\u636eevent\u5224\u65ad\u662f\u5426\u8981\u76d1\u63a7\u8bfb，\u5199\u7b49）\u548c\u6b63\u786e\u7684\u56de\u8c03（\u8bfb，\u5199\u7b49\u89e6\u53d1\u600e\u4e48\u6837\u7684\u56de\u8c03）
\n*\/
\nclass Poller;
\nclass EventLoop;
\nclass Channel
\n{
\nprivate:
\n int _fd;
\n EventLoop *_loop;
\n uint32_t _events; \/\/ \u5f53\u524d\u8981\u76d1\u63a7\u7684\u4e8b\u4ef6
\n uint32_t _revents; \/\/ \u5bf9\u89e6\u53d1\u4e8b\u4ef6\u7684\u76d1\u63a7
\n using EventCallBack = std::function<void()>;
\n EventCallBack _read_callback; \/\/ \u53ef\u8bfb\u4e8b\u4ef6\u7684\u56de\u8c03\u51fd\u6570
\n EventCallBack _write_callback; \/\/ \u53ef\u5199\u4e8b\u4ef6\u7684\u56de\u8c03\u51fd\u6570
\n EventCallBack _error_callback; \/\/ \u9519\u8bef\u4e8b\u4ef6\u7684\u56de\u8c03\u51fd\u6570
\n EventCallBack _close_callback; \/\/ \u5173\u95ed\u4e8b\u4ef6\u7684\u56de\u8c03\u51fd\u6570
\n EventCallBack _event_callback; \/\/ \u4efb\u610f\u4e8b\u4ef6\u89e6\u53d1\u7684\u56de\u8c03\u51fd\u6570<\/p>\n

public:
\n Channel(EventLoop *Loop, int fd)
\n : _loop(Loop),
\n _fd(fd),
\n _events(0),
\n _revents(0)
\n {
\n }<\/p>\n

int Fd()
\n {
\n return _fd;
\n }
\n \/\/ \u8bbe\u7f6e\u5b9e\u9645\u5c31\u7eea\u7684\u4e8b\u4ef6
\n void SetRevents(uint32_t events)
\n {
\n _revents = events;
\n }
\n \/\/ \u83b7\u53d6\u60f3\u8981\u76d1\u63a7\u7684\u4e8b\u4ef6
\n uint32_t Event()
\n {
\n return _events;
\n }
\n \/\/ \u8bbe\u7f6e\u53ef\u8bfb\u4e8b\u4ef6\u56de\u8c03
\n void SetReadCallBack(const EventCallBack cb)
\n {
\n _read_callback = cb;
\n }
\n \/\/ \u8bbe\u7f6e\u53ef\u5199\u4e8b\u4ef6\u56de\u8c03
\n void SetWriteCallBack(const EventCallBack cb)
\n {
\n _write_callback = cb;
\n }
\n \/\/ \u8bbe\u7f6e\u9519\u8bef\u4e8b\u4ef6\u56de\u8c03
\n void SetErrorCallBack(const EventCallBack cb)
\n {
\n _error_callback = cb;
\n }
\n \/\/ \u8bbe\u7f6e\u5173\u95ed\u4e8b\u4ef6\u56de\u8c03
\n void SetCloseCallBack(const EventCallBack cb)
\n {
\n _close_callback = cb;
\n }
\n \/\/ \u8bbe\u7f6e\u4efb\u610f\u4e8b\u4ef6\u56de\u8c03
\n void SetEventCallBack(const EventCallBack cb)
\n {
\n _event_callback = cb;
\n }
\n \/\/ \u5f53\u524d\u662f\u5426\u53ef\u8bfb
\n bool ReadAble()
\n {
\n return _events & EPOLLIN;
\n }
\n \/\/ \u5f53\u524d\u662f\u5426\u53ef\u5199
\n bool WriteAble()
\n {
\n return _events & EPOLLOUT;
\n }
\n \/\/ \u542f\u52a8\u8bfb\u4e8b\u4ef6\u76d1\u63a7
\n void EnableRead()
\n {
\n _events |= EPOLLIN;
\n Update();
\n }
\n \/\/ \u542f\u52a8\u5199\u4e8b\u4ef6\u76d1\u63a7
\n void EnableWrite()
\n {
\n _events |= EPOLLOUT;
\n Update();
\n }
\n \/\/ \u5173\u95ed\u5199\u4e8b\u4ef6\u76d1\u63a7
\n void DisableWrite()
\n {
\n _events &= ~EPOLLOUT;
\n Update();
\n }
\n \/\/ \u5173\u95ed\u8bfb\u4e8b\u4ef6\u76d1\u63a7
\n void DisableRead()
\n {
\n _events &= ~EPOLLIN;
\n Update();
\n }
\n \/\/ \u5173\u95ed\u6240\u6709\u4e8b\u4ef6\u76d1\u63a7
\n void DisableAll()
\n {
\n _events = 0;
\n Update();
\n }
\n \/\/ \u79fb\u9664\u5bf9\u4e8b\u4ef6\u7684\u76d1\u63a7
\n void Remove();
\n void Update();
\n \/\/ \u4e8b\u4ef6\u5904\u7406，\u4e00\u65e6\u89e6\u53d1\u5c31\u8c03\u7528\u8be5\u51fd\u6570，\u8ba9\u89e6\u53d1\u7684\u4e8b\u4ef6\u81ea\u5df1\u51b3\u5b9a\u5982\u4f55\u5904\u7406
\n void HandleEvent()
\n {
\n \/\/\u53ef\u8bfb\u53ef\u5199\u4e8b\u4ef6\u7531\u4e8e\u53ef\u80fd\u8017\u65f6\u6bd4\u8f83\u957f，\u6240\u4ee5\u9632\u6b62\u5148\u5237\u65b0\u6d3b\u8dc3\u5ea6\u5bfc\u81f4\u5904\u7406\u4e8b\u4ef6\u7684\u65f6\u5019\u8d85\u65f6，\u6240\u4ee5\u5148\u5904\u7406\u4e8b\u4ef6\u518d\u5237\u65b0\u6d3b\u8dc3\u5ea6\u9632\u6b62\u8d85\u65f6
\n \/\/ \u53ef\u8bfb\u4e8b\u4ef6\u8c03\u7528
\n if ((_revents & EPOLLIN) || (_revents & EPOLLRDHUP) || (_revents & EPOLLPRI))
\n {
\n if (_read_callback)
\n _read_callback();
\n \/\/ \u4efb\u4f55\u4e8b\u4ef6\u90fd\u8c03\u7528，\u5237\u65b0\u6d3b\u8dc3\u5ea6
\n if (_event_callback)
\n _event_callback();
\n }
\n \/\/ \u53ef\u5199\u4e8b\u4ef6\u8c03\u7528
\n if (_revents & EPOLLOUT)
\n {
\n if (_write_callback)
\n _write_callback();
\n \/\/ \u4efb\u4f55\u4e8b\u4ef6\u90fd\u8c03\u7528，\u5237\u65b0\u6d3b\u8dc3\u5ea6
\n if (_event_callback)
\n _event_callback();
\n }
\n \/\/\u9519\u8bef\u6216\u8005\u5173\u95ed\u4e8b\u4ef6\u7531\u4e8e\u53ef\u80fd\u4f1a\u5bfc\u81f4\u8fde\u63a5\u5173\u95ed，\u6240\u4ee5\u5148\u5237\u65b0\u6d3b\u8dc3\u5ea6\u9632\u6b62\u8fde\u63a5\u88ab\u91ca\u653e\u4ee5\u540e\u518d\u5237\u65b0\u5bfc\u81f4\u9519\u8bef
\n \/\/\u5e76\u4e14\u7531\u4e8e\u53ef\u80fd\u5bfc\u81f4\u8fde\u63a5\u5173\u95ed，\u6240\u4ee5\u4e00\u6b21\u53ea\u5904\u7406\u4e00\u4e2a
\n \/\/ \u9519\u8bef\u4e8b\u4ef6\u8c03\u7528
\n if (_revents & EPOLLERR)
\n {
\n \/\/ \u4efb\u4f55\u4e8b\u4ef6\u90fd\u8c03\u7528，\u5237\u65b0\u6d3b\u8dc3\u5ea6
\n if (_event_callback)
\n _event_callback();
\n if (_error_callback)
\n _error_callback();
\n }\/\/ \u5173\u95ed\u4e8b\u4ef6\u8c03\u7528
\n else if (_revents & EPOLLHUP)
\n {
\n \/\/ \u4efb\u4f55\u4e8b\u4ef6\u90fd\u8c03\u7528，\u5237\u65b0\u6d3b\u8dc3\u5ea6
\n if (_event_callback)
\n _event_callback();
\n DBG_LOG("_CLOSE_CALLBACK");
\n if (_close_callback)
\n {
\n _close_callback();
\n }
\n }<\/p>\n

}
\n};<\/p>\n

#define MAX_EPOLLEVENTS 1024
\n\/\/\u5b9e\u9645\u7684\u76d1\u63a7\u8005，\u8d1f\u8d23\u76d1\u63a7\u6240\u6709\u4e8b\u4ef6（\u5e76\u6839\u636echannel\u8fdb\u884c\u4e8b\u4ef6\u7ba1\u7406）
\nclass Poller
\n{
\nprivate:
\n int _epfd;
\n struct epoll_event _evs[MAX_EPOLLEVENTS];
\n std::unordered_map<int, Channel *> _channels;<\/p>\n

private:
\n \/\/ \u5bf9epoll\u76f4\u63a5\u64cd\u4f5c
\n void Update(Channel *channel, int op)
\n {
\n \/\/ \u83b7\u53d6Channel\u5bf9\u8c61\u7684\u6587\u4ef6\u63cf\u8ff0\u7b26
\n int fd = channel->Fd();<\/p>\n

\/\/ \u521b\u5efaepoll\u4e8b\u4ef6\u7ed3\u6784\u4f53
\n struct epoll_event ev;
\n \/\/ \u8bbe\u7f6e\u4e8b\u4ef6\u7ed3\u6784\u4f53\u4e2d\u7684\u6587\u4ef6\u63cf\u8ff0\u7b26
\n ev.data.fd = fd;
\n \/\/ \u8bbe\u7f6e\u4e8b\u4ef6\u7ed3\u6784\u4f53\u4e2d\u7684\u4e8b\u4ef6\u7c7b\u578b
\n ev.events = channel->Event();<\/p>\n

\/\/ \u8c03\u7528epoll_ctl\u51fd\u6570\u66f4\u65b0epoll\u4e8b\u4ef6
\n int ret = epoll_ctl(_epfd, op, fd, &ev);
\n \/\/ \u5982\u679cepoll_ctl\u51fd\u6570\u6267\u884c\u5931\u8d25
\n if (ret < 0)
\n {
\n \/\/ \u6253\u5370\u9519\u8bef\u4fe1\u606f
\n DBG_LOG("EPOLL_CTL FAILED");
\n }
\n }
\n \/\/ \u5224\u65adchannel\u662f\u5426\u5df2\u7ecf\u88abpoller\u7ba1\u7406
\n bool HasChannel(Channel *channel)
\n {
\n auto it = _channels.find(channel->Fd());<\/p>\n

if (it != _channels.end())
\n return true;
\n else
\n return false;
\n }<\/p>\n

public:
\n Poller()
\n {
\n _epfd = epoll_create(MAX_EPOLLEVENTS);
\n if (_epfd < 0)
\n {
\n DBG_LOG("EPOLL_CREATE ERROR");
\n abort();
\n }
\n }<\/p>\n

\/\/ \u6dfb\u52a0，\u4fee\u6539\u76d1\u63a7\u4e8b\u4ef6
\n void UpdateEvent(Channel *channel)
\n {
\n bool ret = HasChannel(channel);
\n if (ret)
\n {
\n \/\/ \u5b58\u5728\u5c31\u4fee\u6539
\n Update(channel, EPOLL_CTL_MOD);
\n }
\n else
\n {
\n _channels[channel->Fd()] = channel;
\n Update(channel, EPOLL_CTL_ADD);
\n }
\n }
\n \/\/ \u79fb\u9664\u76d1\u63a7
\n void RemoveEvent(Channel *channel)
\n {
\n auto it = _channels.find(channel->Fd());
\n if (it != _channels.end())
\n {
\n _channels.erase(it);
\n Update(channel, EPOLL_CTL_DEL);
\n return;
\n }
\n DBG_LOG("Remove Event Error");
\n }
\n \/\/ \u5f00\u59cb\u76d1\u63a7，\u83b7\u53d6\u6d3b\u8dc3\u8fde\u63a5
\n \/\/ epoll\u4f1a\u8fd4\u56de\u5c31\u7eea\u4e8b\u4ef6\u7684fd，\u7136\u540e\u6839\u636efd\u518d\u67e5\u627e\u5bf9\u5e94\u7684channel,\u518d\u7531EventLoop\u8c03\u7528HandleEvent
\n void Poll(std::vector<Channel *> *active)
\n {
\n int _nfds = epoll_wait(_epfd, _evs, MAX_EPOLLEVENTS, -1);
\n if (_nfds < 0)
\n {
\n if (errno == EINTR)
\n {
\n return;
\n }
\n ERR_LOG("EPOLL_WAIT FAILED");
\n abort();
\n }<\/p>\n

for (int i = 0; i < _nfds; i++)
\n {
\n auto it = _channels.find(_evs[i].data.fd);
\n if (it != _channels.end())
\n {
\n it->second->SetRevents(_evs[i].events); \/\/ \u8bbe\u7f6e\u5b9e\u9645\u5c31\u7eea\u4e8b\u4ef6\u7c7b\u578b
\n active->push_back(it->second);
\n }
\n else
\n {
\n DBG_LOG("_CHANNELS FIND ERROR");
\n }
\n }
\n }
\n}; <\/p>\n

\u63cf\u8ff0\u7b26\u4e8b\u4ef6\u76d1\u63a7Poller\u7c7b\u5b9e\u73b0：<\/span><\/h4>\n

\"\"<\/p>\n

#define MAX_EPOLLEVENTS 1024
\n\/\/\u5b9e\u9645\u7684\u76d1\u63a7\u8005，\u8d1f\u8d23\u76d1\u63a7\u6240\u6709\u4e8b\u4ef6（\u5e76\u6839\u636echannel\u8fdb\u884c\u4e8b\u4ef6\u7ba1\u7406）
\nclass Poller
\n{
\nprivate:
\n int _epfd;
\n struct epoll_event _evs[MAX_EPOLLEVENTS];
\n std::unordered_map<int, Channel *> _channels;<\/p>\n

private:
\n \/\/ \u5bf9epoll\u76f4\u63a5\u64cd\u4f5c
\n void Update(Channel *channel, int op)
\n {
\n \/\/ \u83b7\u53d6Channel\u5bf9\u8c61\u7684\u6587\u4ef6\u63cf\u8ff0\u7b26
\n int fd = channel->Fd();<\/p>\n

\/\/ \u521b\u5efaepoll\u4e8b\u4ef6\u7ed3\u6784\u4f53
\n struct epoll_event ev;
\n \/\/ \u8bbe\u7f6e\u4e8b\u4ef6\u7ed3\u6784\u4f53\u4e2d\u7684\u6587\u4ef6\u63cf\u8ff0\u7b26
\n ev.data.fd = fd;
\n \/\/ \u8bbe\u7f6e\u4e8b\u4ef6\u7ed3\u6784\u4f53\u4e2d\u7684\u4e8b\u4ef6\u7c7b\u578b
\n ev.events = channel->Event();<\/p>\n

\/\/ \u8c03\u7528epoll_ctl\u51fd\u6570\u66f4\u65b0epoll\u4e8b\u4ef6
\n int ret = epoll_ctl(_epfd, op, fd, &ev);
\n \/\/ \u5982\u679cepoll_ctl\u51fd\u6570\u6267\u884c\u5931\u8d25
\n if (ret < 0)
\n {
\n \/\/ \u6253\u5370\u9519\u8bef\u4fe1\u606f
\n DBG_LOG("EPOLL_CTL FAILED");
\n }
\n }
\n \/\/ \u5224\u65adchannel\u662f\u5426\u5df2\u7ecf\u88abpoller\u7ba1\u7406
\n bool HasChannel(Channel *channel)
\n {
\n auto it = _channels.find(channel->Fd());<\/p>\n

if (it != _channels.end())
\n return true;
\n else
\n return false;
\n }<\/p>\n

public:
\n Poller()
\n {
\n _epfd = epoll_create(MAX_EPOLLEVENTS);
\n if (_epfd < 0)
\n {
\n DBG_LOG("EPOLL_CREATE ERROR");
\n abort();
\n }
\n }<\/p>\n

\/\/ \u6dfb\u52a0，\u4fee\u6539\u76d1\u63a7\u4e8b\u4ef6
\n void UpdateEvent(Channel *channel)
\n {
\n bool ret = HasChannel(channel);
\n if (ret)
\n {
\n \/\/ \u5b58\u5728\u5c31\u4fee\u6539
\n Update(channel, EPOLL_CTL_MOD);
\n }
\n else
\n {
\n _channels[channel->Fd()] = channel;
\n Update(channel, EPOLL_CTL_ADD);
\n }
\n }
\n \/\/ \u79fb\u9664\u76d1\u63a7
\n void RemoveEvent(Channel *channel)
\n {
\n auto it = _channels.find(channel->Fd());
\n if (it != _channels.end())
\n {
\n _channels.erase(it);
\n Update(channel, EPOLL_CTL_DEL);
\n return;
\n }
\n DBG_LOG("Remove Event Error");
\n }
\n \/\/ \u5f00\u59cb\u76d1\u63a7，\u83b7\u53d6\u6d3b\u8dc3\u8fde\u63a5
\n \/\/ epoll\u4f1a\u8fd4\u56de\u5c31\u7eea\u4e8b\u4ef6\u7684fd，\u7136\u540e\u6839\u636efd\u518d\u67e5\u627e\u5bf9\u5e94\u7684channel,\u518d\u7531EventLoop\u8c03\u7528HandleEvent
\n void Poll(std::vector<Channel *> *active)
\n {
\n int _nfds = epoll_wait(_epfd, _evs, MAX_EPOLLEVENTS, -1);
\n if (_nfds < 0)
\n {
\n if (errno == EINTR)
\n {
\n return;
\n }
\n ERR_LOG("EPOLL_WAIT FAILED");
\n abort();
\n }<\/p>\n

for (int i = 0; i < _nfds; i++)
\n {
\n auto it = _channels.find(_evs[i].data.fd);
\n if (it != _channels.end())
\n {
\n it->second->SetRevents(_evs[i].events); \/\/ \u8bbe\u7f6e\u5b9e\u9645\u5c31\u7eea\u4e8b\u4ef6\u7c7b\u578b
\n active->push_back(it->second);
\n }
\n else
\n {
\n DBG_LOG("_CHANNELS FIND ERROR");
\n }
\n }
\n }
\n}; <\/p>\n

<\/h3>\n

Reactor-EventLoop\u5b9e\u73b0： <\/span><\/h4>\n

\"\"<\/p>\n

class EventLoop
\n{
\n using Functor = std::function<void()>;
\n std::thread::id _thread_id; \/\/ \u7ebf\u7a0bId
\n int _event_fd; \/\/ \u5524\u9192\u7531\u4e8eIO\u4e8b\u4ef6\u53ef\u80fd\u5bfc\u81f4\u7684\u963b\u585e
\n std::unique_ptr<Channel> _event_channel;
\n Poller _poller; \/\/ \u5bf9\u63cf\u8ff0\u7b26\u8fdb\u884c\u76d1\u63a7
\n std::vector<Functor> _tasks; \/\/ \u4efb\u52a1\u6c60
\n std::mutex _mutex; \/\/ \u4fdd\u969c\u5bf9\u4efb\u52a1\u6c60\u64cd\u4f5c\u7684\u5b89\u5168\u6027
\n TimeWheel _timer_wheel;<\/p>\n

public:
\n \/\/ \u6267\u884c\u4efb\u52a1\u6c60\u4e2d\u7684\u6240\u6709\u64cd\u4f5c
\n void RunAllTask()
\n {
\n std::vector<Functor> tasks;
\n {
\n \/\/\u6267\u884c\u4efb\u52a1\u7684\u65f6\u5019\u76f4\u63a5\u5c06\u4efb\u52a1\u6c60\u4e2d\u7684\u4efb\u52a1\u7f6e\u6362\u51fa\u6765，\u518d\u5904\u7406，\u907f\u514d\u6267\u884c\u4efb\u52a1\u7684\u65f6\u5019\u963b\u585e\u4efb\u52a1\u6c60
\n std::unique_lock<std::mutex> _lock(_mutex);
\n tasks.swap(_tasks);
\n }
\n for (auto f : tasks)
\n {
\n f();
\n }
\n return;
\n }
\n static int CreateEventFd()
\n {
\n int efd = eventfd(0, EFD_CLOEXEC | EFD_NONBLOCK);
\n if (efd < 0)
\n {
\n ERR_LOG("EVENT FD CREATE FAILED");
\n abort();
\n }<\/p>\n

return efd;
\n }
\n void ReadEventFd()
\n {
\n uint64_t res = 0;
\n res = read(_event_fd, &res, sizeof(res));
\n if (res < 0)
\n {
\n if (errno == EINTR)
\n {
\n return;
\n }
\n ERR_LOG("ReadEventFd ERROR");
\n }
\n }
\n \/**
\n * @brief \u5524\u9192\u4e8b\u4ef6\u6587\u4ef6\u63cf\u8ff0\u7b26
\n *
\n * \u901a\u8fc7\u5411\u4e8b\u4ef6\u6587\u4ef6\u63cf\u8ff0\u7b26\u5199\u5165\u6570\u636e\u6765\u5524\u9192\u7b49\u5f85\u8be5\u63cf\u8ff0\u7b26\u7684\u7ebf\u7a0b\u3002
\n *
\n * @return \u65e0\u8fd4\u56de\u503c
\n *\/
\n void WakeUpEventFd()
\n {
\n \/\/ \u8bbe\u7f6e\u5199\u5165\u7684\u503c
\n uint64_t val = 1;
\n \/\/ \u5c06\u503c\u5199\u5165\u5230\u4e8b\u4ef6\u6587\u4ef6\u63cf\u8ff0\u7b26
\n int ret = write(_event_fd, &val, sizeof(val));
\n if (ret < 0)
\n {
\n \/\/ \u5224\u65ad\u9519\u8bef\u7801\u662f\u5426\u4e3aEINTR\u6216EAGAIN
\n \/\/ EINTR:\u88ab\u4fe1\u53f7\u6253\u65ad EAGAIN:\u65e0\u6570\u636e\u53ef\u8bfb
\n if (errno == EINTR || errno == EAGAIN)
\n {
\n \/\/ \u5982\u679c\u662f\u8fd9\u4e24\u79cd\u9519\u8bef\u7801\u4e4b\u4e00，\u5219\u76f4\u63a5\u8fd4\u56de
\n return;
\n }
\n \/\/ \u5982\u679c\u4e0d\u662f\u8fd9\u4e24\u79cd\u9519\u8bef\u7801，\u5219\u8bb0\u5f55\u9519\u8bef\u65e5\u5fd7
\n ERR_LOG("ReadEventFd ERROR");
\n }
\n }<\/p>\n

public:
\n EventLoop()
\n : _thread_id(std::this_thread::get_id()),
\n _event_fd(CreateEventFd()),
\n _event_channel(new Channel(this, _event_fd)),
\n _timer_wheel(this)
\n {
\n \/\/ \u7ed9Event_fd\u6dfb\u52a0\u56de\u8c03\u51fd\u6570\u8bfb\u53d6eventfd，\u901a\u8fc7readEventfd\u6765\u6253\u65adIO\u963b\u585e
\n \/\/\u7531\u4e8eepoll\u7684\u4e8b\u4ef6\u76d1\u63a7，\u6709\u53ef\u80fd\u4f1a\u56e0\u4e3a\u6ca1\u6709\u4e8b\u4ef6\u5230\u6765\u2f7d\u6301\u7eed\u963b\u585e，\u5bfc\u81f4\u4efb\u52a1\u961f\u5217\u4e2d\u7684\u4efb\u52a1\u4e0d\u80fd\u53ca\u65f6\u5f97
\n \/\/\u5230\u6267\u2f8f，\u56e0\u6b64\u521b\u5efa\u4e86eventfd，\u6dfb\u52a0\u5230Poller\u7684\u4e8b\u4ef6\u76d1\u63a7\u4e2d，\u2f64\u4e8e\u5b9e\u73b0\u6bcf\u6b21\u5411\u4efb\u52a1\u961f\u5217\u6dfb\u52a0\u4efb\u52a1\u7684\u65f6
\n \/\/\u5019，\u901a\u8fc7\u5411eventfd\u5199\u2f0a\u6570\u636e\u6765\u5524\u9192epoll\u7684\u963b\u585e\u3002
\n _event_channel->SetReadCallBack(std::bind(&EventLoop::ReadEventFd, this));
\n _event_channel->EnableRead();
\n }
\n \/\/ \u5224\u65ad\u8981\u6267\u884c\u7684\u4efb\u52a1\u662f\u5426\u5728\u5f53\u524d\u7ebf\u7a0b\u4e2d，\u5982\u679c\u662f\u5c31\u76f4\u63a5\u6267\u884c，\u5426\u5219\u5c31\u538b\u5165\u961f\u5217
\n void RunInLoop(const Functor &cb)
\n {
\n if (IsInLoop())
\n {
\n cb();
\n }
\n else
\n {
\n QueueInLoop(cb);
\n }
\n }
\n \/\/ \u5f00\u59cb\u8fd0\u884c\u4e09\u6b65\u8d70–\u4e8b\u4ef6\u76d1\u63a7=\u300b\u5c31\u7eea\u4e8b\u4ef6\u5904\u7406=\u300b\u6267\u884c\u4efb\u52a1
\n void Start()
\n {
\n while (1)
\n {
\n std::vector<Channel *> actives;
\n _poller.Poll(&actives);<\/p>\n

\/\/\u5148\u5904\u7406\u4e8b\u4ef6\u89e6\u53d1\u7684\u56de\u8c03（\u8bfb\u4e8b\u4ef6\u56de\u8c03，\u5199\u4e8b\u4ef6\u56de\u8c03…..）
\n for (auto &channel : actives)
\n {
\n channel->HandleEvent();
\n }
\n \/\/\u7136\u540e\u518d\u6267\u884c\u4efb\u52a1\u6c60\u4e2d\u7684\u4efb\u52a1
\n RunAllTask();
\n }
\n }
\n \/\/ \u5c06\u4efb\u52a1\u538b\u5165\u961f\u5217
\n void QueueInLoop(const Functor &cb)
\n {
\n {
\n std::unique_lock<std::mutex> _lock(_mutex);
\n _tasks.push_back(cb);
\n }
\n \/\/ \u5524\u9192\u56e0\u4e3a\u6ca1\u6709\u4e8b\u4ef6\u5c31\u7eea\u4ece\u800c\u5bfc\u81f4\u7684epoll\u963b\u585e
\n \/\/ \u5176\u5b9e\u5c31\u662f\u7ed9eventfd\u5199\u5165\u4e00\u4e2a\u6570\u636e，\u4ece\u800c\u89e6\u53d1\u53ef\u8bfb\u4e8b\u4ef6\u6253\u65ad\u963b\u585e
\n \/\/ \u56e0\u4e3a\u4efb\u52a1\u6c60\u7684\u5904\u7406\u662f\u5728\u6709IO\u4e8b\u4ef6\u88ab\u89e6\u53d1\u4ee5\u540e\u624d\u4f1a\u88ab\u5904\u7406\u7684，\u6240\u6709\u5982\u679c\u5b8c\u5168\u6ca1\u6709IO\u4e8b\u4ef6\u5bfc\u81f4\u963b\u585e\u5c31\u4f1a\u5bfc\u81f4\u4efb\u52a1\u6c60\u7684\u4efb\u52a1\u4e5f\u4e00\u76f4\u4e0d\u88ab\u6267\u884c
\n WakeUpEventFd();
\n }
\n \/\/ \u5224\u65ad\u5f53\u524d\u7ebf\u7a0b\u662f\u5426\u662fEventLoop\u5bf9\u5e94\u7684\u7ebf\u7a0b
\n bool IsInLoop()
\n {
\n return (_thread_id == std::this_thread::get_id());
\n }
\n \/\/ \u66f4\u65b0\u4e8b\u4ef6\u76d1\u63a7
\n void UpdateEvent(Channel *channel)
\n {
\n _poller.UpdateEvent(channel);
\n }
\n \/\/ \u79fb\u9664\u4e8b\u4ef6\u76d1\u63a7
\n void RemoveEvent(Channel *channel)
\n {
\n _poller.RemoveEvent(channel);
\n }
\n \/\/\u5bf9\u5b9a\u65f6\u5668\u7684\u64cd\u4f5c\u5c01\u88c5，\u65b9\u4fbf\u4e0a\u5c42\u8c03\u7528
\n void TimerAdd(uint64_t id, uint32_t delay, const TaskFunc &cb)
\n {
\n return _timer_wheel.TimerAdd(id, delay, cb);
\n }
\n void TimerRefresh(uint64_t id)
\n {
\n return _timer_wheel.TimerRefresh(id);
\n }
\n void TimerCancel(uint64_t id)
\n {
\n return _timer_wheel.TimerCancel(id);
\n }
\n bool HasTimer(uint64_t id)
\n {
\n return _timer_wheel.HasTimer(id);
\n }
\n}; <\/p>\n

\u5b9a\u65f6\u5668\u6a21\u5757\u7684\u6574\u5408<\/h4>\n

\"\"<\/p>\n

using TaskFunc = std::function<void()>;
\nusing ReleaseFunc = std::function<void()>;
\nclass TimerTask
\n{
\n uint64_t _id; \/\/ \u5b9a\u65f6\u5668\u7684ID
\n uint64_t _timeout; \/\/ \u8d85\u65f6\u65f6\u95f4
\n bool _canceled; \/\/ \u53d6\u6d88\u5b9a\u65f6\u4efb\u52a1
\n TaskFunc _task_cb; \/\/ \u56de\u8c03\u51fd\u6570\u7684\u4efb\u52a1
\n ReleaseFunc _release; \/\/ \u6e05\u9664\u65f6\u95f4\u8f6e\u4e2d\u7684\u8bb0\u5f55<\/p>\n

public:
\n TimerTask(uint64_t id, uint64_t timeout, TaskFunc cb)
\n : _id(id),
\n _timeout(timeout),
\n _task_cb(cb),
\n _canceled(false)
\n {
\n }<\/p>\n

uint64_t ID()
\n {
\n return _id;
\n }<\/p>\n

void SetRelease(ReleaseFunc release)
\n {
\n _release = release;
\n }<\/p>\n

~TimerTask()
\n {
\n if (!_canceled)
\n _task_cb();
\n _release();
\n }<\/p>\n

void Cancel()
\n {
\n DBG_LOG("TIMER CANCEL");
\n _canceled = true;
\n }
\n \/\/\u83b7\u53d6\u8d85\u65f6\u65f6\u95f4
\n uint32_t DelayTime()
\n {
\n return _timeout;
\n }
\n};<\/p>\n

class TimeWheel
\n{
\nprivate:
\n using WeakTask = std::weak_ptr<TimerTask>;
\n using PtrTask = std::shared_ptr<TimerTask>;
\n int _tick; \/\/ \u79d2\u9488
\n int _capacity; \/\/ \u6700\u5927\u5b9a\u65f6\u65f6\u95f4
\n std::vector<std::vector<PtrTask>> _timeWheel; \/\/ \u65f6\u95f4\u8f6e
\n std::unordered_map<uint32_t, WeakTask> _timers; \/\/ \u7528\u6765\u4fdd\u5b58\u5b9a\u65f6\u5668\u7684\u4fe1\u606f<\/p>\n

EventLoop *_loop;
\n int _timerfd; \/\/ \u5b9a\u65f6\u5668\u63cf\u8ff0\u7b26–\u53ef\u8bfb\u4e8b\u4ef6\u56de\u8c03\u5c31\u662f\u8bfb\u53d6\u8ba1\u65f6\u5668\u6267\u884c\u5b9a\u65f6\u4efb\u52a1
\n std::unique_ptr<Channel> _timer_channel;<\/p>\n

private:
\n void RemoveTimer(uint64_t id)
\n {
\n DBG_LOG("REMOVE TIMER");
\n auto it = _timers.find(id);
\n if (it != _timers.end())
\n {
\n _timers.erase(it);
\n }
\n }
\n \/\/\u901a\u8fc7\u5b9a\u65f6\u5668\u6765\u8fdb\u884c\u5b9a\u65f6，\u89e6\u53d1\u4e00\u6b21\u8bfbIO\u4e8b\u4ef6，\u4fdd\u8bc1\u4e00\u79d2\u89e6\u53d1\u4e00\u6b21\u65f6\u95f4\u8f6e\u7684\u8d70\u52a8
\n static int CreateTimerfd()
\n {
\n int timerfd = timerfd_create(CLOCK_MONOTONIC, 0);
\n if (timerfd < 0)
\n {
\n ERR_LOG("CREATE TIMERFD FAILED");
\n abort();
\n }<\/p>\n

struct itimerspec itime;
\n itime.it_interval.tv_sec = 1;
\n itime.it_interval.tv_nsec = 0;
\n itime.it_value.tv_nsec = 0;
\n itime.it_value.tv_sec = 1;<\/p>\n

timerfd_settime(timerfd, 0, &itime, nullptr);
\n DBG_LOG("CREATE TIMERFD SUCCESS :%d",timerfd);
\n return timerfd;
\n }
\n int ReadTimeFd()
\n {
\n uint64_t times;
\n int ret = read(_timerfd, &times, 8);
\n if (ret < 0)
\n {
\n ERR_LOG("READ TIME FD:%d FAILED %s",_timerfd, strerror(errno));
\n abort();
\n }<\/p>\n

return times;
\n }
\n void RunTimerTask()
\n {
\n \/\/ DBG_LOG("\u65f6\u95f4\u8f6e\u88ab\u9a71\u52a8");
\n _tick = (_tick + 1) % _capacity;
\n _timeWheel[_tick].clear();
\n }
\n \/\/\u5b9a\u65f6\u5668\u7684\u56de\u8c03\u8bfb\u4e8b\u4ef6，\u8bfb\u4e8b\u4ef6\u56de\u8c03\u4f1a\u88abIO\u4e8b\u4ef6\u89e6\u53d1\u5f15\u53d1\u8bfb\u56de\u8c03（\u8bbe\u7f6e\u4e3a\u8be5OnTime\u51fd\u6570），\u6839\u636e\u8d85\u65f6\u65f6\u95f4，\u79fb\u52a8\u65f6\u95f4\u8f6e\u53bb\u6267\u884c\u5b9a\u65f6\u4efb\u52a1
\n void OnTime()
\n {
\n int ret = ReadTimeFd();
\n for (int i = 0; i < ret; i++)
\n RunTimerTask();
\n }<\/p>\n

public:
\n TimeWheel(EventLoop *loop)
\n : _tick(0),
\n _capacity(60),
\n _timeWheel(_capacity),
\n _loop(loop),
\n _timerfd(CreateTimerfd()),
\n _timer_channel(new Channel(_loop, _timerfd))
\n {
\n _timer_channel->SetReadCallBack(std::bind(&TimeWheel::OnTime, this));
\n _timer_channel->EnableRead();
\n }<\/p>\n

void TimerAdd(uint64_t id, uint64_t delay, TaskFunc cb);<\/p>\n

void TimerRefresh(uint64_t id);<\/p>\n

void TimerCancel(uint64_t id);
\n \/\/ \u8be5\u63a5\u53e3\u5b58\u5728\u7ebf\u7a0b\u5b89\u5168\u95ee\u9898，\u53ea\u80fd\u5728\u5bf9\u5e94\u7684EventLoop\u7ebf\u7a0b\u4e2d\u88ab\u8c03\u7528
\n bool HasTimer(uint64_t id)
\n {
\n auto it = _timers.find(id);
\n if (it != _timers.end())
\n {
\n return true;
\n }
\n return false;
\n }<\/p>\n

void TimerAddInLoop(uint64_t id, uint64_t timeout, TaskFunc cb)
\n {
\n PtrTask pt(new TimerTask(id, timeout, cb)); \/\/ \u521b\u5efa\u4efb\u52a1<\/p>\n

pt->SetRelease(std::bind(&TimeWheel::RemoveTimer, this, id)); \/\/ \u8bbe\u7f6e\u5220\u9664\u51fd\u6570\u56de\u8c03
\n int pos = (_tick + pt->DelayTime()) % _capacity; \/\/ \u627e\u5230\u8981\u63d2\u5165\u5230\u65f6\u95f4\u8f6e\u7684\u4f4d\u7f6e
\n _timeWheel[pos].push_back(pt); \/\/ \u63d2\u5165\u65f6\u95f4\u8f6e
\n _timers[id] = WeakTask(pt); \/\/ \u4fdd\u5b58\u5b9a\u65f6\u5668\u7684\u4fe1\u606f
\n }<\/p>\n

void TimerRefreshInLoop(uint64_t id)
\n {
\n auto it = _timers.find(id);
\n if (it == _timers.end())
\n {
\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 int pos = (_tick + pt->DelayTime()) % _capacity; \/\/ \u627e\u5230\u8981\u63d2\u5165\u5230\u65f6\u95f4\u8f6e\u7684\u4f4d\u7f6e
\n _timeWheel[pos].push_back(pt); \/\/ \u63d2\u5165\u65f6\u95f4\u8f6e
\n \/\/ DBG_LOG("\u65f6\u95f4\u8f6e\u88ab\u5237\u65b0");
\n }<\/p>\n

void TimerCancelInLoop(uint64_t id)
\n {
\n auto it = _timers.find(id);
\n if (it == _timers.end())
\n {
\n return; \/\/ \u6ca1\u627e\u7740\u5b9a\u65f6\u4efb\u52a1，\u6ca1\u6cd5\u5237\u65b0，\u6ca1\u6cd5\u5ef6\u8fdf
\n }<\/p>\n

PtrTask pt = it->second.lock();
\n if(pt)
\n pt->Cancel();
\n else DBG_LOG("TIMER CANCEL ERROR! PT IS NULL");
\n DBG_LOG("TIMER CANCEL IN LOOP");
\n }
\n}; <\/p>\n

Connection\u6a21\u5757<\/h4>\n

\"\"<\/p>\n

\"\"<\/p>\n

\/\/ DISCONNECTED \u5df2\u7ecf\u5173\u95ed
\n\/\/ CONNECTING \u8fde\u63a5\u5efa\u7acb\u6210\u529f-\u5f85\u5904\u7406\u72b6\u6001
\n\/\/ CONNECTED \u8fde\u63a5\u5df2\u7ecf\u5efa\u7acb\u5b8c\u6210，\u5404\u9879\u8bbe\u7f6e\u5df2\u5c31\u7eea，\u53ef\u4ee5\u901a\u4fe1
\n\/\/ DISCONNECTING \u51c6\u5907\u65ad\u5f00\u8fde\u63a5
\ntypedef enum
\n{
\n DISCONNECTED,
\n CONNECTING,
\n CONNECTED,
\n DISCONNECTING
\n} ConnStatu;<\/p>\n

class Connection;
\nusing PtrConnection = std::shared_ptr<Connection>;
\nclass Connection : public std::enable_shared_from_this<Connection>
\n \/\/\u7ee7\u627f\u81eastd::enable_shared_from_this<Connection>，\u8fd9\u6837\u5c31\u53ef\u4ee5\u5728Connection\u5185\u90e8\u83b7\u53d6\u81ea\u5df1\u7684shared_ptr\u7ba1\u7406\u5bf9\u8c61
\n{<\/p>\n

int _conn_id; \/\/ Connection\u7684id
\n \/\/ _tiemr_id \u5b9a\u65f6\u5668id，\u8fd9\u91cc\u4f7f\u7528conn_id\u4ee3\u66ff
\n int _sockfd; \/\/ \u8fde\u63a5\u5173\u8054\u7684\u63cf\u8ff0\u7b26
\n ConnStatu _statu; \/\/ \u8fde\u63a5\u72b6\u6001
\n EventLoop *_loop; \/\/ \u8fde\u63a5\u5173\u8054\u4e00\u4e2aEventLoop
\n bool _enable_inactive_release = false; \/\/ \u662f\u5426\u542f\u52a8\u975e\u6d3b\u8dc3\u81ea\u52a8\u9500\u6bc1，\u9ed8\u8ba4\u5173\u95ed
\n Socket _socket; \/\/ \u5bf9\u5957\u63a5\u5b57\u7684\u7ba1\u7406
\n Channel _channel; \/\/ \u5bf9\u8fde\u63a5\u4e8b\u4ef6\u7684\u7ba1\u7406
\n Buffer _in_buffer; \/\/ \u8f93\u5165\u7f13\u51b2\u533a
\n Buffer _out_buffer; \/\/ \u8f93\u51fa\u7f13\u51b2\u533a
\n Any _context; \/\/ \u8fde\u63a5\u7684\u4e0a\u4e0b\u6587<\/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 ConnectedCallBack _connected_callback;
\n MessageCallBack _message_callback;
\n ClosedCallBack _closed_callback;
\n AnyEventCallBack _event_callback;
\n \/\/ \u670d\u52a1\u5668\u7684\u8fde\u63a5\u5173\u95ed\u56de\u8c03\u51fd\u6570–\u7ec4\u4ef6\u5185\u8bbe\u7f6e，\u670d\u52a1\u5668\u4f1a\u628a\u6240\u6709\u8fde\u63a5\u7ba1\u7406\u8d77\u6765
\n \/\/ \u4e00\u65e6\u67d0\u4e2a\u8fde\u63a5\u8981\u5173\u95ed，\u5c31\u5e94\u8be5\u628a\u81ea\u5df1\u7684\u4fe1\u606f\u4ece\u7ba1\u7406\u7684\u5730\u65b9\u79fb\u9664
\n ClosedCallBack _server_closed_callback;<\/p>\n

private:
\n \/\/ \u76d1\u63a7\u53ef\u8bfb\u4e8b\u4ef6\u7684\u56de\u8c03\u51fd\u6570，\u8bfb\u53d6\u7f13\u51b2\u533a\u7684\u6570\u636e\u8c03\u7528_read_callback
\n void HandleRead()
\n {
\n DBG_LOG("HANDLE READ");
\n \/\/ 1. \u63a5\u6536socket\u7684\u6570\u636e，\u653e\u5230\u7f13\u51b2\u533a
\n char buf[65536];
\n ssize_t ret = _socket.NoBlockRecv(buf, 65535);
\n if (ret < 0)
\n {
\n \/\/ \u51fa\u9519\u4e86,\u4e0d\u80fd\u76f4\u63a5\u5173\u95ed\u8fde\u63a5
\n DBG_LOG("RECV ERROR AND SHUT DOWN");
\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 {
\n DBG_LOG("_message_callback()");
\n \/\/ shared_from_this–\u4ece\u5f53\u524d\u5bf9\u8c61\u81ea\u8eab\u83b7\u53d6\u81ea\u8eab\u7684shared_ptr\u7ba1\u7406\u5bf9\u8c61
\n if (_message_callback)
\n return _message_callback(shared_from_this(), &_in_buffer);
\n DBG_LOG("_message_callback()");
\n }
\n DBG_LOG("HANDLE READ END");
\n }
\n \/\/ \u76d1\u63a7\u53ef\u5199\u4e8b\u4ef6\u7684\u56de\u8c03\u51fd\u6570，\u53d1\u9001\u7f13\u51b2\u533a\u4e2d\u7684\u6570\u636e
\n void HandleWrite()
\n {
\n DBG_LOG("HANDLE WRITE");
\n int ret = _socket.NoBlockSend(_out_buffer.ReadPosition(), _out_buffer.ReadAbleSize());
\n if (ret < 0)
\n {
\n \/\/ \u53d1\u9001\u9519\u8bef\u5c31\u8981\u5173\u95ed\u8fde\u63a5，\u4f46\u662f\u8981\u5148\u628a\u7f13\u51b2\u533a\u63a5\u6536\u5230\u5269\u4f59\u6570\u636e\u5904\u7406\u5b8c\u6bd5
\n if (_in_buffer.ReadAbleSize() > 0)
\n {
\n _message_callback(shared_from_this(), &_in_buffer);
\n }
\n return Release();
\n }
\n _out_buffer.MoveReadOffset(ret); \/\/ \u8fd9\u91cc\u5e94\u8be5\u662f\u5c06\u8bfb\u53d6\u6570\u636e\u4f4d\u7f6e\u5411\u540e\u504f\u79fb，\u800c\u4e0d\u662f\u53ef\u5199，\u53ef\u5199\u662f\u5199\u5165\u6570\u636e\u65f6\u79fb\u52a8\u7684
\n DBG_LOG("\u5269\u4f59\u6570\u636e\u91cf：%ld,status:%d", _out_buffer.ReadAbleSize(), _statu);<\/p>\n

if (_out_buffer.ReadAbleSize() == 0)
\n {
\n _channel.DisableWrite(); \/\/ \u6ca1\u6709\u6570\u636e\u8981\u53d1\u9001，\u5173\u95ed\u5199\u4e8b\u4ef6\u76d1\u63a7，\u907f\u514d\u88ab\u91cd\u590d\u89e6\u53d1
\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 {
\n return Release();
\n }
\n }<\/p>\n

\/\/ \u5982\u679c\u662f\u5f85\u5173\u95ed\u8fde\u63a5\u72b6\u6001，\u90a3\u4e48\u6709\u6570\u636e\u5c31\u5148\u5904\u7406\u6570\u636e，\u6ca1\u6709\u5219\u76f4\u63a5\u91ca\u653e
\n }
\n \/\/ \u76d1\u63a7\u5173\u95ed\u4e8b\u4ef6\u7684\u56de\u8c03\u51fd\u6570
\n void HandleClose()
\n {
\n DBG_LOG("HANDLE CLOSE");
\n if (_in_buffer.ReadAbleSize() > 0)
\n {
\n _message_callback(shared_from_this(), &_in_buffer);
\n }
\n return Release();
\n }
\n \/\/ \u76d1\u63a7\u9519\u8bef\u4e8b\u4ef6\u7684\u56de\u8c03\u51fd\u6570
\n void HandleError()
\n {
\n return HandleClose();
\n }
\n \/\/ \u76d1\u63a7\u4efb\u610f\u4e8b\u4ef6\u7684\u56de\u8c03\u51fd\u6570 1.\u5237\u65b0\u6d3b\u8dc3\u5ea6 2.\u8c03\u7528\u56de\u8c03
\n void HandleEvent()
\n {
\n if (_enable_inactive_release == true)
\n {
\n _loop->TimerRefresh(_conn_id);
\n }
\n if (_event_callback)
\n {
\n _event_callback(shared_from_this());
\n }
\n }
\n \/\/ \u8fde\u63a5\u83b7\u53d6\u4ee5\u540e\u8981\u8fdb\u884c\u5404\u79cd\u8bbe\u7f6e（\u7ed9channel\u8bbe\u7f6e\u56de\u8c03，\u542f\u52a8\u8bfb\u76d1\u63a7）
\n void EstablishedInLoop()
\n {
\n \/\/ 1.\u4fee\u6539\u8fde\u63a5\u72b6\u6001 2.\u542f\u52a8\u8bfb\u4e8b\u4ef6\u76d1\u63a7 3.\u8c03\u7528\u56de\u8c03\u51fd\u6570
\n \/\/ \u5f53\u524d\u6b65\u9aa4\u4e00\u5b9a\u662f\u5904\u4e8e\u534a\u8fde\u63a5\u72b6\u6001，\u5426\u5219\u5fc5\u7136\u662f\u51fa\u9519\u4e86
\n if (_statu != CONNECTING)
\n {
\n ERR_LOG("ESTABLISHED IN LOOP ERROR");
\n abort();
\n }
\n _statu = CONNECTED;
\n _channel.EnableRead();
\n if (_connected_callback)
\n _connected_callback(shared_from_this());
\n }
\n \/\/ \u5b9e\u9645\u7684\u91ca\u653e\u63a5\u53e3
\n void ReleaseInLoop()
\n {
\n DBG_LOG("REALEASE IN LOOP");
\n \/\/ 1.\u4fee\u6539\u8fde\u63a5\u72b6\u6001，\u8bbe\u4e3aDISCONNECTED
\n _statu = DISCONNECTED;
\n \/\/ 2.\u79fb\u9664\u8fde\u63a5\u4e8b\u4ef6\u76d1\u63a7
\n _channel.Remove();
\n \/\/ 3.\u5173\u95ed\u63cf\u8ff0\u7b26
\n _socket.Close();
\n \/\/ DBG_LOG("REALEASE IN LOOP MIDDLE");
\n \/\/ 4.\u5982\u679c\u5f53\u524d\u5b9a\u65f6\u5668\u961f\u5217\u4e2d\u8fd8\u6709\u4efb\u52a1，\u5219\u53d6\u6d88\u4efb\u52a1
\n if (_loop->HasTimer(_conn_id))
\n {
\n CancelInactiveReleaseInLoop();
\n }
\n DBG_LOG("REALEASE IN LOOP MIDDLE");
\n \/\/ 5.\u5148\u8c03\u7528\u5173\u95ed\u56de\u8c03\u51fd\u6570，\u907f\u514d\u5148\u79fb\u9664\u670d\u52a1\u5668\u5185\u90e8\u4fe1\u606f\u5bfc\u81f4Connection\u88ab\u9500\u6bc1，\u518d\u5904\u7406\u4f1a\u51fa\u9519
\n if (_closed_callback)
\n _closed_callback(shared_from_this());
\n \/\/ \u79fb\u9664\u670d\u52a1\u5668\u5185\u90e8\u7684\u8fde\u63a5\u4fe1\u606f
\n if (_server_closed_callback)
\n _server_closed_callback(shared_from_this());
\n DBG_LOG("REALEASE IN LOOP END");
\n }
\n \/\/ \u5e76\u975e\u5b9e\u9645\u7684\u6570\u636e\u53d1\u9001\u63a5\u53e3，\u53ea\u662f\u5c06\u6570\u636e\u5199\u5165\u7f13\u51b2\u533a，\u542f\u52a8\u5199\u4e8b\u4ef6
\n void SendInLoop(Buffer &buf)
\n {
\n if (_statu == DISCONNECTED)
\n return;
\n _out_buffer.WriteBufferAndPush(buf);
\n if (_channel.WriteAble() == false)
\n {
\n _channel.EnableWrite();
\n }
\n }
\n \/\/ \u5e76\u975e\u5b9e\u9645\u7684\u5173\u95ed\u8fde\u63a5\u63a5\u53e3，\u8fd8\u9700\u8981\u5224\u65ad\u6570\u636e\u662f\u5426\u5904\u7406\u5b8c\u6bd5
\n void ShutDownInLoop()
\n {
\n DBG_LOG("SHUT DWON IN LOOP");
\n _statu = DISCONNECTING;
\n if (_in_buffer.ReadAbleSize() > 0)
\n {
\n if (_message_callback)
\n _message_callback(shared_from_this(), &_in_buffer);
\n }<\/p>\n

\/\/ \u8981\u4e48\u5199\u5165\u6570\u636e\u51fa\u9519\u5173\u95ed，\u8981\u4e48\u6570\u636e\u53d1\u9001\u5b8c\u7136\u540e\u518d\u5173\u95ed
\n if (_out_buffer.ReadAbleSize() > 0)
\n {
\n if (_channel.WriteAble() == false)
\n {
\n _channel.EnableWrite();
\n }
\n }<\/p>\n

if (_out_buffer.ReadAbleSize() == 0)
\n {
\n DBG_LOG("BUFFER EMPTY AND RELEASE IN LOOP");
\n Release();
\n }
\n DBG_LOG("SHUT DOWN IN LOOP:%ld", _out_buffer.ReadAbleSize());
\n }
\n \/\/ \u542f\u52a8\u975e\u6d3b\u8dc3\u8fde\u63a5\u8d85\u65f6
\n void EnableInactiveReleaseInLoop(int sec)
\n {
\n _enable_inactive_release = true;
\n \/\/ \u5982\u679c\u5b9a\u65f6\u9500\u6bc1\u4efb\u52a1\u5df2\u7ecf\u5b58\u5728，\u5219\u9700\u8981\u5148\u5237\u65b0\u4efb\u52a1\u4e00\u4e0b
\n if (_loop->HasTimer(_conn_id))
\n {
\n return _loop->TimerRefresh(_conn_id);
\n }
\n \/\/ \u5982\u679c\u4e0d\u5b58\u5728\u5b9a\u65f6\u9500\u6bc1\u4efb\u52a1\u5219\u65b0\u589e
\n DBG_LOG("ENABLE INACTIVE RELEASE IN LOOP");
\n _loop->TimerAdd(_conn_id, sec, std::bind(&Connection::Release, this));
\n }
\n void CancelInactiveReleaseInLoop()
\n {
\n _enable_inactive_release = false;
\n if (_loop->HasTimer(_conn_id))
\n {
\n return _loop->TimerCancel(_conn_id);
\n }
\n }
\n void UpgradeInLoop(const Any &context, const ConnectedCallBack &con, const MessageCallBack &msg, const ClosedCallBack &clo, const AnyEventCallBack &evt)
\n {
\n _context = context;
\n _connected_callback = con;
\n _message_callback = msg;
\n _closed_callback = clo;
\n _event_callback = evt;
\n }<\/p>\n

public:
\n Connection(EventLoop *loop, uint64_t coon_id, int sockfd) : _conn_id(coon_id), _sockfd(sockfd), _enable_inactive_release(false), _loop(loop),
\n _statu(CONNECTING), _socket(sockfd), _channel(loop, _sockfd)
\n {
\n _channel.SetReadCallBack(std::bind(&Connection::HandleRead, this));
\n _channel.SetWriteCallBack(std::bind(&Connection::HandleWrite, this));
\n _channel.SetCloseCallBack(std::bind(&Connection::HandleClose, this));
\n _channel.SetErrorCallBack(std::bind(&Connection::HandleError, this));
\n _channel.SetEventCallBack(std::bind(&Connection::HandleEvent, this));
\n }
\n ~Connection() { DBG_LOG("RELEASE CONNECTION :%p", this); }
\n \/\/ \u53d1\u9001\u6570\u636e，\u5c06\u6570\u636e\u653e\u5230\u7f13\u51b2\u533a，\u542f\u52a8\u5199\u4e8b\u4ef6\u76d1\u63a7
\n void Send(const char *data, size_t len)
\n {
\n Buffer buf;
\n buf.WriteAndPush(data, len);
\n _loop->RunInLoop(std::bind(&Connection::SendInLoop, this, std::move(buf)));
\n }
\n int Fd()
\n {
\n return _sockfd;
\n }
\n int Id()
\n {
\n return _conn_id;
\n }
\n \/\/ \u8fdb\u884cchannel\u56de\u8c03，\u542f\u52a8\u8bfb\u76d1\u63a7，\u8c03\u7528_connected_callback
\n void Establish()
\n {
\n _loop->RunInLoop(std::bind(&Connection::EstablishedInLoop, this));
\n }
\n \/\/ \u662f\u5426\u5904\u4e8e\u8fde\u63a5\u72b6\u6001
\n bool Connected()
\n {
\n return _statu;
\n }
\n \/\/ \u8bbe\u7f6e\u4e0a\u4e0b\u6587
\n void SetContext(const Any &context)
\n {
\n _context = context;
\n }
\n \/\/ \u83b7\u53d6\u4e0a\u4e0b\u6587
\n Any *GetContext()
\n {
\n return &_context;
\n }
\n \/\/ \u8bbe\u7f6e\u56de\u8c03
\n void SetConnectedCallBack(const ConnectedCallBack &cb)
\n {
\n _connected_callback = cb;
\n }
\n void SetMessageCallBack(const MessageCallBack &cb)
\n {
\n _message_callback = cb;
\n }
\n void SetClosedCallBack(const ClosedCallBack &cb)
\n {
\n _closed_callback = cb;
\n }
\n void SetAnyEventCallBack(const AnyEventCallBack &cb)
\n {
\n _event_callback = cb;
\n }
\n void SetSrvClosedCallBack(const ClosedCallBack &cb)
\n {
\n _server_closed_callback = cb;
\n }
\n \/\/ \u63d0\u4f9b\u7ed9\u7ec4\u4ef6\u4f7f\u7528\u8005\u7684\u5173\u95ed\u63a5\u53e3，\u5e76\u4e0d\u5b9e\u9645\u5173\u95ed，\u8fd8\u9700\u8981\u5224\u65ad\u6570\u636e\u5b9e\u9645\u662f\u5426\u5904\u7406\u5b8c\u6bd5
\n void ShutDown()
\n {
\n _loop->RunInLoop(std::bind(&Connection::ShutDownInLoop, this));
\n }
\n void Release()
\n {
\n _loop->QueueInLoop(std::bind(&Connection::ReleaseInLoop, this));
\n }
\n \/\/ \u542f\u52a8\u975e\u6d3b\u8dc3\u9500\u6bc1
\n void EnableInactiveRelease(int sec)
\n {
\n _loop->RunInLoop(std::bind(&Connection::EnableInactiveReleaseInLoop, this, sec));
\n }
\n \/\/ \u53d6\u6d88\u975e\u6d3b\u8dc3\u9500\u6bc1
\n void CancelInactiveRelease()
\n {
\n _loop->RunInLoop(std::bind(&Connection::CancelInactiveReleaseInLoop, this));
\n }
\n \/\/ \u5207\u6362\u534f\u8bae-\u91cd\u7f6e\u4e0a\u4e0b\u6587\u53ca\u5904\u7406\u9636\u6bb5\u6027\u6570\u636e \u975e\u7ebf\u7a0b\u5b89\u5168
\n void Upgrade(const Any &context, const ConnectedCallBack &con, const MessageCallBack &msg, const ClosedCallBack &clo, const AnyEventCallBack &evt)
\n {
\n _loop->RunInLoop(std::bind(&Connection::UpgradeInLoop, this, context, con, msg, clo, evt));
\n }
\n}; <\/p>\n

Accepter\u6a21\u5757<\/h4>\n

\"\"<\/p>\n

class Accepter
\n{
\nprivate:
\n Socket _socket; \/\/ \u521b\u5efa\u76d1\u542c\u5957\u63a5\u5b57
\n EventLoop *_loop; \/\/ \u5bf9\u76d1\u542c\u5957\u63a5\u5b57\u8fdb\u884c\u4e8b\u4ef6\u76d1\u63a7
\n Channel _channel; \/\/ \u5bf9\u76d1\u542c\u4e8b\u4ef6\u8fdb\u884c\u4e8b\u4ef6\u7ba1\u7406<\/p>\n

using AcceptCallBack = std::function<void(int)>;
\n AcceptCallBack _accept_callback;<\/p>\n

private:
\n \/\/ \u76d1\u542c\u5957\u63a5\u5b57\u8bfb\u4e8b\u4ef6\u7684\u56de\u8c03–\u83b7\u53d6\u65b0\u8fde\u63a5 \u56de\u8c03_accept_callback
\n void HandleRead()
\n {
\n int newfd = _socket.Accept();
\n if (newfd < 0)
\n {
\n return;
\n }
\n if (_accept_callback)
\n _accept_callback(newfd);
\n }
\n int CreateServer(int port)
\n {
\n bool ret = _socket.CreateServer(port);
\n if (ret == false)
\n {
\n abort();
\n }
\n return _socket.Fd();
\n }<\/p>\n

public:
\n Accepter(EventLoop *loop, int port)
\n : _socket(CreateServer(port)),
\n _loop(loop),
\n _channel(loop, _socket.Fd())
\n {
\n _channel.SetReadCallBack(std::bind(&Accepter::HandleRead, this));
\n }
\n void SetAcceptCallBack(const AcceptCallBack &cb)
\n {
\n _accept_callback = cb;
\n }
\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 void Listen()
\n {
\n _channel.EnableRead();
\n }
\n}; <\/p>\n

LoopThread\u6a21\u5757<\/h4>\n

\"\"<\/p>\n

class LoopThread
\n{
\nprivate:
\n \/\/ \u7528\u4e8e\u5b9e\u73b0\u83b7\u53d6Loop\u7684\u540c\u6b65,\u907f\u514d\u7ebf\u7a0b\u5df2\u7ecf\u88ab\u521b\u5efa\u4e86，\u4f46\u662fEventLoop\u6ca1\u6709\u88ab\u5b9e\u4f8b\u5316\u4e4b\u524d\u5c31\u88ab\u83b7\u53d6\u5bfc\u81f4\u7684\u95ee\u9898
\n std::mutex _mutex; \/\/ \u4e92\u65a5\u9501
\n std::condition_variable _cond; \/\/ \u6761\u4ef6\u53d8\u91cf
\n EventLoop *_loop; \/\/ \u5b9e\u4f8b\u5bf9\u8c61\u9700\u8981\u5728\u7ebf\u7a0b\u5185\u518d\u5b9e\u4f8b\u5316
\n std::thread _thread; \/\/ EventLoop\u5bf9\u5e94\u7684\u7ebf\u7a0b<\/p>\n

private:
\n \/\/ \u5b9e\u4f8b\u5316EventLoop\u5bf9\u8c61，\u5f00\u59cb\u8fd0\u884cEventLoop\u6a21\u5757\u7684\u529f\u80fd
\n void ThreadEntry()
\n {
\n \/\/ \u5b9e\u4f8b\u5316\u5bf9\u8c61，\u5524\u9192\u6240\u6709\u88ab_cond.wait\u963b\u585e\u7684\u7ebf\u7a0b
\n EventLoop loop;
\n {
\n std::unique_lock<std::mutex> lock(_mutex);
\n _loop = &loop;
\n _cond.notify_all();
\n }
\n loop.Start();
\n }<\/p>\n

public:
\n \/\/ \u521b\u5efa\u7ebf\u7a0b，\u8bbe\u5b9a\u7ebf\u7a0b\u5165\u53e3\u51fd\u6570
\n LoopThread()
\n : _loop(nullptr),
\n _thread(std::thread(&LoopThread::ThreadEntry, this))
\n {
\n }
\n \/\/ \u83b7\u53d6EventLoop
\n EventLoop *GetLoop()
\n {
\n \/\/ \u7b49\u5f85_loop\u4e0d\u4e3a\u7a7a，\u4e5f\u5c31\u662f\u7ebf\u7a0b\u5df2\u7ecf\u88ab\u521b\u5efa\u5e76\u4e14EventLoop\u5bf9\u8c61\u5df2\u7ecf\u5b9e\u4f8b\u5316
\n \/\/ \u4f8b\u5982\u4e3bReactor\u7ebf\u7a0b\u5728\u521b\u5efa\u4e86LoopThread\u4e4b\u540e\u5c31\u7acb\u523b\u83b7\u53d6EventLoop\u5bf9\u8c61，\u8fd9\u65f6\u5019\u5bf9\u8c61\u8fd8\u6ca1\u6709\u5b9e\u4f8b\u5316\u5c31\u4f1a\u5bfc\u81f4\u95ee\u9898
\n EventLoop *loop = nullptr;
\n {
\n std::unique_lock<std::mutex> lock(_mutex);
\n _cond.wait(lock, [&](){ return _loop != nullptr; });
\n loop = _loop;
\n }<\/p>\n

return loop;
\n }
\n}; <\/p>\n

\u7ed3\u5408\u4e0a\u8ff0\u7684\u5206\u6790\u6240\u4ee5\u6211\u4eec\u8981\u6784\u9020\u4e00\u4e2a\u65b0\u6a21\u5757<\/p>\n

\"\"<\/p>\n

LoopThreadPool\u6a21\u5757<\/h4>\n

\"\"<\/p>\n

\/\/ \u7ebf\u7a0b\u6c60，\u7528\u4e8e\u5206\u53d1\u4efb\u52a1\u5230\u4e0d\u540c\u7684IO\u7ebf\u7a0b
\n\/\/ baseloop\u662f\u4e3bReactor\u6240\u5728\u7684\u7ebf\u7a0b\u7684EventLoop\u5bf9\u8c61，\u7528\u4e8e\u5206\u53d1\u5230\u5176\u4ed6IO\u7ebf\u7a0b
\n\/\/ _threads\u662f\u6240\u6709\u4eceReactor\u7ebf\u7a0b\u7684LoopThread\u5bf9\u8c61
\n\/\/ _loops\u662f\u6240\u6709\u4eceReactor\u7ebf\u7a0b\u7684EventLoop\u5bf9\u8c61
\nclass LoopThreadPool
\n{
\nprivate:
\n int _thread_count;
\n int _next_idx;
\n EventLoop *_baseloop;
\n std::vector<LoopThread *> _threads;
\n std::vector<EventLoop *> _loops;<\/p>\n

public:
\n LoopThreadPool(EventLoop *baseloop)
\n : _thread_count(0),
\n _next_idx(0),
\n _baseloop(baseloop)
\n {
\n }
\n void SetThreadCount(int count)
\n {
\n _thread_count = count;
\n }
\n void Create()
\n {
\n if (_thread_count > 0)
\n {
\n _threads.resize(_thread_count);
\n _loops.resize(_thread_count);
\n for (int i = 0; i < _thread_count; i++)
\n {
\n _threads[i] = new LoopThread();
\n _loops[i] = _threads[i]->GetLoop();
\n }
\n }
\n }
\n \/\/\u91c7\u7528\u516c\u5e73\u8f6e\u8f6c\u5206\u914d(RR\u8f6e\u8f6c)
\n EventLoop *NextLoop()
\n {
\n if (_thread_count == 0)
\n {
\n return _baseloop;
\n }
\n _next_idx = (_next_idx + 1) % _thread_count;
\n return _loops[_next_idx];
\n }
\n}; <\/p>\n

TcpServer\u6a21\u5757<\/h4>\n

\"\"<\/p>\n

\"\"<\/p>\n

class TcpServer
\n{
\n using Functor = std::function<void()>;<\/p>\n

private:
\n uint64_t _next_id; \/\/ \u81ea\u589eid
\n int _port;
\n int _timeout; \/\/ \u975e\u6d3b\u8dc3\u8fde\u63a5\u7684\u8d85\u65f6\u65f6\u95f4
\n bool _Enable_Inactive_Release; \/\/ \u662f\u5426\u542f\u52a8\u975e\u6d3b\u8dc3\u6d88\u8017\u6807\u5fd7
\n Accepter _accepter; \/\/ \u76d1\u542c\u5957\u63a5\u5b57\u7684\u7ba1\u7406\u5bf9\u8c61
\n EventLoop _baseloop; \/\/ \u4e3b\u7ebf\u7a0b\u7684EventLoop
\n LoopThreadPool _pool; \/\/ \u4ece\u7ebf\u7a0bloop\u7684\u7ebf\u7a0b\u6c60
\n std::unordered_map<uint64_t, PtrConnection> _coons; \/\/ \u4fdd\u5b58\u7ba1\u7406\u6240\u6709\u5bf9\u5e94\u8fde\u63a5\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 ConnectedCallBack _connected_callback;
\n MessageCallBack _message_callback;
\n ClosedCallBack _closed_callback;
\n AnyEventCallBack _event_callback;<\/p>\n

private:
\n \/\/ \u4e3a\u65b0\u8fde\u63a5\u6784\u5efa\u4e00\u4e2aConnection\u8fdb\u884c\u7ba1\u7406
\n void NewConnection(int fd)
\n {
\n _next_id++;
\n PtrConnection coon(new Connection(_pool.NextLoop(), _next_id, fd));
\n coon->SetMessageCallBack(_message_callback);
\n coon->SetClosedCallBack(_closed_callback);
\n coon->SetConnectedCallBack(_connected_callback);
\n coon->SetAnyEventCallBack(_event_callback);
\n coon->SetSrvClosedCallBack(std::bind(&TcpServer::RemoveConnection, this, std::placeholders::_1));
\n if (_Enable_Inactive_Release)
\n coon->EnableInactiveRelease(_timeout);
\n coon->Establish();
\n _coons[_next_id] = coon;
\n }
\n void RemoveConnectionInLoop(const PtrConnection &coon)
\n {
\n int id = coon->Id();
\n auto it = _coons.find(id);
\n if (it != _coons.end())
\n {
\n _coons.erase(it);
\n }
\n }
\n \/\/ \u4ece\u7ba1\u7406Connection\u7684_conns\u79cd\u79fb\u9664\u8fde\u63a5\u4fe1\u606f
\n void RemoveConnection(const PtrConnection &coon)
\n {
\n _baseloop.RunInLoop(std::bind(&TcpServer::RemoveConnectionInLoop, this, coon));
\n }
\n void RunAfterInLoop(const Functor &task, int delay)
\n {
\n _next_id++;
\n _baseloop.TimerAdd(_next_id, delay, task);
\n }<\/p>\n

public:
\n TcpServer(int port)
\n : _port(port),
\n _next_id(0),
\n _Enable_Inactive_Release(false),
\n _accepter(&_baseloop, port),
\n _pool(&_baseloop)
\n {<\/p>\n

_accepter.SetAcceptCallBack(std::bind(&TcpServer::NewConnection, this, std::placeholders::_1));
\n _accepter.Listen(); \/\/ \u5c06\u76d1\u542c\u4e8b\u4ef6\u6302\u5230baseloop\u4e0a\u5f00\u59cb\u76d1\u63a7
\n }
\n void SetThreadCount(int count)
\n {
\n return _pool.SetThreadCount(count);
\n }
\n void SetConnectedCallBack(const ConnectedCallBack &cb)
\n {
\n _connected_callback = cb;
\n }
\n void SetMessageCallBack(const MessageCallBack &cb)
\n {
\n _message_callback = cb;
\n }
\n void SetClosedCallBack(const ClosedCallBack &cb)
\n {
\n _closed_callback = cb;
\n }
\n void SetAnyEventCallBack(const AnyEventCallBack &cb)
\n {
\n _event_callback = cb;
\n }
\n void EnableInactiveRelease(int timeout)
\n {
\n _timeout = timeout;
\n _Enable_Inactive_Release = true;
\n }<\/p>\n

\/\/ \u7528\u4e8e\u6dfb\u52a0\u4e00\u4e2a\u5b9a\u65f6\u4efb\u52a1
\n void RunAfter(const Functor &task, int delay)
\n {
\n _baseloop.RunInLoop(std::bind(&TcpServer::RunAfterInLoop, this, task, delay));
\n }
\n void Start()
\n {
\n _pool.Create(); \/\/ \u521b\u5efa\u4ece\u5c5e\u7ebf\u7a0b
\n _baseloop.Start();
\n }
\n}; <\/p>\n

Http\u534f\u8bae\u6a21\u5757\u5b9e\u73b0<\/h3>\n

Util\u6a21\u5757<\/h4>\n

class Util
\n{
\npublic:
\n \/\/ \u5b57\u7b26\u4e32\u5206\u5272\u51fd\u6570 \u5c06src\u6309\u7167sep\u8fdb\u884c\u5206\u5272，\u5c06\u7ed3\u679c\u653e\u5165array，\u8fd4\u56de\u5206\u5272\u4e4b\u540e\u7684\u5b57\u7b26\u4e32\u6570\u91cf
\n static size_t Split(const std::string &src, const std::string &sep, std::vector<std::string> *array)
\n {
\n size_t offset = 0;
\n while (offset < src.size())
\n {
\n \/\/ \u5728src\u504f\u79fb\u91cfoffset\u5904\u5411\u540e\u67e5\u627e\u5b57\u7b26sep，\u8fd4\u56de\u67e5\u5230\u7684\u4f4d\u7f6e
\n size_t pos = src.find(sep, offset);
\n if (pos == std::string::npos)
\n {
\n if (pos == src.size())
\n break;
\n array->push_back(src.substr(offset));
\n return array->size();
\n }
\n if (pos == offset)
\n {
\n offset = pos + sep.size();
\n continue; \/\/ \u7a7a\u4e32\u4e0d\u6dfb\u52a0
\n }
\n array->push_back(src.substr(offset, pos – offset));
\n offset = pos + sep.size();
\n }<\/p>\n

return array->size();
\n }
\n \/\/ \u8bfb\u53d6\u6587\u4ef6\u5185\u5bb9
\n static bool ReadFile(const std::string filename, std::string *buf)
\n {
\n std::ifstream ifs(filename, std::ios::binary);
\n if (ifs.is_open() == false)
\n {
\n ERR_LOG("FILE %s OPEN FAILED", filename.c_str());
\n return false;
\n }
\n size_t fsize = 0;
\n ifs.seekg(0, ifs.end);
\n fsize = ifs.tellg(); \/\/ \u83b7\u53d6\u8bfb\u5199\u4f4d\u7f6e\u4e0e\u6587\u4ef6\u5f00\u5934\u7684\u504f\u79fb\u91cf，\u5c31\u662f\u6587\u4ef6\u5927\u5c0f
\n ifs.seekg(0, ifs.beg);
\n buf->resize(fsize);
\n ifs.read(&((*buf)[0]), fsize);
\n if (ifs.good() == false)
\n {
\n ERR_LOG("READ %s FILE FAILED", filename.c_str());
\n ifs.close();
\n return false;
\n }
\n ifs.close();
\n return true;
\n }
\n \/\/ \u5199\u5165\u6587\u4ef6\u5185\u5bb9
\n static bool WriteFile(const std::string &filename, const std::string &buf)
\n {
\n std::ofstream ofs(filename, std::ios::binary | std::ios::trunc);
\n if (ofs.is_open() == false)
\n {
\n ERR_LOG("FILE %s OPEN FAILED", filename.c_str());
\n return false;
\n }
\n ofs.write(buf.c_str(), buf.size());
\n if (ofs.good() == false)
\n {
\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\u7684\u7279\u6b8a\u5b57\u7b26\u4ea7\u751f\u6b67\u4e49
\n \/\/ RFC3986\u6587\u6863\u89c4\u5b9a，\u7f16\u7801\u683c\u5f0f\u4e3a%HH,\u5176\u4e2d\u4e5f\u89c4\u5b9a . – _ ~ \u6570\u5b57，\u5b57\u6bcd\u4e3a\u7edd\u5bf9\u4e0d\u7f16\u7801\u5b57\u7b26 \u5982C++ -> C%2B%2B
\n \/\/ W3C\u6587\u6863\u89c4\u5b9a，\u67e5\u8be2\u5b57\u7b26\u4e32\u4e2d\u7684\u7a7a\u683c，\u9700\u8981\u7f16\u7801\u4e3a+，\u67e5\u8be2\u5219\u662f+\u8f6c\u7a7a\u683c<\/p>\n

static std::string UrlEncode(const std::string &url, bool convert_space_to_plus)
\n {
\n std::string ret;
\n for (auto c : url)
\n {
\n if (c == '.' || c == '-' || c == '_' || c == '~' || isalnum(c))
\n {
\n ret += c;
\n continue;
\n }
\n if (c == ' ')
\n {
\n if (convert_space_to_plus == true)
\n {
\n ret += '+';
\n continue;
\n }
\n else
\n {
\n ret += ' ';
\n continue;
\n }
\n }
\n char tmp[4] = {0};
\n snprintf(tmp, 4, "%%%02X", c);
\n ret += tmp;
\n }<\/p>\n

return ret;
\n }<\/p>\n

static char HEXTOI(char c)
\n {
\n if (c >= '0' && c <= '9')
\n {
\n return c – '0';
\n }
\n if (c >= 'a' && c <= 'z')
\n {
\n return c – 'a' + 10;
\n }
\n if (c >= 'A' && c <= 'Z')
\n {
\n return c – 'A' + 10;
\n }
\n return -1;
\n }<\/p>\n

\/\/ Url\u89e3\u7801
\n static std::string UrlDecode(const std::string &url, bool convert_space_to_plus)
\n {
\n std::string ret;
\n \/\/ \u9047\u5230\u767e\u5206\u53f7\u5c31\u5c06\u5176\u540e\u7684\u4e24\u4e2a\u5b57\u7b26\u91cd\u65b0\u8f6c\u5316\u4e3a\u6570\u5b57，\u7b2c\u4e00\u4e2a\u5b57\u7b26\u5411\u5de6\u79fb4\u4f4d+\u7b2c\u4e8c\u4e2a\u5b57\u7b26
\n for (int i = 0; i < url.size(); i++)
\n {
\n if (url[i] == '+' && convert_space_to_plus == true)
\n {
\n ret += ' ';
\n continue;
\n }
\n if (url[i] == '%' && i + 2 < url.size())
\n {
\n char val1 = url[i + 1];
\n char val2 = url[i + 2];<\/p>\n

char v = (val1 << 4) + val2;
\n ret += v;
\n i += 2;
\n continue;
\n }
\n ret += url[i];
\n }<\/p>\n

return ret;
\n }
\n \/\/ \u54cd\u5e94\u72b6\u6001\u7801\u7684\u63cf\u8ff0\u4fe1\u606f\u83b7\u53d6
\n static std::string StatuDesc(int statu)
\n {<\/p>\n

auto it = stu_msg.find(statu);
\n if (it == stu_msg.end())
\n {
\n return "UnKnow";
\n }<\/p>\n

return it->second;
\n }
\n \/\/ \u6839\u636e\u6587\u4ef6\u540e\u7f00\u540d\u83b7\u53d6mime
\n \/**
\n * @brief \u6839\u636e\u6587\u4ef6\u540d\u83b7\u53d6\u6587\u4ef6\u7684MIME\u7c7b\u578b
\n *
\n * \u6839\u636e\u63d0\u4f9b\u7684\u6587\u4ef6\u540d，\u67e5\u627e\u5e76\u8fd4\u56de\u8be5\u6587\u4ef6\u5bf9\u5e94\u7684MIME\u7c7b\u578b\u3002
\n *
\n * @param filename \u6587\u4ef6\u540d
\n * @return \u6587\u4ef6\u7684MIME\u7c7b\u578b，\u5982\u679c\u65e0\u6cd5\u786e\u5b9a\u5219\u8fd4\u56de "application\/octet-stream"
\n *\/
\n static std::string ExtMime(const std::string &filename)
\n {<\/p>\n

size_t pos = filename.find_last_of('.');
\n if (pos == std::string::npos)
\n {
\n return "application\/ocet-stream";
\n }<\/p>\n

std::string ext = filename.substr(pos);
\n auto it = mime_msg.find(ext);
\n if (it == mime_msg.end())
\n {
\n return "application\/ocet-stream";
\n }<\/p>\n

return it->second;
\n }
\n \/\/ \u5224\u65ad\u4e00\u4e2a\u6587\u4ef6\u662f\u5426\u662f\u76ee\u5f55
\n static bool IsDirectory(const std::string &filename)
\n {
\n \/\/ \u5b9a\u4e49\u7ed3\u6784\u4f53stat\u53d8\u91cfst
\n struct stat st;<\/p>\n

\/\/ \u8c03\u7528stat\u51fd\u6570\u83b7\u53d6\u6587\u4ef6\u72b6\u6001\u4fe1\u606f，\u5c06\u7ed3\u679c\u5b58\u50a8\u5728st\u4e2d
\n int ret = stat(filename.c_str(), &st);<\/p>\n

\/\/ \u5982\u679cstat\u51fd\u6570\u8fd4\u56de\u5c0f\u4e8e0\u7684\u503c，\u8bf4\u660e\u83b7\u53d6\u6587\u4ef6\u72b6\u6001\u4fe1\u606f\u5931\u8d25
\n if (ret < 0)
\n {
\n \/\/ \u8fd4\u56defalse，\u8868\u793a\u8be5\u6587\u4ef6\u4e0d\u662f\u4e00\u4e2a\u76ee\u5f55
\n return false;
\n }<\/p>\n

\/\/ \u8fd4\u56deS_ISDIR(st.st_mode)\u7684\u7ed3\u679c，\u5982\u679c\u6587\u4ef6\u662f\u4e00\u4e2a\u76ee\u5f55，\u5219\u8fd4\u56detrue，\u5426\u5219\u8fd4\u56defalse
\n return S_ISDIR(st.st_mode);
\n }
\n \/\/ \u5224\u65ad\u4e00\u4e2a\u6587\u4ef6\u662f\u5426\u662f\u666e\u901a\u6587\u4ef6
\n static bool IsRegular(const std::string &filename)
\n {
\n struct stat st;
\n int ret = stat(filename.c_str(), &st);
\n if (ret < 0)
\n {
\n return false;
\n }<\/p>\n

return S_ISREG(st.st_mode);
\n }
\n \/\/ \u5224\u65adhttp\u8bf7\u6c42\u7684\u8d44\u6e90\u8def\u5f84\u6709\u6548\u6027
\n \/\/ \u9632\u6b62\u7528\u6237\u8bbf\u95ee\u5230\u76f8\u5bf9\u6839\u76ee\u5f55\u4e4b\u5916
\n \/\/ \u4e3b\u8981\u601d\u8def\u662f\u63a7\u5236\u76ee\u5f55\u6df1\u5ea6
\n static bool ValidPath(const std::string &path)
\n {
\n int level = 0;
\n std::vector<std::string> subdir;
\n Split(path, "\/", &subdir);
\n for (auto dir : subdir)
\n {
\n if (dir == "..")
\n {
\n level–;
\n if (level < 0)
\n {
\n return false;
\n }
\n }
\n else
\n {
\n level++;
\n }
\n }<\/p>\n

return true;
\n }
\n};<\/p>\n

class HttpRequest
\n{
\npublic:
\n std::string _method; \/\/ \u8bf7\u6c42\u65b9\u6cd5
\n std::string _path; \/\/ \u8bf7\u6c42\u8def\u5f84
\n std::string _version; \/\/ \u534f\u8bae\u7248\u672c
\n std::string _body; \/\/ \u6b63\u6587
\n std::smatch _matches; \/\/ \u8d44\u6e90\u8def\u5f84\u7684\u6b63\u5219\u63d0\u53d6\u8def\u5f84
\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
\npublic:
\n HttpRequest() : _version("HTTP\/1.1") {}
\n void ReSet()
\n {
\n _method.clear();
\n _path.clear();
\n _version="HTTP\/1.1";
\n _body.clear();
\n std::smatch tmp;
\n _matches.swap(tmp);
\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 {
\n DBG_LOG("REQ SET HEADER KEY:%s,Val:%s",key.c_str(),val.c_str());
\n _headers[key] = val;
\n }
\n \/\/ \u5224\u65ad\u662f\u5426\u6709\u5934\u90e8\u5b57\u6bb5
\n bool HasHeader(const std::string &key) const
\n {
\n auto it = _headers.find(key);
\n if (it == _headers.end())
\n {
\n return false;
\n }<\/p>\n

return true;
\n }
\n \/\/ \u83b7\u53d6\u5934\u90e8\u5b57\u6bb5
\n std::string GetHeader(const std::string &key) const
\n {
\n auto it = _headers.find(key.c_str());
\n if (it == _headers.end())
\n {
\n DBG_LOG("NOT FIND:%s",key.c_str());
\n return "";
\n }<\/p>\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 {
\n _params[key] = val;
\n }
\n \/\/ \u5224\u65ad\u662f\u5426\u6709\u67d0\u4e2a\u67e5\u8be2\u5b57\u7b26\u4e32
\n bool HasParam(const std::string &key)
\n {
\n auto it = _params.find(key);
\n if (it == _params.end())
\n {
\n return false;
\n }<\/p>\n

return true;
\n }
\n \/\/ \u83b7\u53d6\u6307\u5b9a\u67e5\u8be2\u5b57\u7b26\u4e32
\n std::string GetParam(const std::string &key)
\n {
\n auto it = _params.find(key);
\n if (it == _params.end())
\n {
\n return "";
\n }<\/p>\n

return it->second;
\n }
\n \/\/ \u83b7\u53d6\u6b63\u6587\u957f\u5ea6
\n size_t ContentLenth()
\n {
\n bool ret = HasHeader("Content-Length");
\n if (ret == false)
\n {
\n return 0;
\n }<\/p>\n

std::string len = GetHeader("Content-Length");
\n return std::stol(len);
\n }
\n \/\/ \u5224\u65ad\u662f\u5426\u662f\u77ed\u8fde\u63a5
\n bool Close () const
\n {
\n \/\/ \u6ca1\u6709Connection \u6216\u8005Connection\u7684\u503c\u4e3afalse\u90fd\u662f\u77ed\u8fde\u63a5
\n if (HasHeader("Connection") == true && GetHeader("Connection") == "keep-alive")
\n {
\n DBG_LOG("CLOSE RETURN FALSE");
\n return false;
\n }
\n return true;
\n }
\n}; <\/p>\n

HttpResquest\u6a21\u5757<\/h4>\n

\"\"<\/p>\n

class HttpRequest
\n{
\npublic:
\n std::string _method; \/\/ \u8bf7\u6c42\u65b9\u6cd5
\n std::string _path; \/\/ \u8bf7\u6c42\u8def\u5f84
\n std::string _version; \/\/ \u534f\u8bae\u7248\u672c
\n std::string _body; \/\/ \u6b63\u6587
\n std::smatch _matches; \/\/ \u8d44\u6e90\u8def\u5f84\u7684\u6b63\u5219\u63d0\u53d6\u8def\u5f84
\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
\npublic:
\n HttpRequest() : _version("HTTP\/1.1") {}
\n void ReSet()
\n {
\n _method.clear();
\n _path.clear();
\n _version="HTTP\/1.1";
\n _body.clear();
\n std::smatch tmp;
\n _matches.swap(tmp);
\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 {
\n DBG_LOG("REQ SET HEADER KEY:%s,Val:%s",key.c_str(),val.c_str());
\n _headers[key] = val;
\n }
\n \/\/ \u5224\u65ad\u662f\u5426\u6709\u5934\u90e8\u5b57\u6bb5
\n bool HasHeader(const std::string &key) const
\n {
\n auto it = _headers.find(key);
\n if (it == _headers.end())
\n {
\n return false;
\n }<\/p>\n

return true;
\n }
\n \/\/ \u83b7\u53d6\u5934\u90e8\u5b57\u6bb5
\n std::string GetHeader(const std::string &key) const
\n {
\n auto it = _headers.find(key.c_str());
\n if (it == _headers.end())
\n {
\n DBG_LOG("NOT FIND:%s",key.c_str());
\n return "";
\n }<\/p>\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 {
\n _params[key] = val;
\n }
\n \/\/ \u5224\u65ad\u662f\u5426\u6709\u67d0\u4e2a\u67e5\u8be2\u5b57\u7b26\u4e32
\n bool HasParam(const std::string &key)
\n {
\n auto it = _params.find(key);
\n if (it == _params.end())
\n {
\n return false;
\n }<\/p>\n

return true;
\n }
\n \/\/ \u83b7\u53d6\u6307\u5b9a\u67e5\u8be2\u5b57\u7b26\u4e32
\n std::string GetParam(const std::string &key)
\n {
\n auto it = _params.find(key);
\n if (it == _params.end())
\n {
\n return "";
\n }<\/p>\n

return it->second;
\n }
\n \/\/ \u83b7\u53d6\u6b63\u6587\u957f\u5ea6
\n size_t ContentLenth()
\n {
\n bool ret = HasHeader("Content-Length");
\n if (ret == false)
\n {
\n return 0;
\n }<\/p>\n

std::string len = GetHeader("Content-Length");
\n return std::stol(len);
\n }
\n \/\/ \u5224\u65ad\u662f\u5426\u662f\u77ed\u8fde\u63a5
\n bool Close () const
\n {
\n \/\/ \u6ca1\u6709Connection \u6216\u8005Connection\u7684\u503c\u4e3afalse\u90fd\u662f\u77ed\u8fde\u63a5
\n if (HasHeader("Connection") == true && GetHeader("Connection") == "keep-alive")
\n {
\n DBG_LOG("CLOSE RETURN FALSE");
\n return false;
\n }
\n return true;
\n }
\n}; <\/p>\n

HttpResponse\u6a21\u5757<\/h4>\n

\"\"<\/p>\n

class HttpResponse
\n{
\npublic:
\n int _statu;
\n bool _redirect;
\n std::string _body;
\n std::string _redirect_url;
\n std::unordered_map<std::string, std::string> _headers;<\/p>\n

public:
\n HttpResponse()
\n : _statu(200),
\n _redirect(false)
\n {
\n }
\n HttpResponse(int statu)
\n : _statu(statu),
\n _redirect(false)
\n {
\n }
\n void ReSet()
\n {
\n _statu = 200;
\n _redirect = false;
\n _body.clear();
\n _redirect_url.clear();
\n _headers.clear();
\n }
\n void SetHeader(const std::string &key, const std::string &val)
\n {
\n DBG_LOG("RES SET HEADER KEY:%s,Val:%s",key.c_str(),val.c_str());
\n _headers[key] = val;
\n }
\n bool HasHeader(const std::string &key)
\n {
\n auto it = _headers.find(key);
\n if (it == _headers.end())
\n {
\n return false;
\n }<\/p>\n

return true;
\n }
\n \/\/ \u83b7\u53d6\u6307\u5b9a\u62a5\u5934
\n std::string GetHeader(const std::string &key)
\n {
\n auto it = _headers.find(key);
\n if (it == _headers.end())
\n {
\n return "";
\n }<\/p>\n

return it->second;
\n }
\n \/\/ \u8bbe\u7f6e\u7c7b\u578b
\n void SetContent(const std::string &body, const std::string &type)
\n {
\n _body = body;
\n SetHeader("Content-Type", type);
\n }
\n \/\/ \u8bbe\u7f6e\u91cd\u5b9a\u5411
\n void SetRedirect(const std::string &url, int statu = 302)
\n {
\n _statu = statu;
\n _redirect = true;
\n _redirect_url = url;
\n }
\n \/\/ \u5224\u65ad\u662f\u5426\u4e3a\u77ed\u8fde\u63a5
\n bool Close()
\n {
\n DBG_LOG("JUDGE CLOSE");
\n \/\/ \u6ca1\u6709Connection \u6216\u8005Connection\u7684\u503c\u4e3afalse\u90fd\u662f\u77ed\u8fde\u63a5
\n if (HasHeader("Connection") == true && GetHeader("Connection") == "keep-alive")
\n {
\n return false;\/\/\u957f\u8fde\u63a5
\n }
\n DBG_LOG("TRUE:%s",GetHeader("Connection").c_str());
\n return true;
\n \/\/\u77ed\u8fde\u63a5
\n }
\n}; <\/p>\n

HttpContext\u6a21\u5757<\/h4>\n

\"\"<\/p>\n

\"\"<\/p>\n

\"\"<\/h4>\n

typedef enum
\n{
\n RECV_HTTP_ERROR,
\n RECV_HTTP_LINE,
\n RECV_HTTP_HEAD,
\n RECV_HTTP_BODY,
\n RECV_HTTP_OVER
\n} HttpRecvStatu;<\/p>\n

#define MAX_LINE 8 * 1024
\nclass HttpContext
\n{
\nprivate:
\n int _resp_statu; \/\/ \u54cd\u5e94\u72b6\u6001\u7801
\n HttpRecvStatu _recv_statu; \/\/ \u63a5\u6536\u53ca\u89e3\u6790\u7684\u72b6\u6001
\n HttpRequest _request; \/\/ \u5df2\u7ecf\u89e3\u6790\u5230\u7684\u8bf7\u6c42\u4fe1\u606f
\nprivate:
\n \/\/ \u9996\u884c\u63a5\u6536
\n bool RecvHttpLine(Buffer *buf)
\n {
\n DBG_LOG("RecvHttpLine");
\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 }<\/p>\n

if (line.size() > MAX_LINE) {
\n _recv_statu = RECV_HTTP_ERROR;
\n _resp_statu = 414;\/\/URI TOO LONG
\n return false;
\n }<\/p>\n

bool ret = ParseHttpLine(line);<\/p>\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 \/\/ \u9996\u884c\u89e3\u6790
\n bool ParseHttpLine(const std::string &line)
\n {
\n DBG_LOG("ParseHttpLine 1 %s",line.c_str());
\n std::smatch matches;<\/p>\n

std::regex e("(GET|HEAD|POST|PUT|DELETE) ([^?]*)(?:\\\\\\\\?(.*))? (HTTP\/1\\\\\\\\.[01])(?:\\\\n|\\\\r\\\\n)?", std::regex::icase);<\/p>\n

ERR_LOG("LINE=%s",line.c_str());
\n bool ret = std::regex_match(line, matches, e);<\/p>\n

if (ret == false)
\n {
\n _recv_statu = RECV_HTTP_ERROR;
\n _resp_statu = 400; \/\/ BAD REQUEST
\n return false;
\n }
\n \/\/ 0 : GET \/juhuo\/login?user=xiaoming&pass=123123 HTTP\/1.1
\n \/\/ 1 : GET
\n \/\/ 2 : \/juhuo\/login
\n \/\/ 3 : user=xiaoming&pass=123123
\n \/\/ 4 : HTTP\/1.1
\n \/\/ \u8bf7\u6c42\u65b9\u6cd5\u7684\u83b7\u53d6<\/p>\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 {
\n size_t pos = str.find("=");
\n if (pos == std::string::npos)
\n {
\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 DBG_LOG("ParseHttpLine 4");
\n return true;
\n }
\n \/\/ \u89e3\u6790\u62a5\u5934
\n bool RecvHttpHead(Buffer *buf)
\n {
\n if (_recv_statu != RECV_HTTP_HEAD)
\n \/\/if (_recv_statu != RECV_HTTP_LINE)
\n return false;
\n \/\/ \u4e00\u884c\u4e00\u884c\u89e3\u6790\u6570\u636e，\u9047\u5230\u7a7a\u884c\u7ed3\u675f
\n while (1)
\n {
\n std::string line = buf->GetLineAndPop();
\n if (line.size() == 0)
\n {
\n \/\/ \u5982\u679c\u7f13\u51b2\u533a\u6570\u636e\u4e0d\u8db3\u4e00\u884c，\u4e14\u7f13\u51b2\u533a\u6570\u636e\u8fc7\u5927，\u5219url\u53ef\u80fd\u5b58\u5728\u95ee\u9898
\n if (buf->ReadAbleSize() > MAX_LINE)
\n {
\n _recv_statu = RECV_HTTP_ERROR;
\n _resp_statu = 414; \/\/ url too long
\n return false;
\n }
\n \/\/ \u6570\u636e\u4e0d\u8db3\u4e00\u884c，\u4f46\u662f\u6570\u636e\u4e0d\u591a\u5219\u8fd4\u56de\u7b49\u5f85\u65b0\u6570\u636e
\n return true;
\n }
\n if (line.size() > MAX_LINE)
\n {
\n _recv_statu = RECV_HTTP_ERROR;
\n _resp_statu = 414; \/\/ url too long
\n return false;
\n }
\n \/\/ \u89e3\u6790\u5b8c\u6bd5，\u7ed3\u675f\u89e3\u6790
\n if (line == "\\\\n" || line == "\\\\r\\\\n")
\n {
\n break;
\n }
\n bool ret = ParseHttpHead(line);
\n if (ret = false)
\n {
\n return false;
\n }
\n }
\n \/\/ \u5934\u90e8\u5904\u7406\u5b8c\u6bd5\u8fdb\u5165\u6b63\u6587\u9636\u6bb5
\n _recv_statu = RECV_HTTP_BODY;
\n return true;
\n }
\n \/\/\u89e3\u6790\u62a5\u5934
\n bool ParseHttpHead(std::string &line)
\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 {
\n _recv_statu = RECV_HTTP_ERROR;
\n _resp_statu = 400; \/\/ BAD REQUEST
\n return false;
\n }
\n std::string key = Util::UrlDecode(line.substr(0, pos), true);
\n std::string val = Util::UrlDecode(line.substr(pos + 2), true);
\n DBG_LOG("Parse Http Head:KEY:%s,Val:%s",key.c_str(),val.c_str());
\n _request.SetHeader(key, val);
\n return true;
\n }
\n bool RecvHttpBody(Buffer *buf)
\n {
\n if (_recv_statu != RECV_HTTP_BODY)
\n return false;
\n size_t content_length = _request.ContentLenth();
\n if (content_length == 0)
\n {
\n \/\/ \u6ca1\u6709\u6b63\u6587\u5219\u8bf7\u6c42\u7ed3\u675f
\n _recv_statu = RECV_HTTP_OVER;
\n return true;
\n }
\n \/\/ \u83b7\u53d6\u6b63\u6587\u957f\u5ea6
\n \/\/ \u5f53\u524d\u5df2\u7ecf\u63a5\u6536\u591a\u5c11\u6b63\u6587
\n size_t real_length = content_length – _request._body.size(); \/\/ \u5b9e\u9645\u8fd8\u8981\u63a5\u6536\u7684\u6570\u636e\u957f\u5ea6
\n \/\/ \u63a5\u6536\u6b63\u6587\u5230body\u4e2d，\u4e5f\u8981\u8003\u8651\u5f53\u524d\u7684\u7f13\u51b2\u533a\u6570\u636e\u662f\u5426\u662f\u4e00\u4e2a\u6b63\u6587
\n \/\/ \u82e5\u6070\u597d\u5305\u542b\u5219\u76f4\u63a5\u63d0\u53d6
\n if (buf->ReadAbleSize() >= real_length)
\n {
\n _request._body.append(buf->ReadPosition(), real_length);
\n buf->MoveReadOffset(real_length);
\n _recv_statu = RECV_HTTP_OVER;
\n return true;
\n }
\n \/\/ \u82e5\u4e0d\u8db3\u5219\u7b49\u5f85\u65b0\u6570\u636e
\n _request._body.append(buf->ReadPosition(), buf->ReadAbleSize());
\n buf->MoveReadOffset(buf->ReadAbleSize());
\n return true;
\n }<\/p>\n

public:
\n HttpContext()
\n : _resp_statu(200),
\n _recv_statu(RECV_HTTP_LINE)
\n {
\n }
\n void ReSet()
\n {
\n _resp_statu = 200;
\n _recv_statu = RECV_HTTP_LINE;
\n _request.ReSet();
\n }
\n int ResponseStatu()
\n {
\n return _resp_statu;
\n }
\n HttpRecvStatu RecvStatu()
\n {
\n return _recv_statu;
\n }
\n HttpRequest &Request()
\n {
\n return _request;
\n }
\n void RecvHttpRequest(Buffer *buf)
\n {
\n DBG_LOG("RecvHttpRequest");
\n switch (_recv_statu)
\n {
\n \/\/ \u6b64\u5904\u4e0d\u9700\u8981break,\u672c\u8eab\u5c31\u9700\u8981\u6309\u7167line,head,body\u4f9d\u6b21\u63a5\u6536\u89e3\u6790！
\n case RECV_HTTP_LINE:
\n RecvHttpLine(buf);
\n case RECV_HTTP_HEAD:
\n DBG_LOG("RECV_HTTP_HEAD");
\n RecvHttpHead(buf);
\n case RECV_HTTP_BODY:
\n RecvHttpBody(buf);
\n }
\n }
\n}; <\/p>\n

HttpServer\u6a21\u5757<\/h4>\n

\"\"<\/p>\n

\"\"<\/p>\n

\"\"<\/p>\n

\"\"<\/p>\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 WriteResponse(const PtrConnection &conn, const HttpRequest &req, HttpResponse &rsp) {
\n \/\/1. \u5148\u5b8c\u5584\u5934\u90e8\u5b57\u6bb5
\n DBG_LOG("WRITE RESPONSE!!!");
\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 == 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 \/**
\n * @brief \u5224\u65ad\u8bf7\u6c42\u662f\u5426\u662f\u6587\u4ef6\u5904\u7406\u8bf7\u6c42
\n *
\n * \u8be5\u51fd\u6570\u7528\u4e8e\u5224\u65ad\u4f20\u5165\u7684 HTTP \u8bf7\u6c42\u662f\u5426\u662f\u4e00\u4e2a\u6587\u4ef6\u5904\u7406\u8bf7\u6c42\u3002
\n *
\n * @param req HTTP \u8bf7\u6c42\u5bf9\u8c61
\n * @return \u5982\u679c\u8bf7\u6c42\u662f\u6587\u4ef6\u5904\u7406\u8bf7\u6c42，\u5219\u8fd4\u56de true；\u5426\u5219\u8fd4\u56de false\u3002
\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 DBG_LOG("hahah: %s",req._path.c_str());
\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 }<\/p>\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 DBG_LOG("ON Dispatcher");
\n \/\/ \u904d\u5386\u6240\u6709\u7684\u5904\u7406\u5668
\n for (auto &handler : handlers) {
\n \/\/ \u83b7\u53d6\u6b63\u5219\u8868\u8fbe\u5f0f
\n const std::regex &re = handler.first;
\n \/\/ \u83b7\u53d6\u5904\u7406\u51fd\u6570
\n const Handler &functor = handler.second;
\n \/\/ \u4f7f\u7528\u6b63\u5219\u8868\u8fbe\u5f0f\u5bf9\u8bf7\u6c42\u7684\u8d44\u6e90\u8def\u5f84\u8fdb\u884c\u6b63\u5219\u5339\u914d
\n bool ret = std::regex_match(req._path, req._matches, re);
\n \/\/ \u5982\u679c\u5339\u914d\u5931\u8d25，\u5219\u7ee7\u7eed\u904d\u5386\u4e0b\u4e00\u4e2a\u5904\u7406\u5668
\n if (ret == false) {
\n continue;
\n }
\n \/\/ \u5339\u914d\u6210\u529f，\u8c03\u7528\u5904\u7406\u51fd\u6570，\u4f20\u5165\u8bf7\u6c42\u4fe1\u606f\u548c\u7a7a\u7684\u54cd\u5e94\u5bf9\u8c61
\n return functor(req, rsp);\/\/\u4f20\u5165\u8bf7\u6c42\u4fe1\u606f，\u548c\u7a7a\u7684rsp，\u6267\u884c\u5904\u7406\u51fd\u6570
\n }
\n \/\/ \u5982\u679c\u904d\u5386\u5b8c\u6240\u6709\u5904\u7406\u5668\u90fd\u6ca1\u6709\u5339\u914d\u5230\u5bf9\u5e94\u7684\u5904\u7406\u51fd\u6570，\u5219\u8bbe\u7f6e\u54cd\u5e94\u72b6\u6001\u4e3a404
\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 DBG_LOG("Route");
\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 DBG_LOG("ON MESSAGE 1");
\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);<\/p>\n

HttpRequest &req = context->Request();
\n HttpResponse rsp(context->ResponseStatu());
\n if (context->ResponseStatu() >= 400) {
\n \/\/\u8fdb\u884c\u9519\u8bef\u54cd\u5e94，\u5173\u95ed\u8fde\u63a5
\n DBG_LOG("ON MESSAGE ERROR");
\n ErrorHandler(req, &rsp);\/\/\u586b\u5145\u4e00\u4e2a\u9519\u8bef\u663e\u793a\u9875\u9762\u6570\u636e\u5230rsp\u4e2d
\n WriteResponse(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 WriteResponse(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)
\n {
\n DBG_LOG("rsp.close()");
\n conn->ShutDown();
\n \/\/\u77ed\u94fe\u63a5\u5219\u76f4\u63a5\u5173\u95ed
\n }
\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 if(Util::IsDirectory(path) == true)
\n _basedir = path;
\n else abort();
\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

\u7b80\u5355\u670d\u52a1\u5668\u642d\u5efa\u4f7f\u7528\u6837\u4f8b<\/h3>\n

#include "http.hpp"<\/p>\n

#define WWWROOT ".\/wwwroot\/"<\/p>\n

std::string RequestStr(const HttpRequest &req)
\n{
\n std::stringstream ss;
\n ss << req._method << " " << req._path << " " << req._version << "\\\\r\\\\n";
\n for (auto &it : req._params)
\n {
\n ss << it.first << ": " << it.second << "\\\\r\\\\n";
\n }
\n for (auto &it : req._headers)
\n {
\n ss << it.first << ": " << it.second << "\\\\r\\\\n";
\n }
\n ss << "\\\\r\\\\n";
\n ss << req._body;
\n return ss.str();
\n}
\nvoid Hello(const HttpRequest &req, HttpResponse *rsp)
\n{
\n rsp->SetContent(RequestStr(req), "text\/plain");
\n \/\/sleep(15);
\n}
\nvoid Login(const HttpRequest &req, HttpResponse *rsp)
\n{
\n rsp->SetContent(RequestStr(req), "text\/plain");
\n}
\nvoid PutFile(const HttpRequest &req, HttpResponse *rsp)
\n{
\n rsp->SetContent(RequestStr(req), "text\/plain");
\n std::string pathname = WWWROOT + req._path;
\n Util::WriteFile(pathname, req._body);
\n}
\nvoid DelFile(const HttpRequest &req, HttpResponse *rsp)
\n{
\n rsp->SetContent(RequestStr(req), "text\/plain");
\n}
\nint main()
\n{
\n HttpServer server(8085);
\n server.SetThreadCount(3);
\n server.SetBaseDir(WWWROOT); \/\/ \u8bbe\u7f6e\u9759\u6001\u8d44\u6e90\u6839\u76ee\u5f55，\u544a\u8bc9\u670d\u52a1\u5668\u6709\u9759\u6001\u8d44\u6e90\u8bf7\u6c42\u5230\u6765，\u9700\u8981\u5230\u54ea\u91cc\u53bb\u627e\u8d44\u6e90\u6587\u4ef6
\n server.Get("\/hello", Hello);
\n server.Post("\/login", Login);
\n server.Put("\/1234.txt", PutFile);
\n server.Delete("\/1234.txt", DelFile);
\n INF_LOG("\u670d\u52a1\u5668\u8bbe\u7f6e\u5b8c\u6bd5");
\n server.Listen();
\n return 0;
\n} <\/p>\n","protected":false},"excerpt":{"rendered":"

\u6587\u7ae0\u6d4f\u89c8\u9605\u8bfb1k\u6b21\uff0c\u70b9\u8d5e27\u6b21\uff0c\u6536\u85cf19\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\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\u5bb9\u3002<\/p>\n","protected":false},"author":2,"featured_media":15650,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[1],"tags":[55,1039,43],"topic":[],"class_list":["post-15670","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-server","tag-c","tag-muduo","tag-43"],"yoast_head":"\n\u4effmudou\u5e93one thread oneloop\u5f0f\u5e76\u53d1\u670d\u52a1\u5668 - \u7f51\u7855\u4e92\u8054\u5e2e\u52a9\u4e2d\u5fc3<\/title>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/www.wsisp.com\/helps\/15670.html\" \/>\n<meta property=\"og:locale\" content=\"zh_CN\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"\u4effmudou\u5e93one thread oneloop\u5f0f\u5e76\u53d1\u670d\u52a1\u5668 - \u7f51\u7855\u4e92\u8054\u5e2e\u52a9\u4e2d\u5fc3\" \/>\n<meta property=\"og:description\" content=\"\u6587\u7ae0\u6d4f\u89c8\u9605\u8bfb1k\u6b21\uff0c\u70b9\u8d5e27\u6b21\uff0c\u6536\u85cf19\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\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\u5bb9\u3002\" \/>\n<meta property=\"og:url\" content=\"https:\/\/www.wsisp.com\/helps\/15670.html\" \/>\n<meta property=\"og:site_name\" content=\"\u7f51\u7855\u4e92\u8054\u5e2e\u52a9\u4e2d\u5fc3\" \/>\n<meta property=\"article:published_time\" content=\"2025-04-18T14:12:55+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/www.wsisp.com\/helps\/wp-content\/uploads\/2025\/04\/20250418141243-68025ddb91edf.png\" \/>\n<meta name=\"author\" content=\"admin\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"\u4f5c\u8005\" \/>\n\t<meta name=\"twitter:data1\" content=\"admin\" \/>\n\t<meta name=\"twitter:label2\" content=\"\u9884\u8ba1\u9605\u8bfb\u65f6\u95f4\" \/>\n\t<meta name=\"twitter:data2\" content=\"45 \u5206\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\/\/schema.org\",\"@graph\":[{\"@type\":\"WebPage\",\"@id\":\"https:\/\/www.wsisp.com\/helps\/15670.html\",\"url\":\"https:\/\/www.wsisp.com\/helps\/15670.html\",\"name\":\"\u4effmudou\u5e93one thread oneloop\u5f0f\u5e76\u53d1\u670d\u52a1\u5668 - \u7f51\u7855\u4e92\u8054\u5e2e\u52a9\u4e2d\u5fc3\",\"isPartOf\":{\"@id\":\"https:\/\/www.wsisp.com\/helps\/#website\"},\"datePublished\":\"2025-04-18T14:12:55+00:00\",\"dateModified\":\"2025-04-18T14:12:55+00:00\",\"author\":{\"@id\":\"https:\/\/www.wsisp.com\/helps\/#\/schema\/person\/358e386c577a3ab51c4493330a20ad41\"},\"breadcrumb\":{\"@id\":\"https:\/\/www.wsisp.com\/helps\/15670.html#breadcrumb\"},\"inLanguage\":\"zh-Hans\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\/\/www.wsisp.com\/helps\/15670.html\"]}]},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\/\/www.wsisp.com\/helps\/15670.html#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"\u9996\u9875\",\"item\":\"https:\/\/www.wsisp.com\/helps\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"\u4effmudou\u5e93one thread oneloop\u5f0f\u5e76\u53d1\u670d\u52a1\u5668\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\/\/www.wsisp.com\/helps\/#website\",\"url\":\"https:\/\/www.wsisp.com\/helps\/\",\"name\":\"\u7f51\u7855\u4e92\u8054\u5e2e\u52a9\u4e2d\u5fc3\",\"description\":\"\u9999\u6e2f\u670d\u52a1\u5668_\u9999\u6e2f\u4e91\u670d\u52a1\u5668\u8d44\u8baf_\u670d\u52a1\u5668\u5e2e\u52a9\u6587\u6863_\u670d\u52a1\u5668\u6559\u7a0b\",\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\/\/www.wsisp.com\/helps\/?s={search_term_string}\"},\"query-input\":\"required name=search_term_string\"}],\"inLanguage\":\"zh-Hans\"},{\"@type\":\"Person\",\"@id\":\"https:\/\/www.wsisp.com\/helps\/#\/schema\/person\/358e386c577a3ab51c4493330a20ad41\",\"name\":\"admin\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"zh-Hans\",\"@id\":\"https:\/\/www.wsisp.com\/helps\/#\/schema\/person\/image\/\",\"url\":\"https:\/\/gravatar.wp-china-yes.net\/avatar\/?s=96&d=mystery\",\"contentUrl\":\"https:\/\/gravatar.wp-china-yes.net\/avatar\/?s=96&d=mystery\",\"caption\":\"admin\"},\"sameAs\":[\"http:\/\/wp.wsisp.com\"],\"url\":\"https:\/\/www.wsisp.com\/helps\/author\/admin\"}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"\u4effmudou\u5e93one thread oneloop\u5f0f\u5e76\u53d1\u670d\u52a1\u5668 - \u7f51\u7855\u4e92\u8054\u5e2e\u52a9\u4e2d\u5fc3","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/www.wsisp.com\/helps\/15670.html","og_locale":"zh_CN","og_type":"article","og_title":"\u4effmudou\u5e93one thread oneloop\u5f0f\u5e76\u53d1\u670d\u52a1\u5668 - \u7f51\u7855\u4e92\u8054\u5e2e\u52a9\u4e2d\u5fc3","og_description":"\u6587\u7ae0\u6d4f\u89c8\u9605\u8bfb1k\u6b21\uff0c\u70b9\u8d5e27\u6b21\uff0c\u6536\u85cf19\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\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\u5bb9\u3002","og_url":"https:\/\/www.wsisp.com\/helps\/15670.html","og_site_name":"\u7f51\u7855\u4e92\u8054\u5e2e\u52a9\u4e2d\u5fc3","article_published_time":"2025-04-18T14:12:55+00:00","og_image":[{"url":"https:\/\/www.wsisp.com\/helps\/wp-content\/uploads\/2025\/04\/20250418141243-68025ddb91edf.png"}],"author":"admin","twitter_card":"summary_large_image","twitter_misc":{"\u4f5c\u8005":"admin","\u9884\u8ba1\u9605\u8bfb\u65f6\u95f4":"45 \u5206"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"WebPage","@id":"https:\/\/www.wsisp.com\/helps\/15670.html","url":"https:\/\/www.wsisp.com\/helps\/15670.html","name":"\u4effmudou\u5e93one thread oneloop\u5f0f\u5e76\u53d1\u670d\u52a1\u5668 - \u7f51\u7855\u4e92\u8054\u5e2e\u52a9\u4e2d\u5fc3","isPartOf":{"@id":"https:\/\/www.wsisp.com\/helps\/#website"},"datePublished":"2025-04-18T14:12:55+00:00","dateModified":"2025-04-18T14:12:55+00:00","author":{"@id":"https:\/\/www.wsisp.com\/helps\/#\/schema\/person\/358e386c577a3ab51c4493330a20ad41"},"breadcrumb":{"@id":"https:\/\/www.wsisp.com\/helps\/15670.html#breadcrumb"},"inLanguage":"zh-Hans","potentialAction":[{"@type":"ReadAction","target":["https:\/\/www.wsisp.com\/helps\/15670.html"]}]},{"@type":"BreadcrumbList","@id":"https:\/\/www.wsisp.com\/helps\/15670.html#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"\u9996\u9875","item":"https:\/\/www.wsisp.com\/helps"},{"@type":"ListItem","position":2,"name":"\u4effmudou\u5e93one thread oneloop\u5f0f\u5e76\u53d1\u670d\u52a1\u5668"}]},{"@type":"WebSite","@id":"https:\/\/www.wsisp.com\/helps\/#website","url":"https:\/\/www.wsisp.com\/helps\/","name":"\u7f51\u7855\u4e92\u8054\u5e2e\u52a9\u4e2d\u5fc3","description":"\u9999\u6e2f\u670d\u52a1\u5668_\u9999\u6e2f\u4e91\u670d\u52a1\u5668\u8d44\u8baf_\u670d\u52a1\u5668\u5e2e\u52a9\u6587\u6863_\u670d\u52a1\u5668\u6559\u7a0b","potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/www.wsisp.com\/helps\/?s={search_term_string}"},"query-input":"required name=search_term_string"}],"inLanguage":"zh-Hans"},{"@type":"Person","@id":"https:\/\/www.wsisp.com\/helps\/#\/schema\/person\/358e386c577a3ab51c4493330a20ad41","name":"admin","image":{"@type":"ImageObject","inLanguage":"zh-Hans","@id":"https:\/\/www.wsisp.com\/helps\/#\/schema\/person\/image\/","url":"https:\/\/gravatar.wp-china-yes.net\/avatar\/?s=96&d=mystery","contentUrl":"https:\/\/gravatar.wp-china-yes.net\/avatar\/?s=96&d=mystery","caption":"admin"},"sameAs":["http:\/\/wp.wsisp.com"],"url":"https:\/\/www.wsisp.com\/helps\/author\/admin"}]}},"_links":{"self":[{"href":"https:\/\/www.wsisp.com\/helps\/wp-json\/wp\/v2\/posts\/15670","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.wsisp.com\/helps\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.wsisp.com\/helps\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.wsisp.com\/helps\/wp-json\/wp\/v2\/users\/2"}],"replies":[{"embeddable":true,"href":"https:\/\/www.wsisp.com\/helps\/wp-json\/wp\/v2\/comments?post=15670"}],"version-history":[{"count":0,"href":"https:\/\/www.wsisp.com\/helps\/wp-json\/wp\/v2\/posts\/15670\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.wsisp.com\/helps\/wp-json\/wp\/v2\/media\/15650"}],"wp:attachment":[{"href":"https:\/\/www.wsisp.com\/helps\/wp-json\/wp\/v2\/media?parent=15670"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.wsisp.com\/helps\/wp-json\/wp\/v2\/categories?post=15670"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.wsisp.com\/helps\/wp-json\/wp\/v2\/tags?post=15670"},{"taxonomy":"topic","embeddable":true,"href":"https:\/\/www.wsisp.com\/helps\/wp-json\/wp\/v2\/topic?post=15670"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}