1.6.C++项目：仿muduo库实现并发服务器之channel模块的设计

项目完整版在：

一、channel模块：事件管理Channel类实现

二、提供的功能

1.对监控事件的管理
描述符是否可读
描述符是否可写
对描述符监控可读
对描述符监控可写
解除可读事件监控
解除可写事件监控
解除所有事件监控
2.对监控事件触发后的处理
设置对于不同事件的回调处理函数
明确触发了某个事件该如何处理

三、实现思想

（一）功能

对socket套接字的操作进行封装。

（二）意义

对socket套接字的操作进行封装。

（三）功能设计

1.对监控事件的管理
描述符是否可读
描述符是否可写
对描述符监控可读
对描述符监控可写
解除可读事件监控
解除可写事件监控
解除所有事件监控
2.对监控事件触发后的处理
设置对于不同事件的回调处理函数
明确触发了某个事件该如何处理

四、代码

（一）框架

class Channel {

        private:
                int _fd;
                uint32_t events;  // 当前需要监控的事件
                uint32_t revents; // 当前连接触发的事件
                using eventCallback = std::function<void()>>;
                eventCallback _read_callback;  // 可读事件被触发的回调函数
                eventCallback _error_callback; // 可写事件被触发的回调函数
                eventCallback _close_callback; // 连接关闭事件被触发的回调函数
                eventCallback _event_callback; // 任意事件被触发的回调函数
                eventCallback _write_callback; // 可写事件被触发的回调函数
        public:
                Channel(int fd) : fd(_fd) {}
                int Fd() {return _fd ;}
                void setReadCallback(const eventCallback &cb);
                void setWriteCallback(const eventCallback &cb);
                void setErrorCallback(const eventCallback &cb);
                void setCloseCallback(const eventCallback &cb);
                void setEventCallback(const eventCallback &cb);
                bool readAble();   // 当前是否可读
                bool writeAble();  // 当前是否可写
                void enableRead(); // 启动读事件监控
                void enableWrite(); // 启动写事件监控
                void disableRead();     // 关闭读事件监控
                void disableWrite(); // 关闭写事件监控
                void disableAll();  // 关闭所有事件监控
                void Remove();  //移除监控
                void handleEvent(); // 事件处理，一旦触发了某个事件，就调用这个函数！

};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

（二）完整

class Channel {

        private:
                int _fd;
                uint32_t events;  // 当前需要监控的事件
                uint32_t revents; // 当前连接触发的事件
                using eventCallback = std::function<void()>>;
                eventCallback _read_callback;  // 可读事件被触发的回调函数
                eventCallback _error_callback; // 可写事件被触发的回调函数
                eventCallback _close_callback; // 连接关闭事件被触发的回调函数
                eventCallback _event_callback; // 任意事件被触发的回调函数
                eventCallback _write_callback; // 可写事件被触发的回调函数
        public:
                Channel(int fd) : fd(_fd) {}
                int Fd() {return _fd ;}
                void SetRevents(uint32_t events) {_revents = events; }
                void setReadCallback(const eventCallback &cb) { _read_callback = cb;}
                void setWriteCallback(const eventCallback &cb) { _write_callback = cb; }
                void setErrorCallback(const eventCallback &cb) { _error_callback = cb; }
                void setCloseCallback(const eventCallback &cb) { _close_callback = cb; }
                void setEventCallback(const eventCallback &cb) { _event_callback = cb; }
                bool readAble() {  // 当前是否可读 
                        return (_events & EPOLLIN);
                }
                bool writeAble() {  // 当前是否可写
                        return (_events & EPOLLOUT);
                }
                void enableRead() {// 启动读事件监控
                        _events |= EPOLLIN; // 后面会添加到EventLoop的事件监控！
                }
                void enableWrite() { // 启动写事件监控 
                        _events |= EPOLLOUT; // 后面会添加到EventLoop的事件监控！
                }
                void disableRead() {    // 关闭读事件监控
                        _events &= ~EPOLLIN;   // 后面会修改到EventLoop的事件监控！
                }
                void disableWrite() { // 关闭写事件监控 
                        _events &= ~EPOLLOUT;
                }
                void disableAll() { // 关闭所有事件监控
                        _events = 0;
                }
                void Remove();  // 后面会调用EventLoop接口移除监控
                void HandleEvent() {
                        if ((_revents & EPOLLIN) || (_revents & EPOLLRDHUP) || (_revents & EPOLLPRI)) {
                        
                                if (_read_callback) _read_callback();
                                }
                        /*有可能会释放连接的操作事件，一次只处理一个*/
                                if (_revents & EPOLLOUT) {
                                if (_write_callback) _write_callback();
                                }
                                else if (_revents & EPOLLERR) {
                                if (_error_callback) _error_callback();//一旦出错，就会释放连接，因此要放到前边调用任意回调
                                }else if (_revents & EPOLLHUP) {
                                if (_close_callback) _close_callback();
                                }
                        /*不管任何事件，都调用的回调函数*/
                        if (_event_callback) _event_callback();
        }

};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62