这个模块看着代码挺多的实则真的很多，但是不难，我为大家将各个函数拿出来理一理。
connection就是将主线程监听的网络套接字上的客户端套接字进行包装，使被包装的套接字可以进行，各种事件的处理，比如读写事件。下面就来详细看看。
这是connection模块在代码中的运用，每一个Connection对象对应一个客户端。
Connection模块刚开始，就继承了一个类enable_shared_from_this,这里有篇文章介绍了这个类，大家需要去了解一下。
Connection模块成员变量：
_conn_id和_sockfd:
一个客户端连接就对应一个connection对象，为甚怎么说，因为_sockfd连接关联的文件描述符，有许多客户端就要有许多Connection对象，这些对象需要管理起来，为了方便在每个对象中都要有一个编号与之对应。
_enable_inactive_release：
这是一个标志，连接是否启动非活跃销毁的判断标志，默认为false，表示没启动。没启动就定时器模块就不会运作。
这是TcpServer模块中调用的，从上面可看出，设置了定时时间和非活跃连接标识。
EventLoop 对象的作用：
上面的这几个函数接口，只有红色方框中的函数调用，是在主线程上调用的。
有新的客户端到来时，主线程会为其分配对应的EventLoop，分配的EventLoop对象与子线程是绑定的，但是这个调用在主线程上。
我在RunInLoop中做了打印，一个就是EventLoop对象绑定的子线程，另一个就是，正在运行的线程，发现这两个线程不一样，但是有一个是主线程，你也可以查看线程池中的线程，你将发现，有一子线程，和打印的线程是一样的。
这些接口都是在其它模块进行调用的：
有TcpServer模块，HttpServer模块等；后面会见到，如果你看了源码的话。
连接状态ConnStatu：
连接状态决定着，这个连接在该阶段要做那些事情，比如说半连接状态，就没事做，就变为连接状态；连接状态就会启动读事件监控，将Channel对象添加到Poller对象中进行管理。半关闭状态，将接受缓冲区中的数据处理，并放到发送缓冲区，再发给用户。之后，再将连接状态设置为连接关闭。
Socket对象和Buffer对象：
socket对象就是为了向客户端连接发送（_out_buffer）/接收（_in_buffer）数据的，因为连接模块就是干这件事的，与连接状态进行配合，实现网络通信。
channel对象：
这个对象就是用客户端的网络套接字进行的实例化。
从这五个函数就可以看出，所有的Channel模块所对应的事件就绪回调函数都是相同的。 就绪就触发。
既然已经对实例化了channel对象，那么就要将Channel对象添加到Poller对象中去，以便于管理，如何添加呢？
我之前在Channel模块中讲到，启动时间监控函数，不仅仅是对要监控的事件_events做修改，而且还调用了UpDate()，这是谁调用的的呢？是EventLoop调用的。
Any _context:
这是进行网络协议的切换，该项目用的是http协议，就会编写一套关于http解析头部字段，用户数据的协议。
Any是可以接收任意对象的，因为其内部实现用的是多态，父类对象指向子类对象。后面再介绍。
用户设置的回调函数：
比如说，用户想在连接完成时，打印内容，或者连接关闭时打印内容，就会设置对应的回调函数。
设置回调函数的接口：
连接关闭回调函数：
上图是Connection模块中的回调函数成员。
上面是在TcpServer模块中，建立新连接时设置如何关闭Connection连接，需要将Connection对象删除掉，不过这是最后做的，为什么？
因为你将Connection对象删除之后,它里面保存的Channel对象，和socket创建的文件描述符等资源不就无法释放了吗？
上面的关闭回调函数就是用户设置的，就比如说，用户想看关闭连接后的现象，那就可以设置这个回调函数，有则调用。
所以说先要释放这些资源最后释放Connection对象。
这是向外提供的释放接口，这两个接口的使用目的是不一样的。
第一个就相当于，用户自己释放。
第二个，就是连接断开时，客户端对应的套接字会返回0,表示客户端已经关闭了文件描述符，这时候调用这个函数进行释放。
非活跃连接的释放：
刷新就是将客户端连接进行了延迟，因为在规定时间内，客户端与服务器进行了通信，所以是活跃状态。
在断开连接之后，就会将该连接对应的定时器任务全部取消，怎么取消呢？
定时器任务中有一个标识符，我在定时器模块讲过，这里不做介绍。
公开接口：
发送接口：
既然有发送接口，那为什么没有接收接口，原因是在Http模块中进行处理，为什么，首先HTTP模块中，对客户端的请求有一系列的处理模块所以说，有请求来临时，就会读出请求。
怎样读取请求呢？
TcpServer对象中就保存了对应的Connection对象，而Connection对象中就包含了_in_buffer结束缓冲区。就可以读取请求。
上面这些调用就是Http模块中怎样读取和处理http请求的代码。
更新上下文：
本项目用的是http协议，如果要用其他协议，就需要重新设计一套，解析请求，构造响应的代码，再去更换协议。
这个接口必须立即执行。因为设置完上下文之后，客户端可能会立即发送请求，如果不立即执行，就会用原来的协议去处理这些请求，当然这是不合理的，所以说这就是非常严重的问题。就没必要再执行下去了。
你不理解的话，可以逆向思维，如果存在这种情况，服务器不是有崩溃的风险，谁会去用。当然，这是在你不理解的情况下。
剩余公开接口在用的时候会再去讲解，现在讲解也只是大白话，过后就没什么印象。
以上讲解如果又不理解或者错误的地方，尽管提出来，我会进行纠正，感谢大家。
Connection模块整体代码：
class Connection;
//DISCONECTED -- 连接关闭状态； CONNECTING -- 连接建立成功-待处理状态
//CONNECTED -- 连接建立完成，各种设置已完成，可以通信的状态； DISCONNECTING -- 待关闭状态
typedef enum { DISCONNECTED, CONNECTING, CONNECTED, DISCONNECTING}ConnStatu;
using PtrConnection = std::shared_ptr<Connection>;
class Connection : public std::enable_shared_from_this<Connection> {
private:
uint64_t _conn_id; // 连接的唯一ID，便于连接的管理和查找
//uint64_t _timer_id; //定时器ID，必须是唯一的，这块为了简化操作使用conn_id作为定时器ID
int _sockfd; // 连接关联的文件描述符
bool _enable_inactive_release; // 连接是否启动非活跃销毁的判断标志，默认为false
EventLoop *_loop; // 连接所关联的一个EventLoop
ConnStatu _statu; // 连接状态
Socket _socket; // 套接字操作管理
Channel _channel; // 连接的事件管理
Buffer _in_buffer; // 输入缓冲区---存放从socket中读取到的数据
Buffer _out_buffer; // 输出缓冲区---存放要发送给对端的数据
Any _context; // 请求的接收处理上下文
/*这四个回调函数，是让服务器模块来设置的（其实服务器模块的处理回调也是组件使用者设置的）*/
/*换句话说，这几个回调都是组件使用者使用的*/
using ConnectedCallback = std::function<void(const PtrConnection&)>;
using MessageCallback = std::function<void(const PtrConnection&, Buffer *)>;
using ClosedCallback = std::function<void(const PtrConnection&)>;
using AnyEventCallback = std::function<void(const PtrConnection&)>;
ConnectedCallback _connected_callback;
MessageCallback _message_callback;
ClosedCallback _closed_callback;
AnyEventCallback _event_callback;
/*组件内的连接关闭回调--组件内设置的，因为服务器组件内会把所有的连接管理起来，一旦某个连接要关闭*/
/*就应该从管理的地方移除掉自己的信息*/
ClosedCallback _server_closed_callback;
private:
/*五个channel的事件回调函数*/
//描述符可读事件触发后调用的函数，接收socket数据放到接收缓冲区中，然后调用_message_callback
void HandleRead() {
//1. 接收socket的数据，放到缓冲区
char buf[65536];
ssize_t ret = _socket.NonBlockRecv(buf, 65535);
if (ret < 0) {
//出错了,不能直接关闭连接
return ShutdownInLoop();
}
//这里的等于0表示的是没有读取到数据，而并不是连接断开了，连接断开返回的是-1
//将数据放入输入缓冲区,写入之后顺便将写偏移向后移动
_in_buffer.WriteAndPush(buf, ret);
//2. 调用message_callback进行业务处理
if (_in_buffer.ReadAbleSize() > 0) {
//shared_from_this--从当前对象自身获取自身的shared_ptr管理对象
return _message_callback(shared_from_this(), &_in_buffer);
}
}
//描述符可写事件触发后调用的函数，将发送缓冲区中的数据进行发送
void HandleWrite() {
//_out_buffer中保存的数据就是要发送的数据
ssize_t ret = _socket.NonBlockSend(_out_buffer.ReadPosition(), _out_buffer.ReadAbleSize());
if (ret < 0) {
//发送错误就该关闭连接了，
if (_in_buffer.ReadAbleSize() > 0) {
_message_callback(shared_from_this(), &_in_buffer);
}
return Release();//这时候就是实际的关闭释放操作了。
}
_out_buffer.MoveReadOffset(ret);//千万不要忘了，将读偏移向后移动
if (_out_buffer.ReadAbleSize() == 0) {
_channel.DisableWrite();// 没有数据待发送了，关闭写事件监控
//如果当前是连接待关闭状态，则有数据，发送完数据释放连接，没有数据则直接释放
if (_statu == DISCONNECTING) {
return Release();
}
}
return;
}
//描述符触发挂断事件
void HandleClose() {
/*一旦连接挂断了，套接字就什么都干不了了，因此有数据待处理就处理一下，完毕关闭连接*/
if (_in_buffer.ReadAbleSize() > 0) {
_message_callback(shared_from_this(), &_in_buffer);
}
return Release();
}
//描述符触发出错事件
void HandleError() {
return HandleClose();
}
//描述符触发任意事件: 1. 刷新连接的活跃度--延迟定时销毁任务； 2. 调用组件使用者的任意事件回调
void HandleEvent() {
if (_enable_inactive_release == true) { _loop->TimerRefresh(_conn_id); }
if (_event_callback) { _event_callback(shared_from_this()); }
}
//连接获取之后，所处的状态下要进行各种设置（启动读监控,调用回调函数）
void EstablishedInLoop() {
// 1. 修改连接状态； 2. 启动读事件监控； 3. 调用回调函数
assert(_statu == CONNECTING);//当前的状态必须一定是上层的半连接状态
_statu = CONNECTED;//当前函数执行完毕，则连接进入已完成连接状态
// 一旦启动读事件监控就有可能会立即触发读事件，如果这时候启动了非活跃连接销毁
_channel.EnableRead();
if (_connected_callback) _connected_callback(shared_from_this());
}
//这个接口才是实际的释放接口
void ReleaseInLoop() {
//1. 修改连接状态，将其置为DISCONNECTED
_statu = DISCONNECTED;
//2. 移除连接的事件监控
_channel.Remove();
//3. 关闭描述符
_socket.Close();
//4. 如果当前定时器队列中还有定时销毁任务，则取消任务
if (_loop->HasTimer(_conn_id)) CancelInactiveReleaseInLoop();
//5. 调用关闭回调函数，避免先移除服务器管理的连接信息导致Connection被释放，再去处理会出错，因此先调用用户的回调函数
if (_closed_callback) _closed_callback(shared_from_this());
//移除服务器内部管理的连接信息
if (_server_closed_callback) _server_closed_callback(shared_from_this());
}
//这个接口并不是实际的发送接口，而只是把数据放到了发送缓冲区，启动了可写事件监控
void SendInLoop(Buffer &buf) {
if (_statu == DISCONNECTED) return ;
_out_buffer.WriteBufferAndPush(buf);
if (_channel.WriteAble() == false) {
_channel.EnableWrite();
}
}
//这个关闭操作并非实际的连接释放操作，需要判断还有没有数据待处理，待发送
void ShutdownInLoop() {
_statu = DISCONNECTING;// 设置连接为半关闭状态
if (_in_buffer.ReadAbleSize() > 0) {
if (_message_callback) _message_callback(shared_from_this(), &_in_buffer);
}
//要么就是写入数据的时候出错关闭，要么就是没有待发送数据，直接关闭
if (_out_buffer.ReadAbleSize() > 0) {
if (_channel.WriteAble() == false) {
_channel.EnableWrite();
}
}
if (_out_buffer.ReadAbleSize() == 0) {
Release();
}
}
//启动非活跃连接超时释放规则
void EnableInactiveReleaseInLoop(int sec) {
//1. 将判断标志 _enable_inactive_release 置为true
_enable_inactive_release = true;
//2. 如果当前定时销毁任务已经存在，那就刷新延迟一下即可
if (_loop->HasTimer(_conn_id)) {
return _loop->TimerRefresh(_conn_id);
}
//3. 如果不存在定时销毁任务，则新增
_loop->TimerAdd(_conn_id, sec, std::bind(&Connection::Release, this));
}
void CancelInactiveReleaseInLoop() {
_enable_inactive_release = false;
if (_loop->HasTimer(_conn_id)) {
_loop->TimerCancel(_conn_id);
}
}
void UpgradeInLoop(const Any &context,
const ConnectedCallback &conn,
const MessageCallback &msg,
const ClosedCallback &closed,
const AnyEventCallback &event) {
_context = context;
_connected_callback = conn;
_message_callback = msg;
_closed_callback = closed;
_event_callback = event;
}
public:
Connection(EventLoop *loop, uint64_t conn_id, int sockfd):_conn_id(conn_id), _sockfd(sockfd),
_enable_inactive_release(false), _loop(loop), _statu(CONNECTING), _socket(_sockfd),
_channel(loop, _sockfd) {
_channel.SetCloseCallback(std::bind(&Connection::HandleClose, this));
_channel.SetEventCallback(std::bind(&Connection::HandleEvent, this));
_channel.SetReadCallback(std::bind(&Connection::HandleRead, this));
_channel.SetWriteCallback(std::bind(&Connection::HandleWrite, this));
_channel.SetErrorCallback(std::bind(&Connection::HandleError, this));
}
~Connection() { DBG_LOG("RELEASE CONNECTION:%p", this); }
//获取管理的文件描述符
int Fd() { return _sockfd; }
//获取连接ID
int Id() { return _conn_id; }
//是否处于CONNECTED状态
bool Connected() { return (_statu == CONNECTED); }
//设置上下文--连接建立完成时进行调用
void SetContext(const Any &context) { _context = context; }
//获取上下文，返回的是指针
Any *GetContext() { return &_context; }
void SetConnectedCallback(const ConnectedCallback&cb) { _connected_callback = cb; }
void SetMessageCallback(const MessageCallback&cb) { _message_callback = cb; }
void SetClosedCallback(const ClosedCallback&cb) { _closed_callback = cb; }
void SetAnyEventCallback(const AnyEventCallback&cb) { _event_callback = cb; }
void SetSrvClosedCallback(const ClosedCallback&cb) { _server_closed_callback = cb; }
//连接建立就绪后，进行channel回调设置，启动读监控，调用_connected_callback
void Established() {
_loop->RunInLoop(std::bind(&Connection::EstablishedInLoop, this));
}
//发送数据，将数据放到发送缓冲区，启动写事件监控
void Send(const char *data, size_t len) {
//外界传入的data，可能是个临时的空间，我们现在只是把发送操作压入了任务池，有可能并没有被立即执行
//因此有可能执行的时候，data指向的空间有可能已经被释放了。
Buffer buf;
buf.WriteAndPush(data, len);
_loop->RunInLoop(std::bind(&Connection::SendInLoop, this, std::move(buf)));
}
//提供给组件使用者的关闭接口--并不实际关闭，需要判断有没有数据待处理
void Shutdown() {
_loop->RunInLoop(std::bind(&Connection::ShutdownInLoop, this));
}
void Release() {
_loop->QueueInLoop(std::bind(&Connection::ReleaseInLoop, this));
}
//启动非活跃销毁，并定义多长时间无通信就是非活跃，添加定时任务
void EnableInactiveRelease(int sec) {
_loop->RunInLoop(std::bind(&Connection::EnableInactiveReleaseInLoop, this, sec));
}
//取消非活跃销毁
void CancelInactiveRelease() {
_loop->RunInLoop(std::bind(&Connection::CancelInactiveReleaseInLoop, this));
}
//切换协议---重置上下文以及阶段性回调处理函数 -- 而是这个接口必须在EventLoop线程中立即执行
//防备新的事件触发后，处理的时候，切换任务还没有被执行--会导致数据使用原协议处理了。
void Upgrade(const Any &context, const ConnectedCallback &conn, const MessageCallback &msg,
const ClosedCallback &closed, const AnyEventCallback &event) {
_loop->AssertInLoop();
_loop->RunInLoop(std::bind(&Connection::UpgradeInLoop, this, context, conn, msg, closed, event));
}
};
