![\"\"](\"https:\/\/www.wsisp.com\/helps\/wp-content\/uploads\/2025\/05\/20250520113103-682c67f78f176.png\")
<\/p>\n\u76ee\u5f55<\/p>\n
1.\u51c6\u5907\u77e5\u8bc6<\/p>\n
1.1\u65f6\u95f4\u8f6e<\/p>\n
1.2\u6b63\u5219\u8868\u8fbe\u5f0f<\/p>\n
1.3 \u901a\u7528\u7c7b\u578bAny\u7c7b\u578b\u7684\u5b9e\u73b0<\/p>\n
2.Server\u670d\u52a1\u5668\u6a21\u5757\u5b9e\u73b0：<\/p>\n
2.1 \u7f13\u51b2\u533aBuffer\u7c7b\u7684\u5b9e\u73b0<\/p>\n
2.2 \u65e5\u5fd7\u5b8f\u7684\u5b9e\u73b0<\/p>\n
\u00a02.3 \u5957\u63a5\u5b57\u6a21\u5757\u7684\u5b9e\u73b0<\/p>\n
2.4\u00a0\u4e8b\u4ef6\u7ba1\u7406Channel\u7c7b\u7684\u5b9e\u73b0<\/p>\n
2.5\u00a0\u63cf\u8ff0\u7b26\u4e8b\u4ef6\u76d1\u63a7Poller\u7c7b\u5b9e\u73b0<\/p>\n
2.6 \u5b9a\u65f6\u4efb\u52a1\u7ba1\u7406TimerWheel\u7c7b\u5b9e\u73b0<\/p>\n
2.7\u00a0Reactor-EventLoop\u7ebf\u7a0b\u6c60\u7c7b\u5b9e\u73b0<\/p>\n
\u00a02.8 \u7528\u4e8e\u7ba1\u7406\u5355\u4e2a\u4e8b\u4ef6\u5faa\u73af\u7ebf\u7a0bLoopThread\u7c7b<\/p>\n
2.9\u00a0\u00a0\u7ebf\u7a0b\u6c60\u7684\u4e3b\u8981\u903b\u8f91LoopThreadPool\u7c7b<\/p>\n
\u00a02.10 Any\u7c7b\u4ee3\u7801\u7684\u5b9e\u73b0<\/p>\n
2.11 \u901a\u4fe1\u8fde\u63a5\u7ba1\u7406Connection\u7c7b\u5b9e\u73b0<\/p>\n
\u00a02.12 \u76d1\u542c\u63cf\u8ff0\u7b26\u7ba1\u7406Acceptor\u6a21\u5757<\/p>\n
2.13 \u670d\u52a1\u5668\u7c7bTcpServer\u7c7b\u7684\u5b9e\u73b0<\/p>\n
3.HTTP\u534f\u8bae\u652f\u6301\u6a21\u5757\u5b9e\u73b0<\/p>\n
3.1 Util\u5b9e\u7528\u5de5\u5177\u7c7b\u5b9e\u73b0<\/p>\n
3.2 HttpRequest \u7c7b\u7684\u5b9e\u73b0<\/p>\n
3.3 HttpResponse\u7c7b\u7684\u5b9e\u73b0<\/p>\n
3.4 HttpContext\u7c7b\u7684\u5b9e\u73b0<\/p>\n
3.5 HttpServer\u7c7b\u7684\u5b9e\u73b0<\/p>\n
4.\u7ed3\u8bed<\/p>\n
\u5982\u4e0b\u56fe，\u8fd9\u5c31\u662f\u65f6\u95f4\u8f6e\u7684\u56fe\u50cf，\u63a5\u4e0b\u6765\u6211\u6765\u89e3\u91ca\u4e00\u4e0b\u8fd9\u4e2a\u65f6\u95f4\u8f6e\u7684\u539f\u7406<\/p>\n
<\/p>\n
\u00a0\u4e2d\u95f4\u7684\u6307\u9488\u6211\u4eec\u79f0\u4e3a_tick，\u7528\u6765\u8868\u793a\u73b0\u5728\u6307\u9488\u6307\u5411\u7684\u4f4d\u7f6e，\u6307\u9488\u6307\u5411\u8fd9\u4e2a\u4f4d\u7f6e\u7684\u65f6\u5019，\u5c31\u53bb\u68c0\u67e5\u8fd9\u4e2a\u4f4d\u7f6e\u4e0a\u9762\u662f\u5426\u6709\u5bf9\u5e94\u4efb\u52a1\u5230\u4e86\u65f6\u95f4，\u5982\u679c\u65f6\u95f4\u5df2\u5230，\u90a3\u4e48\u5c31\u79fb\u9664\u8fd9\u4e2a\u4efb\u52a1，\u5e76\u4e14\u6267\u884c\u8fd9\u4e2a\u5bf9\u5e94\u7684\u4efb\u52a1\u3002<\/p>\n
\u5982\u4f55\u5b9e\u73b0？<\/p>\n
\u9996\u5148\u6211\u4eec\u5b9e\u73b0\u4e00\u4e2aTimerTask\u7684\u7c7b，\u8fd9\u4e2a\u7c7b\u5c31\u662f\u7528\u6765\u5305\u542b\u5177\u4f53\u7684\u4efb\u52a1，\u8d85\u65f6\u65f6\u95f4\u7b49\u7b49，\u4ee5\u4fbf\u8fd9\u4e2a\u4efb\u52a1\u65f6\u95f4\u5230\u4e86\u7684\u65f6\u5019\u6267\u884c\u5bf9\u5e94\u7684\u4efb\u52a1<\/p>\n
\u5148\u5305\u88c5\u4efb\u52a1\u51fd\u6570<\/p>\n
using TaskFunc = std::function<void()>;
\nusing ReleaseFunc = std::function<void()>; <\/p>\n
\u5305\u542b\u7684\u79c1\u6709\u6210\u5458<\/p>\n
uint64_t _id; \/\/ \u5b9a\u65f6\u5668\u4efb\u52a1\u5bf9\u8c61id
\nuint32_t _timeout; \/\/ \u5b9a\u65f6\u4efb\u52a1\u7684\u8d85\u65f6\u65f6\u95f4
\nbool _canceled; \/\/ false-\u8868\u793a\u6ca1\u6709\u88ab\u53d6\u6d88
\nTaskFunc _task_cb; \/\/ \u5b9a\u65f6\u5668\u5bf9\u8c61\u8981\u6267\u884c\u7684\u5b9a\u65f6\u4efb\u52a1
\nReleaseFunc _release; \/\/ \u7528\u4e8e\u5220\u9664TimerWheel\u4e2d\u4fdd\u5b58\u7684\u5b9a\u65f6\u5668\u5bf9\u8c61\u4fe1\u606f <\/p>\n
\u5305\u542b\u7684\u516c\u6709\u6210\u5458\u6709\u8bbe\u7f6e\u662f\u5426\u53d6\u6d88\u4efb\u52a1\u3001\u8bbe\u7f6e\u91ca\u653e\u65f6\u7528\u6765\u5220\u9664\u5b9a\u65f6\u5668\u5bf9\u8c61\u4fe1\u606f\u7684\u51fd\u6570\u3001\u8bbe\u7f6e\u8d85\u65f6\u65f6\u95f4<\/p>\n
void Cancel()
\n{
\n _canceled = true;
\n}<\/p>\n
void SetRelease(const ReleaseFunc& cb)
\n{
\n _release = cb;
\n}<\/p>\n
uint32_t DelayTime()
\n{
\n return _timeout;
\n} <\/p>\n
TimerTask\u7684\u6574\u4f53\u4ee3\u7801\u5982\u4e0b：<\/p>\n
class TimerTask
\n{
\nprivate:
\n uint64_t _id; \/\/ \u5b9a\u65f6\u5668\u4efb\u52a1\u5bf9\u8c61id
\n uint32_t _timeout; \/\/ \u5b9a\u65f6\u4efb\u52a1\u7684\u8d85\u65f6\u65f6\u95f4
\n bool _canceled; \/\/ false-\u8868\u793a\u6ca1\u6709\u88ab\u53d6\u6d88
\n TaskFunc _task_cb; \/\/ \u5b9a\u65f6\u5668\u5bf9\u8c61\u8981\u6267\u884c\u7684\u5b9a\u65f6\u4efb\u52a1
\n ReleaseFunc _release; \/\/ \u7528\u4e8e\u5220\u9664TimerWheel\u4e2d\u4fdd\u5b58\u7684\u5b9a\u65f6\u5668\u5bf9\u8c61\u4fe1\u606f
\npublic:
\n TimerTask(uint64_t id, uint32_t delay, const TaskFunc &cb)
\n : _id(id), _timeout(delay), _task_cb(cb), _canceled(false)
\n {
\n }<\/p>\n
~TimerTask()
\n {
\n if(_canceled == false)_task_cb();
\n _release();
\n }<\/p>\n
void Cancel()
\n {
\n _canceled = true;
\n }<\/p>\n
void SetRelease(const ReleaseFunc& cb)
\n {
\n _release = cb;
\n }<\/p>\n
uint32_t DelayTime()
\n {
\n return _timeout;
\n }
\n}; <\/p>\n
\u63a5\u4e0b\u6765\u5c31\u662f\u65f6\u95f4\u8f6e\u7684\u4e3b\u4f53，\u65f6\u95f4\u8f6e_wheel\u6211\u4eec\u4f7f\u7528\u4e00\u4e2avector\u6765\u5b9e\u73b0，_tick\u6307\u9488\u904d\u5386\u5b8c\u4e00\u904d\u6570\u7ec4\u4e4b\u540e\u4ece\u5934\u5f00\u59cb\u904d\u5386\u6570\u7ec4，\u6570\u7ec4\u7684\u6bcf\u4e00\u4e2a\u4f4d\u7f6e\u4e2d，\u4e5f\u5b58\u653e\u7740\u4e00\u4e2a\u6570\u7ec4，\u8fd9\u4e2a\u6570\u7ec4\u4e2d\u5b58\u653e\u4efb\u52a1\u3002<\/p>\n
using WeakTask = std::weak_ptr<TimerTask>;
\nusing PtrTask = std::shared_ptr<TimerTask>;
\nint _tick; \/\/ \u5f53\u524d\u7684\u79d2\u9488，\u8d70\u5230\u54ea\u91cc\u91ca\u653e\u54ea\u91cc
\nint _capacity; \/\/ \u8868\u76d8\u6700\u5927\u6570\u91cf，\u5176\u5b9e\u5c31\u662f\u6700\u5927\u5ef6\u8fdf\u65f6\u95f4
\nstd::vector<std::vector<PtrTask>> _wheel;
\nstd::unordered_map<uint64_t, WeakTask> _timers; \/\/\u4f7f\u7528\u4efb\u52a1ID\u627e\u5230\u5bf9\u5e94\u7684weak_ptr <\/p>\n
\u8fd9\u91cc\u89e3\u91ca\u4e00\u4e0b\u4e3a\u4ec0\u4e48\u8981\u4f7f\u7528weak_ptr\u6765\u4f5c\u4e3a\u5bf9\u5e94TimerTask\u7684\u6307\u9488，\u56e0\u4e3aweak_ptr\u4e0d\u4f1a\u589e\u52a0\u5176\u5f15\u7528\u8ba1\u6570，\u4e0d\u5f71\u54cdshared_ptr\u4e2d\u7684\u5f15\u7528\u8ba1\u6570\u4e3a0\u65f6\u5bf9TimerTask\u7684\u6b63\u5e38\u91ca\u653e<\/p>\n
\u628aTimerTask\u4ece_timers\u4e2d\u79fb\u9664<\/p>\n
void RemoveTimer(uint16_t id)
\n{
\n auto it = _timers.find(id);
\n if(it != _timers.end())
\n {
\n _timers.erase(it);
\n }
\n} <\/p>\n
\u6dfb\u52a0\u5b9a\u65f6\u4efb\u52a1<\/p>\n
void TimerAdd(uint64_t id, uint32_t delay, const TaskFunc& cb)
\n{
\n \/\/ \u521b\u5efa\u4e00\u4e2a\u65b0\u7684
\n PtrTask pt(new TimerTask(id, delay, cb));
\n \/\/ \u8bbe\u7f6e\u91ca\u653e\u51fd\u6570
\n pt->SetRelease(std::bind(&TimerWheel::RemoveTimer, this, id));
\n \/\/ \u5f53\u524d\u6307\u9488\u7684\u4f4d\u7f6e \u52a0\u4e0a \u8d85\u65f6\u65f6\u95f4 \u9664 \u65f6\u95f4\u8f6e\u7684\u5bb9\u91cf\u5f97\u5230\u63d2\u5165\u4f4d\u7f6e
\n int pos = (_tick + delay) % _capacity;
\n _wheel[pos].push_back(pt);
\n \/\/ \u628a\u4efb\u52a1\u653e\u5165\u54c8\u5e0c\u8868\u4e2d
\n _timers[id] = WeakTask(pt);
\n} <\/p>\n
\u5237\u65b0\/\u5ef6\u8fdf\u5b9a\u65f6\u4efb\u52a1，\u8fd9\u91cc\u9700\u8981\u8bf4\u660e\u7684\u662f，\u8fd9\u91cc\u4f7f\u7528\u7684lock()，\u662f\u53ef\u4ee5\u628aweak_ptr\u63d0\u5347\u4e3ashared_ptr \u5f3a\u667a\u80fd\u6307\u9488，\u518d\u6dfb\u52a0\u4e00\u4e2aTimerTask\u8fdb\u53bb，\u76f8\u5f53\u4e8e\u628ashared_ptr\u7684\u5f15\u7528\u8ba1\u6570\u589e\u52a01，\u53d8\u76f8\u5730\u8d77\u5230\u4e86\u5237\u65b0\/\u5ef6\u8fdf\u5b9a\u65f6\u4efb\u52a1\u7684\u4f5c\u7528<\/p>\n
void TimerRefresh(uint64_t id)\/\/\u5237\u65b0\/\u5ef6\u8fdf\u5b9a\u65f6\u4efb\u52a1
\n{
\n \/\/\u901a\u8fc7\u4fdd\u5b58\u7684\u5b9a\u65f6\u5668\u5bf9\u8c61\u7684weakptr\u6784\u9020\u4e00\u4e2ashared_ptr\u51fa\u6765，\u6dfb\u52a0\u5230\u8f6e\u5b50\u4e2d
\n auto it = _timers.find(id);
\n if(it == _timers.end())
\n {
\n \/\/\u6ca1\u6709\u627e\u5230\u5b9a\u65f6\u4efb\u52a1
\n return;
\n }
\n PtrTask pt = it->second.lock();\/\/lock\u83b7\u53d6weakptr\u7ba1\u7406\u7684\u5bf9\u8c61\u5bf9\u5e94\u7684shared_ptr;
\n int delay = pt->DelayTime();
\n int pos = (_tick + delay) % _capacity;
\n _wheel[pos].push_back(pt);
\n} <\/p>\n
\u53d6\u6d88\u5b9a\u65f6\u4efb\u52a1<\/p>\n
void TimerCancel(uint64_t id)
\n{
\n auto it = _timers.find(id);
\n if(it == _timers.end())
\n {
\n \/\/\u6ca1\u6709\u627e\u5230\u5b9a\u65f6\u4efb\u52a1
\n return;
\n }
\n PtrTask pt = it->second.lock();
\n if(pt) pt->Cancel();
\n} <\/p>\n
\u6267\u884c\u5b9a\u65f6\u4efb\u52a1<\/p>\n
void RunTimeTask()
\n{
\n _tick = (_tick + 1) % _capacity;
\n _wheel[_tick].clear();
\n} <\/p>\n
\u603b\u4f53\u7684\u65f6\u95f4\u8f6e\u4ee3\u7801<\/p>\n
class TimerWheel
\n{
\nprivate:
\n using WeakTask = std::weak_ptr<TimerTask>;
\n using PtrTask = std::shared_ptr<TimerTask>;
\n int _tick; \/\/ \u5f53\u524d\u7684\u79d2\u9488，\u8d70\u5230\u54ea\u91cc\u91ca\u653e\u54ea\u91cc
\n int _capacity; \/\/ \u8868\u76d8\u6700\u5927\u6570\u91cf，\u5176\u5b9e\u5c31\u662f\u6700\u5927\u5ef6\u8fdf\u65f6\u95f4
\n std::vector<std::vector<PtrTask>> _wheel;
\n std::unordered_map<uint64_t, WeakTask> _timers; \/\/\u4f7f\u7528\u4efb\u52a1ID\u627e\u5230\u5bf9\u5e94\u7684weak_ptr
\nprivate:
\n void RemoveTimer(uint16_t id)
\n {
\n auto it = _timers.find(id);
\n if(it != _timers.end())
\n {
\n _timers.erase(it);
\n }
\n }
\npublic:
\n TimerWheel()
\n : _capacity(60),
\n _tick(0),
\n _wheel(_capacity)
\n {
\n }
\n void TimerAdd(uint64_t id, uint32_t delay, const TaskFunc& cb) \/\/\u6dfb\u52a0\u5b9a\u65f6\u4efb\u52a1
\n {
\n PtrTask pt(new TimerTask(id, delay, cb));
\n pt->SetRelease(std::bind(&TimerWheel::RemoveTimer, this, id));
\n int pos = (_tick + delay) % _capacity;
\n _wheel[pos].push_back(pt);
\n _timers[id] = WeakTask(pt);
\n }
\n void TimerRefresh(uint64_t id)\/\/\u5237\u65b0\/\u5ef6\u8fdf\u5b9a\u65f6\u4efb\u52a1
\n {
\n \/\/\u901a\u8fc7\u4fdd\u5b58\u7684\u5b9a\u65f6\u5668\u5bf9\u8c61\u7684weakptr\u6784\u9020\u4e00\u4e2ashared_ptr\u51fa\u6765，\u6dfb\u52a0\u5230\u8f6e\u5b50\u4e2d
\n auto it = _timers.find(id);
\n if(it == _timers.end())
\n {
\n \/\/\u6ca1\u6709\u627e\u5230\u5b9a\u65f6\u4efb\u52a1
\n return;
\n }
\n PtrTask pt = it->second.lock();\/\/lock\u83b7\u53d6weakptr\u7ba1\u7406\u7684\u5bf9\u8c61\u5bf9\u5e94\u7684shared_ptr;
\n int delay = pt->DelayTime();
\n int pos = (_tick + delay) % _capacity;
\n _wheel[pos].push_back(pt);
\n }
\n void TimerCancel(uint64_t id)
\n {
\n auto it = _timers.find(id);
\n if(it == _timers.end())
\n {
\n \/\/\u6ca1\u6709\u627e\u5230\u5b9a\u65f6\u4efb\u52a1
\n return;
\n }
\n PtrTask pt = it->second.lock();
\n if(pt) pt->Cancel();
\n }
\n \/\/\u8fd9\u4e2a\u51fd\u6570\u6bcf\u79d2\u88ab\u6267\u884c\u4e00\u6b21，\u76f8\u5f53\u4e8e\u79d2\u9488\u5411\u540e\u8d70\u4e86\u4e00\u6b65
\n void RunTimeTask()
\n {
\n _tick = (_tick + 1) % _capacity;
\n _wheel[_tick].clear();
\n }
\n}; <\/p>\n
\u9996\u5148，\u5fc5\u4e0d\u53ef\u5c11\u7684，\u662f\u5bf9http\u8bf7\u6c42\u884c\u7684\u89e3\u6790，\u4f46\u662f，\u5982\u679c\u76f4\u63a5\u624b\u6495\u8bf7\u6c42\u884c，\u628a\u8bf7\u6c42\u884c\u5206\u4e3a\u591a\u4e2a\u90e8\u5206，\u672a\u514d\u6709\u4e9b\u9ebb\u70e6，\u6240\u4ee5\u6211\u4eec\u9009\u62e9\u4f7f\u7528\u6b63\u5219\u8868\u8fbe\u5f0f\u6765\u89e3\u6790\u8bf7\u6c42\u884c，\u66f4\u4e3a\u7cbe\u786e\u9ad8\u6548，<\/p>\n
\u9996\u5148\u6211\u4eec\u9700\u8981\u77e5\u9053HTTP\u8bf7\u6c42\u884c\u7684\u57fa\u672c\u7ed3\u6784<\/p>\n
<HTTP\u65b9\u6cd5> <\u8bf7\u6c42\u76ee\u6807> <HTTP\u7248\u672c><\/p>\n
\u00a0HTTP\u65b9\u6cd5\u5305\u62ecGET\u3001POST\u3001PUT\u3001DELETE\u7b49\u65b9\u6cd5<\/p>\n
\u8bf7\u6c42\u76ee\u6807\u5c31\u662f\u7528\u6237\u60f3\u8981\u8bf7\u6c42\u8d44\u6e90\u7684\u5bf9\u5e94\u8def\u5f84<\/p>\n
\u4e0b\u9762\u662f\u4e00\u4e2aHTTP\u8bf7\u6c42\u884c\u7684\u4f8b\u5b50：<\/p>\n
GET \/helloworld\/index?user=diluodexingzi&pass=123456 HTTP\/1.1\\\\r\\\\n<\/p>\n
\u00a0\u9996\u5148\u6211\u4eec\u9700\u8981\u5339\u914dHTTP\u65b9\u6cd5，\u5982\u4e0b：<\/p>\n
(GET|HEAD|POST|PUT|DELETE)\u00a0<\/p>\n
| \u4ee3\u8868\u6216\u7684\u610f\u601d，\u8868\u793a\u4ece\u8fd9\u51e0\u4e2a\u5e38\u89c1\u7684HTTP\u65b9\u6cd5\u4e2d\u9009\u62e9\u4e00\u4e2a<\/p>\n
\u63a5\u4e0b\u6765\u6211\u4eec\u9700\u8981\u6765\u5339\u914d\u8d44\u6e90\u8def\u5f84<\/p>\n
\u00a0([^?]*)<\/p>\n
[^?]\u8868\u793a\u5339\u914d\u7684\u662f\u975e?\u7684\u5b57\u7b26，\u52a0\u4e0a\u540e\u9762\u7684*\u5c31\u8868\u793a\u5339\u914d\u975e？\u5b57\u7b260\u6b21\u6216\u591a\u6b21<\/p>\n
\u00a0\u540e\u9762\u7684user=diluodexingzi&pass=123456\u662f\u6211\u4eec\u4e0d\u9700\u8981\u83b7\u53d6\u7684，\u53ea\u5339\u914d\u4f46\u662f\u4e0d\u6355\u83b7<\/p>\n
(?:\\\\\\\\?(.*))?<\/p>\n
(?:pattern)\u8868\u793a\u5339\u914dpattern\u4f46\u662f\u4e0d\u83b7\u53d6\u5339\u914d\u7ed3\u679c<\/p>\n
\\\\\\\\? \u8868\u793a\u539f\u59cb\u7684?\u5b57\u7b26，\u8fd9\u91cc\u8868\u793a\u4ee5?\u5b57\u7b26\u4f5c\u4e3a\u8d77\u59cb<\/p>\n
.*\u4ee3\u8868\u63d0\u53d6\u9664\\\\n\u4e4b\u5916\u7684\u4efb\u610f\u5b57\u7b260\u6b21\u6216\u591a\u6b21<\/p>\n
\u6700\u540e\u7684?\u8868\u793a\u5339\u914d\u524d\u9762\u7684\u8868\u8fbe\u5f0f0\u6b21\u6216\u8005\u4e00\u6b21，\u6709\u7684\u8bf7\u6c42\u662f\u6ca1\u6709\u67e5\u8be2\u5b57\u7b26\u4e32\u7684<\/p>\n
\u00a0\u6700\u540e\u6765\u5339\u914dHTTP\u7248\u672c<\/p>\n
(HTTP\/1\\\\\\\\.[01])(?:\\\\n|\\\\r\\\\n)?<\/p>\n
HTTP\/1 \u8868\u793a\u4ee5HTTP\/1\u5f00\u59cb\u7684\u5b57\u7b26\u4e32<\/p>\n
\\\\\\\\. \u8868\u793a\u5339\u914d . \u539f\u59cb\u5b57\u7b26<\/p>\n
[01]\u8868\u793a\u5339\u914d\u5b57\u7b26\u4e320\u6216\u80051\u5b57\u7b26<\/p>\n
(?:\\\\r\\\\n) \u8868\u793a\u5339\u914d\u4e00\u4e2a\\\\r\\\\n\u6216\u8005\\\\n\u5b57\u7b26，\u4f46\u662f\u4e0d\u6355\u6349\u8fd9\u4e2a\u5185\u5bb9<\/p>\n
\u603b\u7684\u6765\u8bf4\u5c31\u662f\u5339\u914d\u4ee5HTTP\/1.\u5f00\u59cb，\u540e\u9762\u8ddf\u4e86\u4e00\u4e2a0\u62161\u7684\u5b57\u7b26，\u4e14\u6700\u7ec8\u4ee5\\\\n\u6216\u8005\\\\r\\\\n\u4f5c\u4e3a\u7ed3\u5c3e\u7684\u5b57\u7b26\u4e32<\/p>\n
\u6bcf\u4e00\u4e2aConnection\u5bf9\u8fde\u63a5\u8fdb\u884c\u7ba1\u7406，\u6700\u7ec8\u90fd\u4e0d\u53ef\u907f\u514d\u9700\u8981\u6d89\u53ca\u5230\u5e94\u7528\u5c42\u534f\u8bae\u7684\u5904\u7406，\u56e0\u6b64\u5728Connection\u4e2d\u9700\u8981\u8bbe\u7f6e\u534f\u8bae\u5904\u7406\u7684\u4e0a\u4e0b\u6587\u6765\u63a7\u5236\u5904\u7406\u8282\u594f\u3002\u4f46\u662f\u5e94\u7528\u5c42\u534f\u8bae\u5343\u5343\u4e07，\u4e3a\u4e86\u964d\u4f4e\u8026\u5408\u5ea6，\u8fd9\u4e2a\u534f\u8bae\u63a5\u6536\u89e3\u6790\u4e0a\u4e0b\u6587\u5c31\u4e0d\u80fd\u6709\u660e\u663e\u7684\u534f\u8bae\u503e\u5411，\u5b83\u53ef\u4ee5\u662f\u4efb\u610f\u534f\u8bae\u7684\u4e0a\u4e0b\u6587\u4fe1\u606f\u56e0\u6b64\u5c31\u9700\u8981\u4e00\u4e2a\u901a\u7528\u7684\u7c7b\u578b\u6765\u4fdd\u5b58\u5404\u79cd\u4e0d\u540c\u7684\u6570\u636e\u7ed3\u6784\u3002<\/p>\n
\u4e3a\u4e86\u589e\u52a0\u4ee3\u7801\u7684\u53ef\u79fb\u690d\u6027，\u6211\u4eec\u51cf\u5c11\u5bf9\u7b2c\u4e09\u65b9\u5e93\u7684\u4f9d\u8d56，\u51b3\u5b9a\u81ea\u5df1\u6765\u5b9e\u73b0\u3002<\/p>\n
Any\u7c7b\u80af\u5b9a\u4e0d\u80fd\u662f\u4e00\u4e2a\u6a21\u7248\u7c7b，\u5426\u5219\u7f16\u8bd1\u7684\u65f6\u5019Any<int> a，Any<float> b，\u9700\u8981\u4f20\u5165\u7c7b\u578b\u4f5c\u4e3a\u6a21\u7248\u53c2\u6570，\u4e5f\u5c31\u662f\u8bf4\u5728\u4f7f\u7528\u7684\u65f6\u5019\u5c31\u8981\u786e\u5b9a\u5176\u7c7b\u578b\u3002 \u8fd9\u662f\u4e0d\u53ef\u4ee5\u7684，\u56e0\u4e3a\u4fdd\u5b58\u5728Content\u4e2d\u7684\u534f\u8bae\u4e0a\u4e0b\u6587，\u6211\u4eec\u5728\u5b9a\u4e49any\u5bf9\u8c61\u7684\u65f6\u5019\u662f\u4e0d\u77e5\u9053\u4ed6\u4eec\u7684\u534f\u8bae\u7c7b\u578b\u7684，\u56e0\u6b64\u65e0\u6cd5\u4f20\u9012\u7c7b\u578b\u4f5c\u4e3a\u6a21\u7248\u53c2\u6570 \u56e0\u6b64\u8003\u8651Any\u5185\u90e8\u8bbe\u8ba1\u4e00\u4e2a\u6a21\u7248\u5bb9\u5668holder\u7c7b，\u53ef\u4ee5\u4fdd\u5b58\u5404\u79cd\u7c7b\u578b\u6570\u636e \u800c\u56e0\u4e3a\u5728Any\u7c7b\u4e2d\u65e0\u6cd5\u5b9a\u4e49\u8fd9\u4e2aholder\u5bf9\u8c61\u6216\u6307\u9488，\u56e0\u4e3aAny\u4e5f\u4e0d\u77e5\u9053\u8fd9\u4e2a\u7c7b\u8981\u4fdd\u5b58\u4ec0\u4e48\u7c7b\u578b\u7684\u6570\u636e，\u56e0\u6b64\u65e0\u6cd5\u4f20\u9012\u7c7b\u578b\u53c2\u6570 \u6240\u4ee5\u3002\u5b9a\u4e49\u4e00\u4e2a\u57fa\u7c7bplaceholder，\u8ba9holder\u7ee7\u627f\u4e8eplaceholder，\u800cAny\u7c7b\u4fdd\u5b58\u7236\u7c7b\u6307\u9488\u5373\u53ef \u5f53\u9700\u8981\u4fdd\u5b58\u6570\u636e\u65f6，\u5219new\u4e00\u4e2a\u5e26\u6709\u6a21\u7248\u53c2\u6570\u7684\u5b50\u7c7bholder\u5bf9\u8c61\u53bb\u4fdd\u5b58\u6570\u636e\u3002\u7136\u540e\u8ba9Any\u7c7b\u4e2d\u7684\u7236\u7c7b\u6307\u9488，\u6307\u5411\u8fd9\u4e2a\u5b50\u7c7b\u5bf9\u8c61\u5c31\u53ef\u4ee5\u4e86<\/p>\n
Any\u7c7b\u7684\u5177\u4f53\u5b9e\u73b0：<\/p>\n
class Any
\n{
\nprivate:
\n class holder
\n {
\n public:
\n virtual ~holder()
\n {}
\n \/\/ \u6570\u636e\u7c7b\u578b
\n virtual const std::type_info& type() = 0;
\n \/\/ \u514b\u9686\u51fa\u65b0\u7684\u5bf9\u8c61
\n virtual holder* clone() = 0;
\n };
\n template<class T>
\n class placeholder: public holder
\n {
\n public:
\n placeholder(const T& val): _val(val){}
\n \/\/ \u83b7\u53d6\u5b50\u7c7b\u5bf9\u8c61\u4fdd\u5b58\u7684\u6570\u636e\u7c7b\u578b
\n virtual const std::type_info& type()
\n {
\n return typeid(T);
\n }
\n \/\/ \u9488\u5bf9\u51fa\u5f53\u524d\u7684\u5bf9\u8c61\u81ea\u8eab，\u514b\u9686\u51fa\u4e00\u4e2a\u65b0\u7684\u5bf9\u8c61
\n virtual holder* clone()
\n {
\n return new placeholder(_val);
\n }
\n public:
\n T _val;
\n };
\n holder* _content;
\n public:
\n Any():_content(NULL){}
\n template<class T>
\n Any(const T& val):_content(new placeholder<T>(val)){}
\n Any(const Any& other):_content(other._content ? other._content->clone() : NULL) {}
\n ~Any(){ delete _content;}<\/p>\n
Any &swap(Any& other)
\n {
\n std::swap(_content, other._content);
\n return *this;
\n } <\/p>\n
template<class T>
\n \/\/\u8fd4\u56de\u5b50\u7c7b\u5bf9\u8c61\u4fdd\u5b58\u7684\u6570\u636e\u7684\u6307\u9488
\n T* get()
\n {
\n \/\/ \u60f3\u8981\u83b7\u53d6\u7684\u6570\u636e\u7c7b\u578b，\u5fc5\u987b\u548c\u4fdd\u5b58\u7684\u6570\u636e\u7c7b\u578b\u4e00\u81f4
\n \/\/if(typeid(T) != _content->type()) return NULL;
\n assert(typeid(T) == _content->type());
\n return &((placeholder<T>*)_content)->_val;
\n }
\n \/\/\u8d4b\u503c\u8fd0\u7b97\u7b26\u91cd\u8f7d\u51fd\u6570
\n template<class T>
\n Any& operator=(const T& val)
\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
\n \/\/\u4e34\u65f6\u5bf9\u8c61\u91ca\u653e\u7684\u65f6\u5019，\u539f\u5148\u4fdd\u5b58\u7684\u6570\u636e\u4e5f\u5c31\u88ab\u91ca\u653e\u4e86
\n Any(val).swap(*this);
\n return *this;
\n }
\n Any& operator=(const Any& other)
\n {
\n Any(other).swap(*this);
\n return *this;
\n }
\n}; <\/p>\n
Buffer\u7c7b\u7528\u4e8e\u5b9e\u73b0\u7528\u6237\u6001\u7f13\u51b2\u533a，\u63d0\u4f9b\u6570\u636e\u7f13\u51b2，\u53d6\u51fa\u7684\u529f\u80fd<\/p>\n
\u9996\u5148Buffer\u8fd9\u4e2a\u7c7b\u6709\u4e09\u4e2a\u79c1\u6709\u6210\u5458\u53d8\u91cf，\u5206\u522b\u662f_buffer，_reader_idx，_writer_idx\u3002\u8fd9\u4e09\u4e2a\u79c1\u6709\u6210\u5458\u5206\u522b\u4ee3\u8868\u7f13\u51b2\u533a，\u8bfb\u504f\u79fb\u548c\u5199\u504f\u79fb\u3002\u9700\u8981\u89e3\u91ca\u7684\u662f\u8bfb\u504f\u79fb\u662f\u6307\u8bfb\u5230\u7684\u4f4d\u7f6e，\u5199\u504f\u79fb\u662f\u6307\u5df2\u7ecf\u5199\u8fdb\u7f13\u51b2\u533a\u4e2d\u7684\u4f4d\u7f6e<\/p>\n
\u79c1\u6709\u6210\u5458\u53d8\u91cf\u7684\u4ee3\u7801\u5982\u4e0b：<\/p>\n
\/\/ \u4f7f\u7528vector\u8fdb\u884c\u5185\u5b58\u7a7a\u95f4\u7ba1\u7406
\nstd::vector<char> _buffer;
\nuint64_t _reader_idx; \/\/ \u8bfb\u504f\u79fb
\nuint64_t _writer_idx; \/\/ \u5199\u504f\u79fb <\/p>\n
\u9996\u5148\u6211\u4eec\u9700\u8981\u6709\u4e2a\u51fd\u6570\u80fd\u8fd4\u56de\u8fd9\u4e2a_buffer\u7684\u8d77\u59cb\u5730\u5740<\/p>\n
char* Begin()
\n{
\n return &*_buffer.begin();
\n} <\/p>\n
_buffer.begin()\u8fd4\u56de\u7684\u662f\u8fed\u4ee3\u5668\u7684\u521d\u59cb\u4f4d\u7f6e，\u6211\u4eec\u9700\u8981\u5bf9\u8fed\u4ee3\u5668\u8fdb\u884c\u89e3\u5f15\u7528\u7136\u540e\u53d6\u5730\u5740\u624d\u80fd\u83b7\u5f97char*\u7684\u5730\u5740\u3002<\/p>\n
\u7136\u540e\u6211\u4eec\u4e5f\u9700\u8981\u83b7\u5f97\u5f53\u524d\u5199\u5165\u8d77\u59cb\u5730\u5740\u548c\u5f53\u524d\u8bfb\u53d6\u8d77\u59cb\u5730\u5740<\/p>\n
\/\/ \u83b7\u53d6\u5f53\u524d\u5199\u5165\u8d77\u59cb\u5730\u5740
\nchar *WritePosition()
\n{
\n \/\/_buffer\u7684\u7a7a\u95f4\u8d77\u59cb\u5730\u5740，\u52a0\u4e0a\u5199\u504f\u79fb\u91cf
\n return Begin() + _writer_idx;
\n}
\n\/\/ \u83b7\u53d6\u5f53\u524d\u8bfb\u53d6\u8d77\u59cb\u5730\u5740
\nchar *ReadPosition()
\n{
\n return Begin() + _reader_idx;
\n} <\/p>\n
\u83b7\u5f97\u7f13\u51b2\u533a\u672b\u5c3e\u548c\u8d77\u59cb\u7a7a\u95f4\u7684\u5927\u5c0f<\/p>\n
\/\/ \u83b7\u53d6\u7f13\u51b2\u533a\u672b\u5c3e\u7a7a\u95f2\u7a7a\u95f4\u5927\u5c0f–\u5199\u504f\u79fb\u4e4b\u540e\u7684\u7a7a\u95f2\u7a7a\u95f4
\nuint64_t TailIdleSize()
\n{
\n return _buffer.size() – _writer_idx;
\n}
\n\/\/ \u83b7\u53d6\u7f13\u51b2\u533a\u8d77\u59cb\u7a7a\u95f2\u7a7a\u95f4\u5927\u5c0f–\u8bfb\u504f\u79fb\u4e4b\u524d\u7684\u7a7a\u95f2\u7a7a\u95f4
\nuint64_t HeadIdleSize()
\n{
\n return _reader_idx;
\n} <\/p>\n
\u53ef\u8bfb\u6570\u636e\u7684\u5927\u5c0f\u5373\u662f\u5199\u504f\u79fb\u51cf\u53bb\u8bfb\u504f\u79fb<\/p>\n
\/\/ \u83b7\u53d6\u53ef\u8bfb\u6570\u636e\u5927\u5c0f
\nuint64_t ReadAbleSize()
\n{
\n return _writer_idx – _reader_idx;
\n} <\/p>\n
\u8bfb\u5b8c\u6570\u636e\u6216\u8005\u5199\u5b8c\u6570\u636e\u90fd\u9700\u8981\u5c06\u8bfb\u504f\u79fb\u548c\u5199\u504f\u79fb\u5411\u540e\u79fb\u52a8<\/p>\n
\/\/ \u5c06\u8bfb\u504f\u79fb\u5411\u540e\u79fb\u52a8
\nvoid 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\u7684\u5927\u5c0f
\n assert(len <= ReadAbleSize());
\n _reader_idx += len;
\n}
\n\/\/ \u5c06\u5199\u504f\u79fb\u5411\u540e\u79fb\u52a8
\nvoid 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 assert(len <= TailIdleSize());
\n _writer_idx += len;
\n} <\/p>\n
\u7136\u540e，\u6211\u4eec\u4e5f\u9700\u8981\u786e\u4fdd\u53ef\u5199\u7684\u7a7a\u95f4\u8db3\u591f，\u5982\u679c\u7a7a\u95f4\u591f\u5c31\u76f4\u63a5\u79fb\u52a8\u6570\u636e\u3002<\/p>\n
\u95ee\u9898\u6765\u4e86，\u5982\u4f55\u79fb\u52a8\u6570\u636e？<\/p>\n
\u5f88\u7b80\u5355，\u5373\u628a\u5728\u8bfb\u504f\u79fb\u548c\u5199\u504f\u79fb\u4e4b\u95f4\u7684\u6570\u636e\u90fd\u79fb\u52a8\u5230_buffer\u7684\u8d77\u59cb\u4f4d\u7f6e，\u8fd9\u91cc\u9700\u8981\u7528\u5230std::copy\u51fd\u6570，\u4e0b\u9762\u662f\u6211\u4eec\u9700\u8981\u7528\u5230\u7684copy\u51fd\u6570\u7684\u5b9a\u4e49<\/p>\n
inline char *std::copy<char *, char *>(char *__first, char *__last, char *__result)<\/p>\n
\u7b2c\u4e00\u4e2a\u548c\u7b2c\u4e8c\u4e2a\u53c2\u6570\u5206\u522b\u8868\u793a\u6570\u636e\u7684\u8d77\u59cb\u4f4d\u7f6e\u548c\u7ed3\u675f\u4f4d\u7f6e，\u7b2c\u4e09\u4e2a\u53c2\u6570\u5219\u8868\u793a\u62f7\u8d1d\u5230\u7684\u4f4d\u7f6e<\/p>\n
\u5982\u679c\u5373\u4f7f\u79fb\u52a8\u6570\u636e，\u7a7a\u95f4\u8fd8\u662f\u4e0d\u591f，\u6211\u4eec\u5c31\u9700\u8981\u6269\u5bb9，\u4f7f\u7528\u5230\u7684\u51fd\u6570\u662fresize\u00a0<\/p>\n
\u4e0b\u9762\u662f\u8be6\u7ec6\u4ee3\u7801<\/p>\n
\/\/ \u786e\u4fdd\u53ef\u5199\u7a7a\u95f4\u8db3\u591f(\u8db3\u591f\u5c31\u79fb\u52a8\u6570\u636e，\u5426\u5219\u5c31\u6269\u5bb9)
\nvoid EnsureWriteSpace(uint64_t len)
\n{
\n \/\/ \u5982\u679c\u672b\u5c3e\u7a7a\u95f2\u7a7a\u95f4\u5927\u5c0f\u8db3\u591f，\u76f4\u63a5\u8fd4\u56de
\n if (TailIdleSize() >= len)
\n {
\n return;
\n }
\n \/\/ \u672b\u5c3e\u7a7a\u95f2\u7a7a\u95f4\u4e0d\u591f，\u5219\u5224\u65ad\u52a0\u4e0a\u8d77\u59cb\u4f4d\u7f6e\u7684\u7a7a\u95f2\u7a7a\u95f4\u5927\u5c0f\u662f\u5426\u8db3\u591f，\u591f\u4e86\u5c31\u5c06\u6570\u636e\u79fb\u52a8\u5230\u8d77\u59cb\u4f4d\u7f6e
\n if (len <= TailIdleSize() + HeadIdleSize())
\n {
\n \/\/ \u5c06\u6570\u636e\u79fb\u52a8\u5230\u8d77\u59cb\u4f4d\u7f6e
\n uint64_t rsz = ReadAbleSize();
\n \/\/ \u628a\u53ef\u8bfb\u6570\u636e\u62f7\u8d1d\u5230\u8d77\u59cb\u4f4d\u7f6e
\n std::copy(ReadPosition(), ReadPosition() + rsz, Begin());
\n _reader_idx = 0; \/\/ \u5c06\u8bfb\u504f\u79fb\u5f520
\n _writer_idx = rsz; \/\/ \u5c06\u5199\u4f4d\u7f6e\u7f6e\u4e3a\u53ef\u8bfb\u6570\u636e\u5927\u5c0f，\u56e0\u4e3a\u5f53\u524d\u7684\u53ef\u8bfb\u6570\u636e\u5927\u5c0f\u5c31\u662f\u5199\u504f\u79fb\u91cf
\n }
\n else
\n {
\n \/\/ \u603b\u4f53\u7a7a\u95f4\u4e0d\u591f，\u5219\u9700\u8981\u6269\u5bb9，\u4e0d\u79fb\u52a8\u6570\u636e，\u76f4\u63a5\u7ed9\u5199\u504f\u79fb\u4e4b\u540e\u6269\u5bb9\u8db3\u591f\u7a7a\u95f4\u5373\u53ef
\n DBG_LOG("RESIZE %ld", _writer_idx + len);
\n _buffer.resize(_writer_idx + len);
\n }
\n} <\/p>\n
\u8981\u5199\u5165\u6570\u636e\u8fdb\u53bb，\u9700\u8981\u4e24\u6b65，\u5373\u4fdd\u8bc1\u6709\u8db3\u591f\u7a7a\u95f4\u548c\u62f7\u8d1d\u6570\u636e\u8fdb\u5165_buffer\u3002<\/p>\n
\/\/ \u5199\u5165\u6570\u636e
\nvoid Write(const void *data, uint64_t len)
\n{
\n \/\/ 1.\u4fdd\u8bc1\u6709\u8db3\u591f\u7a7a\u95f4
\n if (len == 0)
\n return;
\n EnsureWriteSpace(len);
\n const char *d = (const char *)data;
\n \/\/ 2.\u62f7\u8d1d\u6570\u636e\u8fdb\u53bb
\n std::copy(d, d + len, WritePosition());
\n} <\/p>\n
\u63a5\u4e0b\u6765\u7684\u51e0\u4e2a\u51fd\u6570\u90fd\u662f\u57fa\u4e8eWrite\u51fd\u6570\u7684\u62d3\u5c55\u96c6\u6210，\u5305\u62ec\u5199\u5165string\u3001Buffer\u7c7b\u578b\u7684\u6570\u636e<\/p>\n
void WriteAndPush(const void *data, uint64_t len)
\n{
\n Write(data, len);
\n MoveWriteOffset(len);
\n}
\nvoid WriteString(const std::string &data)
\n{
\n return Write(data.c_str(), data.size());
\n}
\nvoid WriteStringAndPush(const std::string &data)
\n{
\n WriteString(data);
\n \/\/ std::cout << WritePosition() << std::endl;
\n MoveWriteOffset(data.size());
\n \/\/ std::cout << ReadAbleSize() << std::endl;
\n}
\nvoid WriteBuffer(Buffer &data)
\n{
\n return Write(data.ReadPosition(), data.ReadAbleSize());
\n}
\nvoid WriteBufferAndPush(Buffer &data)
\n{
\n WriteBuffer(data);
\n MoveWriteOffset(data.ReadAbleSize());
\n} <\/p>\n
\u63a5\u4e0b\u6765\u7684\u662fRead\u51fd\u6570，\u5305\u542b\u4e24\u4e2a\u53c2\u6570\u5206\u522b\u662f\u628a\u6570\u636e\u8bfb\u5230\u90a3\u4e2a\u4f4d\u7f6e，\u548c\u8bfb\u53d6\u7684\u957f\u5ea6<\/p>\n
\/\/ \u8bfb\u53d6\u6570\u636e
\nvoid Read(void *buf, uint64_t len)
\n{
\n assert(len <= ReadAbleSize());
\n \/\/ std::cout << ReadPosition() << std::endl;
\n std::copy(ReadPosition(), ReadPosition() + len, (char *)buf);
\n} <\/p>\n
\u540c\u6837，\u4e0b\u9762\u7684\u51fd\u6570\u4e5f\u662f\u57fa\u4e8eRead\u51fd\u6570\u7684\u62d3\u5c55\u96c6\u6210<\/p>\n
void ReadAndPop(void *buf, uint64_t len)
\n{
\n Read(buf, len);
\n MoveReadOffset(len);
\n}
\n\/\/ \u628a\u7f13\u51b2\u533a\u4e2d\u7684\u6570\u636e\u5f53\u505astring\u8bfb\u53d6
\nstd::string ReadAsString(uint64_t len)
\n{
\n assert(len <= ReadAbleSize());
\n std::string str;
\n str.resize(len);
\n Read(&str[0], len);
\n return str;
\n}
\nstd::string ReadAsStringAndPop(uint64_t len)
\n{
\n assert(len <= ReadAbleSize());
\n std::string str = ReadAsString(len);
\n MoveReadOffset(len);
\n return str;
\n} <\/p>\n
\u5728\u8bfb\u53d6\u7684\u65f6\u5019，\u4f8b\u5982\u8bfb\u53d6Http\u534f\u8bae，\u5c31\u9700\u8981\u4e00\u884c\u4e00\u884c\u7684\u8bfb，\u8fd9\u65f6\u5019\u5c31\u9700\u8981\u8bfb\u53d6\u5230\u6bcf\u4e00\u884c\u7684\\\\r\\\\n，\u6240\u4ee5\u5c31\u6709\u4e86FindCRLF\u51fd\u6570\u4f7f\u7528\u5230\u7684\u662fcstring\u4e2d\u7684memchr\u51fd\u6570<\/p>\n
void *memchr(const void *buf, int c, size_t count);<\/p>\n
buf：\u6307\u5411\u5f85\u641c\u7d22\u5185\u5b58\u5757\u7684\u6307\u9488<\/p>\n
c：\u8981\u67e5\u627e\u7684\u5b57\u7b26<\/p>\n
count：\u8981\u641c\u7d22\u7684\u5b57\u8282\u6570<\/p>\n
\u7531\u4e8e\u6211\u4eec\u9700\u8981\u7684\u662fchar* \u7684\u8fd4\u56de\u503c，\u6240\u4ee5\u9700\u8981\u5f3a\u5236\u8f6c\u6362\u4e00\u4e0b<\/p>\n
char *FindCRLF()
\n{
\n char *res = (char *)memchr(ReadPosition(), '\\\\n', ReadAbleSize());
\n return res;
\n}
\n\/*\u901a\u5e38\u83b7\u53d6\u4e00\u884c\u6570\u636e，\u8fd9\u79cd\u60c5\u51b5\u9488\u5bf9\u662fHTTP\u534f\u8bae*\/
\nstd::string GetLine()
\n{
\n char *pos = FindCRLF();
\n if (pos == NULL)
\n {
\n return "";
\n }
\n \/\/ +1 \u662f\u4e3a\u4e86\u628a\u6362\u884c\u5b57\u7b26\u4e5f\u53d6\u51fa\u6765
\n return ReadAsString(pos – ReadPosition() + 1);
\n} <\/p>\n
\u4e0b\u9762\u662f\u8fd9\u4e2aBuffer\u7c7b\u7684\u6574\u4f53\u4ee3\u7801<\/p>\n
#define BUFFER_DEFAULT_SIZE 1024
\nclass Buffer
\n{
\nprivate:
\n \/\/ \u4f7f\u7528vector\u8fdb\u884c\u5185\u5b58\u7a7a\u95f4\u7ba1\u7406
\n std::vector<char> _buffer;
\n uint64_t _reader_idx; \/\/ \u8bfb\u504f\u79fb
\n uint64_t _writer_idx; \/\/ \u5199\u504f\u79fb
\npublic:
\n Buffer() : _reader_idx(0), _writer_idx(0), _buffer(BUFFER_DEFAULT_SIZE) {}
\n char *Begin() { return &*_buffer.begin(); }
\n void TestPrint()
\n {
\n for (auto e : _buffer)
\n {
\n std::cout << e;
\n }
\n }
\n \/\/ \u83b7\u53d6\u5f53\u524d\u5199\u5165\u8d77\u59cb\u5730\u5740
\n char *WritePosition()
\n {
\n \/\/_buffer\u7684\u7a7a\u95f4\u8d77\u59cb\u5730\u5740，\u52a0\u4e0a\u5199\u504f\u79fb\u91cf
\n return Begin() + _writer_idx;
\n }
\n \/\/ \u83b7\u53d6\u5f53\u524d\u8bfb\u53d6\u8d77\u59cb\u5730\u5740
\n char *ReadPosition()
\n {
\n return Begin() + _reader_idx;
\n }
\n \/\/ \u83b7\u53d6\u7f13\u51b2\u533a\u672b\u5c3e\u7a7a\u95f2\u7a7a\u95f4\u5927\u5c0f–\u5199\u504f\u79fb\u4e4b\u540e\u7684\u7a7a\u95f2\u7a7a\u95f4
\n uint64_t TailIdleSize()
\n {
\n return _buffer.size() – _writer_idx;
\n }
\n \/\/ \u83b7\u53d6\u7f13\u51b2\u533a\u8d77\u59cb\u7a7a\u95f2\u7a7a\u95f4\u5927\u5c0f–\u8bfb\u504f\u79fb\u4e4b\u524d\u7684\u7a7a\u95f2\u7a7a\u95f4
\n uint64_t HeadIdleSize()
\n {
\n return _reader_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\u7684\u5927\u5c0f
\n assert(len <= ReadAbleSize());
\n _reader_idx += len;
\n }
\n \/\/ \u5c06\u5199\u504f\u79fb\u5411\u540e\u79fb\u52a8
\n void MoveWriteOffset(uint64_t len)
\n {
\n \/\/ \u5411\u540e\u79fb\u52a8\u7684\u5927\u5c0f，\u5fc5\u987b\u5c0f\u4e8e\u5f53\u524d\u540e\u8fb9\u7684\u7a7a\u95f2\u7a7a\u95f4\u5927\u5c0f
\n assert(len <= TailIdleSize());
\n _writer_idx += len;
\n }
\n \/\/ \u786e\u4fdd\u53ef\u5199\u7a7a\u95f4\u8db3\u591f(\u8db3\u591f\u5c31\u79fb\u52a8\u6570\u636e，\u5426\u5219\u5c31\u6269\u5bb9)
\n void EnsureWriteSpace(uint64_t len)
\n {
\n \/\/ \u5982\u679c\u672b\u5c3e\u7a7a\u95f2\u7a7a\u95f4\u5927\u5c0f\u8db3\u591f，\u76f4\u63a5\u8fd4\u56de
\n if (TailIdleSize() >= len)
\n {
\n return;
\n }
\n \/\/ \u672b\u5c3e\u7a7a\u95f2\u7a7a\u95f4\u4e0d\u591f，\u5219\u5224\u65ad\u52a0\u4e0a\u8d77\u59cb\u4f4d\u7f6e\u7684\u7a7a\u95f2\u7a7a\u95f4\u5927\u5c0f\u662f\u5426\u8db3\u591f，\u591f\u4e86\u5c31\u5c06\u6570\u636e\u79fb\u52a8\u5230\u8d77\u59cb\u4f4d\u7f6e
\n if (len <= TailIdleSize() + HeadIdleSize())
\n {
\n \/\/ \u5c06\u6570\u636e\u79fb\u52a8\u5230\u8d77\u59cb\u4f4d\u7f6e
\n uint64_t rsz = ReadAbleSize();
\n \/\/ \u628a\u53ef\u8bfb\u6570\u636e\u62f7\u8d1d\u5230\u8d77\u59cb\u4f4d\u7f6e
\n std::copy(ReadPosition(), ReadPosition() + rsz, Begin());
\n _reader_idx = 0; \/\/ \u5c06\u8bfb\u504f\u79fb\u5f520
\n _writer_idx = rsz; \/\/ \u5c06\u5199\u4f4d\u7f6e\u7f6e\u4e3a\u53ef\u8bfb\u6570\u636e\u5927\u5c0f，\u56e0\u4e3a\u5f53\u524d\u7684\u53ef\u8bfb\u6570\u636e\u5927\u5c0f\u5c31\u662f\u5199\u504f\u79fb\u91cf
\n }
\n else
\n {
\n \/\/ \u603b\u4f53\u7a7a\u95f4\u4e0d\u591f，\u5219\u9700\u8981\u6269\u5bb9，\u4e0d\u79fb\u52a8\u6570\u636e，\u76f4\u63a5\u7ed9\u5199\u504f\u79fb\u4e4b\u540e\u6269\u5bb9\u8db3\u591f\u7a7a\u95f4\u5373\u53ef
\n DBG_LOG("RESIZE %ld", _writer_idx + len);
\n _buffer.resize(_writer_idx + len);
\n }
\n }
\n \/\/ \u5199\u5165\u6570\u636e
\n void Write(const void *data, uint64_t len)
\n {
\n \/\/ 1.\u4fdd\u8bc1\u6709\u8db3\u591f\u7a7a\u95f4
\n if (len == 0)
\n return;
\n EnsureWriteSpace(len);
\n const char *d = (const char *)data;
\n \/\/ 2.\u62f7\u8d1d\u6570\u636e\u8fdb\u53bb
\n std::copy(d, d + len, WritePosition());
\n }
\n void WriteAndPush(const void *data, uint64_t len)
\n {
\n Write(data, len);
\n MoveWriteOffset(len);
\n }
\n void WriteString(const std::string &data)
\n {
\n return Write(data.c_str(), data.size());
\n }
\n void WriteStringAndPush(const std::string &data)
\n {
\n WriteString(data);
\n \/\/ std::cout << WritePosition() << std::endl;
\n MoveWriteOffset(data.size());
\n \/\/ std::cout << ReadAbleSize() << std::endl;
\n }
\n void WriteBuffer(Buffer &data)
\n {
\n return Write(data.ReadPosition(), data.ReadAbleSize());
\n }
\n void WriteBufferAndPush(Buffer &data)
\n {
\n WriteBuffer(data);
\n MoveWriteOffset(data.ReadAbleSize());
\n }
\n \/\/ \u8bfb\u53d6\u6570\u636e
\n void Read(void *buf, uint64_t len)
\n {
\n assert(len <= ReadAbleSize());
\n \/\/ std::cout << ReadPosition() << std::endl;
\n std::copy(ReadPosition(), ReadPosition() + len, (char *)buf);
\n }
\n void ReadAndPop(void *buf, uint64_t len)
\n {
\n Read(buf, len);
\n MoveReadOffset(len);
\n }
\n \/\/ \u628a\u7f13\u51b2\u533a\u4e2d\u7684\u6570\u636e\u5f53\u505astring\u8bfb\u53d6
\n std::string ReadAsString(uint64_t len)
\n {
\n assert(len <= ReadAbleSize());
\n std::string str;
\n str.resize(len);
\n Read(&str[0], len);
\n return str;
\n }
\n std::string ReadAsStringAndPop(uint64_t len)
\n {
\n assert(len <= ReadAbleSize());
\n std::string str = ReadAsString(len);
\n MoveReadOffset(len);
\n return str;
\n }
\n char *FindCRLF()
\n {
\n char *res = (char *)memchr(ReadPosition(), '\\\\n', ReadAbleSize());
\n return res;
\n }
\n \/*\u901a\u5e38\u83b7\u53d6\u4e00\u884c\u6570\u636e，\u8fd9\u79cd\u60c5\u51b5\u9488\u5bf9\u662fHTTP\u534f\u8bae*\/
\n std::string GetLine()
\n {
\n char *pos = FindCRLF();
\n if (pos == NULL)
\n {
\n return "";
\n }
\n \/\/ +1 \u662f\u4e3a\u4e86\u628a\u6362\u884c\u5b57\u7b26\u4e5f\u53d6\u51fa\u6765
\n return ReadAsString(pos – ReadPosition() + 1);
\n }
\n std::string GetLineAndPop()
\n {
\n std::string str = GetLine();
\n MoveReadOffset(str.size());
\n return str;
\n }
\n \/\/ \u6e05\u7a7a\u7f13\u51b2\u533a
\n void Clear()
\n {
\n \/\/ \u53ea\u9700\u8981\u5c06\u504f\u79fb\u91cf\u5f52\u96f6
\n _reader_idx = 0;
\n _writer_idx = 0;
\n }
\n}; <\/p>\n
\u4f5c\u4e3a\u4e00\u540d\u5408\u683c\u7684\u7a0b\u5e8f\u5458，\u65e5\u5fd7\u5b8f\u662f\u4e0d\u53ef\u6216\u7f3a\u7684，\u6211\u4eec\u5c06\u5728\u8fd9\u91cc\u5199\u4e00\u4e2a\u7b80\u5355\u7684\u65e5\u5fd7\u5b8f<\/p>\n
\u9996\u5148\u6211\u4eec\u7684\u65e5\u5fd7\u5e94\u8be5\u5305\u542b\u65e5\u5fd7\u7b49\u7ea7，\u65b9\u4fbf\u6211\u4eec\u8c03\u8bd5，\u8fd9\u91cc\u6211\u4eec\u7ed9\u51fa\u4e86\u4e09\u79cd\u7b49\u7ea7\u7684\u65e5\u5fd7\u7b49\u7ea7<\/p>\n
INF，DBG，ERR，\u5206\u522b\u8bbe\u7f6e\u4e3a0 1 2 \u7136\u540e1\u4ee5\u4e0a\u7684\u65e5\u5fd7\u7b49\u7ea7\u5c06\u6253\u5370\u51fa\u5177\u4f53\u7684\u65e5\u5fd7\u4fe1\u606f<\/p>\n
\u6211\u4eec\u4e5f\u60f3\u65e5\u5fd7\u80fd\u6253\u5370\u51fa\u73b0\u5728\u7684\u65f6\u95f4，\u9700\u8981\u4f7f\u7528\u5230ctime\u8fd9\u4e2a\u5934\u6587\u4ef6<\/p>\n
\u91cc\u9762\u6709\u4e00\u4e2atm\u7ed3\u6784\u4f53，\u5b9a\u4e49\u5982\u4e0b：<\/p>\n
struct tm<\/p>\n
{<\/p>\n
\u00a0 int tm_sec; \u00a0 \u00a0 \u00a0 \u00a0\/* Seconds. [0-60] (1 leap second) *\/<\/p>\n
\u00a0 int tm_min; \u00a0 \u00a0 \u00a0 \u00a0\/* Minutes. [0-59] *\/<\/p>\n
\u00a0 int tm_hour; \u00a0 \u00a0 \u00a0 \/* Hours. \u00a0 [0-23] *\/<\/p>\n
\u00a0 int tm_mday; \u00a0 \u00a0 \u00a0 \/* Day. \u00a0 \u00a0 [1-31] *\/<\/p>\n
\u00a0 int tm_mon; \u00a0 \u00a0 \u00a0 \u00a0\/* Month. \u00a0 [0-11] *\/<\/p>\n
\u00a0 int tm_year; \u00a0 \u00a0 \u00a0 \/* Year \u00a0– 1900. \u00a0*\/<\/p>\n
\u00a0 int tm_wday; \u00a0 \u00a0 \u00a0 \/* Day of week. \u00a0 [0-6] *\/<\/p>\n
\u00a0 int tm_yday; \u00a0 \u00a0 \u00a0 \/* Days in year.[0-365] *\/<\/p>\n
\u00a0 int tm_isdst; \u00a0 \u00a0 \u00a0 \u00a0 \/* DST. \u00a0 \u00a0 [-1\/0\/1]*\/<\/p>\n
}<\/p>\n
\u6211\u4eec\u53ef\u4ee5\u4f7f\u7528localtime\u8fd9\u4e2a\u51fd\u6570\u6765\u628a\u65f6\u95f4\u6233\u7684\u4fe1\u606f\u8f6c\u79fb\u5230\u8fd9\u4e2atm\u7ed3\u6784\u4f53\u5f53\u4e2d\u7136\u540e\u8bfb\u53d6，\u5728\u4ee5\u7279\u5b9a\u683c\u5f0f\u6765\u6253\u5370\u51fa\u65f6\u95f4<\/p>\n
\u8fd9\u91cc\u6709\u51e0\u4e2a\u5c0f\u7684\u77e5\u8bc6\u70b9<\/p>\n
1.\u5982\u4f55\u6253\u5370\u5bf9\u5e94\u7684\u884c\u53f7\u548c\u6587\u4ef6\u5462？<\/p>\n
\u53ef\u4ee5\u4f7f\u7528__FILE__ \u548c __LINE__ \u4e24\u4e2a\u5b8f\u5b9a\u4e49\u6765\u6253\u5370\u5bf9\u5e94\u7684\u6587\u4ef6\u540d\u548c\u884c\u53f7<\/p>\n
2.\u5b8f\u5b9a\u4e49\u4e2d\u7684\u53ef\u53d8\u53c2\u6570\u8be5\u5982\u4f55\u8868\u793a\u5462？<\/p>\n
\u4f7f\u7528##__VA_ARGS__\u6765\u8868\u793a<\/p>\n
\u4e0b\u9762\u5c31\u662f\u8be6\u7ec6\u7684\u4ee3\u7801<\/p>\n
#define INF 0
\n#define DBG 1
\n#define ERR 2
\n#define LOG_LEVEL DBG
\n#define LOG(level, format, …) \\\\
\n do \\\\
\n { \\\\
\n if (level < LOG_LEVEL) \\\\
\n 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)
\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\u5b57\u662f\u670d\u52a1\u5668\u7f16\u7a0b\u4e2d\u4e0d\u53ef\u7f3a\u5c11\u7684，\u6211\u4eec\u4f7f\u7528\u4e00\u4e2a\u7ed3\u6784\u4f53Socket\u6765\u7edf\u4e00\u7ba1\u7406<\/p>\n
1.\u9996\u5148\u5c01\u88c5\u521b\u5efa\u5957\u63a5\u5b57\u7684\u51fd\u6570Create()<\/p>\n
bool Create()
\n{
\n _sockfd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
\n if (_sockfd < 0)
\n {
\n ERR_LOG("CREATE SOCKET FAILED!!");
\n return false;
\n }
\n return true;
\n} <\/p>\n
\u8fd9\u91cc\u89e3\u91ca\u4e00\u4e0bsocket\u7684\u4e09\u4e2a\u53c2\u6570，\u7b2c\u4e00\u4e2a\u53c2\u6570\u8868\u793a\u4f7f\u7528IPV4\u534f\u8bae，\u7b2c\u4e8c\u4e2a\u53c2\u6570\u8868\u793a\u4f7f\u7528\u9762\u5411\u8fde\u63a5\u7684\u5957\u63a5\u5b57，\u7b2c\u4e09\u4e2a\u53c2\u6570\u8868\u793a\u9009\u62e9TCP\u534f\u8bae，\u4e5f\u53ef\u4ee5\u628a\u7b2c\u4e09\u4e2a\u53c2\u6570\u76f4\u63a5\u5199\u62100，\u7cfb\u7edf\u4f1a\u81ea\u52a8\u9009\u62e9\u534f\u8bae<\/p>\n
2.\u5c01\u88c5\u7ed1\u5b9a\u5730\u5740\u4fe1\u606f\u7684\u51fd\u6570Bind()，\u4f20\u5165\u4e24\u4e2a\u53c2\u6570\u5373\u53ef，\u5373ip\u548cport<\/p>\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(_sockfd, (struct sockaddr *)&addr, len);
\n if (ret < 0)
\n {
\n ERR_LOG("BIND ADDRESS FAILED!");
\n return false;
\n }
\n return true;
\n} <\/p>\n
\u5176\u4e2dsockaddr_in \u8fd9\u4e2a\u7ed3\u6784\u4f53\u5305\u542b\u4e09\u4e2a\u6210\u5458，\u5206\u522b\u662fsin_family，sin_port，sin_addr<\/p>\n
sin_family：sin_family\u8bbe\u7f6e\u4e3aAF_INET\u8868\u793a\u4f7f\u7528IPV4\u534f\u8bae<\/p>\n
sin_port：\u4f20\u5165sin_port\u53c2\u6570\u7684\u65f6\u5019，\u9700\u8981\u5c06\u4e3b\u673a\u5b57\u8282\u5e8f\u8f6c\u5316\u4e3a\u7f51\u7edc\u5b57\u8282\u5e8f\u3002\u56e0\u4e3a\u7f51\u7edc\u534f\u8bae\u4e2d\u7edf\u4e00\u4f7f\u7528\u5927\u7aef\u6a21\u5f0f\u4f5c\u4e3a\u6807\u51c6\u5b57\u8282\u5e8f<\/p>\n
sin_addr：\u9700\u8981\u4f7f\u7528inet_addr\u628a\u70b9\u5206\u5341\u8fdb\u5236\u5b57\u7b26\u4e32\u8f6c\u5316\u4e3a\u7f51\u7edc\u5b57\u8282\u5e8f\u768432\u4f4d\u65e0\u7b26\u53f7\u6574\u6570\u7684\u51fd\u6570<\/p>\n
\u63a5\u4e0b\u6765\u89e3\u91cabind\u51fd\u6570，\u7b2c\u4e00\u4e2a\u53c2\u6570\u4f20\u5165\u521b\u5efa\u51fa\u6765\u7684\u5957\u63a5\u5b57， \u7b2c\u4e8c\u4e2a\u53c2\u6570\u662faddr\u5f3a\u8f6c\u7684\u5730\u5740，\u7b2c\u4e09\u4e2a\u53c2\u6570\u8868\u793a\u8868\u793aaddr\u7684\u5927\u5c0f<\/p>\n
3.\u7ed1\u5b9a\u597d\u5730\u5740\u4fe1\u606f\u540e，\u5c31\u8981\u5f00\u59cb\u76d1\u542c\u4e86，\u8fd9\u91cc\u6211\u4eec\u4f7f\u7528Listen\u51fd\u6570\u6765\u5305\u88c5，Listen\u4f20\u5165\u4e00\u4e2a\u7f3a\u7701\u53c2\u6570backlog<\/p>\n
bool Listen(int backlog = MAX_LISTEN)
\n{
\n int ret = listen(_sockfd, backlog);
\n if (ret < 0)
\n {
\n ERR_LOG("SOCKET LISTEN FAILED!");
\n return false;
\n }
\n return true;
\n} <\/p>\n
\u8fd9\u91cc\u89e3\u91ca\u4e00\u4e0blisten\u51fd\u6570\u7684\u4e24\u4e2a\u53c2\u6570，\u7b2c\u4e00\u4e2a\u53c2\u6570\u8868\u793a\u4f20\u5165\u7684\u5957\u63a5\u5b57，\u7b2c\u4e8c\u4e2a\u53c2\u6570\u8868\u793a\u5b9a\u4e49\u4e86\u00a0\u5df2\u5b8c\u6210\u8fde\u63a5\u961f\u5217（ESTABLISHED \u72b6\u6001）\u7684\u6700\u5927\u957f\u5ea6\u3002<\/p>\n
4.\u63a5\u4e0b\u6765\u5c31\u662f\u5411\u670d\u52a1\u5668\u53d1\u8d77\u8fde\u63a5Connect()，\u4f20\u5165\u4e24\u4e2a\u53c2\u6570，ip\u548cport<\/p>\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(_sockfd, (struct sockaddr *)&addr, len);
\n if (ret < 0)
\n {
\n ERR_LOG("CONNECT ADDRESS FAILED!");
\n return false;
\n }
\n return true;
\n} <\/p>\n
\u8fd9\u91ccconnect\u7684\u53c2\u6570\u5c31\u4e0d\u591a\u8bf4<\/p>\n
ssize_t Recv(void *buf, size_t len, int flag = 0) \/\/ flag\u4ee3\u8868\u8bbe\u7f6e\u4e00\u4e9b\u963b\u585e\u76f8\u5173\u7684\u64cd\u4f5c
\n{
\n ssize_t ret = recv(_sockfd, buf, len, flag);
\n if (ret <= 0)
\n {
\n if (errno == EAGAIN || errno == EINTR)
\n {
\n return 0;
\n }
\n ERR_LOG("SOCKET RECV FAILED!");
\n return -1;
\n }
\n return ret;
\n} <\/p>\n
5. \u83b7\u53d6\u65b0\u94fe\u63a5\u4f7f\u7528Accept()\u51fd\u6570\u6765\u5c01\u88c5<\/p>\n
int Accept()
\n{
\n int newfd = accept(_sockfd, NULL, NULL);
\n if (newfd < 0)
\n {
\n ERR_LOG("SOCKET ACCEPT FAILED!");
\n return -1;
\n }
\n return newfd;
\n} <\/p>\n
\u8fd9\u91cc\u6211\u4eec\u9009\u62e9\u5c06accept\u7684\u7b2c\u4e8c\u4e2a\u548c\u7b2c\u4e09\u4e2a\u53c2\u6570\u90fd\u8bbe\u7f6e\u4e3aNULL\u8868\u793a\u6211\u4eec\u4e0d\u5173\u5fc3\u5ba2\u6237\u7aef\u5730\u5740\u4fe1\u606f\u3002\u6240\u4ee5\u53ea\u4f20\u5165\u4e86\u7b2c\u4e00\u4e2a\u53c2\u6570\u5957\u63a5\u5b57，\u7528\u4e8e\u4ece\u5df2\u5b8c\u6210\u8fde\u63a5\u961f\u5217\u4e2d\u63d0\u53d6\u8fde\u63a5<\/p>\n
6.\u4f7f\u7528Recv()\u51fd\u6570\u6765\u63a5\u53d7\u6570\u636e<\/p>\n
ssize_t Recv(void *buf, size_t len, int flag = 0) \/\/ flag\u4ee3\u8868\u8bbe\u7f6e\u4e00\u4e9b\u963b\u585e\u76f8\u5173\u7684\u64cd\u4f5c
\n{
\n ssize_t ret = recv(_sockfd, buf, len, flag);
\n if (ret <= 0)
\n {
\n if (errno == EAGAIN || errno == EINTR)
\n {
\n return 0;
\n }
\n ERR_LOG("SOCKET RECV FAILED!");
\n return -1;
\n }
\n return ret;
\n} <\/p>\n
recv\u6709\u56db\u4e2a\u53c2\u6570，\u7b80\u5355\u89e3\u91ca\u4e00\u4e0b，\u7b2c\u4e00\u4e2a\u53c2\u6570\u4f20\u5165\u5957\u63a5\u5b57，\u7b2c\u4e8c\u4e2a\u53c2\u6570\u8868\u793a\u63a5\u53d7\u7684\u6570\u636e\u653e\u5230\u7684\u4f4d\u7f6e，\u7b2c\u4e09\u4e2a\u53c2\u6570\u8868\u793a\u5355\u6b21\u63a5\u53d7\u7684\u6570\u636e\u91cf，flags\u63a7\u5236\u63a5\u6536\u884c\u4e3a\u7684\u6807\u5fd7\u4f4d\u3002\u4f20\u51650\u8868\u793a\u963b\u585e\u8bfb\u53d6\u3002<\/p>\n
7.\u518d\u6b21\u5c01\u88c5\u4e00\u4e2a\u51fd\u6570NonBlockRecv\u8868\u793a\u975e\u963b\u585e\u63a5\u53d7<\/p>\n
ssize_t NonBlockRecv(void *buf, size_t len)
\n{
\n if (len == 0)
\n return 0;
\n return Recv(buf, len, MSG_DONTWAIT);
\n} <\/p>\n
MSG_DONTWAIT\u8868\u793a\u4e0d\u8981\u7b49\u5f85\u7684\u63a5\u53d7<\/p>\n
8.\u53d1\u9001\u6570\u636e\u5c01\u88c5\u4e00\u4e2aSend()\u51fd\u6570，\u5c01\u88c5\u4e09\u4e2a\u53c2\u6570\u5206\u522b\u662f\u53d1\u9001\u6570\u636e\u7684\u4f4d\u7f6e，len\u8868\u793a\u53d1\u9001\u6570\u636e\u7684\u5927\u5c0f，\u7b2c\u4e09\u4e2a\u53c2\u6570\u4e3aflag\u548cRecv\u53c2\u6570\u4e00\u6837<\/p>\n
ssize_t Send(const void *buf, size_t len, int flag = 0)
\n{
\n \/\/ ssize_t send(int sockfd, void* data, size_t len, int flag);
\n ssize_t ret = send(_sockfd, buf, len, flag);
\n if (ret < 0)
\n {
\n if (errno == EAGAIN || errno == EINTR)
\n {
\n return 0;
\n }
\n ERR_LOG("SOCKET SEND FAILED!");
\n return -1;
\n }
\n return ret;
\n} <\/p>\n
send\u7684\u53c2\u6570\u5c31\u4e0d\u591a\u89e3\u91ca\u4e86 9.\u5c01\u88c5\u4e00\u4e2aNonBlockSend\u51fd\u6570\u8868\u793a\u975e\u963b\u585e\u53d1\u9001<\/p>\n
ssize_t NonBlockSend(void *buf, size_t len)
\n{
\n if (len == 0)
\n return 0;
\n return Send(buf, len, MSG_DONTWAIT);
\n} <\/p>\n
\u8fd9\u91cc\u540c\u6837\u4f7f\u7528MSG_DONTWAIT\u6765\u8868\u793a\u975e\u963b\u585e<\/p>\n
10.\u5957\u63a5\u5b57\u4f7f\u7528\u5b8c\u6bd5\u540e\u9700\u8981\u5173\u95ed，\u8c61\u6587\u4ef6\u63cf\u8ff0\u7b26\u4e00\u6837<\/p>\n
void Close()
\n{
\n if (_sockfd != -1)
\n {
\n close(_sockfd);
\n _sockfd = -1;
\n }
\n} <\/p>\n
11.\u521b\u5efa\u4e00\u4e2a\u670d\u52a1\u5668\u8fde\u63a5，\u5728\u8fd9\u91cc\u5206\u4e3a5\u4e2a\u6b65\u9aa4，\u521b\u5efa\u5957\u63a5\u5b57，\u8bbe\u7f6e\u975e\u963b\u585e，\u7ed1\u5b9a\u5730\u5740，\u5f00\u59cb\u76d1\u542c，\u542f\u52a8\u5730\u5740\u91cd\u7528<\/p>\n
bool CreateServer(uint16_t port, const std::string &ip = "0.0.0.0", bool block_flag = false)
\n{
\n \/\/ \u521b\u5efa\u5957\u63a5\u5b57
\n if (Create() == false)
\n return false;
\n \/\/ \u8bbe\u7f6e\u975e\u963b\u585e
\n if (block_flag)
\n NonBlock();
\n \/\/ \u7ed1\u5b9a\u5730\u5740
\n if (Bind(ip, port) == false)
\n return false;
\n \/\/ \u5f00\u59cb\u76d1\u542c
\n if (Listen() == false)
\n return false;
\n \/\/ \u542f\u52a8\u5730\u5740\u91cd\u7528
\n ReuseAddress();
\n return true;
\n} <\/p>\n
12.\u521b\u5efa\u4e00\u4e2a\u5ba2\u6237\u7aef\u8fde\u63a5，\u5206\u4e3a\u4e24\u4e2a\u6b65\u9aa4：Create\u548cConnect\u5982\u4e0b\u4ee3\u7801\u6240\u793a<\/p>\n
bool CreateClient(uint16_t port, const std::string &ip)
\n{
\n \/\/ 1.\u521b\u5efa\u5957\u63a5\u5b57， 2.\u6307\u5411\u8fde\u63a5\u670d\u52a1\u5668
\n if (Create() == false)
\n return false;
\n if (Connect(ip, port) == false)
\n return false;
\n return true;
\n} <\/p>\n
13.\u5f00\u542f\u5730\u5740\u7aef\u53e3\u91cd\u7528<\/p>\n<\/p>\n
\u8fd9\u91cc\u89e3\u91ca\u4e00\u4e0b\u4ec0\u4e48\u4e8b\u542f\u52a8\u5730\u5740\u91cd\u7528，\u5728\u4e00\u4e2aTCP\u8fde\u63a5\u5173\u95ed\u65f6，\u64cd\u4f5c\u7cfb\u7edf\u4f1a\u4fdd\u7559\u8be5\u94fe\u63a5\u7684\u7aef\u53e3\u4e00\u6bb5\u65f6\u95f4，\u8fd9\u4e2a\u72b6\u6001\u88ab\u79f0\u4e3aTIME_WAIT\u3002\u5728TIME_WAIT\u72b6\u6001\u4e0b，\u7aef\u53e3\u4e0d\u80fd\u88ab\u7acb\u5373\u91cd\u65b0\u4f7f\u7528，\u8fd9\u662f\u4e3a\u4e86\u786e\u4fdd\u6240\u6709\u76f8\u5173\u7684TCP\u62a5\u6587\u6bb5（\u5982\u5ef6\u8fdf\u7684ACK\u6216FIN）\u90fd\u5df2\u7ecf\u88ab\u5904\u7406\u5b8c\u6bd5，\u4ece\u800c\u907f\u514d\u65b0\u94fe\u63a5\u4e0e\u65e7\u94fe\u63a5\u7684\u6570\u636e\u6df7\u6dc6\u3002\u8bbe\u7f6e\u5730\u5740\u91cd\u7528，\u53ef\u4ee5\u5728\u77ed\u65f6\u95f4\u5185\u8fde\u7eed\u542f\u7528\u540c\u4e00\u4e2a\u7aef\u53e3\u53f7<\/p>\n
void ReuseAddress()
\n{
\n int val = 1;
\n setsockopt(_sockfd, SOL_SOCKET, SO_REUSEADDR, (void *)&val, sizeof(int));
\n val = 1;
\n setsockopt(_sockfd, SOL_SOCKET, SO_REUSEPORT, (void *)&val, sizeof(int));
\n} <\/p>\n
\u4e0b\u9762\u662fsetsockopt\u51fd\u6570\u7684\u539f\u578b<\/p>\n
int setsockopt(int sockfd, int level, int option_name, const void*\u00a0option_value, socklen_t option_len)<\/p>\n
socket\u53c2\u6570\u6307\u5b9a\u88ab\u64cd\u4f5c\u7684\u76ee\u6807socket，level\u53c2\u6570\u6307\u5b9a\u8981\u64cd\u4f5c\u90a3\u4e2a\u534f\u8bae\u7684\u9009\u9879，\u6bd4\u5982IPV4，IPV6，TCP\u7b49\u3002option_name\u53c2\u6570\u6307\u5b9a\u9009\u9879\u7684\u540d\u5b57，option_value\u548coption_len\u53c2\u6570\u5206\u522b\u662f\u88ab\u64cd\u4f5c\u9009\u9879\u7684\u503c\u548c\u957f\u5ea6<\/p>\n
\u8fd9\u91cc\u6211\u4eec\u628aval\u8bbe\u7f6e\u4e3a1，val\u662f\u4e00\u4e2a\u6574\u6570，\u901a\u5e38\u8bbe\u7f6e\u4e3a1\u62160\u30021\u8868\u793a\u542f\u52a8\u6307\u5b9a\u7684\u5957\u63a5\u5b57\u9009\u9879，0\u8868\u793a\u7981\u7528\u6307\u5b9a\u7684\u5957\u63a5\u5b57\u9009\u9879<\/p>\n
14.\u8bbe\u7f6e\u5957\u63a5\u5b57\u963b\u585e\u5c5e\u6027—\u8bbe\u7f6e\u4e3a\u975e\u963b\u585e，\u8fd9\u91cc\u6211\u4eec\u7528\u5230\u7684\u51fd\u6570\u662ffcntl\u51fd\u6570，\u4ee3\u7801\u540e\u9762\u5c06\u4f1a\u7ed9\u51fa\u8be6\u7ec6\u7684\u89e3\u91ca<\/p>\n
void NonBlock()
\n{
\n int flag = fcntl(_sockfd, F_GETFL, 0);
\n fcntl(_sockfd, F_SETFL, flag | O_NONBLOCK);
\n} <\/p>\n
fcntl\u51fd\u6570，\u6b63\u5982\u5176\u540d\u5b57\u4e00\u6837，\u63d0\u4f9b\u4e86\u5bf9\u6587\u4ef6\u63cf\u8ff0\u7b26\u7684\u5404\u79cd\u63a7\u5236\u64cd\u4f5c，\u53e6\u5916\u8981\u4e00\u4e2a\u5e38\u89c1\u7684\u63a7\u5236\u6587\u4ef6\u63cf\u8ff0\u7b26\u7684\u5c5e\u6027\u548c\u884c\u4e3a\u7684\u7cfb\u7edf\u8c03\u7528\u65f6ioctl，\u4f46\u662ffcntl\u662f\u7531POSIX \u89c4\u5b9a\u7684\u9996\u9009\u65b9\u6cd5\u3002<\/p>\n
\u6211\u4eec\u5148\u5728flag\u4e2d\u83b7\u53d6fd\u7684\u6807\u5fd7，\u7136\u540e\u518d\u5c06\u8fd9\u4e2a\u51fd\u6570\u7684\u7b2c\u4e8c\u4e2a\u53c2\u6570\u8bbe\u7f6e\u4e3aF_SETFL\u8868\u793a\u8bbe\u7f6efd\u7684\u6807\u5fd7，\u7b2c\u4e09\u4e2a\u53c2\u6570\u5c31\u5199\u6210flag | O_NONBLOCK\u8868\u793a\u518d\u52a0\u4e0a\u975e\u963b\u585e\u5c5e\u6027<\/p>\n
\u6700\u540e\u662f\u5b8c\u6574\u7684socket\u4ee3\u7801<\/p>\n
#define MAX_LISTEN 1024<\/p>\n
class Socket
\n{
\nprivate:
\n int _sockfd;<\/p>\n
public:
\n Socket() : _sockfd(-1) {}
\n Socket(int fd) : _sockfd(fd) {}
\n ~Socket() { Close(); }
\n int Fd() { return _sockfd; }
\n \/\/ \u521b\u5efa\u5957\u63a5\u5b57
\n bool Create()
\n {
\n _sockfd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
\n if (_sockfd < 0)
\n {
\n ERR_LOG("CREATE SOCKET FAILED!!");
\n return false;
\n }
\n return true;
\n }
\n \/\/ \u7ed1\u5b9a\u5730\u5740\u4fe1\u606f
\n bool Bind(const std::string &ip, uint16_t port)
\n {
\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(_sockfd, (struct sockaddr *)&addr, len);
\n if (ret < 0)
\n {
\n ERR_LOG("BIND ADDRESS FAILED!");
\n return false;
\n }
\n return true;
\n }
\n \/\/ \u5f00\u59cb\u76d1\u542c
\n bool Listen(int backlog = MAX_LISTEN)
\n {
\n int ret = listen(_sockfd, backlog);
\n if (ret < 0)
\n {
\n ERR_LOG("SOCKET LISTEN FAILED!");
\n return false;
\n }
\n return true;
\n }
\n \/\/ \u5411\u670d\u52a1\u5668\u53d1\u8d77\u8fde\u63a5
\n bool Connect(const std::string &ip, uint16_t port)
\n {
\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(_sockfd, (struct sockaddr *)&addr, len);
\n if (ret < 0)
\n {
\n ERR_LOG("CONNECT ADDRESS FAILED!");
\n return false;
\n }
\n return true;
\n }
\n \/\/ \u83b7\u53d6\u65b0\u94fe\u63a5
\n int Accept()
\n {
\n int newfd = accept(_sockfd, NULL, NULL);
\n if (newfd < 0)
\n {
\n ERR_LOG("SOCKET ACCEPT FAILED!");
\n return -1;
\n }
\n return newfd;
\n }
\n \/\/ \u63a5\u6536\u6570\u636e
\n ssize_t Recv(void *buf, size_t len, int flag = 0) \/\/ flag\u4ee3\u8868\u8bbe\u7f6e\u4e00\u4e9b\u963b\u585e\u76f8\u5173\u7684\u64cd\u4f5c
\n {
\n ssize_t ret = recv(_sockfd, buf, len, flag);
\n if (ret <= 0)
\n {
\n if (errno == EAGAIN || errno == EINTR)
\n {
\n return 0;
\n }
\n ERR_LOG("SOCKET RECV FAILED!");
\n return -1;
\n }
\n return ret;
\n }
\n ssize_t NonBlockRecv(void *buf, size_t len)
\n {
\n if (len == 0)
\n return 0;
\n return Recv(buf, len, MSG_DONTWAIT);
\n }
\n \/\/ \u53d1\u9001\u6570\u636e
\n ssize_t Send(const void *buf, size_t len, int flag = 0)
\n {
\n \/\/ ssize_t send(int sockfd, void* data, size_t len, int flag);
\n ssize_t ret = send(_sockfd, buf, len, flag);
\n if (ret < 0)
\n {
\n if (errno == EAGAIN || errno == EINTR)
\n {
\n return 0;
\n }
\n ERR_LOG("SOCKET SEND FAILED!");
\n return -1;
\n }
\n return ret;
\n }
\n ssize_t NonBlockSend(void *buf, size_t len)
\n {
\n if (len == 0)
\n return 0;
\n return Send(buf, len, MSG_DONTWAIT);
\n }<\/p>\n
\/\/ \u5173\u95ed\u5957\u63a5\u5b57
\n void Close()
\n {
\n if (_sockfd != -1)
\n {
\n close(_sockfd);
\n _sockfd = -1;
\n }
\n }
\n \/\/ \u521b\u5efa\u4e00\u4e2a\u670d\u52a1\u7aef\u8fde\u63a5
\n bool CreateServer(uint16_t port, const std::string &ip = "0.0.0.0", bool block_flag = false)
\n {
\n \/\/ \u521b\u5efa\u5957\u63a5\u5b57
\n if (Create() == false)
\n return false;
\n \/\/ \u8bbe\u7f6e\u975e\u963b\u585e
\n if (block_flag)
\n NonBlock();
\n \/\/ \u7ed1\u5b9a\u5730\u5740
\n if (Bind(ip, port) == false)
\n return false;
\n \/\/ \u5f00\u59cb\u76d1\u542c
\n if (Listen() == false)
\n return false;
\n \/\/ \u542f\u52a8\u5730\u5740\u91cd\u7528
\n ReuseAddress();
\n return true;
\n }
\n \/\/ \u521b\u5efa\u4e00\u4e2a\u5ba2\u6237\u7aef\u8fde\u63a5
\n bool CreateClient(uint16_t port, const std::string &ip)
\n {
\n \/\/ 1.\u521b\u5efa\u5957\u63a5\u5b57， 2.\u6307\u5411\u8fde\u63a5\u670d\u52a1\u5668
\n if (Create() == false)
\n return false;
\n if (Connect(ip, port) == false)
\n return false;
\n return true;
\n }
\n \/\/ \u8bbe\u7f6e\u5957\u63a5\u5b57\u9009\u9879–\u5f00\u542f\u5730\u5740\u7aef\u53e3\u91cd\u7528
\n void ReuseAddress()
\n {
\n int val = 1;
\n setsockopt(_sockfd, SOL_SOCKET, SO_REUSEADDR, (void *)&val, sizeof(int));
\n val = 1;
\n setsockopt(_sockfd, SOL_SOCKET, SO_REUSEPORT, (void *)&val, sizeof(int));
\n }
\n \/\/ \u8bbe\u7f6e\u5957\u63a5\u5b57\u963b\u585e\u5c5e\u6027–\u8bbe\u7f6e\u4e3a\u975e\u963b\u585e
\n void NonBlock()
\n {
\n int flag = fcntl(_sockfd, F_GETFL, 0);
\n fcntl(_sockfd, F_SETFL, flag | O_NONBLOCK);
\n }
\n}; <\/p>\n
Channel\u6a21\u5757\u662f\u5bf9\u4e00\u4e2a\u63cf\u8ff0\u7b26\u9700\u8981\u8fdb\u884cIO\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\u884cIO\u4e8b\u4ef6\u76d1\u63a7\u5c31\u7eea\u540e，\u6839\u636e\u4e0d\u540c\u7684\u4e8b\u4ef6，\u56de\u8c03\u4e0d\u540c\u7684\u5904\u7406\u51fd\u6570\u529f\u80fd\u3002<\/p>\n
\u5728Channel\u7c7b\u7684\u79c1\u6709\u6210\u5458\u4e2d，\u4e3b\u8981\u5305\u542b\u6587\u4ef6\u63cf\u8ff0\u7b26_fd，\u5f53\u524d\u9700\u8981\u76d1\u63a7\u7684\u4e8b\u4ef6_events\u548c\u5f53\u524d\u89e6\u53d1\u7684\u4e8b\u4ef6_revents\u8fd8\u6709\u5404\u79cd\u4e8b\u4ef6\u88ab\u89e6\u53d1\u65f6\u7684\u56de\u8c03\u51fd\u6570<\/p>\n
int _fd;
\nEventLoop *_loop;
\nuint32_t _events; \/\/ \u5f53\u524d\u9700\u8981\u76d1\u63a7\u7684\u4e8b\u4ef6
\nuint32_t _revents; \/\/ \u5f53\u524d\u89e6\u53d1\u7684\u4e8b\u4ef6
\nusing EventCallback = std::function<void()>;
\nEventCallback _read_callback; \/\/ \u53ef\u8bfb\u4e8b\u4ef6\u88ab\u89e6\u53d1\u7684\u56de\u8c03\u51fd\u6570
\nEventCallback _write_callback; \/\/ \u53ef\u5199\u4e8b\u4ef6\u88ab\u89e6\u53d1\u7684\u56de\u8c03\u51fd\u6570
\nEventCallback _error_callback; \/\/ \u9519\u8bef\u4e8b\u4ef6\u88ab\u89e6\u53d1\u7684\u56de\u8c03\u51fd\u6570
\nEventCallback _close_callback; \/\/ \u8fde\u63a5\u65ad\u5f00\u4e8b\u4ef6\u88ab\u89e6\u53d1\u7684\u56de\u8c03\u51fd\u6570
\nEventCallback _event_callback; \/\/ \u4efb\u610f\u4e8b\u4ef6\u88ab\u89e6\u53d1\u7684\u56de\u8c03\u51fd\u6570 <\/p>\n
\u00a0\u63a5\u4e0b\u6765\u662fChannel\u7c7b\u4e2d\u6240\u5305\u542b\u7684\u6210\u5458\u51fd\u6570<\/p>\n
\u9996\u5148\u662f\u8bbe\u7f6e\u5404\u79cd\u4e8b\u4ef6\u7684\u56de\u8c03\u51fd\u6570<\/p>\n
void SetReadCallback(const EventCallback &cb)
\n{
\n _read_callback = cb;
\n}
\nvoid SetWriteCallback(const EventCallback &cb)
\n{
\n _write_callback = cb;
\n}
\nvoid SetErrorCallback(const EventCallback &cb)
\n{
\n _error_callback = cb;
\n}
\nvoid SetCloseCallback(const EventCallback &cb)
\n{
\n _close_callback = cb;
\n}
\nvoid SetEventCallback(const EventCallback &cb)
\n{
\n _event_callback = cb;
\n} <\/p>\n
\u63a5\u4e0b\u6765\u7684\u4e24\u4e2a\u51fd\u6570\u7528\u6765\u68c0\u6d4b\u5f53\u524d\u662f\u5426\u53ef\u8bfb\u548c\u53ef\u5199<\/p>\n
bool ReadAble() \/\/ \u5f53\u524d\u662f\u5426\u53ef\u8bfb
\n{
\n return (_events & EPOLLIN);
\n}
\nbool WriteAble() \/\/ \u5f53\u524d\u662f\u5426\u53ef\u5199
\n{
\n return (_events & EPOLLOUT);
\n} <\/p>\n
\u8fd9\u56db\u4e2a\u51fd\u6570\u7528\u6765\u542f\u52a8\u4e8b\u4ef6\u76d1\u63a7\u548c\u5173\u95ed\u4e8b\u4ef6\u76d1\u63a7<\/p>\n
void EnableRead() \/\/ \u542f\u52a8\u8bfb\u4e8b\u4ef6\u76d1\u63a7
\n{
\n _events |= EPOLLIN; \/*\u540e\u8fb9\u4f1a\u6dfb\u52a0\u5230EventLoop\u7684\u4e8b\u4ef6\u76d1\u63a7\u4e2d*\/
\n Update();
\n}
\nvoid EnableWrite() \/\/ \u542f\u52a8\u5199\u4e8b\u4ef6\u76d1\u63a7
\n{
\n _events |= EPOLLOUT;
\n Update();
\n}
\nvoid DisableRead() \/\/ \u5173\u95ed\u8bfb\u4e8b\u4ef6\u76d1\u63a7
\n{
\n _events &= ~EPOLLIN;
\n Update();
\n}
\nvoid DisableWrite() \/\/ \u5173\u95ed\u5199\u4e8b\u4ef6\u76d1\u63a7
\n{
\n _events &= ~EPOLLOUT;
\n Update();
\n}
\nvoid DisableAll() \/\/ \u5173\u95ed\u6240\u6709\u4e8b\u4ef6\u76d1\u63a7
\n{
\n _events = 0;
\n Update();
\n} <\/p>\n
\u8fd8\u9700\u8981\u5bf9\u76d1\u63a7\u8fdb\u884c\u79fb\u9664\u548c\u66f4\u65b0\u7684\u51fd\u6570，\u8fd9\u4e24\u4e2a\u51fd\u6570\u9700\u8981\u5728\u7c7b\u5916\u5b9e\u73b0，\u56e0\u4e3aEventLoop\u7c7b\u5728Channel::Remove()\u548cChannel::Update()\u4e2d\u88ab\u4f7f\u7528\u65f6，\u7f16\u8bd1\u5668\u9700\u8981\u770b\u5230\u4ed6\u7684\u5b8c\u6574\u5b9a\u4e49<\/p>\n
void Channel::Remove() \/\/ \u79fb\u9664\u76d1\u63a7
\n{
\n return _loop->RemoveEvent(this);
\n}
\nvoid Channel::Update()
\n{
\n return _loop->UpdateEvent(this);
\n} <\/p>\n
\u63a5\u4e0b\u6765\u662f\u4e8b\u4ef6\u5904\u7406\u51fd\u6570，\u5c31\u8c03\u7528\u8fd9\u4e2a\u51fd\u6570，\u81ea\u5df1\u89e6\u53d1\u4e86\u4ec0\u4e48\u4e8b\u4ef6\u5982\u4f55\u81ea\u5df1\u51b3\u5b9a\u3002\u8fd9\u91cc\u89e3\u91ca\u4e00\u4e9b\u5e38\u7528\u7684epoll\u4e8b\u4ef6\u7c7b\u578b\u3002<\/p>\n
void HandleEvent() \/\/ \u4e8b\u4ef6\u5904\u7406，\u4e00\u65e6\u8fde\u63a5\u89e6\u53d1\u4e86\u4e8b\u4ef6，\u5c31\u8c03\u7528\u8fd9\u4e2a\u51fd\u6570，\u81ea\u5df1\u89e6\u53d1\u4e86\u4ec0\u4e48\u4e8b\u4ef6\u5982\u4f55\u81ea\u5df1\u51b3\u5b9a
\n{
\n if ((_revents & EPOLLIN) || (_revents & EPOLLRDHUP) || (_revents & EPOLLPRI))
\n {
\n \/*\u4e0d\u7ba1\u4efb\u4f55\u4e8b\u4ef6，\u90fd\u8c03\u7528\u7684\u56de\u8c03\u51fd\u6570*\/
\n if (_read_callback)
\n _read_callback();
\n }
\n \/*\u6709\u53ef\u80fd\u4f1a\u91ca\u653e\u8fde\u63a5\u7684\u64cd\u4f5c\u4e8b\u4ef6，\u4e00\u6b21\u53ea\u5904\u7406\u4e00\u4e2a*\/
\n if (_revents & EPOLLOUT)
\n {
\n \/*\u4e0d\u7ba1\u4efb\u4f55\u4e8b\u4ef6，\u90fd\u8c03\u7528\u7684\u56de\u8c03\u51fd\u6570*\/<\/p>\n
if (_write_callback)
\n _write_callback();
\n }
\n else if (_revents & EPOLLERR)
\n {<\/p>\n
if (_error_callback)
\n _error_callback();
\n }
\n else if (_revents & EPOLLHUP)
\n {<\/p>\n
if (_close_callback)
\n _close_callback();
\n }
\n if (_event_callback)
\n _event_callback();
\n} <\/p>\n
\u4e0b\u9762\u662f\u6574\u4e2aChannel\u7c7b\u7684\u5b9e\u73b0<\/p>\n
class Channel
\n{
\nprivate:
\n int _fd;
\n EventLoop *_loop;
\n uint32_t _events; \/\/ \u5f53\u524d\u9700\u8981\u76d1\u63a7\u7684\u4e8b\u4ef6
\n uint32_t _revents; \/\/ \u5f53\u524d\u89e6\u53d1\u7684\u4e8b\u4ef6
\n using EventCallback = std::function<void()>;
\n EventCallback _read_callback; \/\/ \u53ef\u8bfb\u4e8b\u4ef6\u88ab\u89e6\u53d1\u7684\u56de\u8c03\u51fd\u6570
\n EventCallback _write_callback; \/\/ \u53ef\u5199\u4e8b\u4ef6\u88ab\u89e6\u53d1\u7684\u56de\u8c03\u51fd\u6570
\n EventCallback _error_callback; \/\/ \u9519\u8bef\u4e8b\u4ef6\u88ab\u89e6\u53d1\u7684\u56de\u8c03\u51fd\u6570
\n EventCallback _close_callback; \/\/ \u8fde\u63a5\u65ad\u5f00\u4e8b\u4ef6\u88ab\u89e6\u53d1\u7684\u56de\u8c03\u51fd\u6570
\n EventCallback _event_callback; \/\/ \u4efb\u610f\u4e8b\u4ef6\u88ab\u89e6\u53d1\u7684\u56de\u8c03\u51fd\u6570
\npublic:
\n Channel(EventLoop *loop, int fd) : _fd(fd), _events(0), _revents(0), _loop(loop) {}
\n int Fd() { return _fd; }
\n void SetREvents(uint32_t events) { _revents = events; }
\n uint32_t Events() { return _events; }
\n void SetReadCallback(const EventCallback &cb)
\n {
\n _read_callback = cb;
\n }
\n void SetWriteCallback(const EventCallback &cb)
\n {
\n _write_callback = cb;
\n }
\n void SetErrorCallback(const EventCallback &cb)
\n {
\n _error_callback = cb;
\n }
\n void SetCloseCallback(const EventCallback &cb)
\n {
\n _close_callback = cb;
\n }
\n void SetEventCallback(const EventCallback &cb)
\n {
\n _event_callback = cb;
\n }
\n bool ReadAble() \/\/ \u5f53\u524d\u662f\u5426\u53ef\u8bfb
\n {
\n return (_events & EPOLLIN);
\n }
\n bool WriteAble() \/\/ \u5f53\u524d\u662f\u5426\u53ef\u5199
\n {
\n return (_events & EPOLLOUT);
\n }
\n void EnableRead() \/\/ \u542f\u52a8\u8bfb\u4e8b\u4ef6\u76d1\u63a7
\n {
\n _events |= EPOLLIN; \/*\u540e\u8fb9\u4f1a\u6dfb\u52a0\u5230EventLoop\u7684\u4e8b\u4ef6\u76d1\u63a7\u4e2d*\/
\n Update();
\n }
\n void EnableWrite() \/\/ \u542f\u52a8\u5199\u4e8b\u4ef6\u76d1\u63a7
\n {
\n _events |= EPOLLOUT;
\n Update();
\n }
\n void DisableRead() \/\/ \u5173\u95ed\u8bfb\u4e8b\u4ef6\u76d1\u63a7
\n {
\n _events &= ~EPOLLIN;
\n Update();
\n }
\n void DisableWrite() \/\/ \u5173\u95ed\u5199\u4e8b\u4ef6\u76d1\u63a7
\n {
\n _events &= ~EPOLLOUT;
\n Update();
\n }
\n void DisableAll() \/\/ \u5173\u95ed\u6240\u6709\u4e8b\u4ef6\u76d1\u63a7
\n {
\n _events = 0;
\n Update();
\n }
\n void Remove(); \/\/ \u79fb\u9664\u76d1\u63a7
\n void Update();
\n void HandleEvent() \/\/ \u4e8b\u4ef6\u5904\u7406，\u4e00\u65e6\u8fde\u63a5\u89e6\u53d1\u4e86\u4e8b\u4ef6，\u5c31\u8c03\u7528\u8fd9\u4e2a\u51fd\u6570，\u81ea\u5df1\u89e6\u53d1\u4e86\u4ec0\u4e48\u4e8b\u4ef6\u5982\u4f55\u81ea\u5df1\u51b3\u5b9a
\n {
\n if ((_revents & EPOLLIN) || (_revents & EPOLLRDHUP) || (_revents & EPOLLPRI))
\n {
\n \/*\u4e0d\u7ba1\u4efb\u4f55\u4e8b\u4ef6，\u90fd\u8c03\u7528\u7684\u56de\u8c03\u51fd\u6570*\/
\n if (_read_callback)
\n _read_callback();
\n }
\n \/*\u6709\u53ef\u80fd\u4f1a\u91ca\u653e\u8fde\u63a5\u7684\u64cd\u4f5c\u4e8b\u4ef6，\u4e00\u6b21\u53ea\u5904\u7406\u4e00\u4e2a*\/
\n if (_revents & EPOLLOUT)
\n {
\n \/*\u4e0d\u7ba1\u4efb\u4f55\u4e8b\u4ef6，\u90fd\u8c03\u7528\u7684\u56de\u8c03\u51fd\u6570*\/<\/p>\n
if (_write_callback)
\n _write_callback();
\n }
\n else if (_revents & EPOLLERR)
\n {<\/p>\n
if (_error_callback)
\n _error_callback();
\n }
\n else if (_revents & EPOLLHUP)
\n {<\/p>\n
if (_close_callback)
\n _close_callback();
\n }
\n if (_event_callback)
\n _event_callback();
\n }
\n}; <\/p>\n
Poller\u6a21\u5757\u662f\u5bf9epoll\u8fdb\u884c\u5c01\u88c5\u7684\u4e00\u4e2a\u6a21\u5757，\u4e3b\u8981\u5b9e\u73b0epoll\u7684IO\u4e8b\u4ef6\u6dfb\u52a0，\u4fee\u6539，\u79fb\u9664，\u83b7\u53d6\u6d3b\u8dc3\u8fde\u63a5\u529f\u80fd<\/p>\n
\u9996\u5148\u6765\u8bf4\u660e\u4e00\u4e0b\u8fd9\u4e2a\u7c7b\u7684\u79c1\u6709\u6210\u5458\u53d8\u91cf，\u9996\u5148\u662fepoll\u6587\u4ef6\u63cf\u8ff0\u7b26_epfd，\u7136\u540e\u662f_evt，\u8fd9\u662f\u7528\u6765\u63cf\u8ff0\u9700\u8981\u76d1\u63a7\u7684\u6587\u4ef6\u63cf\u8ff0\u7b26，\u6700\u540e\u662f_channels，\u8fd9\u662f\u7528\u6765\u901a\u8fc7\u6587\u4ef6\u63cf\u8ff0\u7b26\u627e\u5230\u5176\u5bf9\u5e94\u7684Channel\u6a21\u5757\u3002<\/p>\n
int _epfd;
\nstruct epoll_event _evs[MAX_EPOLLEVENTS];
\nstd::unordered_map<int, Channel *> _channels;<\/p>\n
\u63a5\u4e0b\u6765\u6ce8\u610f\u4ecb\u7ecd\u5176\u4e2d\u7684\u6210\u5458\u51fd\u6570<\/p>\n
\u9996\u5148\u662f\u5bf9epoll\u7684\u76f4\u63a5\u64cd\u4f5c\u51fd\u6570Update，Update\u4e2d\u4f20\u5165\u4e24\u4e2a\u53c2\u6570，\u5206\u522b\u662fchannel\u6307\u9488\u548c\u9700\u8981\u6267\u884c\u7684\u64cd\u4f5cop，\u9996\u5148\u6211\u4eec\u9700\u8981\u901a\u8fc7channel\u6307\u9488\u83b7\u5f97fd，\u7136\u540e\u521b\u5efa\u4e00\u4e2aepoll_event\u7c7b\u578b\u7684\u7ed3\u6784\u4f53\u5e76\u5bf9\u5176\u8fdb\u884c\u521d\u59cb\u5316，\u8fd9\u91cc\u4ecb\u7ecd\u4e00\u4e0bepoll_event<\/p>\n
struct epoll_event {
\n uint32_t events; \/\/ \u4e8b\u4ef6\u7c7b\u578b（\u4f4d\u63a9\u7801）
\n epoll_data_t data; \/\/ \u7528\u6237\u6570\u636e（\u8054\u5408\u4f53）
\n};<\/p>\n
typedef union epoll_data {
\n void *ptr; \/\/ \u7528\u6237\u81ea\u5b9a\u4e49\u6570\u636e\u6307\u9488
\n int fd; \/\/ \u6587\u4ef6\u63cf\u8ff0\u7b26
\n uint32_t u32; \/\/ 32\u4f4d\u65e0\u7b26\u53f7\u6574\u6570
\n uint64_t u64; \/\/ 64\u4f4d\u65e0\u7b26\u53f7\u6574\u6570
\n} epoll_data_t; <\/p>\n
\u5728epoll_data\u8fd9\u4e2a\u8054\u5408\u4f53\u5f53\u4e2d，\u6700\u5e38\u7528\u7684\u6570\u636e\u662ffd<\/p>\n
\u7136\u540e\u4f7f\u7528epoll_ctl\u5bf9epoll\u5b9e\u4f8b\u6dfb\u52a0\u3001\u4fee\u6539\u6216\u5220\u9664\u76d1\u63a7\u7684\u6587\u4ef6\u63cf\u8ff0\u7b26\u53ca\u5176\u5173\u6ce8\u7684\u4e8b\u4ef6<\/p>\n
int epoll_ctl(int __epfd, int __op, int __fd, epoll_event *) throw() <\/p>\n
\u53c2\u6570\u89e3\u91ca：<\/p>\n
Update\u7684\u5b8c\u6574\u5b9e\u73b0：<\/p>\n
void Update(Channel *channel, int op)
\n{
\n \/\/ int epoll_ctl(int epfd, int op, int fd, struct epoll_event* ev);
\n int fd = channel->Fd();
\n struct epoll_event ev;
\n ev.data.fd = fd;
\n ev.events = channel->Events();
\n int ret = epoll_ctl(_epfd, op, fd, &ev);
\n if (ret < 0)
\n {
\n ERR_LOG("EPOLLCTL FAILED!");
\n \/\/ abort(); \/\/\u9000\u51fa\u7a0b\u5e8f
\n }
\n return;
\n} <\/p>\n
\u7136\u540e\u5c31\u662f\u5224\u65ad\u4e00\u4e2aChannel\u662f\u5426\u5df2\u7ecf\u6dfb\u52a0\u4e86\u4e8b\u4ef6\u76d1\u63a7<\/p>\n
bool HasChannel(Channel *channel)
\n{
\n auto it = _channels.find(channel->Fd());
\n if (it == _channels.end())
\n {
\n return false;
\n }
\n return true;
\n} <\/p>\n
\u6dfb\u52a0\u6216\u4fee\u6539\u76d1\u63a7\u4e8b\u4ef6，\u5982\u679cChannel\u80fd\u627e\u5230，\u90a3\u4e48\u5c31\u4fee\u6539\u5426\u5219\u5c31\u6dfb\u52a0<\/p>\n
void UpdateEvent(Channel *channel)
\n{
\n bool ret = HasChannel(channel);
\n if (ret == false)
\n {
\n \/\/ \u4e0d\u5b58\u5728\u5219\u6dfb\u52a0
\n _channels.insert(std::make_pair(channel->Fd(), channel));
\n return Update(channel, EPOLL_CTL_ADD);
\n }
\n return Update(channel, EPOLL_CTL_MOD);
\n} <\/p>\n
\u79fb\u9664\u76d1\u63a7<\/p>\n
void RemoveEvent(Channel *channel)
\n{
\n auto it = _channels.find(channel->Fd());
\n {
\n if (it != _channels.end())
\n {
\n _channels.erase(it);
\n }
\n Update(channel, EPOLL_CTL_DEL);
\n }
\n} <\/p>\n
\u5f00\u59cb\u76d1\u63a7，\u5e76\u4e14\u8fd4\u56de\u6d3b\u8dc3\u8fde\u63a5<\/p>\n
\u4ecb\u7ecd\u4e00\u4e0bepoll_wait，\u7528\u4e8e\u7b49\u5f85epoll\u5b9e\u4f8b\u76d1\u63a7\u7684\u6587\u4ef6\u63cf\u8ff0\u7b26\u4e0a\u53d1\u751f\u7684\u4e8b\u4ef6，\u8fd4\u56de\u503c\u662f\u5c31\u7eea\u7684\u6587\u4ef6\u63cf\u8ff0\u7b26\u7684\u6570\u91cf\u3002\u5e76\u4e14\u8fd9\u4e2a\u51fd\u6570\u4f1a\u628a\u5c31\u7eea\u4e8b\u4ef6\u586b\u5145\u5230\u7b2c\u4e8c\u4e2a\u53c2\u6570\u6307\u5411\u7684\u6570\u7ec4\u4e2d<\/p>\n
void Poll(std::vector<Channel *> *active)
\n{
\n int nfds = epoll_wait(_epfd, _evs, MAX_EPOLLEVENTS, -1); \/\/-1\u4ee3\u8868\u963b\u585e\u76d1\u63a7
\n if (nfds < 0)
\n {
\n if (errno == EINTR)
\n {
\n return;
\n }
\n ERR_LOG("EPOLL WAIT ERROR:%s\\\\n", strerror(errno));
\n abort();
\n }
\n for (int i = 0; i < nfds; i++)
\n {
\n auto it = _channels.find(_evs[i].data.fd);
\n assert(it != _channels.end());
\n it->second->SetREvents(_evs[i].events);
\n active->push_back(it->second);
\n }
\n return;
\n} <\/p>\n
\u4e0b\u9762\u662f\u5b8c\u6574\u4ee3\u7801<\/p>\n
#define MAX_EPOLLEVENTS 1024
\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\u7684\u76f4\u63a5\u64cd\u4f5c
\n void Update(Channel *channel, int op)
\n {
\n \/\/ int epoll_ctl(int epfd, int op, int fd, struct epoll_event* ev);
\n int fd = channel->Fd();
\n struct epoll_event ev;
\n ev.data.fd = fd;
\n ev.events = channel->Events();
\n int ret = epoll_ctl(_epfd, op, fd, &ev);
\n if (ret < 0)
\n {
\n ERR_LOG("EPOLLCTL FAILED!");
\n \/\/ abort(); \/\/\u9000\u51fa\u7a0b\u5e8f
\n }
\n return;
\n }
\n \/\/ \u5224\u65ad\u4e00\u4e2aChannel\u662f\u5426\u5df2\u7ecf\u6dfb\u52a0\u4e86\u4e8b\u4ef6\u76d1\u63a7
\n bool HasChannel(Channel *channel)
\n {
\n auto it = _channels.find(channel->Fd());
\n if (it == _channels.end())
\n {
\n return false;
\n }
\n return true;
\n }<\/p>\n
public:
\n Poller()
\n {
\n _epfd = epoll_create(MAX_EPOLLEVENTS);
\n if (_epfd < 0)
\n {
\n ERR_LOG("EPOLL CREATE FAILED!");
\n abort();
\n }
\n }
\n void UpdateEvent(Channel *channel) \/\/ \u6dfb\u52a0\u6216\u4fee\u6539\u76d1\u63a7\u4e8b\u4ef6
\n {
\n bool ret = HasChannel(channel);
\n if (ret == false)
\n {
\n \/\/ \u4e0d\u5b58\u5728\u5219\u6dfb\u52a0
\n _channels.insert(std::make_pair(channel->Fd(), channel));
\n return Update(channel, EPOLL_CTL_ADD);
\n }
\n return Update(channel, EPOLL_CTL_MOD);
\n }
\n void RemoveEvent(Channel *channel) \/\/ \u79fb\u9664\u76d1\u63a7
\n {
\n auto it = _channels.find(channel->Fd());
\n {
\n if (it != _channels.end())
\n {
\n _channels.erase(it);
\n }
\n Update(channel, EPOLL_CTL_DEL);
\n }
\n }
\n void Poll(std::vector<Channel *> *active) \/\/ \u5f00\u59cb\u76d1\u63a7,\u8fd4\u56de\u6d3b\u8dc3\u8fde\u63a5
\n {
\n int nfds = epoll_wait(_epfd, _evs, MAX_EPOLLEVENTS, -1); \/\/-1\u4ee3\u8868\u963b\u585e\u76d1\u63a7
\n if (nfds < 0)
\n {
\n if (errno == EINTR)
\n {
\n return;
\n }
\n ERR_LOG("EPOLL WAIT ERROR:%s\\\\n", strerror(errno));
\n abort();
\n }
\n for (int i = 0; i < nfds; i++)
\n {
\n auto it = _channels.find(_evs[i].data.fd);
\n assert(it != _channels.end());
\n it->second->SetREvents(_evs[i].events);
\n active->push_back(it->second);
\n }
\n return;
\n }
\n}; <\/p>\n
\u524d\u9762\u7684\u51c6\u5907\u77e5\u8bc6\u4e2d\u6211\u4eec\u5df2\u7ecf\u57fa\u672c\u5b9e\u73b0\u4e86\u65f6\u95f4\u8f6e，\u552f\u4e00\u9700\u8981\u89e3\u91ca\u7684\u5c31\u662f\u5bf9\u4e8e\u5b9a\u65f6\u5668\u6587\u4ef6\u63cf\u8ff0\u7b26\u7684\u4f7f\u7528<\/p>\n
\u5b9a\u65f6\u5668\u6587\u4ef6\u63cf\u8ff0\u7b26\u7684\u521b\u5efa：timerfd_create<\/p>\n
\u7b2c\u4e00\u4e2a\u53c2\u6570\u4e00\u822c\u4f20\u5165\u7684\u662fCLOCK_MONOTONIC，\u8868\u793a\u4f7f\u7528\u5355\u8c03\u65f6\u949f，\u4e0d\u6536\u7cfb\u7edf\u65f6\u95f4\u8c03\u6574\u5f71\u54cd<\/p>\n
\u7b2c\u4e8c\u4e2a\u53c2\u6570\u4f20\u51650\u8868\u793a\u6ca1\u6709\u7279\u6b8a\u6807\u5fd7<\/p>\n
\u7136\u540e\u6211\u4eec\u9700\u8981\u8bbe\u7f6e\u5b9a\u65f6\u5668\u53c2\u6570，\u8fd9\u91cc\u4f7f\u7528\u7684\u662fitimerspec\u7c7b\u578b\u7684\u7ed3\u6784\u4f53<\/p>\n
struct itimerspec
\n{
\n struct timespec it_interval;
\n struct timespec it_value;
\n};<\/p>\n
it_value\u5305\u542b\u4e24\u4e2a\u53c2\u6570，tv_sec\u548ctv_nsec\u5206\u522b\u7528\u6765\u8bbe\u7f6e\u79d2\u548c\u6beb\u79d2，tv_sec\u7528\u6765\u8bbe\u7f6e\u7b2c\u4e00\u6b21\u8d85\u65f6\u65f6\u95f4，it_interval\u540c\u6837\u5305\u542b\u4e24\u4e2a\u53c2\u6570tv_sec\u548ctv_nsec，\u7528\u6765\u8bbe\u7f6e\u7b2c\u4e00\u6b21\u8d85\u65f6\u540e，\u6bcf\u6b21\u7684\u8d85\u65f6\u65f6\u95f4\u95f4\u9694<\/p>\n
\u53ef\u4ee5\u4f7f\u7528read\u51fd\u6570，\u4f20\u5165\u5b9a\u65f6\u5668\u6587\u4ef6\u63cf\u8ff0\u7b26\u6765\u8bfb\u53d6\u4e00\u5171\u8d85\u65f6\u4e86\u591a\u5c11\u6b21<\/p>\n
int ret = read(_timerfd, ×, 8); <\/p>\n
\u4e0b\u9762\u5c31\u662f\u8fd9\u4e2a\u7c7b\u5b8c\u6574\u4ee3\u7801\u4e86<\/p>\n
using TaskFunc = std::function<void()>;
\nusing ReleaseFunc = std::function<void()>;
\nclass TimerTask
\n{
\nprivate:
\n uint64_t _id; \/\/ \u5b9a\u65f6\u5668\u4efb\u52a1\u5bf9\u8c61id
\n uint32_t _timeout; \/\/ \u5b9a\u65f6\u4efb\u52a1\u7684\u8d85\u65f6\u65f6\u95f4
\n bool _canceled; \/\/ false-\u8868\u793a\u6ca1\u6709\u88ab\u53d6\u6d88
\n TaskFunc _task_cb; \/\/ \u5b9a\u65f6\u5668\u5bf9\u8c61\u8981\u6267\u884c\u7684\u5b9a\u65f6\u4efb\u52a1
\n ReleaseFunc _release; \/\/ \u7528\u4e8e\u5220\u9664TimerWheel\u4e2d\u4fdd\u5b58\u7684\u5b9a\u65f6\u5668\u5bf9\u8c61\u4fe1\u606f
\npublic:
\n TimerTask(uint64_t id, uint32_t delay, const TaskFunc &cb)
\n : _id(id), _timeout(delay), _task_cb(cb), _canceled(false)
\n {
\n }<\/p>\n
~TimerTask()
\n {
\n if (_canceled == false)
\n _task_cb();
\n _release();
\n }<\/p>\n
void Cancel()
\n {
\n _canceled = true;
\n }<\/p>\n
void SetRelease(const ReleaseFunc &cb)
\n {
\n _release = cb;
\n }<\/p>\n
uint32_t DelayTime()
\n {
\n return _timeout;
\n }
\n};<\/p>\n
class TimerWheel
\n{
\nprivate:
\n using WeakTask = std::weak_ptr<TimerTask>;
\n using PtrTask = std::shared_ptr<TimerTask>;
\n int _tick; \/\/ \u5f53\u524d\u7684\u79d2\u9488，\u8d70\u5230\u54ea\u91cc\u91ca\u653e\u54ea\u91cc
\n int _capacity; \/\/ \u8868\u76d8\u6700\u5927\u6570\u91cf，\u5176\u5b9e\u5c31\u662f\u6700\u5927\u5ef6\u8fdf\u65f6\u95f4
\n std::vector<std::vector<PtrTask>> _wheel;
\n std::unordered_map<uint64_t, WeakTask> _timers; \/\/ \u4f7f\u7528\u4efb\u52a1ID\u627e\u5230\u5bf9\u5e94\u7684weak_ptr<\/p>\n
EventLoop *_loop;
\n int _timerfd; \/\/ \u5b9a\u65f6\u5668\u63cf\u8ff0\u7b26
\n std::unique_ptr<Channel> _timer_channel;<\/p>\n
private:
\n void RemoveTimer(uint16_t id)
\n {
\n auto it = _timers.find(id);
\n if (it != _timers.end())
\n {
\n _timers.erase(it);
\n }
\n }
\n static int CreateTimerFd()
\n {
\n int timerfd = timerfd_create(CLOCK_MONOTONIC, 0);
\n if (timerfd < 0)
\n {
\n ERR_LOG("TIMERED CREATE FAILED!");
\n abort();
\n }<\/p>\n
struct itimerspec itime;
\n itime.it_value.tv_sec = 1;
\n itime.it_value.tv_nsec = 0; \/\/ \u7b2c\u4e00\u6b21\u8d85\u65f6\u65f6\u95f4\u4e3a1s\u540e
\n itime.it_interval.tv_sec = 1;
\n itime.it_interval.tv_nsec = 0; \/\/ \u7b2c\u4e00\u6b21\u8d85\u65f6\u540e，\u6bcf\u6b21\u8d85\u65f6\u7684\u65f6\u95f4\u95f4\u9694
\n timerfd_settime(timerfd, 0, &itime, NULL);
\n return timerfd;
\n }
\n int ReadTimefd()
\n {
\n uint64_t times;
\n \/\/\u6709\u53ef\u80fd\u56e0\u4e3a\u5176\u4ed6\u63cf\u8ff0\u7b26\u7684\u4e8b\u4ef6\u5904\u7406\u82b1\u8d39\u65f6\u95f4\u6bd4\u8f83\u957f，\u7136\u540e\u5728\u5904\u7406\u5b9a\u65f6\u5668\u63cf\u8ff0\u7b26\u4e8b\u4ef6\u7684\u65f6\u5019，\u6709\u53ef\u80fd\u5c31\u5df2\u7ecf\u8d85\u65f6\u4e86\u5f88\u591a\u6b21
\n \/\/read\u8bfb\u53d6\u5230\u7684\u6570\u636etimes\u5c31\u662f\u4ece\u4e0a\u4e00\u6b21read\u4e4b\u540e\u8d85\u65f6\u7684\u6b21\u6570
\n int ret = read(_timerfd, ×, 8);
\n if (ret < 0)
\n {
\n ERR_LOG("READ TIMER FAILED!");
\n abort();
\n }
\n return times;
\n }
\n \/\/ \u8fd9\u4e2a\u51fd\u6570\u6bcf\u79d2\u88ab\u6267\u884c\u4e00\u6b21，\u76f8\u5f53\u4e8e\u79d2\u9488\u5411\u540e\u8d70\u4e86\u4e00\u6b65
\n void RunTimeTask()
\n {
\n _tick = (_tick + 1) % _capacity;
\n _wheel[_tick].clear();
\n }
\n void OnTime()
\n {
\n \/\/\u6839\u636e\u5b9e\u9645\u8d85\u65f6\u7684\u6b21\u6570，\u6267\u884c\u5bf9\u5e94\u7684\u8d85\u65f6\u4efb\u52a1
\n int times = ReadTimefd();
\n for(int i = 0; i < times; i++)
\n {
\n RunTimeTask();
\n }
\n }
\n void TimerAddInLoop(uint64_t id, uint32_t delay, const TaskFunc &cb) \/\/ \u6dfb\u52a0\u5b9a\u65f6\u4efb\u52a1
\n {
\n PtrTask pt(new TimerTask(id, delay, cb));
\n pt->SetRelease(std::bind(&TimerWheel::RemoveTimer, this, id));
\n int pos = (_tick + delay) % _capacity;
\n _wheel[pos].push_back(pt);
\n _timers[id] = WeakTask(pt);
\n }<\/p>\n
void TimerRefreshInLoop(uint64_t id) \/\/ \u5237\u65b0\/\u5ef6\u8fdf\u5b9a\u65f6\u4efb\u52a1
\n {
\n \/\/ \u901a\u8fc7\u4fdd\u5b58\u7684\u5b9a\u65f6\u5668\u5bf9\u8c61\u7684weakptr\u6784\u9020\u4e00\u4e2ashared_ptr\u51fa\u6765，\u6dfb\u52a0\u5230\u8f6e\u5b50\u4e2d
\n auto it = _timers.find(id);
\n if (it == _timers.end())
\n {
\n \/\/ \u6ca1\u6709\u627e\u5230\u5b9a\u65f6\u4efb\u52a1
\n return;
\n }
\n PtrTask pt = it->second.lock(); \/\/ lock\u83b7\u53d6weakptr\u7ba1\u7406\u7684\u5bf9\u8c61\u5bf9\u5e94\u7684shared_ptr;
\n int delay = pt->DelayTime();
\n int pos = (_tick + delay) % _capacity;
\n _wheel[pos].push_back(pt);
\n }<\/p>\n
void TimerCancelInLoop(uint64_t id)
\n {
\n auto it = _timers.find(id);
\n if (it == _timers.end())
\n {
\n \/\/ \u6ca1\u6709\u627e\u5230\u5b9a\u65f6\u4efb\u52a1
\n return;
\n }
\n PtrTask pt = it->second.lock();
\n if (pt)
\n pt->Cancel();
\n }<\/p>\n
public:
\n TimerWheel(EventLoop *loop)
\n : _capacity(60),
\n _tick(0),
\n _wheel(_capacity),
\n _loop(loop),
\n _timerfd(CreateTimerFd()),
\n _timer_channel(new Channel(_loop, _timerfd))
\n {
\n _timer_channel->SetReadCallback(std::bind(&TimerWheel::OnTime, this));
\n _timer_channel->EnableRead();
\n }
\n \/*\u5b9a\u65f6\u5668\u4e2d\u6709\u4e2a_timers\u6210\u5458，\u5b9a\u65f6\u5668\u4fe1\u606f\u7684\u64cd\u4f5c\u6709\u53ef\u80fd\u5728\u591a\u7ebf\u7a0b\u4e2d\u8fdb\u884c， \u56e0\u6b64\u9700\u8981\u8003\u8651\u7ebf\u7a0b\u5b89\u5168\u95ee\u9898*\/
\n \/*\u5982\u679c\u4e0d\u60f3\u52a0\u9501，\u90a3\u5c31\u628a\u5bf9\u5b9a\u65f6\u7684\u6240\u6709\u64cd\u4f5c，\u90fd\u653e\u5728\u4e00\u4e2a\u7ebf\u7a0b\u4e2d\u8fdb\u884c*\/
\n void TimerAdd(uint64_t id, uint32_t delay, const TaskFunc &cb);
\n \/\/ \u5237\u65b0\/\u5ef6\u8fdf\u5b9a\u65f6\u4efb\u52a1
\n void TimerRefresh(uint64_t id);
\n void TimerCancel(uint64_t id);
\n \/*\u8fd9\u4e2a\u63a5\u53e3\u5b58\u5728\u7ebf\u7a0b\u5b89\u5168\u95ee\u9898–\u8fd9\u4e2a\u63a5\u53e3\u5b9e\u9645\u4e0a\u4e0d\u80fd\u88ab\u5916\u754c\u4f7f\u7528\u8005\u8c03\u7528，\u53ea\u80fd\u5728\u6a21\u5757\u5185，\u5728\u5bf9\u5e94\u7684EventLoop\u7ebf\u7a0b\u5185\u6267\u884c*\/
\n bool HasTimer(uint64_t id)
\n {
\n auto it = _timers.find(id);
\n if (it == _timers.end())
\n {
\n return false;
\n }
\n return true;
\n }
\n}; <\/p>\n
EventLoop\u6a21\u5757\u53ef\u4ee5\u7406\u89e3\u4e3aReactor\u6a21\u5757，\u5b83\u662f\u5bf9Poller\u6a21\u5757，TimeQueue\u6a21\u5757，Socket\u6a21\u5757\u7684\u4e00\u4e2a\u6574\u4f53\u5c01\u88c5，\u8fdb\u884c\u6240\u6709\u63cf\u8ff0\u7b26\u7684\u4e8b\u4ef6\u76d1\u63a7<\/p>\n
\u9996\u5148\u662fEventLoop\u7684\u79c1\u6709\u6210\u5458\u53d8\u91cf<\/p>\n
using Functor = std::function<void()>;
\nstd::thread::id _thread_id; \/\/ \u7ebf\u7a0bID
\nint _event_fd; \/\/ eventfd\u5524\u9192IO\u4e8b\u4ef6\u76d1\u63a7\u6709\u53ef\u80fd\u5bfc\u81f4\u7684\u963b\u585e
\nstd::unique_ptr<Channel> _event_channel; \/\/ \u901a\u8fc7\u8fd9\u4e2a\u6765\u7ba1\u7406_event_fd\u4e2d\u7684\u4e8b\u4ef6
\nPoller _poller; \/\/ \u8fdb\u884c\u6240\u6709\u63cf\u8ff0\u7b26\u7684\u4e8b\u4ef6\u76d1\u63a7
\nstd::vector<Functor> _tasks; \/\/ \u4efb\u52a1\u6c60
\nstd::mutex _mutex; \/\/ \u5b9e\u73b0\u4efb\u52a1\u6c60\u64cd\u4f5c\u7684\u7ebf\u7a0b\u5b89\u5168
\nTimerWheel _timer_wheel; \/\/ \u5b9a\u65f6\u5668\u6a21\u5757 <\/p>\n
\u7136\u540e\u5c31\u662f\u5bf9\u5176\u4e2d\u7684\u6210\u5458\u51fd\u6570\u89e3\u91ca<\/p>\n
\u9996\u5148\u662f\u6267\u884c\u4efb\u52a1\u6c60\u4e2d\u7684\u6240\u6709\u4efb\u52a1RunAllTask\u51fd\u6570<\/p>\n
void RunAllTask()
\n{
\n std::vector<Functor> functor;
\n {
\n std::unique_lock<std::mutex> _lock(_mutex);
\n _tasks.swap(functor); \/\/ \u4ea4\u6362\u4e4b\u540e，\u4efb\u52a1\u5168\u90e8\u4ea4\u6362\u5230\u4e86functor\u91cc\u9762
\n }
\n for (auto &f : functor)
\n {
\n f();
\n }
\n} <\/p>\n
\u8fd9\u4e2a\u51fd\u6570\u6709\u4e00\u4e2a\u70b9\u9700\u8981\u89e3\u91ca\u4e00\u4e0b，\u5c31\u662f\u4e3a\u4ec0\u4e48\u4e0b\u9762\u8fd9\u6bb5\u4ee3\u7801\u8981\u52a0\u4e0a\u5927\u62ec\u53f7<\/p>\n
{
\n std::unique_lock<std::mutex> _lock(_mutex);
\n _tasks.swap(functor); \/\/ \u4ea4\u6362\u4e4b\u540e，\u4efb\u52a1\u5168\u90e8\u4ea4\u6362\u5230\u4e86functor\u91cc\u9762
\n} <\/p>\n
\u539f\u56e0：\u5927\u62ec\u53f7\u7528\u6765\u5b9a\u4e49\u4e00\u4e2a\u4f5c\u7528\u57df，\u4f7f\u7528\u5927\u62ec\u53f7\u5305\u542bstd::unique_lock<srd::mutex>\u7684\u58f0\u660e\u548c_tasks.swap(functor)\u7684\u8c03\u7528，\u662f\u4e3a\u4e86\u9650\u5236std::unique_lock\u5bf9\u8c61\u7684\u751f\u547d\u5468\u671f\u548c\u4f5c\u7528\u57df\u3002std::unique_lock<std::mutex>\u662f\u4e00\u4e2aRALL\u5bf9\u8c61，\u4f1a\u5728\u6784\u9020\u65f6\u83b7\u53d6\u9501，\u5e76\u5728\u6790\u6784\u65f6\u81ea\u52a8\u91ca\u653e\u9501，\u5c06\u5bf9\u8c61\u7684\u4f5c\u7528\u57df\u9650\u5236\u5728\u5927\u62ec\u53f7\u5185，\u53ef\u4ee5\u786e\u4fdd\u5728\u79bb\u5f00\u8fd9\u4e2a\u4f5c\u7528\u57df\u65f6，\u9501\u4f1a\u88ab\u81ea\u52a8\u91ca\u653e，\u8fd9\u53ef\u4ee5\u9632\u6b62\u7531\u4e8e\u5f02\u5e38\u6216\u63d0\u524d\u8fd4\u56de\u5bfc\u81f4\u7684\u9501\u672a\u91ca\u653e\u95ee\u9898<\/p>\n
\u521b\u5efaeventfd<\/p>\n
static int CreateEventFd()
\n{
\n int efd = eventfd(0, EFD_CLOEXEC | EFD_NONBLOCK);
\n if (efd < 0)
\n {
\n ERR_LOG("CREATE EVENTFD FAILED!");
\n abort();
\n }
\n return efd;
\n} <\/p>\n
\u8fd9\u91cc\u89e3\u91ca\u4e00\u4e0beventfd\u51fd\u6570<\/p>\n
\u7b2c\u4e00\u4e2a\u53c2\u65700\u8868\u793a\u521d\u59cb\u4e8b\u4ef6\u8ba1\u6570\u4e3a0，\u7b2c\u4e8c\u4e2a\u53c2\u6570\u662f\u6807\u5fd7\u4f4d，\u7528\u4e8e\u63a7\u5236eventfd\u7684\u884c\u4e3a<\/p>\n
EFD_CLOEXEC：\u8bbe\u7f6eclose-on-exec\u6807\u5fd7，\u786e\u4fdd\u5728\u6267\u884cexec\u7cfb\u5217\u51fd\u6570\u65f6\u5173\u95ed\u6587\u4ef6\u63cf\u8ff0\u7b26<\/p>\n
\u4f8b\u5982，\u5728\u521b\u5efa\u5b50\u8fdb\u7a0b\u65f6，\u7236\u8fdb\u7a0b\u53ef\u80fd\u6253\u5f00\u4e86\u4e00\u4e9b\u6587\u4ef6\u63cf\u8ff0\u7b26\u7528\u4e8e\u5185\u90e8\u901a\u4fe1\u3002\u5982\u679c\u4e0d\u8bbe\u7f6eclose-on-exec\u6807\u5fd7，\u8fd9\u4e9b\u6587\u4ef6\u63cf\u8ff0\u7b26\u53ef\u80fd\u4f1a\u88ab\u5b50\u8fdb\u7a0b\u7ee7\u627f，\u5bfc\u81f4\u8d44\u6e90\u6cc4\u6f0f\u6216\u5b89\u5168\u95ee\u9898\u3002<\/p>\n
EFD_NONBLOCK：\u8bbe\u7f6e\u975e\u963b\u585e\u6a21\u5f0f，\u5bf9eventfd\u7684\u8bfb\u5199\u64cd\u4f5c\u4e0d\u4f1a\u963b\u585e\u8c03\u7528\u7ebf\u7a0b<\/p>\n
\u4ece_event_fd\u4e2d\u8bfb\u53d6\u4e8b\u4ef6\u8ba1\u6570<\/p>\n
void ReadEventFd()
\n{
\n uint64_t res = 0;
\n int ret = read(_event_fd, &res, sizeof(res));
\n if (ret < 0)
\n {
\n if (errno == EINTR || errno == EAGAIN)
\n {
\n return;
\n }
\n ERR_LOG("READ EVENTFD FAILED!");
\n abort();
\n }
\n return;
\n} <\/p>\n
\u5411eventfd\u4e2d\u5199\u5165\u4e00\u4e2a\u4e8b\u4ef6\u8ba1\u6570，\u4ee5\u901a\u77e5\u5176\u4ed6\u7ebf\u7a0b\u6216\u8fdb\u7a0b\u4e8b\u4ef6\u7684\u53d1\u751f<\/p>\n
void WakeUpEventFd()
\n{
\n uint64_t val = 1;
\n int ret = write(_event_fd, &val, sizeof(val));
\n if (ret < 0)
\n {
\n if (errno == EINTR)
\n {
\n return;
\n }
\n ERR_LOG("READ EVENTFD FAILED!");
\n abort();
\n }
\n return;
\n} <\/p>\n
Start\u51fd\u6570，\u5206\u4e3a\u4e09\u4e2a\u6b65\u9aa4：\u4e8b\u4ef6\u76d1\u63a7->\u5c31\u7eea\u4e8b\u4ef6\u5904\u7406->\u6267\u884c\u4efb\u52a1<\/p>\n
void Start()
\n{
\n while (1)
\n {
\n std::vector<Channel *> actives;
\n _poller.Poll(&actives);<\/p>\n
for (auto &channel : actives)
\n {
\n channel->HandleEvent();
\n }<\/p>\n
RunAllTask();
\n }
\n} <\/p>\n
\u4f7f\u7528IsInLoop\u51fd\u6570\u5224\u65ad\u5f53\u524d\u7ebf\u7a0b\u662f\u5426\u4e3aeventloop\u5bf9\u5e94\u7684\u7ebf\u7a0b<\/p>\n
bool IsInLoop()
\n{
\n return (_thread_id == std::this_thread::get_id());
\n} <\/p>\n
\u5224\u65ad\u8981\u6267\u884c\u7684\u4efb\u52a1\u662f\u5426\u5904\u4e8e\u5f53\u524d\u7ebf\u7a0b\u4e2d，\u5982\u679c\u662f\u5219\u6267\u884c，\u4e0d\u662f\u5219\u538b\u5165\u961f\u5217<\/p>\n
void RunInLoop(const Functor &cb)
\n{
\n if (IsInLoop())
\n {
\n return cb();
\n }
\n return QueueInLoop(cb);
\n} <\/p>\n
\u5c06\u64cd\u4f5c\u538b\u5165\u4efb\u52a1\u6c60<\/p>\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\u6709\u53ef\u80fd\u56e0\u4e3a\u6ca1\u6709\u4e8b\u4ef6\u5c31\u7eea\u800c\u5bfc\u81f4\u7684epoll\u963b\u585e
\n \/\/ \u5176\u5b9e\u5c31\u662f\u7ed9eventfd\u5199\u5165\u4e00\u4e2a\u6570\u636e，eventfd\u5c31\u4f1a\u89e6\u53d1\u53ef\u8bfb\u4e8b\u4ef6
\n WakeUpEventFd();
\n} <\/p>\n
\u6700\u540e\u5c31\u662f\u5bf9\u63cf\u8ff0\u7b26\u76d1\u63a7\u7684\u64cd\u4f5c<\/p>\n
\/\/ \u6dfb\u52a0\/\u4fee\u6539\u63cf\u8ff0\u7b26\u7684\u4e8b\u4ef6\u76d1\u63a7
\nvoid UpdateEvent(Channel *channel)
\n{
\n return _poller.UpdateEvent(channel);
\n}
\n\/\/ \u79fb\u9664\u63cf\u8ff0\u7b26\u7684\u76d1\u63a7
\nvoid RemoveEvent(Channel *channel)
\n{
\n return _poller.RemoveEvent(channel);
\n}
\nvoid TimerAdd(uint64_t id, uint32_t delay, const TaskFunc &cb)
\n{
\n return _timer_wheel.TimerAdd(id, delay, cb);
\n}
\nvoid TimerRefresh(uint64_t id)
\n{
\n return _timer_wheel.TimerRefresh(id);
\n}
\nvoid TimerCancel(uint64_t id)
\n{
\n return _timer_wheel.TimerCancel(id);
\n}
\nbool HasTimer(uint64_t id)
\n{
\n return _timer_wheel.HasTimer(id);
\n} <\/p>\n
\u5168\u90e8\u4ee3\u7801\u5982\u4e0b<\/p>\n
class EventLoop
\n{
\nprivate:
\n using Functor = std::function<void()>;
\n std::thread::id _thread_id; \/\/ \u7ebf\u7a0bID
\n int _event_fd; \/\/ eventfd\u5524\u9192IO\u4e8b\u4ef6\u76d1\u63a7\u6709\u53ef\u80fd\u5bfc\u81f4\u7684\u963b\u585e
\n std::unique_ptr<Channel> _event_channel; \/\/ \u901a\u8fc7\u8fd9\u4e2a\u6765\u7ba1\u7406_event_fd\u4e2d\u7684\u4e8b\u4ef6
\n Poller _poller; \/\/ \u8fdb\u884c\u6240\u6709\u63cf\u8ff0\u7b26\u7684\u4e8b\u4ef6\u76d1\u63a7
\n std::vector<Functor> _tasks; \/\/ \u4efb\u52a1\u6c60
\n std::mutex _mutex; \/\/ \u5b9e\u73b0\u4efb\u52a1\u6c60\u64cd\u4f5c\u7684\u7ebf\u7a0b\u5b89\u5168
\n TimerWheel _timer_wheel; \/\/ \u5b9a\u65f6\u5668\u6a21\u5757
\npublic:
\n \/\/ \u6267\u884c\u4efb\u52a1\u6c60\u4e2d\u7684\u6240\u6709\u4efb\u52a1
\n void RunAllTask()
\n {
\n std::vector<Functor> functor;
\n {
\n std::unique_lock<std::mutex> _lock(_mutex);
\n _tasks.swap(functor); \/\/ \u4ea4\u6362\u4e4b\u540e，\u4efb\u52a1\u5168\u90e8\u4ea4\u6362\u5230\u4e86functor\u91cc\u9762
\n }
\n for (auto &f : functor)
\n {
\n f();
\n }
\n }
\n static int CreateEventFd()
\n {
\n int efd = eventfd(0, EFD_CLOEXEC | EFD_NONBLOCK);
\n if (efd < 0)
\n {
\n ERR_LOG("CREATE EVENTFD FAILED!");
\n abort();
\n }
\n return efd;
\n }
\n void ReadEventFd()
\n {
\n uint64_t res = 0;
\n int ret = read(_event_fd, &res, sizeof(res));
\n if (ret < 0)
\n {
\n if (errno == EINTR || errno == EAGAIN)
\n {
\n return;
\n }
\n ERR_LOG("READ EVENTFD FAILED!");
\n abort();
\n }
\n return;
\n }
\n void WakeUpEventFd()
\n {
\n uint64_t val = 1;
\n int ret = write(_event_fd, &val, sizeof(val));
\n if (ret < 0)
\n {
\n if (errno == EINTR)
\n {
\n return;
\n }
\n ERR_LOG("READ EVENTFD FAILED!");
\n abort();
\n }
\n return;
\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 _event_channel->SetReadCallback(std::bind(&EventLoop::ReadEventFd, this));
\n \/\/ \u542f\u52a8eventfd\u8bfb\u4e8b\u4ef6\u76d1\u63a7
\n _event_channel->EnableRead();
\n }
\n void Start() \/\/ \u4e09\u6b65\u8d70–\u4e8b\u4ef6\u76d1\u63a7->\u5c31\u7eea\u4e8b\u4ef6\u5904\u7406->\u6267\u884c\u4efb\u52a1
\n {
\n while (1)
\n {
\n std::vector<Channel *> actives;
\n _poller.Poll(&actives);<\/p>\n
for (auto &channel : actives)
\n {
\n channel->HandleEvent();
\n }<\/p>\n
RunAllTask();
\n }
\n }
\n \/\/ \u7528\u4e8e\u5224\u65ad\u5f53\u524d\u7ebf\u7a0b\u662f\u5426\u662feventloop\u5bf9\u5e94\u7684\u7ebf\u7a0b
\n bool IsInLoop()
\n {
\n return (_thread_id == std::this_thread::get_id());
\n }
\n void AssertInLoop()
\n {
\n assert(_thread_id == std::this_thread::get_id());
\n }
\n \/\/ \u5224\u65ad\u8981\u6267\u884c\u7684\u4efb\u52a1\u662f\u5426\u5904\u4e8e\u5f53\u524d\u7ebf\u7a0b\u4e2d，\u5982\u679c\u662f\u5219\u6267\u884c，\u5982\u679c\u4e0d\u662f\u5219\u538b\u5165\u961f\u5217
\n void RunInLoop(const Functor &cb)
\n {
\n if (IsInLoop())
\n {
\n return cb();
\n }
\n return QueueInLoop(cb);
\n }
\n \/\/ \u5c06\u64cd\u4f5c\u538b\u5165\u4efb\u52a1\u6c60
\n void QueueInLoop(const Functor &cb)
\n {
\n {
\n std::unique_lock<std::mutex> _lock(_mutex);
\n _tasks.push_back(cb);
\n }
\n \/\/ \u5524\u9192\u6709\u53ef\u80fd\u56e0\u4e3a\u6ca1\u6709\u4e8b\u4ef6\u5c31\u7eea\u800c\u5bfc\u81f4\u7684epoll\u963b\u585e
\n \/\/ \u5176\u5b9e\u5c31\u662f\u7ed9eventfd\u5199\u5165\u4e00\u4e2a\u6570\u636e，eventfd\u5c31\u4f1a\u89e6\u53d1\u53ef\u8bfb\u4e8b\u4ef6
\n WakeUpEventFd();
\n }
\n \/\/ \u6dfb\u52a0\/\u4fee\u6539\u63cf\u8ff0\u7b26\u7684\u4e8b\u4ef6\u76d1\u63a7
\n void UpdateEvent(Channel *channel)
\n {
\n return _poller.UpdateEvent(channel);
\n }
\n \/\/ \u79fb\u9664\u63cf\u8ff0\u7b26\u7684\u76d1\u63a7
\n void RemoveEvent(Channel *channel)
\n {
\n return _poller.RemoveEvent(channel);
\n }
\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
\u8fd9\u4e2a\u7c7b\u7684\u4e3b\u8981\u4f5c\u7528\u662f\u786e\u4fdd\u7ebf\u7a0b\u5b89\u5168\u5730\u521b\u5efa\u548c\u8bbf\u95eeEventLoop\u5bf9\u8c61<\/p>\n
\u5173\u4e8e\u6210\u5458\u53d8\u91cf<\/p>\n
std::mutex _mutex; \/\/ \u4e92\u65a5\u9501
\nstd::condition_variable _cond; \/\/ \u6761\u4ef6\u53d8\u91cf
\nEventLoop *_loop; \/\/ EventLoop\u6307\u9488\u53d8\u91cf，\u8fd9\u4e2a\u5bf9\u8c61\u9700\u8981\u5728\u7ebf\u7a0b
\nstd::thread _thread; \/\/ EventLoop\u5bf9\u5e94\u7684\u7ebf\u7a0b <\/p>\n
\u63a5\u4e0b\u6765\u89e3\u91ca\u4e00\u4e0b\u6210\u5458\u51fd\u6570<\/p>\n
\u9996\u5148\u662fThreadEntry，\u8d1f\u8d23\u5728\u7ebf\u7a0b\u4e2d\u5b9e\u4f8b\u5316EventLoop\u5bf9\u8c61，\u5e76\u786e\u4fdd\u5176\u4ed6\u7ebf\u7a0b\u80fd\u591f\u5b89\u5168\u5730\u8bbf\u95ee\u8fd9\u4e2aEventLoop\u5bf9\u8c61\u3002<\/p>\n
void ThreadEntry()
\n{
\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
\u8fd9\u91cc\u89e3\u91ca\u4e00\u4e0b_cond.notify_all()，\u4ed6\u53ef\u4ee5\u5524\u9192\u6240\u6709\u5728_cond\u6761\u4ef6\u53d8\u91cf\u4e0a\u7b49\u5f85\u7684\u7ebf\u7a0b，\u901a\u77e5\u4ed6\u4eec_loop\u5df2\u7ecf\u521d\u59cb\u5316\u5b8c\u6210\u3002<\/p>\n
\u5173\u4e8e\u8fd9\u4e2a\u7c7b\u7684\u521d\u59cb\u5316\u51fd\u6570<\/p>\n
\u521d\u59cb\u5316_thread\u6210\u5458\u53d8\u91cf\u4e3a\u4e00\u4e2a\u65b0\u7684\u7ebf\u7a0b，\u8be5\u7ebf\u7a0b\u5c06\u6267\u884cThreadEntry\u65b9\u6cd5\u3002<\/p>\n
LoopThread()
\n : _loop(NULL),
\n _thread(std::thread(&LoopThread::ThreadEntry, this))
\n{
\n} <\/p>\n
\u7136\u540e\u5c31\u662f\u8fd4\u56de\u5f53\u524d\u7ebf\u7a0b\u5173\u8054\u7684EventLoop\u6307\u9488<\/p>\n
\u76f4\u5230_loop\u4e0d\u4e3a\u7a7a\u624d\u5c06loop\u521d\u59cb\u5316<\/p>\n
EventLoop *GetLoop()
\n{
\n EventLoop *loop = NULL;
\n {
\n std::unique_lock<std::mutex> lock(_mutex); \/\/ \u52a0\u9501
\n \/*\u6ee1\u8db3\u4ec0\u4e48\u7684\u6761\u4ef6\u5c31\u4e0d\u4f1a\u7b49\u5f85*\/
\n \/\/ loop\u4e3a\u7a7a\u5c31\u4e00\u76f4\u963b\u585e
\n _cond.wait(lock, [&]()
\n { return _loop != NULL; });
\n loop = _loop;
\n }
\n return loop;
\n} <\/p>\n
\u4e0b\u9762\u662f\u5b8c\u6574\u4ee3\u7801<\/p>\n
class LoopThread
\n{
\nprivate:
\n \/*\u7528\u4e8e\u5b9e\u73b0_loop\u83b7\u53d6\u7684\u540c\u6b65\u5173\u7cfb，\u907f\u514d\u7ebf\u7a0b\u521b\u5efa\u4e86，\u4f46\u662f_loop\u8fd8\u6ca1\u6709\u5b9e\u4f8b\u5316\u4e4b\u524d\u53bb\u83b7\u53d6_loop*\/
\n std::mutex _mutex; \/\/ \u4e92\u65a5\u9501
\n std::condition_variable _cond; \/\/ \u6761\u4ef6\u53d8\u91cf
\n EventLoop *_loop; \/\/ EventLoop\u6307\u9488\u53d8\u91cf，\u8fd9\u4e2a\u5bf9\u8c61\u9700\u8981\u5728\u7ebf\u7a0b
\n std::thread _thread; \/\/ EventLoop\u5bf9\u5e94\u7684\u7ebf\u7a0b
\nprivate:
\n \/*\u5b9e\u4f8b\u5316EventLoop\u5bf9\u8c61，\u5524\u9192_cond\u4e0a\u6709\u53ef\u80fd\u963b\u585e\u7684\u7ebf\u7a0b，\u5e76\u4e14\u5f00\u59cb\u8fd0\u884cEventLoop\u6a21\u5757\u7684\u529f\u80fd*\/
\n void ThreadEntry()
\n {
\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\u7f6e\u7ebf\u7a0b\u5165\u53e3\u51fd\u6570*\/
\n LoopThread()
\n : _loop(NULL),
\n _thread(std::thread(&LoopThread::ThreadEntry, this))
\n {
\n }
\n \/*\u8fd4\u56de\u5f53\u524d\u7ebf\u7a0b\u5173\u8054\u7684EventLoop\u6307\u9488*\/
\n EventLoop *GetLoop()
\n {
\n EventLoop *loop = NULL;
\n {
\n std::unique_lock<std::mutex> lock(_mutex); \/\/ \u52a0\u9501
\n \/*\u6ee1\u8db3\u4ec0\u4e48\u7684\u6761\u4ef6\u5c31\u4e0d\u4f1a\u7b49\u5f85*\/
\n \/\/ loop\u4e3a\u7a7a\u5c31\u4e00\u76f4\u963b\u585e
\n _cond.wait(lock, [&]()
\n { return _loop != NULL; });
\n loop = _loop;
\n }
\n return loop;
\n }
\n}; <\/p>\n
LoopThreadPool\u7528\u4e8e\u7ba1\u7406\u591a\u4e2aLoopThread\u5bf9\u8c61，\u63d0\u4f9b\u7ebf\u7a0b\u6c60\u529f\u80fd<\/p>\n
\u9996\u5148\u662f\u6210\u5458\u53d8\u91cf<\/p>\n
int _thread_count;
\nint _next_idx;
\nEventLoop *_baseloop;
\nstd::vector<LoopThread *> _threads;
\nstd::vector<EventLoop *> _loops; <\/p>\n
\u7136\u540e\u5c31\u662f\u5bf9\u4e3b\u8981\u7684\u6210\u5458\u51fd\u6570\u7684\u89e3\u91ca<\/p>\n
\u9996\u5148\u662f\u5bf9\u7ebf\u7a0b\u6c60\u7684\u521b\u5efaCreate()<\/p>\n
\u5f53\u7ebf\u7a0b\u7684\u603b\u6570\u5927\u4e8e0\u7684\u65f6\u5019，\u9996\u5148\u9700\u8981\u5bf9_threads\u548c_loops\u8fd9\u4e24\u4e2a\u6570\u7ec4\u8fdb\u884c\u521d\u59cb\u5316，\u7136\u540e\u521b\u5efa_thread_count\u6570\u76ee\u7684\u7ebf\u7a0b\u4ee5\u53ca\u7ebf\u7a0b\u5bf9\u5e94\u7684EventLoop<\/p>\n
\u63a5\u4e0b\u6765\u662fNextLoop\u51fd\u6570，\u8fd9\u4e2a\u4f7f\u7528\u4e86\u8f6e\u8be2\u7684\u65b9\u5f0f\u6765\u5206\u914d\u4efb\u52a1<\/p>\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} <\/p>\n
\u5982\u679c\u53ef\u7528\u7684\u5de5\u4f5c\u7ebf\u7a0b\u6570\u76ee\u4e3a0，\u90a3\u4e48\u8fd4\u56de_baseloop，\u5373\u57fa\u7840\u7684\u4e8b\u4ef6\u5faa\u73af\u3002\u901a\u8fc7\u6a21\u8fd0\u7b97\u66f4\u65b0_next_idx\u5b9e\u73b0\u8f6e\u8be2\u9009\u62e9，\u6700\u540e\u6839\u636e\u66f4\u65b0\u540e\u7684_next_idx\u8fd4\u56de\u76f8\u5e94\u7684\u4e8b\u4ef6\u5faa\u73af<\/p>\n
\u4e0b\u9762\u5c31\u662f\u8fd9\u4e2a\u7c7b\u7684\u5b8c\u6574\u4ee3\u7801<\/p>\n
class 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 return;
\n }
\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
\u524d\u9762\u7684\u51c6\u5907\u77e5\u8bc6\u4e2d\u5df2\u7ecf\u8be6\u7ec6\u89e3\u91ca\u4e86Any\u7c7b\u7684\u5177\u4f53\u5b9e\u73b0，\u90a3\u4e48\u8fd9\u91cc\u76f4\u63a5\u7ed9\u51fa\u4ee3\u7801<\/p>\n
class Any
\n{
\nprivate:
\n class holder
\n {
\n public:
\n virtual ~holder()
\n {
\n }
\n \/\/ \u6570\u636e\u7c7b\u578b
\n virtual const std::type_info &type() = 0;
\n \/\/ \u514b\u9686\u51fa\u65b0\u7684\u5bf9\u8c61
\n virtual holder *clone() = 0;
\n };
\n template <class T>
\n class placeholder : public holder
\n {
\n public:
\n placeholder(const T &val) : _val(val) {}
\n \/\/ \u83b7\u53d6\u5b50\u7c7b\u5bf9\u8c61\u4fdd\u5b58\u7684\u6570\u636e\u7c7b\u578b
\n virtual const std::type_info &type()
\n {
\n return typeid(T);
\n }
\n \/\/ \u9488\u5bf9\u51fa\u5f53\u524d\u7684\u5bf9\u8c61\u81ea\u8eab，\u514b\u9686\u51fa\u4e00\u4e2a\u65b0\u7684\u5bf9\u8c61
\n virtual holder *clone()
\n {
\n return new placeholder(_val);
\n }<\/p>\n
public:
\n T _val;
\n };
\n holder *_content;<\/p>\n
public:
\n Any() : _content(NULL) {}
\n template <class T>
\n Any(const T &val) : _content(new placeholder<T>(val)) {}
\n Any(const Any &other) : _content(other._content ? other._content->clone() : NULL) {}
\n ~Any() { delete _content; }<\/p>\n
Any &swap(Any &other)
\n {
\n std::swap(_content, other._content);
\n return *this;
\n }<\/p>\n
template <class T>
\n \/\/ \u8fd4\u56de\u5b50\u7c7b\u5bf9\u8c61\u4fdd\u5b58\u7684\u6570\u636e\u7684\u6307\u9488
\n T *get()
\n {
\n \/\/ \u60f3\u8981\u83b7\u53d6\u7684\u6570\u636e\u7c7b\u578b，\u5fc5\u987b\u548c\u4fdd\u5b58\u7684\u6570\u636e\u7c7b\u578b\u4e00\u81f4
\n \/\/ if(typeid(T) != _content->type()) return NULL;
\n assert(typeid(T) == _content->type());
\n return &((placeholder<T> *)_content)->_val;
\n }
\n \/\/ \u8d4b\u503c\u8fd0\u7b97\u7b26\u91cd\u8f7d\u51fd\u6570
\n template <class T>
\n Any &operator=(const T &val)
\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
\n \/\/ \u4e34\u65f6\u5bf9\u8c61\u91ca\u653e\u7684\u65f6\u5019，\u539f\u5148\u4fdd\u5b58\u7684\u6570\u636e\u4e5f\u5c31\u88ab\u91ca\u653e\u4e86
\n Any(val).swap(*this);
\n return *this;
\n }
\n Any &operator=(const Any &other)
\n {
\n Any(other).swap(*this);
\n return *this;
\n }
\n}; <\/p>\n
Connection\u6a21\u5757\u65f6\u5bf9Buffer\u6a21\u5757，Socket\u6a21\u5757Channel\u6a21\u5757\u7684\u4e00\u4e2a\u6574\u4f53\u5c01\u88c5，\u5b9e\u73b0\u4e86\u5bf9\u4e00\u4e2a\u5957\u63a5\u901a\u4fe1\u5b57\u6574\u4f53\u7684\u7ba1\u7406，\u6bcf\u4e00\u4e2a\u8fdb\u884c\u6570\u636e\u901a\u4fe1\u7684\u5957\u63a5\u5b57（\u4e5f\u5c31\u662faccept\u83b7\u53d6\u5230\u7684\u65b0\u94fe\u63a5）\u90fd\u4f1a\u4f7f\u7528Connecition\u8fdb\u884c\u7ba1\u7406\u3002<\/p>\n
\u9996\u5148，\u8fde\u63a5Connection\u7684\u72b6\u6001\u80af\u5b9a\u6709\u591a\u79cd，\u8fd9\u91cc\u6211\u4eec\u4f7f\u7528enum\u6765\u7ba1\u7406\u8fde\u63a5\u7684\u72b6\u6001<\/p>\n
typedef enum
\n{
\n DISCONNECTED, \/\/ \u8fde\u63a5\u5173\u95ed\u72b6\u6001
\n CONNECTING, \/\/ \u8fde\u63a5\u5efa\u7acb\u6210\u529f\u5f85\u5904\u7406\u72b6\u6001
\n CONNECTED, \/\/ \u8fde\u63a5\u5efa\u7acb\u5b8c\u6210，\u5404\u79cd\u8bbe\u7f6e\u5df2\u5b8c\u6210\u53ef\u4ee5\u901a\u4fe1\u7684\u72b6\u6001
\n DISCONNECTING \/\/ \u5f85\u5173\u95ed\u72b6\u6001
\n} ConnStatu;<\/p>\n
\u63a5\u4e0b\u6765\u4ecb\u7ecd\u4e00\u4e0bConnection\u4e3b\u9898\u7684\u8bbe\u8ba1<\/p>\n
\u8fd9\u91cc\u4ecb\u7ecd\u4e00\u4e0bshared_from_this，\u4ed6\u662fC++\u6807\u51c6\u5e93\u7684\u4e00\u4e2a\u673a\u5236，\u5b9a\u4e49\u5728<memory>\u5934\u6587\u4ef6\u4e2d，\u901a\u8fc7std::enable_shared_fron_this\u6a21\u7248\u7c7b\u63d0\u4f9b\u3002\u5b83\u5141\u8bb8\u4e00\u4e2a\u5bf9\u8c61\u5b89\u5168\u5730\u751f\u6210\u6307\u5411\u81ea\u8eab\u7684shared_ptr，\u800c\u4e0d\u4f1a\u521b\u5efa\u989d\u5916\u7684\u63a7\u5236\u5757<\/p>\n
shared_fron_this\u89e3\u51b3\u4e86\u4ee5\u4e0b\u95ee\u9898<\/p>\n
\u6240\u4ee5，\u4e3a\u4e86\u5b89\u5168\u5730\u751f\u6210\u6307\u5411\u81ea\u8eab\u7684shared_ptr，\u6211\u4eec\u8ba9Connection\u7ee7\u627fenable_shared_from_this<Connection><\/p>\n
\u4e0b\u9762\u4ecb\u7ecd\u4e00\u4e0b\u8fd9\u4e2a\u7c7b\u7684\u79c1\u6709\u6210\u5458<\/p>\n
uint64_t _conn_id; \/\/ \u8fde\u63a5\u552f\u4e00ID，\u4fbf\u4e8e\u8fde\u63a5\u7684\u7ba1\u7406\u548c\u67e5\u627e
\n\/\/ uint64_t _timer_id; \/\/\u5b9a\u65f6\u5668ID，\u5fc5\u987b\u662f\u552f\u4e00\u7684，\u4e3a\u4e86\u7b80\u5316\u64cd\u4f5c\u4f7f\u7528conn_id\u4f5c\u4e3a\u5b9a\u65f6\u5668ID
\nint _sockfd; \/\/ \u8fde\u63a5\u5173\u8054\u7684\u6587\u4ef6\u63cf\u8ff0\u7b26
\nbool _enable_inactive_release; \/\/ \u8fde\u63a5\u662f\u5426\u542f\u52a8\u975e\u6d3b\u8dc3\u9500\u6bc1，\u9ed8\u8ba4\u662ffalse
\nEventLoop *_loop; \/\/ \u8fde\u63a5\u6240\u5173\u8054\u7684\u4e00\u4e2aloop
\nConnStatu _statu; \/\/ \u8fde\u63a5\u72b6\u6001
\nSocket _socket; \/\/ \u5957\u63a5\u5b57\u8fde\u63a5\u7ba1\u7406
\nChannel _channel; \/\/ \u8fde\u63a5\u7684\u4e8b\u4ef6\u7ba1\u7406
\nBuffer _in_buffer; \/\/ \u8f93\u5165\u7f13\u51b2\u533a—\u5b58\u653e\u4ecesocket\u4e2d\u8bfb\u53d6\u5230\u7684\u6570\u636e
\nBuffer _out_buffer; \/\/ \u8f93\u51fa\u7f13\u51b2\u533a—\u5b58\u653e\u8981\u53d1\u9001\u7ed9\u5bf9\u7aef\u7684\u6570\u636e
\nAny _context; \/\/ \u8bf7\u6c42\u7684\u5904\u7406\u63a5\u6536\u5904\u7406\u4e0a\u4e0b\u6587
\n\/\/ \u5bf9\u5916\u64cd\u4f5c\u4f7f\u7528\u667a\u80fd\u6307\u9488
\n\/\/ \u8fd9\u56db\u4e2a\u56de\u8c03\u51fd\u6570，\u662f\u8ba9\u670d\u52a1\u5668\u6a21\u5757\u6765\u8bbe\u7f6e\u7684(\u5176\u5b9e\u670d\u52a1\u5668\u6a21\u5757\u7684\u5904\u7406\u56de\u8c03\u4e5f\u662f\u7ec4\u4ef6\u4f7f\u7528\u8005\u8bbe\u7f6e\u7684)
\n\/**\/
\nusing ConnectedCallback = std::function<void(const PtrConnection &)>;
\nusing MessageCallback = std::function<void(const PtrConnection &, Buffer *)>;
\nusing ClosedCallback = std::function<void(const PtrConnection &)>;
\nusing AnyEventCallback = std::function<void(const PtrConnection &)>;
\nConnectedCallback _connected_callback;
\nMessageCallback _message_callback;
\nClosedCallback _closed_callback;
\nAnyEventCallback _event_callback;
\n\/*\u7ec4\u4ef6\u5185\u7684\u8fde\u63a5\u5173\u95ed\u56de\u8c03–\u7ec4\u4ef6\u5185\u8bbe\u7f6e\u7684，\u56e0\u4e3a\u670d\u52a1\u5668\u7ec4\u4ef6\u5185\u4f1a\u628a\u6240\u6709\u7684\u94fe\u63a5\u7ba1\u7406\u8d77\u6765，\u4e00\u65e6\u67d0\u4e2a\u8fde\u63a5\u8981\u5173\u95ed*\/
\n\/*\u5c31\u5e94\u8be5\u4ece\u7ba1\u7406\u7684\u5730\u65b9\u79fb\u9664\u6389\u81ea\u5df1\u7684\u4fe1\u606f*\/
\nClosedCallback _server_closed_callback; <\/p>\n
\u7136\u540e\u5c31\u662f\u5173\u4e8e\u6210\u5458\u51fd\u6570\u7684\u4ecb\u7ecd<\/p>\n
\u9996\u5148\u662f\u5bf9\u63cf\u8ff0\u7b26\u53ef\u8bfb\u4e8b\u4ef6\u89e6\u53d1\u540e\u8c03\u7528\u7684\u51fd\u6570，\u63a5\u6536socket\u6570\u636e\u653e\u5230\u63a5\u6536\u7f13\u51b2\u533a\u4e2d，\u7136\u540e\u8c03\u7528_message_callback<\/p>\n
void HandleRead()
\n{
\n \/*\u63a5\u6536socket\u7684\u6570\u636e，\u653e\u5230\u7f13\u51b2\u533a*\/
\n char buf[65536];
\n ssize_t ret = _socket.NonBlockRecv(buf, 65535);
\n if (ret < 0)
\n {
\n \/*\u51fa\u9519\u4e86，\u4e0d\u80fd\u76f4\u63a5\u5173\u95ed\u8fde\u63a5，\u8981\u770b\u63a5\u53d7\u7f13\u51b2\u533a\u548c\u53d1\u9001\u7f13\u51b2\u533a\u4e2d\u8fd8\u6709\u6ca1\u6709\u6570\u636e*\/
\n return ShutDownInLoop();
\n }
\n \/\/ else if(ret == 0)
\n \/\/ {
\n \/\/ \/\/\u8fd9\u91cc\u76840\u8868\u793a\u6ca1\u6709\u8bfb\u53d6\u5230\u6570\u636e，\u800c\u4e0d\u662f\u8fde\u63a5\u65ad\u5f00\u4e86，\u8fde\u63a5\u65ad\u5f00\u8fd4\u56de\u7684\u662f-1
\n \/\/ return;
\n \/\/ }
\n \/\/ \u5c06\u6570\u636e\u653e\u5165\u5230\u8f93\u5165\u7f13\u51b2\u533a,\u5e76\u4e14\u79fb\u52a8\u5199\u504f\u79fb
\n _in_buffer.WriteAndPush(buf, ret);
\n \/*\u8c03\u7528_message_callback\u8fdb\u884c\u4e1a\u52a1\u5904\u7406*\/
\n if (_in_buffer.ReadAbleSize() > 0)
\n {
\n \/\/ shared_fron_this\u4ece\u5f53\u524d\u5bf9\u8c61\u81ea\u8eab\u83b7\u53d6\u5230
\n return _message_callback(shared_from_this(), &_in_buffer);
\n }
\n} <\/p>\n
\u5904\u7406\u5199\u4e8b\u4ef6\u7684\u51fd\u6570\u903b\u8f91\u4e0e\u4e0a\u9762\u5dee\u4e0d\u591a<\/p>\n
void HandleWrite() \/\/ \u63cf\u8ff0\u7b26\u53ef\u5199\u4e8b\u4ef6\u89e6\u53d1\u540e\u8c03\u7528\u7684\u51fd\u6570，\u5c06\u53d1\u9001\u7f13\u51b2\u533a\u4e2d\u7684\u6570\u636e\u8fdb\u884c\u53d1\u9001
\n{
\n \/\/_out_buffer\u4e2d\u4fdd\u5b58\u7684\u6570\u636e\u5c31\u662f\u8981\u53d1\u9001\u7684\u6570\u636e
\n ssize_t ret = _socket.NonBlockSend(_out_buffer.ReadPosition(), _out_buffer.ReadAbleSize());
\n if (ret < 0)
\n {
\n \/\/ \u53d1\u9001\u9519\u8bef\u5c31\u8be5\u5173\u95ed\u8fde\u63a5\u4e86
\n if (_in_buffer.ReadAbleSize() > 0)
\n {
\n _message_callback(shared_from_this(), &_in_buffer);
\n }
\n return Release(); \/\/ \u8fd9\u65f6\u5019\u5c31\u662f\u5b9e\u9645\u7684\u5173\u95ed\u91ca\u653e\u64cd\u4f5c
\n }
\n _out_buffer.MoveReadOffset(ret);
\n if (_out_buffer.ReadAbleSize() == 0)
\n {
\n _channel.DisableWrite(); \/\/ \u6ca1\u6709\u6570\u636e\u5f85\u53d1\u9001\u4e86，\u5173\u95ed\u5199\u4e8b\u4ef6\u76d1\u63a7
\n \/\/ \u5982\u679c\u8fde\u63a5\u65f6\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 }
\n return;
\n} <\/p>\n
\u7136\u540e\u5c31\u662f\u63cf\u8ff0\u7b26\u89e6\u53d1\u6302\u65ad\u4e8b\u4ef6\u548c\u51fa\u9519\u4e8b\u4ef6<\/p>\n
void HandleClose() \/\/ \u63cf\u8ff0\u7b26\u89e6\u53d1\u6302\u65ad\u4e8b\u4ef6
\n{
\n \/\/ \u4e00\u65e6\u8fde\u63a5\u6302\u65ad\u4e86，\u5957\u63a5\u5b57\u5c31\u4ec0\u4e48\u90fd\u5e72\u4e0d\u4e86，\u56e0\u6b64\u6709\u6570\u636e\u5c31\u5904\u7406\u4e00\u4e0b，\u5b8c\u6bd5\u5173\u95ed\u8fde\u63a5
\n if (_in_buffer.ReadAbleSize() > 0)
\n {
\n _message_callback(shared_from_this(), &_in_buffer);
\n }
\n return Release();
\n}
\nvoid HandleError() \/\/ \u63cf\u8ff0\u7b26\u89e6\u53d1\u51fa\u9519\u4e8b\u4ef6
\n{
\n HandleClose();
\n} <\/p>\n
\u5f53\u63cf\u8ff0\u7b26\u89e6\u53d1\u4efb\u4e00\u4e8b\u4ef6\u65f6，\u6211\u4eec\u9700\u8981\u5237\u65b0\u8fde\u63a5\u7684\u6d3b\u8dc3\u5ea6<\/p>\n
void HandleEvent() \/\/ \u63cf\u8ff0\u7b26\u89e6\u53d1\u4efb\u4e00\u4e8b\u4ef6
\n{
\n \/\/ \u5237\u65b0\u94fe\u63a5\u7684\u6d3b\u8dc3\u5ea6 + \u8c03\u7528\u7ec4\u4ef6\u4f7f\u7528\u8005\u7684\u4efb\u610f\u4e8b\u4ef6\u56de\u8c03
\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} <\/p>\n
\u4e0b\u4e2a\u51fd\u6570\u4f1a\u628a\u8fde\u63a5\u72b6\u6001\u4ece\u534a\u8fde\u63a5\u4fee\u6539\u4e3a\u8fde\u63a5\u72b6\u6001，\u5e76\u4e14\u4f1a\u542f\u52a8\u8bfb\u4e8b\u4ef6\u76d1\u63a7<\/p>\n
void EstablishedInLoop() \/\/ \u8fde\u63a5\u83b7\u53d6\u4e4b\u540e，\u6240\u5904\u7684\u72b6\u6001\u4e0b\u8981\u8fdb\u884c\u7684\u5404\u79cd\u8bbe\u7f6e(\u7ed9Channel\u8bbe\u7f6e\u65f6\u95f4\u56de\u8c03，\u542f\u52a8\u8bfb\u76d1\u63a7)
\n{
\n \/\/ \u4fee\u6539\u8fde\u63a5\u72b6\u6001 + \u542f\u52a8\u8bfb\u4e8b\u4ef6\u76d1\u63a7 + \u8c03\u7528\u56de\u8c03\u51fd\u6570
\n assert(_statu == CONNECTING); \/\/ \u5f53\u524d\u7684\u72b6\u6001\u5fc5\u987b\u4e00\u5b9a\u662f\u4e0a\u5c42\u7684\u534a\u8fde\u63a5\u72b6\u6001
\n _statu = CONNECTED; \/\/ \u5f53\u524d\u51fd\u6570\u6267\u884c\u5b8c\u6bd5，\u5219\u8fde\u63a5\u8fdb\u5165\u5df2\u5b8c\u6210\u8fde\u63a5\u72b6\u6001
\n \/\/ \u4e00\u65e6\u542f\u52a8\u8bfb\u4e8b\u4ef6\u76d1\u63a7\u5c31\u6709\u53ef\u80fd\u4f1a\u7acb\u5373\u89e6\u53d1\u8bfb\u4e8b\u4ef6，\u5982\u679c\u8fd9\u65f6\u5019\u542f\u52a8\u4e86\u975e\u6d3b\u8dc3\u94fe\u63a5\u9500\u6bc1
\n _channel.EnableRead();
\n if (_connected_callback)
\n _connected_callback(shared_from_this());
\n} <\/p>\n
\u5bf9\u8fde\u63a5\u8fdb\u884c\u91ca\u653e\u7684\u51fd\u6570ReleaseInLoop()<\/p>\n
void ReleaseInLoop() \/\/ \u8fd9\u4e2a\u63a5\u53e3\u624d\u662f\u5b9e\u9645\u7684\u91ca\u653e\u63a5\u53e3
\n{
\n \/\/ \u4fee\u6539\u8fde\u63a5\u72b6\u6001，\u8bbe\u7f6e\u4e3aDISCONNECTED
\n _statu = DISCONNECTED;
\n \/\/ \u79fb\u9664\u8fde\u63a5\u7684\u4e8b\u4ef6\u76d1\u63a7
\n _channel.Remove();
\n \/\/ \u5173\u95ed\u63cf\u8ff0\u7b26
\n _socket.Close();
\n \/\/ \u5982\u679c\u5f53\u524d\u5b9a\u65f6\u5668\u961f\u5217\u4e2d\u8fd8\u6709\u5b9a\u65f6\u9500\u6bc1\u4efb\u52a1，\u5219\u53d6\u6d88\u4efb\u52a1，\u907f\u514d\u91ce\u6307\u9488\u64cd\u4f5c
\n if (_loop->HasTimer(_conn_id))
\n CancelInactiveReleaseInLoop();
\n \/\/ \u8c03\u7528\u5173\u95ed\u56de\u8c03\u51fd\u6570，\u907f\u514d\u56e0\u4e3a\u5148\u79fb\u9664\u670d\u52a1\u5668\u7ba1\u7406\u7684\u8fde\u63a5\u4fe1\u606f\u5bfc\u81f4Connection\u88ab\u91ca\u653e，\u518d\u53bb\u5904\u7406\u5c31\u4f1a\u51fa\u9519，\u56e0\u6b64\u5148\u8c03\u7528\u7528\u6237
\n if (_closed_callback)
\n _closed_callback(shared_from_this());
\n \/\/ \u79fb\u9664\u670d\u52a1\u5668\u5185\u90e8\u7ba1\u7406\u7684\u8fde\u63a5\u4fe1\u606f
\n if (_server_closed_callback)
\n _server_closed_callback(shared_from_this());
\n} <\/p>\n
\u628a\u6570\u636e\u653e\u5165\u5230\u53d1\u9001\u7f13\u51b2\u533a，\u542f\u52a8\u53ef\u5199\u4e8b\u4ef6\u76d1\u63a7<\/p>\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} <\/p>\n
\u8fd9\u4e2a\u5173\u95ed\u64cd\u4f5c\u5e76\u975e\u5b9e\u9645\u7684\u8fde\u63a5\u91ca\u653e\u64cd\u4f5c，\u9700\u8981\u5224\u65ad\u8fd8\u6709\u6ca1\u6709\u6570\u636e\u5f85\u5904\u7406，\u5f85\u53d1\u9001<\/p>\n
void ShutDownInLoop()
\n{
\n _statu = DISCONNECTED; \/\/ \u8bbe\u7f6e\u8fde\u63a5\u4e3a\u534a\u5173\u95ed\u72b6\u6001
\n if (_in_buffer.ReadAbleSize() > 0)
\n {
\n if (_message_callback)
\n _message_callback(shared_from_this(), &_in_buffer);
\n }
\n \/\/ \u8981\u4e48\u5c31\u662f\u5199\u5165\u6570\u636e\u7684\u65f6\u5019\u51fa\u9519\u5173\u95ed，\u8981\u4e48\u5c31\u662f\u6ca1\u6709\u5f85\u53d1\u9001\u6570\u636e，\u76f4\u63a5\u5173\u95ed
\n if (_out_buffer.ReadAbleSize() > 0)
\n {
\n if (_channel.WriteAble() == false) \/\/ \u662f\u5426\u542f\u52a8\u5199\u4e8b\u4ef6\u76d1\u63a7
\n {
\n _channel.EnableWrite();
\n }
\n }
\n \/\/ \u6ca1\u6709\u6570\u636e\u4e86
\n if (_out_buffer.ReadAbleSize() == 0)
\n {
\n Release();
\n }
\n} <\/p>\n
\u542f\u52a8\u975e\u6d3b\u8dc3\u94fe\u63a5\u8d85\u65f6\u91ca\u653e，\u4e0d\u5b58\u5728\u8fd9\u4e2a\u9500\u6bc1\u4efb\u52a1\u5c31\u65b0\u589e，\u5df2\u7ecf\u5b58\u5728\u5219\u5237\u65b0\u5b9a\u65f6\u5668<\/p>\n
void EnableInactiveReleaseInLoop(int sec)
\n{
\n \/\/ \u5c06\u5224\u65ad\u6807\u5fd7_enable_inactive_release \u7f6e\u4e3atrue
\n _enable_inactive_release = true;
\n \/\/ \u5982\u679c\u5f53\u524d\u5b9a\u65f6\u9500\u6bc1\u4efb\u52a1\u5df2\u7ecf\u5b58\u5728，\u90a3\u5c31\u5237\u65b0\u5ef6\u8fdf\u4e00\u4e0b\u5373\u53ef
\n if (_loop->HasTimer(_conn_id))
\n {
\n return _loop->TimerRefresh(_conn_id);
\n }
\n \/\/ \u5982\u679c\u4e0d\u5b58\u5728\u5b9a\u65f6\u9500\u6bc1\u4efb\u52a1，\u5219\u65b0\u589e
\n _loop->TimerAdd(_conn_id, sec, std::bind(&Connection::Release, this));
\n} <\/p>\n
\u53d6\u6d88\u975e\u6d3b\u8dc3\u8fde\u63a5\u91ca\u653e<\/p>\n
void CancelInactiveReleaseInLoop()
\n{
\n _enable_inactive_release = false;
\n if (_loop->HasTimer(_conn_id))
\n {
\n _loop->TimerCancel(_conn_id);
\n }
\n} <\/p>\n
\u5207\u6362\u534f\u8bae，\u91cd\u7f6e\u4e0a\u4e0b\u6587\u4ee5\u53ca\u9636\u6bb5\u6027\u5904\u7406\u51fd\u6570<\/p>\n
void UpgradeInLoop(const Any &context, const ConnectedCallback &conn, const MessageCallback &msg,
\n const ClosedCallback &closed, const AnyEventCallback &event)
\n{
\n _context = context;
\n _connected_callback = conn;
\n _message_callback = msg;
\n _closed_callback = closed;
\n _event_callback = event;
\n} <\/p>\n
\u4e0b\u9762\u662fConnection\u7c7b\u7684\u5b8c\u6574\u4ee3\u7801<\/p>\n
typedef enum
\n{
\n DISCONNECTED, \/\/ \u8fde\u63a5\u5173\u95ed\u72b6\u6001
\n CONNECTING, \/\/ \u8fde\u63a5\u5efa\u7acb\u6210\u529f\u5f85\u5904\u7406\u72b6\u6001
\n CONNECTED, \/\/ \u8fde\u63a5\u5efa\u7acb\u5b8c\u6210，\u5404\u79cd\u8bbe\u7f6e\u5df2\u5b8c\u6210\u53ef\u4ee5\u901a\u4fe1\u7684\u72b6\u6001
\n DISCONNECTING \/\/ \u5f85\u5173\u95ed\u72b6\u6001
\n} ConnStatu;<\/p>\n
using PtrConnection = std::shared_ptr<Connection>;<\/p>\n
class Connection : public std::enable_shared_from_this<Connection>
\n{
\nprivate:
\n uint64_t _conn_id; \/\/ \u8fde\u63a5\u552f\u4e00ID，\u4fbf\u4e8e\u8fde\u63a5\u7684\u7ba1\u7406\u548c\u67e5\u627e
\n \/\/ uint64_t _timer_id; \/\/\u5b9a\u65f6\u5668ID，\u5fc5\u987b\u662f\u552f\u4e00\u7684，\u4e3a\u4e86\u7b80\u5316\u64cd\u4f5c\u4f7f\u7528conn_id\u4f5c\u4e3a\u5b9a\u65f6\u5668ID
\n int _sockfd; \/\/ \u8fde\u63a5\u5173\u8054\u7684\u6587\u4ef6\u63cf\u8ff0\u7b26
\n bool _enable_inactive_release; \/\/ \u8fde\u63a5\u662f\u5426\u542f\u52a8\u975e\u6d3b\u8dc3\u9500\u6bc1，\u9ed8\u8ba4\u662ffalse
\n EventLoop *_loop; \/\/ \u8fde\u63a5\u6240\u5173\u8054\u7684\u4e00\u4e2aloop
\n ConnStatu _statu; \/\/ \u8fde\u63a5\u72b6\u6001
\n Socket _socket; \/\/ \u5957\u63a5\u5b57\u8fde\u63a5\u7ba1\u7406
\n Channel _channel; \/\/ \u8fde\u63a5\u7684\u4e8b\u4ef6\u7ba1\u7406
\n Buffer _in_buffer; \/\/ \u8f93\u5165\u7f13\u51b2\u533a—\u5b58\u653e\u4ecesocket\u4e2d\u8bfb\u53d6\u5230\u7684\u6570\u636e
\n Buffer _out_buffer; \/\/ \u8f93\u51fa\u7f13\u51b2\u533a—\u5b58\u653e\u8981\u53d1\u9001\u7ed9\u5bf9\u7aef\u7684\u6570\u636e
\n Any _context; \/\/ \u8bf7\u6c42\u7684\u5904\u7406\u63a5\u6536\u5904\u7406\u4e0a\u4e0b\u6587
\n \/\/ \u5bf9\u5916\u64cd\u4f5c\u4f7f\u7528\u667a\u80fd\u6307\u9488
\n \/\/ \u8fd9\u56db\u4e2a\u56de\u8c03\u51fd\u6570，\u662f\u8ba9\u670d\u52a1\u5668\u6a21\u5757\u6765\u8bbe\u7f6e\u7684(\u5176\u5b9e\u670d\u52a1\u5668\u6a21\u5757\u7684\u5904\u7406\u56de\u8c03\u4e5f\u662f\u7ec4\u4ef6\u4f7f\u7528\u8005\u8bbe\u7f6e\u7684)
\n \/**\/
\n using ConnectedCallback = std::function<void(const PtrConnection &)>;
\n using MessageCallback = std::function<void(const PtrConnection &, Buffer *)>;
\n using ClosedCallback = std::function<void(const PtrConnection &)>;
\n using AnyEventCallback = std::function<void(const PtrConnection &)>;
\n ConnectedCallback _connected_callback;
\n MessageCallback _message_callback;
\n ClosedCallback _closed_callback;
\n AnyEventCallback _event_callback;
\n \/*\u7ec4\u4ef6\u5185\u7684\u8fde\u63a5\u5173\u95ed\u56de\u8c03–\u7ec4\u4ef6\u5185\u8bbe\u7f6e\u7684，\u56e0\u4e3a\u670d\u52a1\u5668\u7ec4\u4ef6\u5185\u4f1a\u628a\u6240\u6709\u7684\u94fe\u63a5\u7ba1\u7406\u8d77\u6765，\u4e00\u65e6\u67d0\u4e2a\u8fde\u63a5\u8981\u5173\u95ed*\/
\n \/*\u5c31\u5e94\u8be5\u4ece\u7ba1\u7406\u7684\u5730\u65b9\u79fb\u9664\u6389\u81ea\u5df1\u7684\u4fe1\u606f*\/
\n ClosedCallback _server_closed_callback;<\/p>\n
private:
\n \/*\u4e94\u4e2achannel\u7684\u4e8b\u4ef6\u56de\u8c03\u51fd\u6570*\/
\n void HandleRead() \/\/ \u63cf\u8ff0\u7b26\u53ef\u8bfb\u4e8b\u4ef6\u89e6\u53d1\u540e\u8c03\u7528\u7684\u51fd\u6570，\u63a5\u6536socket\u6570\u636e\u653e\u5230\u63a5\u53d7\u7f13\u51b2\u533a\u4e2d，\u7136\u540e\u8c03\u7528_message_callback
\n {
\n \/*\u63a5\u6536socket\u7684\u6570\u636e，\u653e\u5230\u7f13\u51b2\u533a*\/
\n char buf[65536];
\n ssize_t ret = _socket.NonBlockRecv(buf, 65535);
\n if (ret < 0)
\n {
\n \/*\u51fa\u9519\u4e86，\u4e0d\u80fd\u76f4\u63a5\u5173\u95ed\u8fde\u63a5，\u8981\u770b\u63a5\u53d7\u7f13\u51b2\u533a\u548c\u53d1\u9001\u7f13\u51b2\u533a\u4e2d\u8fd8\u6709\u6ca1\u6709\u6570\u636e*\/
\n return ShutDownInLoop();
\n }
\n \/\/ else if(ret == 0)
\n \/\/ {
\n \/\/ \/\/\u8fd9\u91cc\u76840\u8868\u793a\u6ca1\u6709\u8bfb\u53d6\u5230\u6570\u636e，\u800c\u4e0d\u662f\u8fde\u63a5\u65ad\u5f00\u4e86，\u8fde\u63a5\u65ad\u5f00\u8fd4\u56de\u7684\u662f-1
\n \/\/ return;
\n \/\/ }
\n \/\/ \u5c06\u6570\u636e\u653e\u5165\u5230\u8f93\u5165\u7f13\u51b2\u533a,\u5e76\u4e14\u79fb\u52a8\u5199\u504f\u79fb
\n _in_buffer.WriteAndPush(buf, ret);
\n \/*\u8c03\u7528_message_callback\u8fdb\u884c\u4e1a\u52a1\u5904\u7406*\/
\n if (_in_buffer.ReadAbleSize() > 0)
\n {
\n \/\/ shared_fron_this\u4ece\u5f53\u524d\u5bf9\u8c61\u81ea\u8eab\u83b7\u53d6\u5230
\n return _message_callback(shared_from_this(), &_in_buffer);
\n }
\n }
\n void HandleWrite() \/\/ \u63cf\u8ff0\u7b26\u53ef\u5199\u4e8b\u4ef6\u89e6\u53d1\u540e\u8c03\u7528\u7684\u51fd\u6570，\u5c06\u53d1\u9001\u7f13\u51b2\u533a\u4e2d\u7684\u6570\u636e\u8fdb\u884c\u53d1\u9001
\n {
\n \/\/_out_buffer\u4e2d\u4fdd\u5b58\u7684\u6570\u636e\u5c31\u662f\u8981\u53d1\u9001\u7684\u6570\u636e
\n ssize_t ret = _socket.NonBlockSend(_out_buffer.ReadPosition(), _out_buffer.ReadAbleSize());
\n if (ret < 0)
\n {
\n \/\/ \u53d1\u9001\u9519\u8bef\u5c31\u8be5\u5173\u95ed\u8fde\u63a5\u4e86
\n if (_in_buffer.ReadAbleSize() > 0)
\n {
\n _message_callback(shared_from_this(), &_in_buffer);
\n }
\n return Release(); \/\/ \u8fd9\u65f6\u5019\u5c31\u662f\u5b9e\u9645\u7684\u5173\u95ed\u91ca\u653e\u64cd\u4f5c
\n }
\n _out_buffer.MoveReadOffset(ret);
\n if (_out_buffer.ReadAbleSize() == 0)
\n {
\n _channel.DisableWrite(); \/\/ \u6ca1\u6709\u6570\u636e\u5f85\u53d1\u9001\u4e86，\u5173\u95ed\u5199\u4e8b\u4ef6\u76d1\u63a7
\n \/\/ \u5982\u679c\u8fde\u63a5\u65f6\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 }
\n return;
\n }
\n void HandleClose() \/\/ \u63cf\u8ff0\u7b26\u89e6\u53d1\u6302\u65ad\u4e8b\u4ef6
\n {
\n \/\/ \u4e00\u65e6\u8fde\u63a5\u6302\u65ad\u4e86，\u5957\u63a5\u5b57\u5c31\u4ec0\u4e48\u90fd\u5e72\u4e0d\u4e86，\u56e0\u6b64\u6709\u6570\u636e\u5c31\u5904\u7406\u4e00\u4e0b，\u5b8c\u6bd5\u5173\u95ed\u8fde\u63a5
\n if (_in_buffer.ReadAbleSize() > 0)
\n {
\n _message_callback(shared_from_this(), &_in_buffer);
\n }
\n return Release();
\n }
\n void HandleError() \/\/ \u63cf\u8ff0\u7b26\u89e6\u53d1\u51fa\u9519\u4e8b\u4ef6
\n {
\n HandleClose();
\n }
\n void HandleEvent() \/\/ \u63cf\u8ff0\u7b26\u89e6\u53d1\u4efb\u4e00\u4e8b\u4ef6
\n {
\n \/\/ \u5237\u65b0\u94fe\u63a5\u7684\u6d3b\u8dc3\u5ea6 + \u8c03\u7528\u7ec4\u4ef6\u4f7f\u7528\u8005\u7684\u4efb\u610f\u4e8b\u4ef6\u56de\u8c03
\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 }
\nvoid EstablishedInLoop() \/\/ \u8fde\u63a5\u83b7\u53d6\u4e4b\u540e，\u6240\u5904\u7684\u72b6\u6001\u4e0b\u8981\u8fdb\u884c\u7684\u5404\u79cd\u8bbe\u7f6e(\u7ed9Channel\u8bbe\u7f6e\u65f6\u95f4\u56de\u8c03，\u542f\u52a8\u8bfb\u76d1\u63a7)
\n{
\n \/\/ \u4fee\u6539\u8fde\u63a5\u72b6\u6001 + \u542f\u52a8\u8bfb\u4e8b\u4ef6\u76d1\u63a7 + \u8c03\u7528\u56de\u8c03\u51fd\u6570
\n assert(_statu == CONNECTING); \/\/ \u5f53\u524d\u7684\u72b6\u6001\u5fc5\u987b\u4e00\u5b9a\u662f\u4e0a\u5c42\u7684\u534a\u8fde\u63a5\u72b6\u6001
\n _statu = CONNECTED; \/\/ \u5f53\u524d\u51fd\u6570\u6267\u884c\u5b8c\u6bd5，\u5219\u8fde\u63a5\u8fdb\u5165\u5df2\u5b8c\u6210\u8fde\u63a5\u72b6\u6001
\n \/\/ \u4e00\u65e6\u542f\u52a8\u8bfb\u4e8b\u4ef6\u76d1\u63a7\u5c31\u6709\u53ef\u80fd\u4f1a\u7acb\u5373\u89e6\u53d1\u8bfb\u4e8b\u4ef6，\u5982\u679c\u8fd9\u65f6\u5019\u542f\u52a8\u4e86\u975e\u6d3b\u8dc3\u94fe\u63a5\u9500\u6bc1
\n _channel.EnableRead();
\n if (_connected_callback)
\n _connected_callback(shared_from_this());
\n}
\n void ReleaseInLoop() \/\/ \u8fd9\u4e2a\u63a5\u53e3\u624d\u662f\u5b9e\u9645\u7684\u91ca\u653e\u63a5\u53e3
\n {
\n \/\/ \u4fee\u6539\u8fde\u63a5\u72b6\u6001，\u8bbe\u7f6e\u4e3aDISCONNECTED
\n _statu = DISCONNECTED;
\n \/\/ \u79fb\u9664\u8fde\u63a5\u7684\u4e8b\u4ef6\u76d1\u63a7
\n _channel.Remove();
\n \/\/ \u5173\u95ed\u63cf\u8ff0\u7b26
\n _socket.Close();
\n \/\/ \u5982\u679c\u5f53\u524d\u5b9a\u65f6\u5668\u961f\u5217\u4e2d\u8fd8\u6709\u5b9a\u65f6\u9500\u6bc1\u4efb\u52a1，\u5219\u53d6\u6d88\u4efb\u52a1，\u907f\u514d\u91ce\u6307\u9488\u64cd\u4f5c
\n if (_loop->HasTimer(_conn_id))
\n CancelInactiveReleaseInLoop();
\n \/\/ \u8c03\u7528\u5173\u95ed\u56de\u8c03\u51fd\u6570，\u907f\u514d\u56e0\u4e3a\u5148\u79fb\u9664\u670d\u52a1\u5668\u7ba1\u7406\u7684\u8fde\u63a5\u4fe1\u606f\u5bfc\u81f4Connection\u88ab\u91ca\u653e，\u518d\u53bb\u5904\u7406\u5c31\u4f1a\u51fa\u9519，\u56e0\u6b64\u5148\u8c03\u7528\u7528\u6237
\n if (_closed_callback)
\n _closed_callback(shared_from_this());
\n \/\/ \u79fb\u9664\u670d\u52a1\u5668\u5185\u90e8\u7ba1\u7406\u7684\u8fde\u63a5\u4fe1\u606f
\n if (_server_closed_callback)
\n _server_closed_callback(shared_from_this());
\n }<\/p>\n
\/\/ \u8fd9\u4e2a\u63a5\u53e3\u5e76\u4e0d\u662f\u5b9e\u9645\u7684\u53d1\u9001\u63a5\u53e3，\u800c\u53ea\u662f\u628a\u6570\u636e\u653e\u5230\u53d1\u9001\u7f13\u51b2\u533a，\u542f\u52a8\u53ef\u5199\u4e8b\u4ef6\u76d1\u63a7
\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 \/\/ \u8fd9\u4e2a\u5173\u95ed\u64cd\u4f5c\u5e76\u975e\u5b9e\u9645\u7684\u8fde\u63a5\u91ca\u653e\u64cd\u4f5c，\u9700\u8981\u5224\u65ad\u8fd8\u6709\u6ca1\u6709\u6570\u636e\u5f85\u5904\u7406，\u5f85\u53d1\u9001
\n void ShutDownInLoop()
\n {
\n _statu = DISCONNECTED; \/\/ \u8bbe\u7f6e\u8fde\u63a5\u4e3a\u534a\u5173\u95ed\u72b6\u6001
\n if (_in_buffer.ReadAbleSize() > 0)
\n {
\n if (_message_callback)
\n _message_callback(shared_from_this(), &_in_buffer);
\n }
\n \/\/ \u8981\u4e48\u5c31\u662f\u5199\u5165\u6570\u636e\u7684\u65f6\u5019\u51fa\u9519\u5173\u95ed，\u8981\u4e48\u5c31\u662f\u6ca1\u6709\u5f85\u53d1\u9001\u6570\u636e，\u76f4\u63a5\u5173\u95ed
\n if (_out_buffer.ReadAbleSize() > 0)
\n {
\n if (_channel.WriteAble() == false) \/\/ \u662f\u5426\u542f\u52a8\u5199\u4e8b\u4ef6\u76d1\u63a7
\n {
\n _channel.EnableWrite();
\n }
\n }
\n \/\/ \u6ca1\u6709\u6570\u636e\u4e86
\n if (_out_buffer.ReadAbleSize() == 0)
\n {
\n Release();
\n }
\n }
\n \/\/ \u542f\u52a8\u975e\u6d3b\u8dc3\u8fde\u63a5\u8d85\u65f6\u91ca\u653e\u89c4\u5219
\n void EnableInactiveReleaseInLoop(int sec)
\n {
\n \/\/ \u5c06\u5224\u65ad\u6807\u5fd7_enable_inactive_release \u7f6e\u4e3atrue
\n _enable_inactive_release = true;
\n \/\/ \u5982\u679c\u5f53\u524d\u5b9a\u65f6\u9500\u6bc1\u4efb\u52a1\u5df2\u7ecf\u5b58\u5728，\u90a3\u5c31\u5237\u65b0\u5ef6\u8fdf\u4e00\u4e0b\u5373\u53ef
\n if (_loop->HasTimer(_conn_id))
\n {
\n return _loop->TimerRefresh(_conn_id);
\n }
\n \/\/ \u5982\u679c\u4e0d\u5b58\u5728\u5b9a\u65f6\u9500\u6bc1\u4efb\u52a1，\u5219\u65b0\u589e
\n _loop->TimerAdd(_conn_id, sec, std::bind(&Connection::Release, this));
\n }
\n void CancelInactiveReleaseInLoop()
\n {
\n _enable_inactive_release = false;
\n if (_loop->HasTimer(_conn_id))
\n {
\n _loop->TimerCancel(_conn_id);
\n }
\n }
\n \/\/ \u5207\u6362\u534f\u8bae，\u91cd\u7f6e\u4e0a\u4e0b\u6587\u4ee5\u53ca\u9636\u6bb5\u6027\u5904\u7406\u51fd\u6570
\n void UpgradeInLoop(const Any &context, const ConnectedCallback &conn, const MessageCallback &msg,
\n const ClosedCallback &closed, const AnyEventCallback &event)
\n {
\n _context = context;
\n _connected_callback = conn;
\n _message_callback = msg;
\n _closed_callback = closed;
\n _event_callback = event;
\n }<\/p>\n
public:
\n Connection(EventLoop *loop, uint64_t conn_id, int sockfd)
\n : _conn_id(conn_id),
\n _sockfd(sockfd),
\n _enable_inactive_release(false),
\n _loop(loop),
\n _statu(CONNECTING),
\n _socket(_sockfd),
\n _channel(loop, _sockfd)
\n {
\n _channel.SetCloseCallback(std::bind(&Connection::HandleClose, this));
\n _channel.SetEventCallback(std::bind(&Connection::HandleEvent, this));
\n _channel.SetReadCallback(std::bind(&Connection::HandleRead, this));
\n _channel.SetWriteCallback(std::bind(&Connection::HandleWrite, this));
\n _channel.SetErrorCallback(std::bind(&Connection::HandleError, this));
\n }
\n ~Connection()
\n {
\n DBG_LOG("RELEASE CONNECTION:%p", this);
\n }
\n int Fd() \/\/ \u83b7\u53d6\u7ba1\u7406\u7684\u6587\u4ef6\u63cf\u8ff0\u7b26
\n {
\n return _sockfd;
\n }
\n int Id() \/\/ \u83b7\u53d6\u8fde\u63a5\u7684ID
\n {
\n return _conn_id;
\n }
\n bool Connected() \/\/ \u662f\u5426\u5904\u4e8eConnected\u72b6\u6001
\n {
\n return (_statu == CONNECTED);
\n }
\n void SetContext(const Any &context) \/\/ \u8bbe\u7f6e\u4e0a\u4e0b\u6587–\u8fde\u63a5\u5efa\u7acb\u5b8c\u6210\u65f6
\n {
\n _context = context;
\n }
\n Any *GetContext() \/\/ \u83b7\u53d6\u4e0a\u4e0b\u6587，\u8fd4\u56de\u7684\u662f\u6307\u9488
\n {
\n return &_context;
\n }<\/p>\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 void Established() \/\/ \u8fde\u63a5\u5efa\u7acb\u5c31\u7eea\u540e，\u8fdb\u884cChannel\u56de\u8c03\u8bbe\u7f6e，\u542f\u52a8\u8bfb\u76d1\u63a7–\u8fde\u63a5\u5efa\u7acb\u5b8c\u6210\u65f6\u8fdb\u884c\u8c03\u7528
\n {
\n _loop->RunInLoop(std::bind(&Connection::EstablishedInLoop, this));
\n }
\n void Send(const char *data, size_t len) \/\/ \u53d1\u9001\u6570\u636e，\u5c06\u6570\u636e\u653e\u5230\u53d1\u9001\u7f13\u51b2\u533a，\u542f\u52a8\u5199\u4e8b\u4ef6\u76d1\u63a7
\n {
\n \/\/ \u5916\u754c\u4f20\u5165\u7684data，\u53ef\u80fd\u662f\u4e2a\u4e34\u65f6\u7684\u7a7a\u95f4，\u6211\u4eec\u53ea\u662f\u628a\u53d1\u9001\u64cd\u4f5c\u538b\u5165\u4e86\u4efb\u52a1\u6c60，\u6709\u53ef\u80fd\u5e76\u6ca1\u6709\u88ab\u7acb\u5373\u6267\u884c
\n \/\/ \u56e0\u6b64\u6709\u53ef\u80fd\u6267\u884c\u7684\u65f6\u5019，data\u6307\u5411\u7684\u7a7a\u95f4\u6709\u53ef\u80fd\u5df2\u7ecf\u88ab\u91ca\u653e\u4e86
\n Buffer buf;
\n buf.WriteAndPush(data, len);
\n _loop->RunInLoop(std::bind(&Connection::SendInLoop, this, std::move(buf))); \/\/ \u53f3\u503c\u5f15\u7528
\n \/\/_loop->RunInLoop(std::bind(&Connection::SendInLoop, this, data, len));
\n }
\n void Shutdown() \/\/ \u63d0\u4f9b\u7ed9\u7ec4\u4ef6\u4f7f\u7528\u8005\u7684\u5173\u95ed\u63a5\u53e3–\u5e76\u4e0d\u5b9e\u9645\u5173\u95ed，\u9700\u8981\u5224\u65ad\u6709\u6ca1\u6709\u4e8b\u4ef6\u5f85\u5904\u7406
\n {
\n _loop->RunInLoop(std::bind(&Connection::ShutDownInLoop, this));
\n }
\n void Release()
\n {
\n _loop->QueueInLoop(std::bind(&Connection::ReleaseInLoop, this));
\n }
\n void EnableInactiveRelease(int sec) \/\/ \u542f\u52a8\u975e\u6d3b\u8dc3\u9500\u6bc1\u5e76\u5b9a\u4e49\u591a\u957f\u65f6\u95f4\u65e0\u901a\u4fe1\u5c31\u662f\u975e\u6d3b\u8dc3
\n {
\n _loop->RunInLoop(std::bind(&Connection::EnableInactiveReleaseInLoop, this, sec));
\n }
\n void CancelInactiveRelease() \/\/ \u53d6\u6d88\u975e\u6d3b\u8dc3\u9500\u6bc1
\n {
\n _loop->RunInLoop(std::bind(&Connection::CancelInactiveReleaseInLoop, this));
\n }
\n \/\/ \u5207\u6362\u534f\u8bae，\u91cd\u7f6e\u4e0a\u4e0b\u6587\u4ee5\u53ca\u9636\u6bb5\u6027\u56de\u8c03\u5904\u7406\u51fd\u6570 — \u975e\u7ebf\u7a0b\u5b89\u5168\u7684 — \u8fd9\u4e2a\u63a5\u53e3\u5fc5\u987b\u5728EventLoop\u7ebf\u7a0b\u4e2d\u6267\u884c
\n \/\/ \u9632\u5907\u65b0\u7684\u4e8b\u4ef6\u89e6\u53d1\u540e，\u5904\u7406\u7684\u65f6\u5019，\u5207\u6362\u4efb\u52a1\u8fd8\u6ca1\u6709\u88ab\u6267\u884c — \u4f1a\u5bfc\u81f4\u6570\u636e\u4f7f\u7528\u539f\u534f\u8bae\u5904\u7406\u4e86
\n void Upgrade(const Any &context, const ConnectedCallback &conn, const MessageCallback &msg,
\n const ClosedCallback &closed, const AnyEventCallback &event)
\n {
\n _loop->AssertInLoop();
\n _loop->RunInLoop(std::bind(&Connection::UpgradeInLoop, this, context, conn, msg, closed, event));
\n }
\n}; <\/p>\n
Acceptor\u6a21\u5757\u662f\u5bf9Socket\u6a21\u5757，Channel\u6a21\u5757\u7684\u6574\u4f53\u5c01\u88c5，\u5b9e\u73b0\u5bf9\u4e00\u4e2a\u76d1\u542c\u5957\u63a5\u5b57\u7684\u6574\u4f53\u7684\u7ba1\u7406<\/p>\n
\u9996\u5148\u8fd9\u662fAcceptor\u7c7b\u7684\u6210\u5458\u53d8\u91cf\u4ecb\u7ecd<\/p>\n
Socket _socket; \/\/ \u7528\u4e8e\u521b\u5efa\u76d1\u542c\u5957\u63a5\u5b57
\nEventLoop *_loop; \/\/ \u7528\u4e8e\u5bf9\u76d1\u542c\u5957\u63a5\u5b57\u8fdb\u884c\u4e8b\u4ef6\u76d1\u63a7
\nChannel _channel; \/\/ \u7528\u4e8e\u5bf9\u76d1\u542c\u5957\u63a5\u5b57\u8fdb\u884c\u4e8b\u4ef6\u7ba1\u7406
\nusing AcceptCallback = std::function<void(int)>; \/\/ \u83b7\u53d6\u5230\u94fe\u63a5\u7684\u56de\u8c03\u51fd\u6570
\nAcceptCallback _accept_callback; <\/p>\n
\u4e0b\u9762\u662f\u5bf9\u5176\u4e2d\u7684\u6210\u5458\u51fd\u6570\u89e3\u91ca<\/p>\n
\u76d1\u542c\u5957\u63a5\u5b57\u7684\u8bfb\u4e8b\u4ef6\u5904\u7406\u51fd\u6570，\u83b7\u53d6\u65b0\u94fe\u63a5，\u8c03\u7528_accept_callback\u8fdb\u884c\u65b0\u94fe\u63a5\u5904\u7406<\/p>\n
void HandleRead()
\n{
\n \/\/ DBG_LOG("ACCEPT HANDLE READ");
\n int newfd = _socket.Accept();
\n if (newfd < 0)
\n {
\n return;
\n }
\n if (_accept_callback)
\n _accept_callback(newfd);
\n} <\/p>\n
\u521b\u5efa\u670d\u52a1\u7aef<\/p>\n
int CreateServer(int port)
\n{
\n bool ret = _socket.CreateServer(port);
\n assert(ret == true);
\n return _socket.Fd();
\n} <\/p>\n
\u7136\u540e\u662fAcceptor\u7684\u521d\u59cb\u5316\u51fd\u6570，\u8fd9\u91cc\u9700\u8981\u6ce8\u610f\u7684\u662f，\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<\/p>\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\u6709\u88ab\u8bbe\u7f6e，\u65b0\u94fe\u63a5\u5f97\u4e0d\u5230\u5904\u7406，\u4e14\u8d44\u6e90\u6cc4\u9732<\/p>\n
Acceptor(EventLoop *loop, int port)
\n : _socket(CreateServer(port)),
\n _loop(loop),
\n _channel(loop, _socket.Fd())
\n{
\n _channel.SetReadCallback(std::bind(&Acceptor::HandleRead, this));
\n} <\/p>\n
\u4e0b\u9762\u662f\u8fd9\u4e2a\u7c7b\u7684\u5b8c\u6574\u4ee3\u7801<\/p>\n
class Acceptor
\n{
\nprivate:
\n Socket _socket; \/\/ \u7528\u4e8e\u521b\u5efa\u76d1\u542c\u5957\u63a5\u5b57
\n EventLoop *_loop; \/\/ \u7528\u4e8e\u5bf9\u76d1\u542c\u5957\u63a5\u5b57\u8fdb\u884c\u4e8b\u4ef6\u76d1\u63a7
\n Channel _channel; \/\/ \u7528\u4e8e\u5bf9\u76d1\u542c\u5957\u63a5\u5b57\u8fdb\u884c\u4e8b\u4ef6\u7ba1\u7406
\n using AcceptCallback = std::function<void(int)>; \/\/ \u83b7\u53d6\u5230\u94fe\u63a5\u7684\u56de\u8c03\u51fd\u6570
\n AcceptCallback _accept_callback;<\/p>\n
private:
\n \/*\u76d1\u542c\u5957\u63a5\u5b57\u7684\u8bfb\u4e8b\u4ef6\u5904\u7406\u51fd\u6570—\u83b7\u53d6\u65b0\u94fe\u63a5，\u8c03\u7528_accept_callback\u8fdb\u884c\u65b0\u94fe\u63a5\u5904\u7406*\/
\n void HandleRead()
\n {
\n \/\/ DBG_LOG("ACCEPT HANDLE READ");
\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 assert(ret == true);
\n return _socket.Fd();
\n }<\/p>\n
public:
\n \/*\u4e0d\u80fd\u5c06\u542f\u52a8\u8bfb\u4e8b\u4ef6\u76d1\u63a7，\u653e\u5230\u6784\u9020\u51fd\u6570\u4e2d，\u5fc5\u987b\u5728\u8bbe\u7f6e\u56de\u8c03\u51fd\u6570\u540e，\u518d\u53bb\u542f\u52a8*\/
\n \/*\u5426\u5219\u6709\u53ef\u80fd\u9020\u6210\u542f\u52a8\u76d1\u63a7\u540e，\u7acb\u5373\u6709\u4e8b\u4ef6，\u5904\u7406\u7684\u65f6\u5019，\u56de\u8c03\u51fd\u6570\u8fd8\u6ca1\u8bbe\u7f6e：\u65b0\u94fe\u63a5\u5f97\u4e0d\u5230\u5904\u7406，\u4e14\u8d44\u6e90\u6cc4\u9732*\/
\n Acceptor(EventLoop *loop, int port)
\n : _socket(CreateServer(port)),
\n _loop(loop),
\n _channel(loop, _socket.Fd())
\n {
\n _channel.SetReadCallback(std::bind(&Acceptor::HandleRead, this));
\n }
\n void SetAcceptCallBack(const AcceptCallback &cb)
\n {
\n _accept_callback = cb;
\n }
\n void Listen()
\n {
\n _channel.EnableRead();
\n }
\n}; <\/p>\n
\u8fd9\u4e2a\u6a21\u5757\u65f6\u4e00\u4e2a\u6574\u4f53Tcp\u670d\u52a1\u5668\u6a21\u5757\u7684\u5c01\u88c5，\u5185\u90e8\u5c01\u88c5\u4e86Acceptor\u6a21\u5757，LoopThreadPool\u6a21\u5757<\/p>\n
\u4e0b\u9762\u662f\u5bf9\u5176\u6210\u5458\u53d8\u91cf\u7684\u89e3\u91ca<\/p>\n
uint64_t _next_id; \/\/ \u8fd9\u662f\u4e00\u4e2a\u81ea\u52a8\u589e\u957f\u7684\u8fde\u63a5ID
\nint _timeout; \/\/ \u8fd9\u662f\u975e\u6d3b\u8dc3\u94fe\u63a5\u7684\u7edf\u8ba1\u65f6\u95f4—\u591a\u957f\u65f6\u95f4\u65e0\u901a\u4fe1\u5c31\u662f\u975e\u6d3b\u8dc3\u8fde\u63a5
\nint _port;
\nbool _enable_inactive_release; \/\/ \u662f\u5426\u542f\u52a8\u4e86\u975e\u6d3b\u8dc3\u8fde\u63a5\u8d85\u65f6\u9500\u6bc1\u7684\u5224\u65ad\u6807\u5fd7
\nAcceptor _acceptor; \/\/ \u8fd9\u662f\u76d1\u542c\u5957\u63a5\u5b57\u7684\u7ba1\u7406\u5bf9\u8c61
\nEventLoop _baseloop; \/\/ \u8fd9\u662f\u4e3b\u7ebf\u7a0b\u7684EventLoop\u5bf9\u8c61，\u8d1f\u8d23\u76d1\u542c\u4e8b\u4ef6\u7684\u5904\u7406
\nLoopThreadPool _pool; \/\/ \u8fd9\u662f\u6211\u4eec\u7684\u4ece\u5c5eEventLoop\u7ebf\u7a0b\u6c60
\nstd::unordered_map<uint64_t, PtrConnection> _conns; \/\/ \u4fdd\u5b58\u7ba1\u7406\u6240\u6709\u8fde\u63a5\u5bf9\u5e94\u7684shared_ptr\u5bf9\u8c61<\/p>\n
using ConnectedCallback = std::function<void(const PtrConnection &)>;
\nusing MessageCallback = std::function<void(const PtrConnection &, Buffer *)>;
\nusing ClosedCallback = std::function<void(const PtrConnection &)>;
\nusing AnyEventCallback = std::function<void(const PtrConnection &)>;
\nusing Functor = std::function<void()>;
\nConnectedCallback _connected_callback;
\nMessageCallback _message_callback;
\nClosedCallback _closed_callback;
\nAnyEventCallback _event_callback; <\/p>\n
\u63a5\u4e0b\u6765\u662f\u5bf9\u5176\u6210\u5458\u51fd\u6570\u7684\u89e3\u91ca<\/p>\n
\u9996\u5148\u662f\u5bf9\u4e3b\u7ebf\u7a0b\u7684EventLoop\u5bf9\u8c61\u6dfb\u52a0\u5b9a\u65f6\u5668<\/p>\n
void RunAfterInLoop(const Functor &task, int delay)
\n{
\n _next_id++;
\n _baseloop.TimerAdd(_next_id, delay, task);
\n} <\/p>\n
\u4e3a\u65b0\u94fe\u63a5\u6784\u9020Connection\u8fdb\u884c\u7ba1\u7406<\/p>\n
\u6211\u4eec\u4e3a\u6bcf\u4e00\u4e2a\u94fe\u63a5\u521d\u59cb\u5316\u4e00\u4e2aConnection\u7c7b\u8fdb\u884c\u7ba1\u7406，\u7136\u540e\u8bbe\u7f6e\u5404\u79cd\u56de\u8c03\u51fd\u6570，\u6700\u540e\u5c06\u8fd9\u4e2a\u94fe\u63a5\u52a0\u5165\u5230unordered_map\u4e2d<\/p>\n
void NewConnection(int fd)
\n{
\n \/\/ DBG_LOG("NEWCONNECTION FUNCTION");
\n _next_id++;
\n PtrConnection conn(new Connection(_pool.NextLoop(), _next_id, fd));
\n conn->SetMessageCallback(_message_callback); \/\/ \u4e3a\u901a\u884c\u5957\u63a5\u5b57\u8bbe\u7f6e\u53ef\u8bfb\u4e8b\u4ef6\u7684\u56de\u8c03\u51fd\u6570
\n conn->SetClosedCallback(_closed_callback); \/\/ \u5173\u95ed\u4e8b\u4ef6\u7684\u56de\u8c03\u51fd\u6570
\n conn->SetConnectedCallback(_connected_callback); \/\/ \u9519\u8bef\u4e8b\u4ef6\u7684\u56de\u8c03\u51fd\u6570
\n conn->SetAnyEventCallback(_event_callback);
\n conn->SetSrvClosedCallback(std::bind(&TcpServer::RemoveConnection, this, std::placeholders::_1));
\n if (_enable_inactive_release)
\n conn->EnableInactiveRelease(_timeout); \/\/ \u542f\u52a8\u975e\u6d3b\u8dc3\u8d85\u65f6\u9500\u6bc1
\n conn->Established(); \/\/ \u5c31\u7eea\u521d\u59cb\u5316
\n _conns.insert(std::make_pair(_next_id, conn));
\n} <\/p>\n
\u79fb\u9664\u8fd9\u4e2a\u94fe\u63a5，\u53ea\u9700\u8981\u4ece_conns\u8fd9\u4e2aunordered_map\u4e2d\u79fb\u9664\u5373\u53ef<\/p>\n
void RemoveConnectionInLoop(const PtrConnection &conn)
\n{
\n int id = conn->Id();
\n auto it = _conns.find(id);
\n if (it != _conns.end())
\n {
\n _conns.erase(it);
\n }
\n} <\/p>\n
\u628a\u8fd9\u4e2a\u79fb\u9664Connection\u7684\u4efb\u52a1\u653e\u5230_baseloop\u4e2d\u6267\u884c\u907f\u514d\u4e86\u7ebf\u7a0b\u5b89\u5168\u95ee\u9898<\/p>\n
\/\/ \u4ece\u7ba1\u7406Connection\u7684_conns\u4e2d\u79fb\u9664\u8fde\u63a5\u4fe1\u606f
\nvoid RemoveConnection(const PtrConnection &conn)
\n{
\n _baseloop.RunInLoop(std::bind(&TcpServer::RemoveConnectionInLoop, this, conn));
\n} <\/p>\n
\u4e0b\u9762\u662f\u8fd9\u4e2a\u7c7b\u7684\u5b8c\u6574\u4ee3\u7801<\/p>\n
class TcpServer
\n{
\nprivate:
\n uint64_t _next_id; \/\/ \u8fd9\u662f\u4e00\u4e2a\u81ea\u52a8\u589e\u957f\u7684\u8fde\u63a5ID
\n int _timeout; \/\/ \u8fd9\u662f\u975e\u6d3b\u8dc3\u94fe\u63a5\u7684\u7edf\u8ba1\u65f6\u95f4—\u591a\u957f\u65f6\u95f4\u65e0\u901a\u4fe1\u5c31\u662f\u975e\u6d3b\u8dc3\u8fde\u63a5
\n int _port;
\n bool _enable_inactive_release; \/\/ \u662f\u5426\u542f\u52a8\u4e86\u975e\u6d3b\u8dc3\u8fde\u63a5\u8d85\u65f6\u9500\u6bc1\u7684\u5224\u65ad\u6807\u5fd7
\n Acceptor _acceptor; \/\/ \u8fd9\u662f\u76d1\u542c\u5957\u63a5\u5b57\u7684\u7ba1\u7406\u5bf9\u8c61
\n EventLoop _baseloop; \/\/ \u8fd9\u662f\u4e3b\u7ebf\u7a0b\u7684EventLoop\u5bf9\u8c61，\u8d1f\u8d23\u76d1\u542c\u4e8b\u4ef6\u7684\u5904\u7406
\n LoopThreadPool _pool; \/\/ \u8fd9\u662f\u6211\u4eec\u7684\u4ece\u5c5eEventLoop\u7ebf\u7a0b\u6c60
\n std::unordered_map<uint64_t, PtrConnection> _conns; \/\/ \u4fdd\u5b58\u7ba1\u7406\u6240\u6709\u8fde\u63a5\u5bf9\u5e94\u7684shared_ptr\u5bf9\u8c61<\/p>\n
using ConnectedCallback = std::function<void(const PtrConnection &)>;
\n using MessageCallback = std::function<void(const PtrConnection &, Buffer *)>;
\n using ClosedCallback = std::function<void(const PtrConnection &)>;
\n using AnyEventCallback = std::function<void(const PtrConnection &)>;
\n using Functor = std::function<void()>;
\n ConnectedCallback _connected_callback;
\n MessageCallback _message_callback;
\n ClosedCallback _closed_callback;
\n AnyEventCallback _event_callback;<\/p>\n
private:
\n void RunAfterInLoop(const Functor &task, int delay)
\n {
\n _next_id++;
\n _baseloop.TimerAdd(_next_id, delay, task);
\n }
\n \/\/ \u4e3a\u65b0\u8fde\u63a5\u6784\u9020Connection\u8fdb\u884c\u7ba1\u7406
\n void NewConnection(int fd)
\n {
\n \/\/ DBG_LOG("NEWCONNECTION FUNCTION");
\n _next_id++;
\n PtrConnection conn(new Connection(_pool.NextLoop(), _next_id, fd));
\n conn->SetMessageCallback(_message_callback); \/\/ \u4e3a\u901a\u884c\u5957\u63a5\u5b57\u8bbe\u7f6e\u53ef\u8bfb\u4e8b\u4ef6\u7684\u56de\u8c03\u51fd\u6570
\n conn->SetClosedCallback(_closed_callback); \/\/ \u5173\u95ed\u4e8b\u4ef6\u7684\u56de\u8c03\u51fd\u6570
\n conn->SetConnectedCallback(_connected_callback); \/\/ \u9519\u8bef\u4e8b\u4ef6\u7684\u56de\u8c03\u51fd\u6570
\n conn->SetAnyEventCallback(_event_callback);
\n conn->SetSrvClosedCallback(std::bind(&TcpServer::RemoveConnection, this, std::placeholders::_1));
\n if (_enable_inactive_release)
\n conn->EnableInactiveRelease(_timeout); \/\/ \u542f\u52a8\u975e\u6d3b\u8dc3\u8d85\u65f6\u9500\u6bc1
\n conn->Established(); \/\/ \u5c31\u7eea\u521d\u59cb\u5316
\n _conns.insert(std::make_pair(_next_id, conn));
\n }
\n void RemoveConnectionInLoop(const PtrConnection &conn)
\n {
\n int id = conn->Id();
\n auto it = _conns.find(id);
\n if (it != _conns.end())
\n {
\n _conns.erase(it);
\n }
\n }
\n \/\/ \u4ece\u7ba1\u7406Connection\u7684_conns\u4e2d\u79fb\u9664\u8fde\u63a5\u4fe1\u606f
\n void RemoveConnection(const PtrConnection &conn)
\n {
\n _baseloop.RunInLoop(std::bind(&TcpServer::RemoveConnectionInLoop, this, conn));
\n }<\/p>\n
public:
\n TcpServer(int port)
\n : _port(port),
\n _next_id(0),
\n _enable_inactive_release(false),
\n _acceptor(&_baseloop, port),
\n _pool(&_baseloop)
\n {
\n _acceptor.SetAcceptCallBack(std::bind(&TcpServer::NewConnection, this, std::placeholders::_1));
\n _acceptor.Listen(); \/\/ \u5f00\u59cb\u76d1\u542c，\u6302\u5230_baseloop\u4e0a\u9762\u53bb
\n }
\n void SetThreadCount(int count) \/\/ \u8bbe\u7f6e\u7ebf\u7a0b\u6c60\u7684\u6570\u91cf
\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 }
\n \/\/ \u591a\u5c11\u79d2\u4e4b\u540e\u6267\u884c\u4e00\u4e2a\u4efb\u52a1，\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 \/\/ \u9700\u8981\u6ce8\u610f\u7684\u662f，_pool.Create();\u8fd9\u4e2a\u8c03\u7528\u51fd\u6570\u53ea\u80fd\u53d1\u5728start\u51fd\u6570\u4e4b\u4e2d，
\n \/\/ \u4e0d\u80fd\u653e\u5728\u7c7b\u7684\u521d\u59cb\u5316\u51fd\u6570\u4e2d，\u5426\u5219\u4f1a\u9020\u6210\u8d8a\u754c\u8bbf\u95ee
\n void Start()
\n {
\n _pool.Create(); \/\/ \u521b\u5efa\u7ebf\u7a0b\u6c60\u4e2d\u7684\u4ece\u5c5e\u7ebf\u7a0b
\n _baseloop.Start(); \/\/ \u5f00\u59cb\u53bb\u5904\u7406\u4e8b\u4ef6\u4e86
\n }
\n}; <\/p>\n
\u9996\u5148\u6211\u4eec\u8981\u5199\u4e00\u4e2a\u5b57\u7b26\u4e32\u5206\u5272\u51fd\u6570\u51fa\u6765，\u8fd9\u4e2a\u51fd\u6570\u6709\u4e09\u4e2a\u53c2\u6570，\u5206\u522b\u662f\u9700\u8981\u88ab\u5206\u5272\u7684\u5b57\u7b26\u4e32，\u88ab\u5206\u5272\u7684\u76ee\u6807\u5b57\u7b26\u4e32，\u5206\u5272\u540e\u7684\u5b57\u7b26\u4e32\u653e\u5165\u7684\u4f4d\u7f6e<\/p>\n
\u9996\u5148\u521b\u5efa\u4e00\u4e2a\u53d8\u91cfoffset\u8868\u793a\u4ece0\u4f4d\u7f6e\u5f00\u59cb，\u7136\u540e\u8fdb\u5165\u5faa\u73af，\u6211\u4eec\u4f7f\u7528string\u91cc\u9762\u63d0\u4f9b\u7684find\u51fd\u6570\u5206\u522b\u4f20\u5165\u9700\u8981\u67e5\u627e\u7684\u5b50\u4e32\u548c\u4ece\u54ea\u91cc\u5f00\u59cb\u67e5\u627eoffset，\u5e76\u4e14\u63a5\u53d7\u8fd4\u56de\u503c\u3002\u5f53\u8fd4\u56de\u503c\u662fstd::string::npos，\u8868\u793a\u6ca1\u6709\u627e\u5230\u3002\u5982\u679cpos == offset，\u8bf4\u660e\u627e\u5230\u4e86，\u4f46\u662f\u4e24\u4e2a\u4f4d\u7f6e\u4e4b\u95f4\u4e0d\u5b58\u5728\u5b50\u4e32，\u76f4\u63a5\u8ba9offset\u8df3\u8fc7\u67e5\u627e\u7684\u5b57\u7b26\u4e32，\u8df3\u8fc7\u672c\u6b21\u5faa\u73af\u3002\u5982\u679cpos\u548coffset\u4e0d\u76f8\u7b49，\u5c31\u76f4\u63a5\u628apos\u4e0eoffset\u4e4b\u95f4\u7684\u5b50\u4e32\u4f20\u5165\u5230arry\u4e2d\u3002\u7ecf\u8fc7\u5faa\u73af\u4e4b\u540e，\u6700\u540e\u8fd4\u56dearry\u7684\u5927\u5c0f，\u5373\u5b50\u4e32\u7684\u6570\u91cf<\/p>\n
static size_t Split(const std::string &src, const std::string &sep, std::vector<std::string> *arry)
\n{
\n size_t offset = 0;<\/p>\n
while (offset < src.size())
\n {
\n size_t pos = src.find(sep, offset); \/\/ \u5728src\u5b57\u7b26\u4e32\u504f\u79fb\u91cfoffset\u5904，\u5f00\u59cb\u5411\u540e\u67e5\u627esep\u5b57\u7b26\/\u5b50\u4e32，\u8fd4\u56de\u67e5\u627e\u5230\u7684\u4f4d\u7f6e
\n if (pos == std::string::npos)
\n {
\n \/\/ \u6ca1\u6709\u627e\u5230\u7279\u5b9a\u5b57\u7b26
\n if (pos == src.size())
\n break;
\n arry->push_back(src.substr(offset));
\n return arry->size();
\n }
\n if (pos == offset)
\n {
\n offset = pos + sep.size();
\n continue;
\n } \/\/ \u5f53\u524d\u5b50\u4e32\u662f\u7a7a\u7684，\u6ca1\u6709\u5185\u5bb9
\n arry->push_back(src.substr(offset, pos – offset));
\n offset = pos + sep.size();
\n }
\n return arry->size();
\n} <\/p>\n
\u7136\u540e\u5c31\u662f\u8bfb\u53d6\u6587\u4ef6\u4e2d\u7684\u6240\u6709\u5185\u5bb9，\u5c06\u8bfb\u53d6\u5230\u7684\u5185\u5bb9\u653e\u5230buffer\u4e2d<\/p>\n
\u4f7f\u7528std::ifstream ，\u4f20\u5165\u6587\u4ef6\u7684\u540d\u5b57\u5e76\u4e14\u4ee5\u4e8c\u8fdb\u5236\u7684\u65b9\u5f0f\u8bfb\u53d6<\/p>\n
\u5c06\u6587\u4ef6\u6307\u9488\u8df3\u8f6c\u5230\u672b\u5c3e\u4e4b\u540e，\u4f7f\u7528tellg\u51fd\u6570\u6765\u627e\u5230\u6587\u4ef6\u7684\u5927\u5c0f<\/p>\n
\u627e\u5230\u6587\u4ef6\u5927\u5c0f\u4e4b\u540e\u518d\u6b21\u4f7f\u7528seekg\u628a\u6587\u4ef6\u6307\u9488\u653e\u5230\u8d77\u59cb\u4f4d\u7f6e<\/p>\n
\u628a\u8bfb\u53d6\u5230\u7684\u6570\u636e\u653e\u5165\u5230buf\u5f53\u4e2d，\u5173\u95ed\u6253\u5f00\u7684\u6587\u4ef6\u6d41<\/p>\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("OPEN %s FILE FAILED!!", filename.c_str());
\n return false;
\n }
\n size_t fsize = 0;
\n \/\/ \u6587\u4ef6\u6307\u9488\u8df3\u8f6c\u5230\u672b\u5c3e
\n ifs.seekg(0, ifs.end);
\n fsize = ifs.tellg(); \/\/ \u83b7\u53d6\u5f53\u524d\u8bfb\u5199\u4f4d\u7f6e\u76f8\u5bf9\u4e8e\u8d77\u59cb\u4f4d\u7f6e\u7684\u504f\u79fb\u91cf，\u4ece\u672b\u5c3e\u504f\u79fb\u521a\u597d\u5c31\u662f\u6587\u4ef6\u5927\u5c0f
\n ifs.seekg(0, ifs.beg); \/\/ \u8df3\u8f6c\u5230\u8d77\u59cb\u4f4d\u7f6e
\n buf->resize(fsize); \/\/ \u5f00\u8f9f\u6587\u4ef6\u5927\u5c0f\u7684\u7a7a\u95f4
\n ifs.read(&(*buf)[0], fsize);
\n if (ifs.good() == false)
\n {
\n \/\/ \u8bfb\u53d6\u5931\u8d25
\n ERR_LOG("READ %s FILE FAILED!!", filename.c_str());
\n ifs.close();
\n return false;
\n }
\n ifs.close();
\n return true;
\n} <\/p>\n
\u5411\u6587\u4ef6\u4e2d\u5199\u5165\u6570\u636e<\/p>\n
\u9996\u5148\u9700\u8981\u6253\u5f00\u6587\u4ef6，\u4ee5\u4e8c\u8fdb\u5236\u548c\u622a\u65ad\u65b9\u5f0f\u8bfb\u53d6，\u7136\u540e\u4f7f\u7528write\u51fd\u6570\u5c06buf\u4e2d\u7684\u5185\u5bb9\u5199\u5230\u8fd9\u4e2a\u6587\u4ef6\u5f53\u4e2d，\u6700\u540e\u5173\u95ed\u6587\u4ef6\u6d41<\/p>\n
static bool WriteFile(const std::string &filename, const std::string &buf)
\n{
\n std::ofstream ofs(filename, std::ios::binary | std::ios::trunc); \/\/ trunc\u4ee3\u8868\u622a\u65ad
\n if (ofs.is_open() == false)
\n {
\n ERR_LOG("READ %s FILE 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} <\/p>\n
\u8fd9\u91cc\u7b80\u5355\u4ecb\u7ecd\u4e00\u4e0bURL\u7f16\u7801，\u5b83\u7684\u4f5c\u7528\u662f\u907f\u514dURL\u4e2d\u7684\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\u3002<\/p>\n
\u7f16\u7801\u683c\u5f0f：\u5c06\u7279\u6b8a\u5b57\u7b26\u7684ASCII\u503c，\u8f6c\u6362\u4e3a\u4e24\u4e2a16\u8fdb\u5236\u5b57\u7b26<\/p>\n
\u4e0d\u7f16\u7801\u7684\u7279\u6b8a\u5b57\u7b26 RFC3986\u6587\u6863\u89c4\u5b9a.-_~\u5b57\u6bcd，\u6570\u5b57\u5c5e\u4e8e\u7edd\u5bf9\u4e0d\u7f16\u7801\u5b57\u7b26，\u7f16\u7801\u683c\u5f0f%HH<\/p>\n
W3C\u6587\u6863\u4e2d\u89c4\u5b9a\u67e5\u8be2\u5b57\u7b26\u4e32\u4e2d\u7684\u7a7a\u683c，\u9700\u8981\u88ab\u7f16\u7801\u4e3a +，\u89e3\u7801\u5219\u662f + \u8f6c\u5316\u4e3a\u7a7a\u683c<\/p>\n
\u6bd4\u5982：<\/p>\n
static std::string UrlEncode(const std::string url, bool convert_space_to_plus)
\n{
\n std::string res;
\n for (auto &c : url)
\n {
\n if (c == '.' || c == '-' || c == '_' || c == '~' || isalnum(c))
\n {
\n res += c;
\n continue;
\n }
\n if (c == ' ' && convert_space_to_plus == true)
\n {
\n res += '+';
\n continue;
\n }
\n \/\/ \u5269\u4e0b\u7684\u5b57\u7b26\u90fd\u662f\u9700\u8981\u7f16\u7801\u79f0\u4e3a%HH\u7684\u683c\u5f0f\u7684
\n char tmp[4] = {0};
\n snprintf(tmp, 4, "%%%02X", c);
\n res += tmp;
\n }
\n return res;
\n} <\/p>\n
\u5c06\u5341\u516d\u8fdb\u5236\u5b57\u7b26\u8f6c\u6362\u4e3a\u5bf9\u5e94\u7684\u6574\u6570\u503c<\/p>\n
static char HEXTOI(char c)
\n{
\n if (c >= '0' && c <= '9')
\n {
\n \/\/ \u6570\u5b57\u5b57\u7b26
\n return c – '0';
\n }
\n else if (c >= 'a' && c <= 'z')
\n {
\n return c – 'a' + 10;
\n }
\n else if (c >= 'A' && c <= 'Z')
\n {
\n return c – 'A' + 10;
\n }
\n return -1;
\n} <\/p>\n
\u6709URL\u7f16\u7801\u5f53\u7136\u4e5f\u6709URL\u89e3\u7801，\u5f53\u6211\u4eec\u9047\u5230\u4e86%，\u6211\u4eec\u9700\u8981\u67e5\u770b\u767e\u5206\u53f7\u540e\u9762\u7684\u7b2c\u4e00\u4e2a\u6570\u5b57\u548c\u7b2c\u4e8c\u4e2a\u6570\u5b57，\u5c06\u7b2c\u4e00\u4e2a\u6570\u5b57\u5de6\u79fb4\u4f4d，\u76f8\u5f53\u4e8e\u76f4\u63a5\u4e58\u4ee516，\u7136\u540e\u52a0\u4e0a\u7b2c\u4e8c\u4e2a\u6570\u5b57\u5373\u53ef<\/p>\n
static std::string UrlDecode(const std::string url, bool convert_space_to_space)
\n{
\n \/\/ \u9047\u5230%，\u5219\u5c06\u7d27\u968f\u5176\u540e\u7684\u4e24\u4e2a\u5b57\u7b26，\u8f6c\u5316\u4e3a\u6570\u5b57，\u7b2c\u4e00\u4e2a\u6570\u5b57\u5de6\u79fb\u56db\u4f4d，\u7136\u540e\u52a0\u4e0a\u7b2c\u4e8c\u4e2a\u6570\u5b57
\n \/\/ eg：%2b = 2 * 2^4 + b(\u8f6c\u5316\u4e3a\u5341\u8fdb\u5236)
\n std::string res;
\n for (int i = 0; i < url.size(); i++)
\n {
\n if (url[i] == '+' && convert_space_to_space == true)
\n {
\n res += ' ';
\n continue;
\n }
\n if (url[i] == '%' && i + 2 < url.size())
\n {
\n char v1 = HEXTOI(url[i + 1]);
\n char v2 = HEXTOI(url[i + 2]);
\n char v = (v1 << 4) + v2;
\n res += v;
\n i += 2;
\n continue;
\n }
\n res += url[i];
\n }
\n return res;
\n} <\/p>\n
\u6211\u4eec\u4e5f\u9700\u8981\u901a\u8fc7\u76f8\u5e94\u7684\u72b6\u6001\u7801\u83b7\u53d6\u76f8\u5e94\u7684\u72b6\u6001\u63cf\u8ff0\u4fe1\u606f<\/p>\n
static std::string StatuDesc(int statu)
\n{<\/p>\n
auto it = _statu_msg.find(statu);
\n if (it != _statu_msg.end())
\n {
\n return it->second;
\n }
\n return "Unknown";
\n} <\/p>\n
\u4e0b\u9762\u5c06\u4f1a\u5217\u51fa\u72b6\u6001\u7801\u5bf9\u5e94\u7684\u4fe1\u606f<\/p>\n
std::unordered_map<int, std::string> _statu_msg = {
\n {100, "Continue"},
\n {101, "Switching Protocol"},
\n {102, "Processing"},
\n {103, "Early Hints"},
\n {200, "OK"},
\n {201, "Created"},
\n {202, "Accepted"},
\n {203, "Non-Authoritative Information"},
\n {204, "No Content"},
\n {205, "Reset Content"},
\n {206, "Partial Content"},
\n {207, "Multi-Status"},
\n {208, "Already Reported"},
\n {226, "IM Used"},
\n {300, "Multiple Choice"},
\n {301, "Moved Permanently"},
\n {302, "Found"},
\n {303, "See Other"},
\n {304, "Not Modified"},
\n {305, "Use Proxy"},
\n {306, "unused"},
\n {307, "Temporary Redirect"},
\n {308, "Permanent Redirect"},
\n {400, "Bad Request"},
\n {401, "Unauthorized"},
\n {402, "Payment Required"},
\n {403, "Forbidden"},
\n {404, "Not Found"},
\n {405, "Method Not Allowed"},
\n {406, "Not Acceptable"},
\n {407, "Proxy Authentication Required"},
\n {408, "Request Timeout"},
\n {409, "Conflict"},
\n {410, "Gone"},
\n {411, "Length Required"},
\n {412, "Precondition Failed"},
\n {413, "Payload Too Large"},
\n {414, "URI Too Long"},
\n {415, "Unsupported Media Type"},
\n {416, "Range Not Satisfiable"},
\n {417, "Expectation Failed"},
\n {418, "I'm a teapot"},
\n {421, "Misdirected Request"},
\n {422, "Unprocessable Entity"},
\n {423, "Locked"},
\n {424, "Failed Dependency"},
\n {425, "Too Early"},
\n {426, "Upgrade Required"},
\n {428, "Precondition Required"},
\n {429, "Too Many Requests"},
\n {431, "Request Header Fields Too Large"},
\n {451, "Unavailable For Legal Reasons"},
\n {501, "Not Implemented"},
\n {502, "Bad Gateway"},
\n {503, "Service Unavailable"},
\n {504, "Gateway Timeout"},
\n {505, "HTTP Version Not Supported"},
\n {506, "Variant Also Negotiates"},
\n {507, "Insufficient Storage"},
\n {508, "Loop Detected"},
\n {510, "Not Extended"},
\n {511, "Network Authentication Required"}}; <\/p>\n
\u7136\u540e\u662f\u6839\u636e\u6587\u4ef6\u540e\u7f00\u540d\u83b7\u53d6mime，\u8fd9\u91cc\u89e3\u91ca\u4e00\u4e0bmime\u662f\u4ec0\u4e48，\u662f\u6307\u901a\u8fc7\u6587\u4ef6\u540d\u7684\u6269\u5c55\u540d\u6765\u786e\u5b9a\u8be5\u6587\u4ef6\u5bf9\u5e94\u7684mime\u7c7b\u578b，mime\u7c7b\u578b\u662f\u4e00\u79cd\u6807\u51c6\u5316\u7684\u6587\u4ef6\u7c7b\u578b\u6807\u8bc6\u65b9\u6cd5，\u7528\u4e8e\u544a\u8bc9\u5ba2\u6237\u7aef\u5982\u6b4c\u5904\u7406\u6216\u89e3\u6790\u6536\u5230\u7684\u6587\u4ef6<\/p>\n
std::unordered_map<std::string, std::string> _mime_msg = {
\n {".aac", "audio\/aac"},
\n {".abw", "application\/x-abiword"},
\n {".arc", "application\/x-freearc"},
\n {".avi", "video\/x-msvideo"},
\n {".azw", "application\/vnd.amazon.ebook"},
\n {".bin", "application\/octet-stream"},
\n {".bmp", "image\/bmp"},
\n {".bz", "application\/x-bzip"},
\n {".bz2", "application\/x-bzip2"},
\n {".csh", "application\/x-csh"},
\n {".css", "text\/css"},
\n {".csv", "text\/csv"},
\n {".doc", "application\/msword"},
\n {".docx", "application\/vnd.openxmlformats-officedocument.wordprocessingml.document"},
\n {".eot", "application\/vnd.ms-fontobject"},
\n {".epub", "application\/epub+zip"},
\n {".gif", "image\/gif"},
\n {".htm", "text\/html"},
\n {".html", "text\/html"},
\n {".ico", "image\/vnd.microsoft.icon"},
\n {".ics", "text\/calendar"},
\n {".jar", "application\/java-archive"},
\n {".jpeg", "image\/jpeg"},
\n {".jpg", "image\/jpeg"},
\n {".js", "text\/javascript"},
\n {".json", "application\/json"},
\n {".jsonld", "application\/ld+json"},
\n {".mid", "audio\/midi"},
\n {".midi", "audio\/x-midi"},
\n {".mjs", "text\/javascript"},
\n {".mp3", "audio\/mpeg"},
\n {".mpeg", "video\/mpeg"},
\n {".mpkg", "application\/vnd.apple.installer+xml"},
\n {".odp", "application\/vnd.oasis.opendocument.presentation"},
\n {".ods", "application\/vnd.oasis.opendocument.spreadsheet"},
\n {".odt", "application\/vnd.oasis.opendocument.text"},
\n {".oga", "audio\/ogg"},
\n {".ogv", "video\/ogg"},
\n {".ogx", "application\/ogg"},
\n {".otf", "font\/otf"},
\n {".png", "image\/png"},
\n {".pdf", "application\/pdf"},
\n {".ppt", "application\/vnd.ms-powerpoint"},
\n {".pptx", "application\/vnd.openxmlformats-officedocument.presentationml.presentation"},
\n {".rar", "application\/x-rar-compressed"},
\n {".rtf", "application\/rtf"},
\n {".sh", "application\/x-sh"},
\n {".svg", "image\/svg+xml"},
\n {".swf", "application\/x-shockwave-flash"},
\n {".tar", "application\/x-tar"},
\n {".tif", "image\/tiff"},
\n {".tiff", "image\/tiff"},
\n {".ttf", "font\/ttf"},
\n {".txt", "text\/plain"},
\n {".vsd", "application\/vnd.visio"},
\n {".wav", "audio\/wav"},
\n {".weba", "audio\/webm"},
\n {".webm", "video\/webm"},
\n {".webp", "image\/webp"},
\n {".woff", "font\/woff"},
\n {".woff2", "font\/woff2"},
\n {".xhtml", "application\/xhtml+xml"},
\n {".xls", "application\/vnd.ms-excel"},
\n {".xlsx", "application\/vnd.openxmlformats-officedocument.spreadsheetml.sheet"},
\n {".xml", "application\/xml"},
\n {".xul", "application\/vnd.mozilla.xul+xml"},
\n {".zip", "application\/zip"},
\n {".3gp", "video\/3gpp"},
\n {".3g2", "video\/3gpp2"},
\n {".7z", "application\/x-7z-compressed"}}; <\/p>\n
\u6839\u636e\u6587\u4ef6\u540e\u7f00\u540d\u83b7\u53d6\u6587\u4ef6mime\u7684\u4ee3\u7801\u5982\u4e0b<\/p>\n
static std::string ExtMime(const std::string &filename)
\n{<\/p>\n
\/\/ a.b.txt
\n size_t pos = filename.find_last_of('.');
\n if (pos == std::string::npos)
\n {
\n return "application\/octet-stream";
\n }
\n std::string ext = filename.substr(pos);
\n auto it = _mime_msg.find(ext);
\n if (it == _mime_msg.end())
\n {
\n return "application\/octet-stream";
\n }
\n return it->second;
\n} <\/p>\n
\u5224\u65ad\u4e00\u4e2a\u6587\u4ef6\u662f\u5426\u662f\u4e00\u4e2a\u666e\u901a\u6587\u4ef6<\/p>\n
\u8fd9\u91cc\u9700\u8981\u4f7f\u7528\u5230\u7cfb\u7edf\u8c03\u7528stat\u6765\u83b7\u53d6\u6587\u4ef6\u7684\u72b6\u6001\u4fe1\u606f，\u5e76\u4e14\u9700\u8981\u901a\u8fc7S_ISREG\u5b8f\u6765\u5224\u65ad\u6587\u4ef6\u662f\u5426\u4e3a\u666e\u901a\u6587\u4ef6<\/p>\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 }
\n return S_ISREG(st.st_mode);
\n} <\/p>\n
\u68c0\u67e5http\u8bf7\u6c42\u7684\u8d44\u6e90\u8def\u5f84\u7684\u6709\u6548\u6027\u5224\u65ad<\/p>\n
static bool ValidPath(const std::string &path)
\n{
\n std::vector<std::string> subdir;
\n Split(path, "\/", &subdir);
\n int level = 0;
\n for (auto &dir : subdir)
\n {
\n if (dir == "..")
\n {
\n level–;
\n if (level < 0)
\n {
\n return false;
\n }
\n continue;
\n }
\n level++;
\n }
\n return true;
\n} <\/p>\n
\u4e0b\u9762\u662fUtil\u7c7b\u7684\u5b8c\u6574\u4ee3\u7801<\/p>\n
class Util
\n{
\npublic:
\n \/\/ \u5b57\u7b26\u4e32\u5206\u5272\u51fd\u6570，\u5206\u5272\u540e\u7684\u5b50\u4e32\u653e\u5230vector\u91cc\u9762，\u6700\u7ec8\u8fd4\u56de\u5b50\u4e32\u7684\u6570\u91cf
\n static size_t Split(const std::string &src, const std::string &sep, std::vector<std::string> *arry)
\n {
\n size_t offset = 0;<\/p>\n
while (offset < src.size())
\n {
\n size_t pos = src.find(sep, offset); \/\/ \u5728src\u5b57\u7b26\u4e32\u504f\u79fb\u91cfoffset\u5904，\u5f00\u59cb\u5411\u540e\u67e5\u627esep\u5b57\u7b26\/\u5b50\u4e32，\u8fd4\u56de\u67e5\u627e\u5230\u7684\u4f4d\u7f6e
\n if (pos == std::string::npos)
\n {
\n \/\/ \u6ca1\u6709\u627e\u5230\u7279\u5b9a\u5b57\u7b26
\n if (pos == src.size())
\n break;
\n arry->push_back(src.substr(offset));
\n return arry->size();
\n }
\n if (pos == offset)
\n {
\n offset = pos + sep.size();
\n continue;
\n } \/\/ \u5f53\u524d\u5b50\u4e32\u662f\u7a7a\u7684，\u6ca1\u6709\u5185\u5bb9
\n arry->push_back(src.substr(offset, pos – offset));
\n offset = pos + sep.size();
\n }
\n return arry->size();
\n }
\n \/\/ \u8bfb\u53d6\u6587\u4ef6\u6240\u6709\u5185\u5bb9，\u5c06\u8bfb\u53d6\u7684\u5185\u5bb9\u653e\u5230buffer\u4e2d
\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("OPEN %s FILE FAILED!!", filename.c_str());
\n return false;
\n }
\n size_t fsize = 0;
\n \/\/ \u6587\u4ef6\u6307\u9488\u8df3\u8f6c\u5230\u672b\u5c3e
\n ifs.seekg(0, ifs.end);
\n fsize = ifs.tellg(); \/\/ \u83b7\u53d6\u5f53\u524d\u8bfb\u5199\u4f4d\u7f6e\u76f8\u5bf9\u4e8e\u8d77\u59cb\u4f4d\u7f6e\u7684\u504f\u79fb\u91cf，\u4ece\u672b\u5c3e\u504f\u79fb\u521a\u597d\u5c31\u662f\u6587\u4ef6\u5927\u5c0f
\n ifs.seekg(0, ifs.beg); \/\/ \u8df3\u8f6c\u5230\u8d77\u59cb\u4f4d\u7f6e
\n buf->resize(fsize); \/\/ \u5f00\u8f9f\u6587\u4ef6\u5927\u5c0f\u7684\u7a7a\u95f4
\n ifs.read(&(*buf)[0], fsize);
\n if (ifs.good() == false)
\n {
\n \/\/ \u8bfb\u53d6\u5931\u8d25
\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 \/\/ \u5411\u6587\u4ef6\u5199\u5165\u6570\u636e
\n static bool WriteFile(const std::string &filename, const std::string &buf)
\n {
\n std::ofstream ofs(filename, std::ios::binary | std::ios::trunc); \/\/ trunc\u4ee3\u8868\u622a\u65ad
\n if (ofs.is_open() == false)
\n {
\n ERR_LOG("READ %s FILE 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\u7279\u6b8a\u5b57\u7b26\u4ea7\u751f\u6b67\u4e49
\n \/\/ \u7f16\u7801\u683c\u5f0f：\u5c06\u7279\u6b8a\u5b57\u7b26\u7684ASCII\u503c，\u8f6c\u6362\u4e3a\u4e24\u4e2a16\u8fdb\u5236\u5b57\u7b26，C++ -> C%2B%2B
\n \/\/ \u4e0d\u7f16\u7801\u7684\u7279\u6b8a\u5b57\u7b26 RFC3986\u6587\u6863\u89c4\u5b9a.-_~\u5b57\u6bcd，\u6570\u5b57\u5c5e\u4e8e\u7edd\u5bf9\u4e0d\u7f16\u7801\u5b57\u7b26，\u7f16\u7801\u683c\u5f0f%HH
\n \/\/ W3C\u6587\u6863\u4e2d\u89c4\u5b9a\u67e5\u8be2\u5b57\u7b26\u4e32\u4e2d\u7684\u7a7a\u683c，\u9700\u8981\u88ab\u7f16\u7801\u4e3a +，\u89e3\u7801\u5219\u662f + \u8f6c\u5316\u4e3a\u7a7a\u683c
\n static std::string UrlEncode(const std::string url, bool convert_space_to_plus)
\n {
\n std::string res;
\n for (auto &c : url)
\n {
\n if (c == '.' || c == '-' || c == '_' || c == '~' || isalnum(c))
\n {
\n res += c;
\n continue;
\n }
\n if (c == ' ' && convert_space_to_plus == true)
\n {
\n res += '+';
\n continue;
\n }
\n \/\/ \u5269\u4e0b\u7684\u5b57\u7b26\u90fd\u662f\u9700\u8981\u7f16\u7801\u79f0\u4e3a%HH\u7684\u683c\u5f0f\u7684
\n char tmp[4] = {0};
\n snprintf(tmp, 4, "%%%02X", c);
\n res += tmp;
\n }
\n return res;
\n }
\n static char HEXTOI(char c)
\n {
\n if (c >= '0' && c <= '9')
\n {
\n \/\/ \u6570\u5b57\u5b57\u7b26
\n return c – '0';
\n }
\n else if (c >= 'a' && c <= 'z')
\n {
\n return c – 'a' + 10;
\n }
\n else if (c >= 'A' && c <= 'Z')
\n {
\n return c – 'A' + 10;
\n }
\n return -1;
\n }
\n \/\/ URL\u89e3\u7801
\n static std::string UrlDecode(const std::string url, bool convert_space_to_space)
\n {
\n \/\/ \u9047\u5230%，\u5219\u5c06\u7d27\u968f\u5176\u540e\u7684\u4e24\u4e2a\u5b57\u7b26，\u8f6c\u5316\u4e3a\u6570\u5b57，\u7b2c\u4e00\u4e2a\u6570\u5b57\u5de6\u79fb\u56db\u4f4d，\u7136\u540e\u52a0\u4e0a\u7b2c\u4e8c\u4e2a\u6570\u5b57
\n \/\/ eg：%2b = 2 * 2^4 + b(\u8f6c\u5316\u4e3a\u5341\u8fdb\u5236)
\n std::string res;
\n for (int i = 0; i < url.size(); i++)
\n {
\n if (url[i] == '+' && convert_space_to_space == true)
\n {
\n res += ' ';
\n continue;
\n }
\n if (url[i] == '%' && i + 2 < url.size())
\n {
\n char v1 = HEXTOI(url[i + 1]);
\n char v2 = HEXTOI(url[i + 2]);
\n char v = (v1 << 4) + v2;
\n res += v;
\n i += 2;
\n continue;
\n }
\n res += url[i];
\n }
\n return res;
\n }
\n \/\/ \u76f8\u5e94\u72b6\u6001\u7801\u7684\u63cf\u8ff0\u4fe1\u606f\u83b7\u53d6
\n static std::string StatuDesc(int statu)
\n {<\/p>\n
auto it = _statu_msg.find(statu);
\n if (it != _statu_msg.end())
\n {
\n return it->second;
\n }
\n return "Unknown";
\n }
\n \/\/ \u6839\u636e\u6587\u4ef6\u540e\u7f00\u540d\u83b7\u53d6\u6587\u4ef6mime
\n static std::string ExtMime(const std::string &filename)
\n {<\/p>\n
\/\/ a.b.txt
\n size_t pos = filename.find_last_of('.');
\n if (pos == std::string::npos)
\n {
\n return "application\/octet-stream";
\n }
\n std::string ext = filename.substr(pos);
\n auto it = _mime_msg.find(ext);
\n if (it == _mime_msg.end())
\n {
\n return "application\/octet-stream";
\n }
\n return it->second;
\n }
\n \/\/ \u5224\u65ad\u4e00\u4e2a\u6587\u4ef6\u662f\u5426\u662f\u4e00\u4e2a\u76ee\u5f55
\n static bool IsDirectory(const std::string &filename)
\n {
\n struct stat st;
\n int ret = stat(filename.c_str(), &st);
\n if (ret < 0)
\n {
\n return false;
\n }
\n return S_ISDIR(st.st_mode);
\n }
\n \/\/ \u5224\u65ad\u4e00\u4e2a\u6587\u4ef6\u662f\u5426\u662f\u4e00\u4e2a\u666e\u901a\u6587\u4ef6
\n static bool IsRegular(const std::string &filename)
\n {
\n struct stat st;
\n int ret = stat(filename.c_str(), &st);
\n if (ret < 0)
\n {
\n return false;
\n }
\n return S_ISREG(st.st_mode);
\n }
\n \/\/ http\u8bf7\u6c42\u7684\u8d44\u6e90\u8def\u5f84\u6709\u6548\u6027\u5224\u65ad
\n \/\/ \/index.html — \u524d\u9762\u7684\/\u4e5f\u53eb\u505a\u76f8\u5bf9\u76ee\u5f55 \u6620\u5c04\u7684\u662f\u67d0\u4e2a\u670d\u52a1\u5668\u4e0a\u7684\u5b50\u76ee\u5f55
\n \/\/ \u60f3\u8868\u8fbe\u7684\u610f\u601d\u5c31\u662f，\u5ba2\u6237\u7aef\u53ea\u80fd\u8bf7\u6c42\u76f8\u5bf9\u6839\u76ee\u5f55\u4e2d\u7684\u8d44\u6e90，\u5176\u4ed6\u5730\u65b9\u5c31\u4e0d\u4e88\u7406\u4f1a
\n \/\/ \/..\/login.html\u8fd9\u4e2a\u8def\u5f84\u662f\u5728\u76f8\u5bf9\u6839\u76ee\u5f55\u4e4b\u5916，\u4e0d\u5408\u7406
\n static bool ValidPath(const std::string &path)
\n {
\n std::vector<std::string> subdir;
\n Split(path, "\/", &subdir);
\n int level = 0;
\n for (auto &dir : subdir)
\n {
\n if (dir == "..")
\n {
\n level–;
\n if (level < 0)
\n {
\n return false;
\n }
\n continue;
\n }
\n level++;
\n }
\n return true;
\n }
\n}; <\/p>\n
\u8fd9\u4e2a\u6a21\u5757\u662fHTTP\u8bf7\u6c42\u6570\u636e\u6a21\u5757，\u7528\u4e8e\u4fdd\u5b58HTTP\u8bf7\u6c42\u6570\u636e\u88ab\u89e3\u6790\u540e\u7684\u5404\u9879\u8bf7\u6c42\u5143\u7d20\u4fe1\u606f<\/p>\n
\u5148\u7ed9\u51fa\u4e00\u4e2aHTTP\u8bf7\u6c42\u7684\u4f8b\u5b50<\/p>\n
GET \/index.html HTTP\/1.1
\nHost: example.com
\nUser-Agent: Mozilla\/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit\/537.36 (KHTML, like Gecko) Chrome\/91.0.4472.124 Safari\/537.36
\nAccept: text\/html,application\/xhtml+xml,application\/xml;q=0.9,image\/webp,*\/*;q=0.8
\nAccept-Language: en-US,en;q=0.5
\nAccept-Encoding: gzip, deflate, br
\nConnection: keep-alive <\/p>\n
\u6839\u636e\u4e0a\u9762\u7684\u8bf7\u6c42，\u6211\u4eec\u53ef\u4ee5\u8bbe\u8ba1\u51fa\u5982\u4e0b\u7684\u6210\u5458\u53d8\u91cf<\/p>\n
std::string _method; \/\/ \u8bf7\u6c42\u65b9\u6cd5
\nstd::string _path; \/\/ \u8d44\u6e90\u8def\u5f84
\nstd::string _version; \/\/ \u534f\u8bae\u7248\u672c
\nstd::string _body; \/\/ \u8bf7\u6c42\u6b63\u6587
\nstd::smatch _matches; \/\/ \u8d44\u6e90\u8def\u5f84\u7684\u6b63\u5219\u63d0\u53d6\u6570\u636e
\nstd::unordered_map<std::string, std::string> _headers; \/\/ \u5934\u90e8\u5b57\u6bb5
\nstd::unordered_map<std::string, std::string> _params; \/\/ \u67e5\u8be2\u5b57\u7b26\u4e32\u901a\u5e38\u6307\u7684\u662f URL \u4e2d\u7684\u67e5\u8be2\u53c2\u6570 <\/p>\n
\u7136\u540e\u662f\u5bf9\u5176\u4e2d\u7684\u6210\u5458\u51fd\u6570\u7684\u89e3\u91ca<\/p>\n
\u5173\u4e8e\u5bf9\u8fd9\u4e2a\u7c7b\u7684\u521d\u59cb\u5316，\u6211\u4eec\u9ed8\u8ba4\u5c06\u540c\u884c\u534f\u8bae\u7248\u672c\u8bbe\u7f6e\u4e3aHTTP\/1.1<\/p>\n
HttpRequest()
\n : _version("HTTP\/1.1")
\n{} <\/p>\n
\u5bf9\u7c7b\u7684\u6210\u5458\u53d8\u91cf\u8fdb\u884c\u91cd\u7f6e\u7684\u51fd\u6570<\/p>\n
void ReSet()
\n{
\n _method.clear();
\n _path.clear();
\n _version = "HTTP\/1.1";
\n _body.clear();
\n std::smatch match;
\n _matches.swap(match);
\n _headers.clear();
\n _params.clear();
\n} <\/p>\n
_headers\u662f\u4e00\u4e2a\u54c8\u5e0c\u8868，\u6211\u4eec\u8bbe\u8ba1\u4e00\u4e2a\u51fd\u6570SetHeader\u6765\u63d2\u5165\u5934\u90e8\u5b57\u6bb5<\/p>\n
void SetHeader(std::string &key, std::string &val)
\n{
\n _headers.insert(std::make_pair(key, val));
\n} <\/p>\n
HasHeader\u662f\u7528\u6765\u5224\u65ad\u662f\u5426\u5b58\u5728\u6307\u5b9a\u7684\u5934\u90e8\u5b57\u6bb5，\u5b9e\u73b0\u5b83\u5f88\u7b80\u5355，\u5229\u7528unordered_map\u4e2d\u7684find\u5373\u53ef<\/p>\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 }
\n return true;
\n} <\/p>\n
Content-Length\u662f\u5934\u90e8\u5b57\u6bb5\u7684\u4e00\u79cd，\u8868\u793a\u6b63\u6587\u957f\u5ea6，\u901a\u8fc7ContentLength\u51fd\u6570\u6765\u83b7\u53d6\u6b63\u6587\u7684\u957f\u5ea6<\/p>\n
size_t ContentLength() const
\n{
\n bool ret = HasHeader("Content-Length");
\n if (ret == false)
\n {
\n return 0;
\n }
\n std::string clen = GetHeader("Content-Length");
\n return std::stol(clen);
\n} <\/p>\n
\u4e0b\u9762\u662f\u8fd9\u4e2a\u7c7b\u7684\u5168\u90e8\u4ee3\u7801<\/p>\n
class HttpRequest
\n{
\npublic:
\n std::string _method; \/\/ \u8bf7\u6c42\u65b9\u6cd5
\n std::string _path; \/\/ \u8d44\u6e90\u8def\u5f84
\n std::string _version; \/\/ \u534f\u8bae\u7248\u672c
\n std::string _body; \/\/ \u8bf7\u6c42\u6b63\u6587
\n std::smatch _matches; \/\/ \u8d44\u6e90\u8def\u5f84\u7684\u6b63\u5219\u63d0\u53d6\u6570\u636e
\n std::unordered_map<std::string, std::string> _headers; \/\/ \u5934\u90e8\u5b57\u6bb5
\n std::unordered_map<std::string, std::string> _params; \/\/ \u67e5\u8be2\u5b57\u7b26\u4e32\u901a\u5e38\u6307\u7684\u662f URL \u4e2d\u7684\u67e5\u8be2\u53c2\u6570
\npublic:
\n HttpRequest()
\n : _version("HTTP\/1.1")
\n {
\n }
\n void ReSet()
\n {
\n _method.clear();
\n _path.clear();
\n _version = "HTTP\/1.1";
\n _body.clear();
\n std::smatch match;
\n _matches.swap(match);
\n _headers.clear();
\n _params.clear();
\n }
\n \/\/ \u63d2\u5165\u5934\u90e8\u5b57\u6bb5
\n void SetHeader(std::string &key, std::string &val)
\n {
\n _headers.insert(std::make_pair(key, val));
\n }
\n \/\/ \u5224\u65ad\u662f\u5426\u5b58\u5728\u6307\u5b9a\u5934\u90e8\u5b57\u6bb5
\n bool HasHeader(const std::string &key) const
\n {
\n auto it = _headers.find(key);
\n if (it == _headers.end())
\n {
\n return false;
\n }
\n return true;
\n }
\n \/\/ \u83b7\u53d6\u6307\u5b9a\u5934\u90e8\u5b57\u6bb5\u7684\u503c
\n std::string GetHeader(const std::string &key) const
\n {
\n auto it = _headers.find(key);
\n if (it == _headers.end())
\n {
\n return "";
\n }
\n return it->second;
\n }
\n \/\/ \u63d2\u5165\u67e5\u8be2\u5b57\u7b26\u4e32
\n void SetParam(const std::string &key, const std::string &val)
\n {
\n _params.insert(std::make_pair(key, val));
\n }
\n \/\/ \u5224\u65ad\u662f\u5426\u6709\u67d0\u4e2a\u6307\u5b9a\u7684\u67e5\u8be2\u5b57\u7b26\u4e32
\n bool HasParam(const std::string &key) const
\n {
\n auto it = _params.find(key);
\n if (it == _params.end())
\n {
\n return false;
\n }
\n return true;
\n }
\n \/\/ \u83b7\u53d6\u6307\u5b9a\u7684\u67e5\u8be2\u5b57\u7b26\u4e32
\n std::string GetParam(const std::string &key) const
\n {
\n auto it = _params.find(key);
\n if (it == _params.end())
\n {
\n return "";
\n }
\n return it->second;
\n }
\n \/\/ \u83b7\u53d6\u6b63\u6587\u957f\u5ea6
\n size_t ContentLength() const
\n {
\n bool ret = HasHeader("Content-Length");
\n if (ret == false)
\n {
\n return 0;
\n }
\n std::string clen = GetHeader("Content-Length");
\n return std::stol(clen);
\n }
\n \/\/ \u5224\u65ad\u662f\u5426\u4e3a\u77ed\u8fde\u63a5
\n bool Close() const
\n {
\n \/\/ \u6ca1\u6709Connection\u5b57\u6bb5\u6216\u8005\u6709Connection\u4f46\u662f\u503c\u662ffalse，\u5219\u90fd\u662f\u77ed\u8fde\u63a5，\u5426\u5219\u662f\u957f\u8fde\u63a5
\n \/\/ DBG_LOG("%d", HasHeader("Connection") == true);
\n \/\/ DBG_LOG("%d", GetHeader("Connection") == "keep-alive");
\n \/\/ DBG_LOG("[%s]", GetHeader("Connection").c_str());
\n if (HasHeader("Connection") == true && GetHeader("Connection") == "keep-alive")
\n {
\n return false;
\n }
\n return true;
\n }
\n};<\/p>\n
\u8fd9\u4e2a\u6a21\u5757\u662fHTTP\u54cd\u5e94\u6570\u636e\u6a21\u5757，\u7528\u4e8e\u4e1a\u52a1\u5904\u7406\u540e\u8bbe\u7f6e\u5e76\u4fdd\u5b58HTTp\u54cd\u5e94\u6570\u636e\u7684\u5404\u9879\u5143\u7d20\u4fe1\u606f，\u6700\u7ec8\u4f1a\u88ab\u6309\u7167HTTP\u534f\u8bae\u54cd\u5e94\u683c\u5f0f\u6210\u4e3a\u54cd\u5e94\u4fe1\u606f\u53d1\u9001\u7ed9\u5ba2\u6237\u7aef<\/p>\n
\u4e0b\u9762\u662f\u4e00\u4e2aHTTP\u54cd\u5e94\u7684\u4f8b\u5b50<\/p>\n
HTTP\/1.1 200 OK
\nDate: Sun, 18 May 2025 05:37:15 GMT
\nServer: Apache\/2.4.41 (Ubuntu)
\nContent-Type: text\/html; charset=UTF-8
\nContent-Length: 1256
\nConnection: keep-alive<\/p>\n
<!DOCTYPE html>
\n<html>
\n<head>
\n <title>Example Page<\/title>
\n<\/head>
\n<body>
\n <h1>Welcome to the Example Page<\/h1>
\n <p>This is a simple HTML page returned by the server.<\/p>
\n<\/body>
\n<\/html> <\/p>\n
\u4e0b\u9762\u7684\u6210\u5458\u53d8\u91cf\u5c31\u662f\u7528\u6765\u4fdd\u5b58\u4e0a\u9762\u793a\u4f8b\u62a5\u6587\u7684\u4fe1\u606f<\/p>\n
int _statu;
\nbool _redirect_flag;
\nstd::string _body;
\nstd::string _redirect_url;
\nstd::unordered_map<std::string, std::string> _headers; <\/p>\n
\u8fd9\u91cc\u6709\u4e00\u4e2a\u6210\u5458\u53d8\u91cf\u9700\u8981\u89e3\u91ca\u4e00\u4e0b<\/p>\n
_redirect_flag：\u8fd9\u662f\u4e00\u4e2a\u8868\u793a\u662f\u5426\u91cd\u5b9a\u5411\u7684\u53d8\u91cf，\u5728Web\u5f00\u53d1\u4e2d，HTTP\u91cd\u5b9a\u5411\u662f\u6307\u670d\u52a1\u5668\u8fd4\u56de\u4e00\u4e2a\u7279\u6b8a\u7684\u54cd\u5e94（\u6bd4\u5982\u72b6\u6001\u78013XX），\u8868\u793a\u6307\u793a\u5ba2\u6237\u7aef\u8bbf\u95ee\u53e6\u4e00\u4e2aURL<\/p>\n
\u7136\u540e\u5c31\u662f\u5bf9\u5176\u6210\u5458\u51fd\u6570\u7684\u89e3\u91ca<\/p>\n
\u6709\u65f6\u5019\u6211\u4eec\u9700\u8981\u91cd\u5b9a\u5411\u8fde\u63a5SetRedirect<\/p>\n
void SetRedirect(const std::string &url, int statu = 302)
\n{
\n _statu = statu;
\n _redirect_flag = true;
\n _redirect_url = url;
\n} <\/p>\n
\u7136\u540e\u5c31\u662f\u67e5\u770b\u8fd9\u4e2a\u94fe\u63a5\u662f\u957f\u8fde\u63a5\u8fd8\u662f\u77ed\u8fde\u63a5，\u6211\u4eec\u53ea\u9700\u8981\u67e5\u770bConnection\u5b57\u6bb5，\u5982\u679c\u8fd9\u4e2a\u5b57\u6bb5\u7684value\u503c\u662fkeep-alive\u8868\u793a\u662f\u957f\u8fde\u63a5<\/p>\n
bool Close()
\n{
\n \/\/ \u6ca1\u6709Connection\u5b57\u6bb5\u6216\u8005\u6709Connection\u4f46\u662f\u503c\u662ffalse，\u5219\u90fd\u662f\u77ed\u8fde\u63a5，\u5426\u5219\u662f\u957f\u8fde\u63a5
\n if (HasHeader("Connection") == true && GetHeader("Connection") == "keep-alive")
\n {
\n return false;
\n }
\n return true;
\n} <\/p>\n
\u4e0b\u9762\u662f\u8fd9\u4e2a\u7c7b\u7684\u5168\u90e8\u4ee3\u7801<\/p>\n
class HttpResponse
\n{
\npublic:
\n int _statu;
\n bool _redirect_flag;
\n std::string _body;
\n \/\/ \u91cd\u5b9a\u5411
\n \/\/ \u5728Web\u5f00\u53d1\u4e2d，HTTP \u91cd\u5b9a\u5411\u662f\u6307\u670d\u52a1\u5668\u8fd4\u56de\u4e00\u4e2a\u7279\u6b8a\u7684\u54cd\u5e94（\u72b6\u6001\u78013xx），
\n \/\/ \u6307\u793a\u5ba2\u6237\u7aef（\u5982\u6d4f\u89c8\u5668）\u8bbf\u95ee\u53e6\u4e00\u4e2aURL\u3002
\n std::string _redirect_url;
\n std::unordered_map<std::string, std::string> _headers;<\/p>\n
public:
\n HttpResponse()
\n : _redirect_flag(false),
\n _statu(200)
\n {
\n }
\n HttpResponse(int statu)
\n : _redirect_flag(false),
\n _statu(statu)
\n {
\n }
\n void ReSet()
\n {
\n _statu = 200;
\n _redirect_flag = false;
\n _body.clear();
\n _redirect_url.clear();
\n _headers.clear();
\n }
\n \/\/ \u63d2\u5165\u5934\u90e8\u5b57\u6bb5
\n void SetHeader(const std::string &key, const std::string &val)
\n {
\n _headers.insert(std::make_pair(key, val));
\n }
\n \/\/ \u5224\u65ad\u662f\u5426\u5b58\u5728\u6307\u5b9a\u5934\u90e8\u5b57\u6bb5
\n bool HasHeader(const std::string &key)
\n {
\n auto it = _headers.find(key);
\n if (it == _headers.end())
\n {
\n return false;
\n }
\n return true;
\n }
\n \/\/ \u83b7\u53d6\u6307\u5b9a\u5934\u90e8\u5b57\u6bb5\u7684\u503c
\n std::string GetHeader(const std::string &key)
\n {
\n auto it = _headers.find(key);
\n if (it == _headers.end())
\n {
\n return "";
\n }
\n return it->second;
\n }
\n void SetContent(const std::string &body, const std::string &type = "text\/html")
\n {
\n _body = body;
\n SetHeader("Content-Type", type);
\n }
\n void SetRedirect(const std::string &url, int statu = 302)
\n {
\n _statu = statu;
\n _redirect_flag = true;
\n _redirect_url = url;
\n }
\n bool Close()
\n {
\n \/\/ \u6ca1\u6709Connection\u5b57\u6bb5\u6216\u8005\u6709Connection\u4f46\u662f\u503c\u662ffalse，\u5219\u90fd\u662f\u77ed\u8fde\u63a5，\u5426\u5219\u662f\u957f\u8fde\u63a5
\n if (HasHeader("Connection") == true && GetHeader("Connection") == "keep-alive")
\n {
\n return false;
\n }
\n return true;
\n }
\n}; <\/p>\n
\u8fd9\u4e2a\u6a21\u5757\u662f\u4e00\u4e2aHTTP\u8bf7\u6c42\u63a5\u53d7\u7684\u4e0a\u4e0b\u6587\u6a21\u5757，\u4e3b\u8981\u662f\u4e3a\u4e86\u9632\u6b62\u518d\u4e00\u6b21\u63a5\u6536\u7684\u6570\u636e\u4e2d，\u4e0d\u662f\u4e00\u4e2a\u5b8c\u6574\u7684HTTP\u8bf7\u6c42，\u5219\u89e3\u6790\u8fc7\u7a0b\u5e76\u672a\u5b8c\u6210，\u65e0\u6cd5\u8fdb\u884c\u5b8c\u6574\u7684\u8bf7\u6c42\u5904\u7406，\u9700\u8981\u5728\u4e0b\u6b21\u63a5\u53d7\u5230\u65b0\u6570\u636e\u540e\u7ee7\u7eed\u6839\u636e\u4e0a\u4e0b\u6587\u8fdb\u884c\u89e3\u6790，\u6700\u7ec8\u5f97\u5230\u4e00\u4e2aHttpRequest\u8bf7\u6c42\u4fe1\u606f\u5bf9\u8c61，\u56e0\u6b64\u5728\u8bf7\u6c42\u6570\u636e\u7684\u63a5\u53d7\u4ee5\u53ca\u89e3\u6790\u90e8\u5206\u9700\u8981\u4e00\u4e2a\u4e0a\u4e0b\u6587\u6765\u8fdb\u884c\u63a7\u5236\u63a5\u6536\u548c\u5904\u7406\u8282\u594f<\/p>\n
\u9996\u5148\u63a5\u6536\u5bf9\u5e94\u591a\u79cd\u72b6\u6001\u7801，\u8fd9\u91cc\u51c6\u5907\u4e86\u4e94\u79cd<\/p>\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
\u7136\u540e\u5c31\u662f\u8fd9\u4e2a\u7c7b\u5bf9\u5e94\u7684\u6210\u5458\u53d8\u91cf<\/p>\n
int _resp_statu; \/\/ \u76f8\u5e94\u72b6\u6001\u7801
\nHttpRecvStatu _recv_statu; \/\/ \u5f53\u524d\u63a5\u6536\u53ca\u89e3\u6790\u7684\u9636\u6bb5\u72b6\u6001
\nHttpRequest _request; \/\/ \u5df2\u7ecf\u89e3\u6790\u5f97\u5230\u7684\u8bf7\u6c42\u4fe1\u606f <\/p>\n
\u4e0b\u9762\u662f\u5176\u5bf9\u5e94\u7684\u6210\u5458\u51fd\u6570<\/p>\n
\u6211\u4eec\u9700\u8981\u5bf9\u8bf7\u6c42\u884c\u8fdb\u884c\u89e3\u6790，\u4f7f\u7528ParseHttpLine\u51fd\u6570，\u4f20\u5165\u7684\u53c2\u6570\u4e3astring\u7c7b\u578b\u7684\u8bf7\u6c42\u884c<\/p>\n
bool ParseHttpLine(const std::string &line)
\n{
\n \/\/ std::cout << "string " << line << std::endl;
\n std::smatch matches;
\n std::regex e("(GET|HEAD|POST|PUT|DELETE) ([^?]*)(?:\\\\\\\\?(.*))? (HTTP\/1\\\\\\\\.[01])(?:\\\\n|\\\\r\\\\n)?", std::regex::icase);
\n bool ret = std::regex_match(line, matches, e);
\n if (ret == false)
\n {
\n std::cout << line << std::endl;
\n \/\/ std::cout << "ParseHttpLine 1 error" << std::endl;
\n _recv_statu = RECV_HTTP_ERROR;
\n _resp_statu = 400;
\n return false;
\n }
\n \/\/ \u8bf7\u6c42\u65b9\u6cd5\u7684\u83b7\u53d6
\n _request._method = matches[1];
\n std::transform(_request._method.begin(), _request._method.end(), _request._method.begin(), ::toupper);
\n \/\/ \u8d44\u6e90\u8def\u5f84\u7684\u83b7\u53d6，\u9700\u8981\u8fdb\u884cURL\u89e3\u7801\u64cd\u4f5c，\u4f46\u662f\u4e0d\u9700\u8981+\u8f6c\u7a7a\u683c
\n _request._path = Util::UrlDecode(matches[2], false);
\n \/\/ \u534f\u8bae\u7248\u672c\u7684\u83b7\u53d6
\n _request._version = matches[4];
\n \/\/ \u67e5\u8be2\u5b57\u7b26\u4e32\u7684\u8bfb\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=value&key=value… ,\u5148\u4ee5&\u7b26\u53f7\u8fdb\u884c\u5206\u5272，\u5f97\u5230\u5404\u4e2a\u5b50\u4e32
\n Util::Split(query_string, "&", &query_string_arry);
\n \/\/ \u9488\u5bf9\u5404\u4e2a\u5b50\u4e32，\u4ee5 = \u7b26\u53f7\u8fdb\u884c\u5206\u5272，\u5f97\u5230key \u548c val，\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 \/\/ \u6ca1\u6709\u627e\u5230
\n \/\/ std::cout << "ParseHttpLine 2 error" << std::endl;
\n _recv_statu = RECV_HTTP_ERROR;
\n _resp_statu = 400;
\n return false;
\n }
\n std::string key = Util::UrlDecode(str.substr(0, pos), true);
\n std::string val = Util::UrlDecode(str.substr(pos + 1), true);
\n _request.SetParam(key, val);
\n }
\n return true;
\n} <\/p>\n
\u63a5\u6536\u8bf7\u6c42\u884c\u7684\u903b\u8f91\u8f83\u4e3a\u7b80\u5355，\u4e0d\u591a\u8d58\u8ff0<\/p>\n
bool RecvHttpLine(Buffer *buf)
\n{
\n if (_recv_statu != RECV_HTTP_LINE)
\n return false;
\n \/\/ 1.\u83b7\u53d6\u4e00\u884c\u6570\u636e
\n std::string line = buf->GetLineAndPop();
\n \/\/ std::cout << line << " " << "RecvHttpLine" << std::endl;
\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 {
\n \/\/ \u7f13\u51b2\u533a\u4e2d\u7684\u6570\u636e\u4e0d\u8db3\u4e00\u884c，\u5219\u9700\u8981\u5224\u65ad\u7f13\u51b2\u533a\u4e2d\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 {
\n _recv_statu = RECV_HTTP_ERROR;
\n _resp_statu = 414; \/\/ URI TOO LONG
\n return false;
\n }
\n \/\/ \u7f13\u51b2\u533a\u4e2d\u6570\u636e\u4e0d\u8db3\u4e00\u884c，\u4f46\u662f\u4e5f\u4e0d\u591a，\u5c31\u7b49\u7b49\u65b0\u6570\u636e\u7684\u5230\u6765
\n return true;
\n }
\n if (line.size() > MAX_LINE)
\n {
\n _recv_statu = RECV_HTTP_ERROR;
\n _resp_statu = 414; \/\/ URI TOO LONG
\n return false;
\n }
\n bool ret = ParseHttpLine(line);
\n if (ret == false)
\n {
\n return false;
\n }
\n \/\/ buf->MoveReadOffset(line.size());
\n _recv_statu = RECV_HTTP_HEAD;
\n return true;
\n \/\/ return ParseHttpLine(line);
\n} <\/p>\n
\u63a5\u53d7\u8bf7\u6c42\u5934，\u4e00\u884c\u4e00\u884c\u5730\u53d6\u51fakey:value\u7c7b\u578b\u7684\u6570\u636e，\u76f4\u5230\u9047\u5230\u7a7a\u884c\u505c\u6b62<\/p>\n
bool RecvHttpHead(Buffer *buf)
\n{
\n if (_recv_statu != RECV_HTTP_HEAD)
\n return false;
\n \/\/ \u4e00\u884c\u4e00\u884c\u53d6\u51fa\u6570\u636e，\u76f4\u5230\u9047\u5230\u7a7a\u884c\u4e3a\u6b62
\n \/\/ \u5e76\u4e14\u5934\u90e8\u7684\u683c\u5f0f\u4e3akey:val\\\\r\\\\nkey:val\\\\r\\\\n
\n while (1)
\n {
\n \/\/ 1.\u83b7\u53d6\u4e00\u884c\u6570\u636e
\n std::string line = buf->GetLineAndPop();
\n \/\/ std::cout << "RecvHttpHead " << line << std::endl;
\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 {
\n \/\/ \u7f13\u51b2\u533a\u4e2d\u7684\u6570\u636e\u4e0d\u8db3\u4e00\u884c，\u5219\u9700\u8981\u5224\u65ad\u7f13\u51b2\u533a\u4e2d\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 {
\n _recv_statu = RECV_HTTP_ERROR;
\n _resp_statu = 414; \/\/ URI TOO LONG
\n return false;
\n }
\n \/\/ \u7f13\u51b2\u533a\u4e2d\u6570\u636e\u4e0d\u8db3\u4e00\u884c，\u4f46\u662f\u4e5f\u4e0d\u591a，\u5c31\u7b49\u7b49\u65b0\u6570\u636e\u7684\u5230\u6765
\n return true;
\n }
\n if (line.size() > MAX_LINE)
\n {
\n _recv_statu = RECV_HTTP_ERROR;
\n _resp_statu = 414; \/\/ URI TOO LONG
\n return false;
\n }
\n if (line == "\\\\n" || line == "\\\\r\\\\n")
\n {
\n break;
\n }
\n bool ret = ParseHttpHead(line);
\n if (ret == false)
\n {
\n return false;
\n }
\n }
\n _recv_statu = RECV_HTTP_BODY;
\n return true;
\n} <\/p>\n
\u89e3\u6790\u8bf7\u6c42\u5934，\u628a\u5192\u53f7\u52a0\u7a7a\u683c（: ）\u4f5c\u4e3a\u5206\u9694\u7b26\u53bb\u627e\u5176key\u548cvalue\u503c，\u5e76\u8fdb\u884c\u5b58\u50a8<\/p>\n
bool ParseHttpHead(std::string &line)
\n{
\n if (line.back() == '\\\\n')
\n line.pop_back(); \/\/ \u672b\u5c3e\u662f\u6362\u884c，\u5219\u53bb\u6389
\n if (line.back() == '\\\\r')
\n line.pop_back(); \/\/ \u6709\u56de\u8f66，\u5219\u53bb\u6389
\n size_t pos = line.find(": ");
\n if (pos == std::string::npos)
\n {
\n \/\/ std::cout << "ParseHttpHead error" << std::endl;
\n _recv_statu = RECV_HTTP_ERROR;
\n _resp_statu = 400;
\n return false;
\n }
\n std::string key = line.substr(0, pos);
\n std::string val = line.substr(pos + 2);
\n _request.SetHeader(key, val);
\n return true;
\n} <\/p>\n
\u63a5\u6536\u6b63\u6587\u90e8\u5206，\u4e3b\u8981\u5206\u4e3a\u4e09\u6b65<\/p>\n
bool ParseHttpHead(std::string &line)
\n{
\n if (line.back() == '\\\\n')
\n line.pop_back(); \/\/ \u672b\u5c3e\u662f\u6362\u884c，\u5219\u53bb\u6389
\n if (line.back() == '\\\\r')
\n line.pop_back(); \/\/ \u6709\u56de\u8f66，\u5219\u53bb\u6389
\n size_t pos = line.find(": ");
\n if (pos == std::string::npos)
\n {
\n \/\/ std::cout << "ParseHttpHead error" << std::endl;
\n _recv_statu = RECV_HTTP_ERROR;
\n _resp_statu = 400;
\n return false;
\n }
\n std::string key = line.substr(0, pos);
\n std::string val = line.substr(pos + 2);
\n _request.SetHeader(key, val);
\n return true;
\n}
\nbool RecvHttpBody(Buffer *buf)
\n{
\n if (_recv_statu != RECV_HTTP_BODY)
\n return false;
\n \/\/ 1.\u83b7\u53d6\u6b63\u6587\u957f\u5ea6
\n size_t content_length = _request.ContentLength();
\n if (content_length == 0)
\n {
\n \/\/ \u6ca1\u6709\u6b63\u6587，\u5219\u8bf7\u6c42\u63a5\u6536\u8bf7\u6c42\u5b8c\u6bd5
\n _recv_statu = RECV_HTTP_OVER;
\n return true;
\n }
\n \/\/ 2.\u5f53\u524d\u5df2\u7ecf\u63a5\u6536\u4e86\u591a\u5c11\u6b63\u6587，\u5176\u5b9e\u5c31\u662f\u5f80_request._body\u4e2d\u653e\u4e86\u591a\u5c11\u6570\u636e
\n size_t real_len = content_length – _request._body.size(); \/\/ \u5b9e\u9645\u8fd8\u9700\u8981\u63a5\u53d7\u7684\u6b63\u6587\u957f\u5ea6
\n \/\/ 3.\u63a5\u6536\u6b63\u6587\u653e\u5230body\u4e2d，\u4f46\u662f\u4e5f\u8981\u8003\u8651\u5f53\u524d\u7f13\u51b2\u533a\u4e2d\u7684\u6570\u636e\u662f\u5426\u662f\u5168\u90e8\u7684\u6b63\u6587
\n \/\/ 3.1\u7f13\u51b2\u533a\u4e2d\u7684\u6570\u636e，\u5305\u542b\u4e86\u5f53\u524d\u8bf7\u6c42\u7684\u6240\u6709\u6b63\u6587，\u53d6\u51fa\u6240\u9700\u7684\u6570\u636e
\n if (buf->ReadAbleSize() >= real_len)
\n {
\n _request._body.append(buf->ReadPosition(), real_len);
\n buf->MoveReadOffset(real_len);
\n _recv_statu = RECV_HTTP_OVER;
\n return true;
\n }<\/p>\n
\/\/ 3.2\u7f13\u51b2\u533a\u4e2d\u7684\u6570\u636e，\u65e0\u6cd5\u6ee1\u8db3\u5f53\u524d\u6b63\u6587\u7684\u9700\u8981，\u6570\u636e\u4e0d\u8db3，\u53d6\u51fa\u6570\u636e，\u7136\u540e\u7b49\u5f85\u65b0\u6570\u636e\u5230\u6765
\n _request._body.append(buf->ReadPosition(), buf->ReadAbleSize());
\n buf->MoveReadOffset(buf->ReadAbleSize());
\n return true;
\n} <\/p>\n
\u63a5\u6536\u5e76\u89e3\u6790Http\u8bf7\u6c42，\u6211\u4eec\u4f7f\u7528RecvHttpRequest\u51fd\u6570，\u7136\u540e\u4f7f\u7528switch\u5173\u952e\u5b57，\u901a\u8fc7\u72b6\u6001\u7801\u6765\u5224\u65ad\u505a\u4ec0\u4e48\u4e8b\u60c5<\/p>\n
void RecvHttpRequest(Buffer *buf)
\n{
\n \/\/ buf->TestPrint();
\n \/\/ \u4e0d\u540c\u7684\u72b6\u6001，\u505a\u4e0d\u540c\u7684\u4e8b\u60c5
\n \/\/ \u4e0d\u9700\u8981\u52a0\u5165break，\u5b8c\u6210\u4e00\u6b65\u540e\u76f4\u63a5\u8fdb\u884c\u4e0b\u4e00\u6b65
\n switch (_recv_statu)
\n {
\n case RECV_HTTP_LINE:
\n RecvHttpLine(buf);
\n case RECV_HTTP_HEAD:
\n RecvHttpHead(buf);
\n case RECV_HTTP_BODY:
\n RecvHttpBody(buf);
\n }
\n return;
\n} <\/p>\n
\u4e0b\u9762\u662f\u5168\u90e8\u4ee3\u7801<\/p>\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 8192 \/\/ \u901a\u5e38\u8bbe\u7f6e\u4e3a8kb
\nclass HttpContext
\n{
\nprivate:
\n int _resp_statu; \/\/ \u76f8\u5e94\u72b6\u6001\u7801
\n HttpRecvStatu _recv_statu; \/\/ \u5f53\u524d\u63a5\u6536\u53ca\u89e3\u6790\u7684\u9636\u6bb5\u72b6\u6001
\n HttpRequest _request; \/\/ \u5df2\u7ecf\u89e3\u6790\u5f97\u5230\u7684\u8bf7\u6c42\u4fe1\u606f
\nprivate:
\n \/\/ \u89e3\u6790\u8bf7\u6c42\u884c
\n bool ParseHttpLine(const std::string &line)
\n {
\n \/\/ std::cout << "string " << line << std::endl;
\n std::smatch matches;
\n std::regex e("(GET|HEAD|POST|PUT|DELETE) ([^?]*)(?:\\\\\\\\?(.*))? (HTTP\/1\\\\\\\\.[01])(?:\\\\n|\\\\r\\\\n)?", std::regex::icase);
\n bool ret = std::regex_match(line, matches, e);
\n if (ret == false)
\n {
\n std::cout << line << std::endl;
\n \/\/ std::cout << "ParseHttpLine 1 error" << std::endl;
\n _recv_statu = RECV_HTTP_ERROR;
\n _resp_statu = 400;
\n return false;
\n }
\n \/\/ \u8bf7\u6c42\u65b9\u6cd5\u7684\u83b7\u53d6
\n _request._method = matches[1];
\n std::transform(_request._method.begin(), _request._method.end(), _request._method.begin(), ::toupper);
\n \/\/ \u8d44\u6e90\u8def\u5f84\u7684\u83b7\u53d6，\u9700\u8981\u8fdb\u884cURL\u89e3\u7801\u64cd\u4f5c，\u4f46\u662f\u4e0d\u9700\u8981+\u8f6c\u7a7a\u683c
\n _request._path = Util::UrlDecode(matches[2], false);
\n \/\/ \u534f\u8bae\u7248\u672c\u7684\u83b7\u53d6
\n _request._version = matches[4];
\n \/\/ \u67e5\u8be2\u5b57\u7b26\u4e32\u7684\u8bfb\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=value&key=value… ,\u5148\u4ee5&\u7b26\u53f7\u8fdb\u884c\u5206\u5272，\u5f97\u5230\u5404\u4e2a\u5b50\u4e32
\n Util::Split(query_string, "&", &query_string_arry);
\n \/\/ \u9488\u5bf9\u5404\u4e2a\u5b50\u4e32，\u4ee5 = \u7b26\u53f7\u8fdb\u884c\u5206\u5272，\u5f97\u5230key \u548c val，\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 \/\/ \u6ca1\u6709\u627e\u5230
\n \/\/ std::cout << "ParseHttpLine 2 error" << std::endl;
\n _recv_statu = RECV_HTTP_ERROR;
\n _resp_statu = 400;
\n return false;
\n }
\n std::string key = Util::UrlDecode(str.substr(0, pos), true);
\n std::string val = Util::UrlDecode(str.substr(pos + 1), true);
\n _request.SetParam(key, val);
\n }
\n return true;
\n }
\n \/\/ \u63a5\u6536\u8bf7\u6c42\u884c
\n bool RecvHttpLine(Buffer *buf)
\n {
\n if (_recv_statu != RECV_HTTP_LINE)
\n return false;
\n \/\/ 1.\u83b7\u53d6\u4e00\u884c\u6570\u636e
\n std::string line = buf->GetLineAndPop();
\n \/\/ std::cout << line << " " << "RecvHttpLine" << std::endl;
\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 {
\n \/\/ \u7f13\u51b2\u533a\u4e2d\u7684\u6570\u636e\u4e0d\u8db3\u4e00\u884c，\u5219\u9700\u8981\u5224\u65ad\u7f13\u51b2\u533a\u4e2d\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 {
\n _recv_statu = RECV_HTTP_ERROR;
\n _resp_statu = 414; \/\/ URI TOO LONG
\n return false;
\n }
\n \/\/ \u7f13\u51b2\u533a\u4e2d\u6570\u636e\u4e0d\u8db3\u4e00\u884c，\u4f46\u662f\u4e5f\u4e0d\u591a，\u5c31\u7b49\u7b49\u65b0\u6570\u636e\u7684\u5230\u6765
\n return true;
\n }
\n if (line.size() > MAX_LINE)
\n {
\n _recv_statu = RECV_HTTP_ERROR;
\n _resp_statu = 414; \/\/ URI TOO LONG
\n return false;
\n }
\n bool ret = ParseHttpLine(line);
\n if (ret == false)
\n {
\n return false;
\n }
\n \/\/ buf->MoveReadOffset(line.size());
\n _recv_statu = RECV_HTTP_HEAD;
\n return true;
\n \/\/ return ParseHttpLine(line);
\n }
\n bool RecvHttpHead(Buffer *buf)
\n {
\n if (_recv_statu != RECV_HTTP_HEAD)
\n return false;
\n \/\/ \u4e00\u884c\u4e00\u884c\u53d6\u51fa\u6570\u636e，\u76f4\u5230\u9047\u5230\u7a7a\u884c\u4e3a\u6b62
\n \/\/ \u5e76\u4e14\u5934\u90e8\u7684\u683c\u5f0f\u4e3akey:val\\\\r\\\\nkey:val\\\\r\\\\n
\n while (1)
\n {
\n \/\/ 1.\u83b7\u53d6\u4e00\u884c\u6570\u636e
\n std::string line = buf->GetLineAndPop();
\n \/\/ std::cout << "RecvHttpHead " << line << std::endl;
\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 {
\n \/\/ \u7f13\u51b2\u533a\u4e2d\u7684\u6570\u636e\u4e0d\u8db3\u4e00\u884c，\u5219\u9700\u8981\u5224\u65ad\u7f13\u51b2\u533a\u4e2d\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 {
\n _recv_statu = RECV_HTTP_ERROR;
\n _resp_statu = 414; \/\/ URI TOO LONG
\n return false;
\n }
\n \/\/ \u7f13\u51b2\u533a\u4e2d\u6570\u636e\u4e0d\u8db3\u4e00\u884c，\u4f46\u662f\u4e5f\u4e0d\u591a，\u5c31\u7b49\u7b49\u65b0\u6570\u636e\u7684\u5230\u6765
\n return true;
\n }
\n if (line.size() > MAX_LINE)
\n {
\n _recv_statu = RECV_HTTP_ERROR;
\n _resp_statu = 414; \/\/ URI TOO LONG
\n return false;
\n }
\n if (line == "\\\\n" || line == "\\\\r\\\\n")
\n {
\n break;
\n }
\n bool ret = ParseHttpHead(line);
\n if (ret == false)
\n {
\n return false;
\n }
\n }
\n _recv_statu = RECV_HTTP_BODY;
\n return true;
\n }
\n bool ParseHttpHead(std::string &line)
\n {
\n if (line.back() == '\\\\n')
\n line.pop_back(); \/\/ \u672b\u5c3e\u662f\u6362\u884c，\u5219\u53bb\u6389
\n if (line.back() == '\\\\r')
\n line.pop_back(); \/\/ \u6709\u56de\u8f66，\u5219\u53bb\u6389
\n size_t pos = line.find(": ");
\n if (pos == std::string::npos)
\n {
\n \/\/ std::cout << "ParseHttpHead error" << std::endl;
\n _recv_statu = RECV_HTTP_ERROR;
\n _resp_statu = 400;
\n return false;
\n }
\n std::string key = line.substr(0, pos);
\n std::string val = line.substr(pos + 2);
\n _request.SetHeader(key, val);
\n return true;
\n }
\n bool RecvHttpBody(Buffer *buf)
\n {
\n if (_recv_statu != RECV_HTTP_BODY)
\n return false;
\n \/\/ 1.\u83b7\u53d6\u6b63\u6587\u957f\u5ea6
\n size_t content_length = _request.ContentLength();
\n if (content_length == 0)
\n {
\n \/\/ \u6ca1\u6709\u6b63\u6587，\u5219\u8bf7\u6c42\u63a5\u6536\u8bf7\u6c42\u5b8c\u6bd5
\n _recv_statu = RECV_HTTP_OVER;
\n return true;
\n }
\n \/\/ 2.\u5f53\u524d\u5df2\u7ecf\u63a5\u6536\u4e86\u591a\u5c11\u6b63\u6587，\u5176\u5b9e\u5c31\u662f\u5f80_request._body\u4e2d\u653e\u4e86\u591a\u5c11\u6570\u636e
\n size_t real_len = content_length – _request._body.size(); \/\/ \u5b9e\u9645\u8fd8\u9700\u8981\u63a5\u53d7\u7684\u6b63\u6587\u957f\u5ea6
\n \/\/ 3.\u63a5\u6536\u6b63\u6587\u653e\u5230body\u4e2d，\u4f46\u662f\u4e5f\u8981\u8003\u8651\u5f53\u524d\u7f13\u51b2\u533a\u4e2d\u7684\u6570\u636e\u662f\u5426\u662f\u5168\u90e8\u7684\u6b63\u6587
\n \/\/ 3.1\u7f13\u51b2\u533a\u4e2d\u7684\u6570\u636e，\u5305\u542b\u4e86\u5f53\u524d\u8bf7\u6c42\u7684\u6240\u6709\u6b63\u6587，\u53d6\u51fa\u6240\u9700\u7684\u6570\u636e
\n if (buf->ReadAbleSize() >= real_len)
\n {
\n _request._body.append(buf->ReadPosition(), real_len);
\n buf->MoveReadOffset(real_len);
\n _recv_statu = RECV_HTTP_OVER;
\n return true;
\n }<\/p>\n
\/\/ 3.2\u7f13\u51b2\u533a\u4e2d\u7684\u6570\u636e，\u65e0\u6cd5\u6ee1\u8db3\u5f53\u524d\u6b63\u6587\u7684\u9700\u8981，\u6570\u636e\u4e0d\u8db3，\u53d6\u51fa\u6570\u636e，\u7136\u540e\u7b49\u5f85\u65b0\u6570\u636e\u5230\u6765
\n _request._body.append(buf->ReadPosition(), buf->ReadAbleSize());
\n buf->MoveReadOffset(buf->ReadAbleSize());
\n return true;
\n }<\/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 RespStatu()
\n {
\n return _resp_statu;
\n }
\n HttpRecvStatu RecvStatu()
\n {
\n return _recv_statu;
\n }
\n HttpRequest &Request()
\n {
\n return _request;
\n }
\n \/\/ \u63a5\u6536\u5e76\u89e3\u6790Http\u8bf7\u6c42
\n void RecvHttpRequest(Buffer *buf)
\n {
\n \/\/ buf->TestPrint();
\n \/\/ \u4e0d\u540c\u7684\u72b6\u6001，\u505a\u4e0d\u540c\u7684\u4e8b\u60c5
\n \/\/ \u4e0d\u9700\u8981\u52a0\u5165break，\u5b8c\u6210\u4e00\u6b65\u540e\u76f4\u63a5\u8fdb\u884c\u4e0b\u4e00\u6b65
\n switch (_recv_statu)
\n {
\n case RECV_HTTP_LINE:
\n RecvHttpLine(buf);
\n case RECV_HTTP_HEAD:
\n RecvHttpHead(buf);
\n case RECV_HTTP_BODY:
\n RecvHttpBody(buf);
\n }
\n return;
\n }
\n}; <\/p>\n
\u9996\u5148\u662f\u5176\u6210\u5458\u53d8\u91cf<\/p>\n
using Handler = std::function<void(const HttpRequest &, HttpResponse *)>;
\nusing Handlers = std::vector<std::pair<std::regex, Handler>>;
\nHandlers _get_route;
\nHandlers _post_route;
\nHandlers _put_route;
\nHandlers _delete_route;
\nstd::string _basedir; \/\/ \u9759\u6001\u8d44\u6e90\u6839\u76ee\u5f55
\nTcpServer _server; <\/p>\n
\u7136\u540e\u5c31\u662f\u5176\u6210\u5458\u51fd\u6570<\/p>\n
\u5173\u4e8e\u5bf9\u9519\u8bef\u7684\u5904\u7406ErrorHandler，\u6211\u4eec\u4f7f\u7528\u7b80\u5355\u7684Html\u5199\u4e00\u4e2a\u9875\u9762\u653e\u5230string\u4e2d，\u7136\u540e\u653e\u5165rsp\u5373\u53ef<\/p>\n
void ErrorHandler(const HttpRequest &req, HttpResponse *rsp)
\n{
\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\u505a\u54cd\u5e94\u6b63\u6587，\u653e\u5165rsp\u4e2d
\n rsp->SetContent(body, "text\/html");
\n} <\/p>\n
\u5c06HttpResponse\u4e2d\u7684\u8981\u7d20\u6309\u7167http\u534f\u8bae\u683c\u5f0f\u8fdb\u884c\u7ec4\u7ec7\u53d1\u9001<\/p>\n
void WriteResponse(const PtrConnection &conn, const HttpRequest &req, HttpResponse &rsp)
\n{
\n \/\/ 1.\u5148\u5b8c\u5584\u5934\u90e8\u5b57\u6bb5
\n \/\/ req\u662fconst，\u8c03\u7528\u7684Close\u4e5f\u5fc5\u987b\u662fconst\u7c7b\u578b
\n if (req.Close() == true)
\n {
\n rsp.SetHeader("Connection", "close");
\n }
\n else
\n {
\n rsp.SetHeader("Connection", "keep-alive");
\n }
\n if (rsp._body.empty() == false && rsp.HasHeader("Content-Length") == false)
\n {
\n rsp.SetHeader("Content-Length", std::to_string(rsp._body.size()));
\n }
\n if (rsp._body.empty() == false && rsp.HasHeader("Content-Type") == false)
\n {
\n rsp.SetHeader("Content-Type", "application\/octet-stream"); \/\/ \u4e8c\u8fdb\u5236\u6d41
\n }
\n if (rsp._redirect_flag == true)
\n {
\n rsp.SetHeader("Location", rsp._redirect_url);
\n }
\n \/\/ 2.\u5c06rsp\u7684\u8981\u7d20，\u6309\u7167http\u534f\u8bae\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 {
\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} <\/p>\n
\u5224\u65ad\u662f\u5426\u4e3a\u9759\u6001\u8d44\u6e90，\u5206\u4e3a\u56db\u4e2a\u6b65\u9aa4<\/p>\n
bool IsFileHandler(const HttpRequest &req)
\n{
\n \/\/ 1.\u5fc5\u987b\u8bbe\u7f6e\u4e86\u9759\u6001\u8d44\u6e90\u6839\u76ee\u5f55
\n if (_basedir.empty())
\n {
\n return false;
\n }
\n \/\/ 2.\u8bf7\u6c42\u65b9\u6cd5\u5fc5\u987b\u662fGET\u6216\u8005HEAD
\n if (req._method != "GET" && req._method != "HEAD")
\n {
\n return false;
\n }
\n \/\/ 3.\u8bf7\u6c42\u7684\u8d44\u6e90\u8def\u5f84\u5fc5\u987b\u662f\u4e00\u4e2a\u5408\u6cd5\u8def\u5f84
\n if (Util::ValidPath(req._path) == false)
\n {
\n return false;
\n }
\n \/\/ 4.\u8bf7\u6c42\u7684\u8d44\u6e90\u5fc5\u987b\u5b58\u5728
\n \/\/ \u76f4\u63a5\u8bf7\u6c42\u6839\u76ee\u5f55\u662f\u6bd4\u8f83\u7279\u6b8a\u7684，\u6b64\u65f6\u76f4\u63a5\u8ffd\u52a0\u5230\u9996\u9875
\n \/\/ \u4e0d\u8981\u5fd8\u8bb0\u524d\u7f00\u7684\u76f8\u5bf9\u6839\u76ee\u5f55
\n std::string req_path = _basedir + req._path; \/\/ \u907f\u514d\u76f4\u63a5\u4fee\u6539\u8bf7\u6c42\u7684\u8d44\u6e90\u8def\u5f84
\n if (req_path.back() == '\/')
\n {
\n req_path += "index.html";
\n }
\n if (Util::IsRegular(req_path) == false)
\n {
\n return false;
\n }
\n \/\/ req._path = req_path; \/\/\u5982\u679c\u8bf7\u6c42\u5c31\u662f\u9759\u6001\u8d44\u6e90\u8bf7\u6c42，\u5219\u6709\u53ef\u80fd\u9700\u8981\u8ffd\u52a0index.html
\n return true;
\n} <\/p>\n
\u9759\u6001\u8d44\u6e90\u8bf7\u6c42\u5904\u7406\u51fd\u6570，\u5c06\u9759\u6001\u8d44\u6e90\u6587\u4ef6\u7684\u6570\u636e\u8bfb\u53d6\u51fa\u6765，\u653e\u5230rsp\u7684_body，\u5e76\u8bbe\u7f6emime<\/p>\n
void FileHandler(const HttpRequest &req, HttpResponse *rsp)
\n{
\n std::string req_path = _basedir + req._path; \/\/ \u907f\u514d\u76f4\u63a5\u4fee\u6539\u8bf7\u6c42\u7684\u8d44\u6e90\u8def\u5f84
\n if (req_path.back() == '\/')
\n {
\n req_path += "index.html";
\n }
\n bool ret = Util::ReadFile(req_path, &rsp->_body);
\n if (ret == false)
\n {
\n return;
\n }
\n std::string mime = Util::ExtMime(req_path);
\n rsp->SetHeader("Content-Type", mime);
\n return;
\n} <\/p>\n
\u8bf7\u6c42\u5f53\u7136\u4e5f\u6709\u529f\u80fd\u6027\u8bf7\u6c42<\/p>\n
void Dispatcher(HttpRequest &req, HttpResponse *rsp, Handlers &handlers)
\n{
\n \/\/ \u5728\u5bf9\u5e94\u8bf7\u6c42\u65b9\u6cd5\u7684\u8def\u7531\u8868\u4e2d，\u67e5\u627e\u662f\u54e6\u5426\u542b\u6709\u5bf9\u5e94\u8d44\u6e90\u8bf7\u6c42\u7684\u5904\u7406\u51fd\u6570，\u6709\u5219\u8c03\u7528，\u6ca1\u6709\u5219\u8fd4\u56de404
\n \/\/ \u601d\u60f3：\u8def\u7531\u8868\u5b58\u50a8\u7684\u662f\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\u662f\u6709\u5bf9\u5e94\u51fd\u6570\u8fdb\u884c\u5904\u7406
\n for (auto &handler : handlers)
\n {
\n const std::regex &re = handler.first;
\n const Handler &functor = handler.second;
\n \/\/ std::cout << "\u8fdb\u5165\u4e86\u8fd9\u91cc" << std::endl;
\n \/\/ std::cout << "req._path" << req._path << "req._matches" << req._matches[1] << std::endl;
\n \/\/ std::cout << "req._path" << req._path <<std::endl;
\n bool ret = std::regex_match(req._path, req._matches, re);
\n if (ret == false)
\n {
\n continue;
\n }
\n return functor(req, rsp); \/\/ \u4f20\u5165\u8bf7\u6c42\u4fe1\u606f，\u548c\u7a7a\u7684rsp\u6267\u884c\u5904\u7406\u51fd\u6570
\n \/\/ std::cout << "\u5230\u8fd9\u91cc\u6ca1\u6709\u51fa\u9519" << std::endl;
\n }
\n \/\/ std::cout << "\u6539\u6210404" << std::endl;
\n rsp->_statu = 404;
\n} <\/p>\n
\u8def\u7531\u67e5\u627e\u5339\u914d\u51fd\u6570，\u4e3b\u8981\u662f\u7528\u6765\u8fdb\u884c\u67e5\u627e\u65f6\u9759\u6001\u8d44\u6e90\u8fd8\u662f\u52a8\u6001\u8d44\u6e90，\u7136\u540e\u6267\u884c\u5bf9\u5e94\u7684\u5904\u7406，\u5982\u679c\u90fd\u4e0d\u662f\u5219\u8fd4\u56de404<\/p>\n
\/\/ \u8def\u7531\u67e5\u627e\u5339\u914d
\nvoid Route(HttpRequest &req, HttpResponse *rsp)
\n{
\n \/\/ 1.\u5bf9\u8bf7\u6c42\u8d44\u6e90\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\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\u4e0d\u662f\u529f\u80fd\u6027\u5904\u7406\u8bf7\u6c42，\u5219\u8fd4\u56de404
\n if (IsFileHandler(req) == true)
\n {
\n \/\/ \u662f\u4e00\u4e2a\u9759\u6001\u8d44\u6e90\u8bf7\u6c42，\u5219\u8fdb\u884c\u9759\u6001\u8d44\u6e90\u8bf7\u6c42\u7684\u5904\u7406
\n \/\/ std::cout << "\u8fdb\u5165\u4e86\u8fd9\u91cc" << std::endl;
\n return FileHandler(req, rsp);
\n }
\n \/\/ HEAD\u4e0eGET\u7c7b\u4f3c，\u53ea\u4e0d\u8fc7\u4e0d\u8981\u54cd\u5e94\u6b63\u6587
\n \/\/ std::cout << "req._method" << req._method << std::endl;
\n if (req._method == "GET" || req._method == "HEAD")
\n {
\n \/\/ std::cout << "\u4f7f\u7528\u4e86GET\u8c03\u7528\u51fd\u6570\u6dfb\u52a0\u5904\u7406" << std::endl;
\n return Dispatcher(req, rsp, _get_route);
\n }
\n else if (req._method == "POST")
\n {
\n return Dispatcher(req, rsp, _post_route);
\n }
\n else if (req._method == "PUT")
\n {
\n return Dispatcher(req, rsp, _put_route);
\n }
\n else if (req._method == "DELETE")
\n {
\n return Dispatcher(req, rsp, _delete_route);
\n }
\n rsp->_statu = 405; \/\/ METHOD NOT ALLOWED
\n} <\/p>\n
\u8bbe\u7f6e\u4e0a\u4e0b\u6587\u7684\u51fd\u6570OnConnected<\/p>\n
void OnConnected(const PtrConnection &conn)
\n{
\n conn->SetContext(HttpContext());
\n DBG_LOG("NEW CONNECTION %p", conn.get());
\n}
\n\/\/ \u7f13\u51b2\u533a\u6570\u636e\u89e3\u6790 + \u5904\u7406
\nvoid OnMessage(const PtrConnection &conn, Buffer *buffer)
\n{
\n while (buffer->ReadAbleSize() > 0) \/\/ \u6709\u6570\u636e\u5c31\u7ee7\u7eed\u5904\u7406
\n {
\n \/\/ 1.\u83b7\u53d6\u4e0a\u4e0b\u6587
\n HttpContext *context = conn->GetContext()->get<HttpContext>();
\n \/\/ 2.\u901a\u8fc7\u4e0a\u4e0b\u6587\u5bf9\u7f13\u51b2\u533a\u6570\u636e\u8fdb\u884c\u89e3\u6790，\u5f97\u5230HttpRequest\u5bf9\u8c61
\n \/\/ 1.\u5982\u679c\u7f13\u51b2\u533a\u7684\u6570\u636e\u89e3\u6790\u51fa\u9519，\u5c31\u76f4\u63a5\u56de\u590d\u51fa\u9519\u54cd\u5e94
\n \/\/ 2.\u5982\u679c\u89e3\u6790\u6b63\u5e38，\u4e14\u8bf7\u6c42\u5df2\u7ecf\u83b7\u53d6\u5b8c\u6bd5，\u624d\u5f00\u59cb\u53bb\u8fdb\u884c\u5904\u7406
\n context->RecvHttpRequest(buffer);
\n HttpRequest &req = context->Request();
\n HttpResponse rsp(context->RespStatu());
\n if (context->RespStatu() >= 400)
\n {
\n \/\/ \u51fa\u9519\u4e86，\u5173\u95ed\u8fde\u63a5
\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<\/p>\n
context->ReSet(); \/\/！！！\u91cd\u8981\u4ee3\u7801\u884c！！！\u5982\u679c\u4e0d\u6e05\u7a7a\u72b6\u6001\u7684\u8bdd，\u4ed6\u7684\u72b6\u6001\u7801\u4f1a\u4e00\u76f4\u5728400\u591a，\u5bfc\u81f4\u4e0d\u65ad\u7ed9\u5ba2\u6237\u7aef\u53d1\u9001\u51fa\u9519\u4fe1\u606f
\n buffer->MoveReadOffset(buffer->ReadAbleSize()); \/\/\u51fa\u9519\u4e86\u628a\u7f13\u51b2\u533a\u6e05\u7a7a\u4e0d\u518d\u5904\u7406<\/p>\n
conn->Shutdown(); \/\/ \u5173\u95ed\u8fde\u63a5
\n return;
\n }
\n if (context->RecvStatu() != RECV_HTTP_OVER)
\n {
\n \/\/ \u5f53\u524d\u8bf7\u6c42\u8fd8\u6ca1\u6709\u63a5\u53d7\u5b8c\u6574，\u5219\u9000\u51fa，\u7b49\u5230\u65b0\u6570\u636e\u5230\u6765\u518d\u91cd\u65b0\u5904\u7406
\n return;
\n }<\/p>\n
\/\/ 3.\u8bf7\u6c42\u8def\u7531 + \u4e1a\u52a1\u5904\u7406
\n Route(req, &rsp);
\n \/\/ 4.\u5bf9HttpResponse\u8fdb\u884c\u7ec4\u7ec7\u53d1\u9001
\n \/\/DBG_LOG("%s", rsp._body.c_str());
\n WriteResponse(conn, req, rsp);
\n \/\/ 5.\u91cd\u7f6e\u4e0a\u4e0b\u6587
\n context->ReSet();
\n \/\/ 5.\u6839\u636e\u957f\u77ed\u8fde\u63a5\u5224\u65ad\u662f\u5426\u8fde\u63a5\u6216\u8005\u7ee7\u7eed\u5904\u7406
\n if (rsp.Close() == true) \/\/ \u77ed\u8fde\u63a5
\n {
\n conn->Shutdown();
\n }
\n }
\n return;
\n} <\/p>\n
\u4e0b\u9762\u662f\u8fd9\u4e2a\u7c7b\u7684\u5b8c\u6574\u4ee3\u7801<\/p>\n
class HttpServer
\n{
\npublic:
\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;<\/p>\n
private:
\n void ErrorHandler(const HttpRequest &req, HttpResponse *rsp)
\n {
\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\u505a\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 {
\n \/\/ 1.\u5148\u5b8c\u5584\u5934\u90e8\u5b57\u6bb5
\n \/\/ req\u662fconst，\u8c03\u7528\u7684Close\u4e5f\u5fc5\u987b\u662fconst\u7c7b\u578b
\n if (req.Close() == true)
\n {
\n rsp.SetHeader("Connection", "close");
\n }
\n else
\n {
\n rsp.SetHeader("Connection", "keep-alive");
\n }
\n if (rsp._body.empty() == false && rsp.HasHeader("Content-Length") == false)
\n {
\n rsp.SetHeader("Content-Length", std::to_string(rsp._body.size()));
\n }
\n if (rsp._body.empty() == false && rsp.HasHeader("Content-Type") == false)
\n {
\n rsp.SetHeader("Content-Type", "application\/octet-stream"); \/\/ \u4e8c\u8fdb\u5236\u6d41
\n }
\n if (rsp._redirect_flag == true)
\n {
\n rsp.SetHeader("Location", rsp._redirect_url);
\n }
\n \/\/ 2.\u5c06rsp\u7684\u8981\u7d20，\u6309\u7167http\u534f\u8bae\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 {
\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 \/\/ \u5224\u65ad\u662f\u5426\u4e3a\u9759\u6001\u8d44\u6e90
\n bool IsFileHandler(const HttpRequest &req)
\n {
\n \/\/ 1.\u5fc5\u987b\u8bbe\u7f6e\u4e86\u9759\u6001\u8d44\u6e90\u6839\u76ee\u5f55
\n if (_basedir.empty())
\n {
\n return false;
\n }
\n \/\/ 2.\u8bf7\u6c42\u65b9\u6cd5\u5fc5\u987b\u662fGET\u6216\u8005HEAD
\n if (req._method != "GET" && req._method != "HEAD")
\n {
\n return false;
\n }
\n \/\/ 3.\u8bf7\u6c42\u7684\u8d44\u6e90\u8def\u5f84\u5fc5\u987b\u662f\u4e00\u4e2a\u5408\u6cd5\u8def\u5f84
\n if (Util::ValidPath(req._path) == false)
\n {
\n return false;
\n }
\n \/\/ 4.\u8bf7\u6c42\u7684\u8d44\u6e90\u5fc5\u987b\u5b58\u5728
\n \/\/ \u76f4\u63a5\u8bf7\u6c42\u6839\u76ee\u5f55\u662f\u6bd4\u8f83\u7279\u6b8a\u7684，\u6b64\u65f6\u76f4\u63a5\u8ffd\u52a0\u5230\u9996\u9875
\n \/\/ \u4e0d\u8981\u5fd8\u8bb0\u524d\u7f00\u7684\u76f8\u5bf9\u6839\u76ee\u5f55
\n std::string req_path = _basedir + req._path; \/\/ \u907f\u514d\u76f4\u63a5\u4fee\u6539\u8bf7\u6c42\u7684\u8d44\u6e90\u8def\u5f84
\n if (req_path.back() == '\/')
\n {
\n req_path += "index.html";
\n }
\n if (Util::IsRegular(req_path) == false)
\n {
\n return false;
\n }
\n \/\/ req._path = req_path; \/\/\u5982\u679c\u8bf7\u6c42\u5c31\u662f\u9759\u6001\u8d44\u6e90\u8bf7\u6c42，\u5219\u6709\u53ef\u80fd\u9700\u8981\u8ffd\u52a0index.html
\n return true;
\n }
\n \/\/ \u9759\u6001\u8d44\u6e90\u8bf7\u6c42\u5904\u7406 — \u5c06\u9759\u6001\u8d44\u6e90\u6587\u4ef6\u7684\u6570\u636e\u8bfb\u53d6\u51fa\u6765，\u653e\u5230rsp\u7684_body，\u5e76\u8bbe\u7f6emime
\n void FileHandler(const HttpRequest &req, HttpResponse *rsp)
\n {
\n std::string req_path = _basedir + req._path; \/\/ \u907f\u514d\u76f4\u63a5\u4fee\u6539\u8bf7\u6c42\u7684\u8d44\u6e90\u8def\u5f84
\n if (req_path.back() == '\/')
\n {
\n req_path += "index.html";
\n }
\n bool ret = Util::ReadFile(req_path, &rsp->_body);
\n if (ret == false)
\n {
\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 {
\n \/\/ \u5728\u5bf9\u5e94\u8bf7\u6c42\u65b9\u6cd5\u7684\u8def\u7531\u8868\u4e2d，\u67e5\u627e\u662f\u54e6\u5426\u542b\u6709\u5bf9\u5e94\u8d44\u6e90\u8bf7\u6c42\u7684\u5904\u7406\u51fd\u6570，\u6709\u5219\u8c03\u7528，\u6ca1\u6709\u5219\u8fd4\u56de404
\n \/\/ \u601d\u60f3：\u8def\u7531\u8868\u5b58\u50a8\u7684\u662f\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\u662f\u6709\u5bf9\u5e94\u51fd\u6570\u8fdb\u884c\u5904\u7406
\n for (auto &handler : handlers)
\n {
\n const std::regex &re = handler.first;
\n const Handler &functor = handler.second;
\n \/\/ std::cout << "\u8fdb\u5165\u4e86\u8fd9\u91cc" << std::endl;
\n \/\/ std::cout << "req._path" << req._path << "req._matches" << req._matches[1] << std::endl;
\n \/\/ std::cout << "req._path" << req._path <<std::endl;
\n bool ret = std::regex_match(req._path, req._matches, re);
\n if (ret == false)
\n {
\n continue;
\n }
\n return functor(req, rsp); \/\/ \u4f20\u5165\u8bf7\u6c42\u4fe1\u606f，\u548c\u7a7a\u7684rsp\u6267\u884c\u5904\u7406\u51fd\u6570
\n \/\/ std::cout << "\u5230\u8fd9\u91cc\u6ca1\u6709\u51fa\u9519" << std::endl;
\n }
\n \/\/ std::cout << "\u6539\u6210404" << std::endl;
\n rsp->_statu = 404;
\n }
\n \/\/ \u8def\u7531\u67e5\u627e\u5339\u914d
\n void Route(HttpRequest &req, HttpResponse *rsp)
\n {
\n \/\/ 1.\u5bf9\u8bf7\u6c42\u8d44\u6e90\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\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\u4e0d\u662f\u529f\u80fd\u6027\u5904\u7406\u8bf7\u6c42，\u5219\u8fd4\u56de404
\n if (IsFileHandler(req) == true)
\n {
\n \/\/ \u662f\u4e00\u4e2a\u9759\u6001\u8d44\u6e90\u8bf7\u6c42，\u5219\u8fdb\u884c\u9759\u6001\u8d44\u6e90\u8bf7\u6c42\u7684\u5904\u7406
\n \/\/ std::cout << "\u8fdb\u5165\u4e86\u8fd9\u91cc" << std::endl;
\n return FileHandler(req, rsp);
\n }
\n \/\/ HEAD\u4e0eGET\u7c7b\u4f3c，\u53ea\u4e0d\u8fc7\u4e0d\u8981\u54cd\u5e94\u6b63\u6587
\n \/\/ std::cout << "req._method" << req._method << std::endl;
\n if (req._method == "GET" || req._method == "HEAD")
\n {
\n \/\/ std::cout << "\u4f7f\u7528\u4e86GET\u8c03\u7528\u51fd\u6570\u6dfb\u52a0\u5904\u7406" << std::endl;
\n return Dispatcher(req, rsp, _get_route);
\n }
\n else if (req._method == "POST")
\n {
\n return Dispatcher(req, rsp, _post_route);
\n }
\n else if (req._method == "PUT")
\n {
\n return Dispatcher(req, rsp, _put_route);
\n }
\n else if (req._method == "DELETE")
\n {
\n return Dispatcher(req, rsp, _delete_route);
\n }
\n rsp->_statu = 405; \/\/ METHOD NOT ALLOWED
\n }
\n \/\/ \u8bbe\u7f6e\u4e0a\u4e0b\u6587
\n void OnConnected(const PtrConnection &conn)
\n {
\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 {
\n while (buffer->ReadAbleSize() > 0) \/\/ \u6709\u6570\u636e\u5c31\u7ee7\u7eed\u5904\u7406
\n {
\n \/\/ 1.\u83b7\u53d6\u4e0a\u4e0b\u6587
\n HttpContext *context = conn->GetContext()->get<HttpContext>();
\n \/\/ 2.\u901a\u8fc7\u4e0a\u4e0b\u6587\u5bf9\u7f13\u51b2\u533a\u6570\u636e\u8fdb\u884c\u89e3\u6790，\u5f97\u5230HttpRequest\u5bf9\u8c61
\n \/\/ 1.\u5982\u679c\u7f13\u51b2\u533a\u7684\u6570\u636e\u89e3\u6790\u51fa\u9519，\u5c31\u76f4\u63a5\u56de\u590d\u51fa\u9519\u54cd\u5e94
\n \/\/ 2.\u5982\u679c\u89e3\u6790\u6b63\u5e38，\u4e14\u8bf7\u6c42\u5df2\u7ecf\u83b7\u53d6\u5b8c\u6bd5，\u624d\u5f00\u59cb\u53bb\u8fdb\u884c\u5904\u7406
\n context->RecvHttpRequest(buffer);
\n HttpRequest &req = context->Request();
\n HttpResponse rsp(context->RespStatu());
\n if (context->RespStatu() >= 400)
\n {
\n \/\/ \u51fa\u9519\u4e86，\u5173\u95ed\u8fde\u63a5
\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<\/p>\n
context->ReSet(); \/\/！！！\u91cd\u8981\u4ee3\u7801\u884c！！！\u5982\u679c\u4e0d\u6e05\u7a7a\u72b6\u6001\u7684\u8bdd，\u4ed6\u7684\u72b6\u6001\u7801\u4f1a\u4e00\u76f4\u5728400\u591a，\u5bfc\u81f4\u4e0d\u65ad\u7ed9\u5ba2\u6237\u7aef\u53d1\u9001\u51fa\u9519\u4fe1\u606f
\n buffer->MoveReadOffset(buffer->ReadAbleSize()); \/\/\u51fa\u9519\u4e86\u628a\u7f13\u51b2\u533a\u6e05\u7a7a\u4e0d\u518d\u5904\u7406<\/p>\n
conn->Shutdown(); \/\/ \u5173\u95ed\u8fde\u63a5
\n return;
\n }
\n if (context->RecvStatu() != RECV_HTTP_OVER)
\n {
\n \/\/ \u5f53\u524d\u8bf7\u6c42\u8fd8\u6ca1\u6709\u63a5\u53d7\u5b8c\u6574，\u5219\u9000\u51fa，\u7b49\u5230\u65b0\u6570\u636e\u5230\u6765\u518d\u91cd\u65b0\u5904\u7406
\n return;
\n }<\/p>\n
\/\/ 3.\u8bf7\u6c42\u8def\u7531 + \u4e1a\u52a1\u5904\u7406
\n Route(req, &rsp);
\n \/\/ 4.\u5bf9HttpResponse\u8fdb\u884c\u7ec4\u7ec7\u53d1\u9001
\n \/\/DBG_LOG("%s", rsp._body.c_str());
\n WriteResponse(conn, req, rsp);
\n \/\/ 5.\u91cd\u7f6e\u4e0a\u4e0b\u6587
\n context->ReSet();
\n \/\/ 5.\u6839\u636e\u957f\u77ed\u8fde\u63a5\u5224\u65ad\u662f\u5426\u8fde\u63a5\u6216\u8005\u7ee7\u7eed\u5904\u7406
\n if (rsp.Close() == true) \/\/ \u77ed\u8fde\u63a5
\n {
\n conn->Shutdown();
\n }
\n }
\n return;
\n }<\/p>\n
public:
\n HttpServer(int port, int timeout = DEFAULT_TIMEOUT)
\n : _server(port)
\n {
\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 {
\n int ret = Util::IsDirectory(path);
\n assert(ret == true);
\n _basedir = path;
\n }
\n \/*\u8bbe\u7f6e\/\u6dfb\u52a0\u8bf7\u6c42(\u8bf7\u6c42\u7684\u6b63\u5219\u8868\u8fbe\u5f0f)\u4e0e\u5904\u7406\u51fd\u6570\u7684\u6620\u5c04\u5173\u7cfb*\/
\n void Get(const std::string &patten, const Handler &handler)
\n {
\n _get_route.push_back(std::make_pair(std::regex(patten), handler));
\n }
\n void Post(const std::string &patten, const Handler &handler)
\n {
\n _post_route.push_back(std::make_pair(std::regex(patten), handler));
\n }
\n void Put(const std::string &patten, const Handler &handler)
\n {
\n _put_route.push_back(std::make_pair(std::regex(patten), handler));
\n }
\n void Delete(const std::string &patten, const Handler &handler)
\n {
\n _delete_route.push_back(std::make_pair(std::regex(patten), handler));
\n }
\n void SetThreadCount(int count)
\n {
\n _server.SetThreadCount(count);
\n }
\n void Listen()
\n {
\n _server.Start();
\n }
\n}; <\/p>\n
\u4ee3\u7801\u8fde\u63a5\u5982\u4e0blesson41 \u00b7 \u5f20\u5bb6\u5174\/Linux – \u7801\u4e91 – \u5f00\u6e90\u4e2d\u56fd<\/p>\n
\u6709\u9700\u8981\u81ea\u53d6，\u535a\u5ba2\u4e0d\u7cbe\u51c6\u5730\u65b9\u8bf7\u591a\u8c05\u89e3<\/p>\n","protected":false},"excerpt":{"rendered":"
\u6587\u7ae0\u6d4f\u89c8\u9605\u8bfb743\u6b21\uff0c\u70b9\u8d5e10\u6b21\uff0c\u6536\u85cf18\u6b21\u3002\u672c\u6587\u8be6\u7ec6\u4ecb\u7ecd\u4e86\u5982\u4f55\u5b9e\u73b0\u4e00\u4e2a\u57fa\u4e8eC++\u7684\u9ad8\u6027\u80fdHTTP\u670d\u52a1\u5668\uff0c\u6db5\u76d6\u4e86\u4ece\u57fa\u7840\u6a21\u5757\u5230\u5b8c\u6574\u670d\u52a1\u5668\u5b9e\u73b0\u7684\u5404\u4e2a\u90e8\u5206\u3002\u9996\u5148\uff0c\u6587\u7ae0\u4ecb\u7ecd\u4e86\u65f6\u95f4\u8f6e\u3001\u6b63\u5219\u8868\u8fbe\u5f0f\u548c\u901a\u7528\u7c7b\u578bAny\u7684\u5b9e\u73b0\uff0c\u8fd9\u4e9b\u662f\u670d\u52a1\u5668\u5f00\u53d1\u4e2d\u7684\u57fa\u7840\u5de5\u5177\u3002\u63a5\u7740\uff0c\u6587\u7ae0\u8be6\u7ec6\u8bb2\u89e3\u4e86\u670d\u52a1\u5668\u6a21\u5757\u7684\u5b9e\u73b0\uff0c\u5305\u62ec\u7f13\u51b2\u533a\u7ba1\u7406\u3001\u65e5\u5fd7\u5b8f\u3001\u5957\u63a5\u5b57\u6a21\u5757\u3001\u4e8b\u4ef6\u7ba1\u7406\u3001\u63cf\u8ff0\u7b26\u4e8b\u4ef6\u76d1\u63a7\u3001\u5b9a\u65f6\u4efb\u52a1\u7ba1\u7406\u3001Reactor-EventLoop\u7ebf\u7a0b\u6c60\u7b49\u6838\u5fc3\u7ec4\u4ef6\u3002\u968f\u540e\uff0c\u6587\u7ae0\u6df1\u5165\u63a2\u8ba8\u4e86HTTP\u534f\u8bae\u652f\u6301\u6a21\u5757\u7684\u5b9e\u73b0\uff0c\u5305\u62ec\u5b9e\u7528\u5de5\u5177\u7c7b\u3001HTTP\u8bf7\u6c42\u548c\u54cd\u5e94\u7c7b\u7684\u8bbe\u8ba1\uff0c\u4ee5\u53caHTTP\u4e0a\u4e0b\u6587\u7684\u7ba1\u7406\u3002\u6700\u540e\uff0c\u6587\u7ae0\u5c55\u793a\u4e86\u5982\u4f55\u5c06\u8fd9\u4e9b\u6a21\u5757\u6574\u5408\u6210<\/p>\n","protected":false},"author":2,"featured_media":38610,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[1],"tags":[55,371,43],"topic":[],"class_list":["post-38611","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-server","tag-c","tag-371","tag-43"],"yoast_head":"\n