客户端源码

#include <iostream>
#include <boost/asio.hpp>
#include <string>
int main()
{try{boost::asio::io_context ioc;std::string ip = "127.0.0.1";unsigned short port = 8888;boost::asio::ip::tcp::endpoint ep(boost::asio::ip::address::from_string(ip), port);boost::asio::ip::tcp::socket sock(ioc, ep.protocol());boost::system::error_code ec = boost::asio::error::host_not_found;sock.connect(ep,ec);if (ec.value() != 0){std::cout << ec.value() << ":" << ec.message() << std::endl;return ec.value();}const int MAX_SIZE = 1024;char request[MAX_SIZE];std::cout << "Enter Message:";std::cin.getline(request, MAX_SIZE);size_t request_length = strlen(request);boost::asio::write(sock, boost::asio::buffer(request, request_length));//收到服务端的消息char response[MAX_SIZE];memset(response, '\0', MAX_SIZE);sock.read_some(boost::asio::buffer(response, MAX_SIZE));std::cout << "server echo# " << response << std::endl;}catch (std::exception& e){std::cout << e.what() << std::endl;}return 0;
}

Session类

  Session类的作用是服务端为某个已连接的客户端处理消息收发的会话类(在这里先不考虑粘包问题，并采用和客户端进行应答的方式发送和接收一个固定长度的数据)

class Session
{
public:Session(boost::asio::io_context& ioc):_socket(ioc){}boost::asio::ip::tcp::socket& Socket(){return _socket;}void Start();
private:void handle_read(const boost::system::error_code& ec, size_t bytes_transferred);void handle_write(const boost::system::error_code& ec);boost::asio::ip::tcp::socket _socket;const static int max_length = 1024;char _data[max_length];
};

  其中，成员变量_data就是用来存储数据的，而_socket则是用来服务当前客户端的，handle_read和handle_write分别是异步写和异步读的回调函数

start函数

void Session::Start()
{memset(_data, 0, max_length);_socket.async_read_some(boost::asio::buffer(_data, max_length),std::bind(&Session::handle_read, this, std::placeholders::_1, std::placeholders::_2));
}

  在Start函数中，先将_data中的数据清空防止数据污染。然后采用异步读取方式来准备接收客户端发送过来的数据。

handle_read

void Session::handle_read(const boost::system::error_code& ec, size_t bytes_transferred)
{if (ec.value() == 0){//将读到的数据全部发回去std::cout << "server has received:" << _data << std::endl;boost::asio::async_write(_socket,boost::asio::buffer(_data, bytes_transferred),std::bind(&Session::handle_write, this, std::placeholders::_1));}else{std::cout << "error code:" << ec.value() << " error message:" << ec.message() << std::endl;delete this;}
}

  当一次异步读事件结束之后，会调用回调函数handle_read。在这个回调函数中，会先将收到的数据打印出来，然后进行异步写操作。

handle_write

void Session::handle_write(const boost::system::error_code& ec)
{if (ec.value() == 0){memset(_data, 0, max_length);_socket.async_read_some(boost::asio::buffer(_data, max_length),std::bind(&Session::handle_read, this, std::placeholders::_1, std::placeholders::_2));}else{std::cout << "error code:" << ec.value() << " error message:" << ec.message() << std::endl;delete this;}
}

  当一次写操作结束之后，又会调用handle_write，此时服务端又开始在准备接收客户端的发送过来的消息

Server类

  Server类为服务器接收连接的管理类

class Server
{
public:Server(boost::asio::io_context& ioc, short port);
private:void start_accept();void handle_accept(Session* new_session,const boost::system::error_code& ec);boost::asio::io_context& _ioc;boost::asio::ip::tcp::acceptor _acceptor;
};

构造函数

Server::Server(boost::asio::io_context& ioc, short port):_ioc(ioc),_acceptor(ioc,boost::asio::ip::tcp::endpoint(boost::asio::ip::tcp::v4(),port))
{start_accept();
}

  在构造函数中，先创建一个acceptor对象并绑定ip和端口，然后调用start_accept函数

start_accept

void Server::start_accept()
{Session* session = new Session(_ioc);_acceptor.listen();_acceptor.async_accept(session->Socket(), std::bind(&Server::handle_accept, this, session, std::placeholders::_1));
}

  在start_accept函数中，先创建一个会话类，然后_acceptor对象去监听是否有客户端连接

_acceptor.async_accept(session->Socket(), std::bind(&Server::handle_accept, this, session, std::placeholders::_1));

  以上这段代码就是_acceptor在等待客户端的连接，如果有客户端来连接的话，就用先前创建的会话类对象来管理这个连接，并且调用handle_accept

handle_accept

void Server::handle_accept(Session* new_session, const boost::system::error_code& ec)
{if (ec.value() == 0){new_session->Start();}else{delete new_session;}start_accept();
}

  如果发现没有什么问题的话，就启用这个会话类让它去接收客户端发来的消息并将消息回传回去

可能会造成的隐患

  在实际的应用中，很少会出现异步读和异步写事件只挂起一个的现象，通常情况下，它们是相互独立的，即可能服务端正在接收客户端发来的数据同时，它也正在向客户端发送数据。这样的话，代码就要修改成这样

void Session::handle_read(const boost::system::error_code& ec, size_t bytes_transferred)
{if (ec.value() == 0){//将读到的数据全部发回去memset(_data, 0, max_length);_socket.async_read_some(boost::asio::buffer(_data, max_length),std::bind(&Session::handle_read, this, std::placeholders::_1, std::placeholders::_2));std::cout << "server has received:" << _data << std::endl;boost::asio::async_write(_socket,boost::asio::buffer(_data, bytes_transferred),std::bind(&Session::handle_write, this, std::placeholders::_1));}else{std::cout << "error code:" << ec.value() << " error message:" << ec.message() << std::endl;delete this;}
}

  即在读回调事件处理完之后，又同时挂起一个读事件和一个写事件(暂不考虑数据冲突的问题)。但是如果在服务端正要写数据的时候，客户端关闭连接，就会同时触发读回调和写回调，

利用伪闭包延长连接的生命周期

在这里采用了智能指针的方式来构造一个伪闭包用来延长session对象的生命周期

class Server
{
public:Server(boost::asio::io_context& ioc, short port);void ClearSession(std::string uuid);
private:void start_accept();void handle_accept(std::shared_ptr<Session> new_session,const boost::system::error_code& ec);boost::asio::io_context& _ioc;boost::asio::ip::tcp::acceptor _acceptor;std::map<std::string, std::shared_ptr<Session>> _sessions;
};

void Server::ClearSession(std::string uuid)
{_sessions.erase(uuid);
}

  在Server类中添加了一个map结构用来管理每个Session。ClearSession函数用来将session从map中清除出去

class Server;
class Session:public std::enable_shared_from_this<Session>
{
public:Session(boost::asio::io_context& ioc,Server* server):_socket(ioc),_server(server){boost::uuids::uuid a_uuid = boost::uuids::random_generator()();_uuid = boost::uuids::to_string(a_uuid);}boost::asio::ip::tcp::socket& Socket(){return _socket;}const std::string& uuid();void Start();
private:void handle_read(const boost::system::error_code& ec, size_t bytes_transferred,std::shared_ptr<Session> self_shared);void handle_write(const boost::system::error_code& ec, std::shared_ptr<Session> self_shared);boost::asio::ip::tcp::socket _socket;const static int max_length = 1024;char _data[max_length];Server* _server;std::string _uuid;
};

  在Session类中，首先在构造函数中构造一个uuid用来为每个会话类对象创建一个“key值”以方便Server对每个连接进行管理

void Session::Start()
{memset(_data, 0, max_length);_socket.async_read_some(boost::asio::buffer(_data, max_length),std::bind(&Session::handle_read, this, std::placeholders::_1, std::placeholders::_2,shared_from_this()));
}

  在Start函数中，由于handle_read函数和handle_write函数添加了指向自身的智能指针，所以在bind操作的最后一个参数采用了shared_from_this的写法用来确保每个智能指针共享的是同一份引用计数。

void Session::handle_read(const boost::system::error_code& ec, size_t bytes_transferred, std::shared_ptr<Session> self_shared)
{if (ec.value() == 0){//memset(_data, 0, max_length);_socket.async_read_some(boost::asio::buffer(_data, max_length),std::bind(&Session::handle_read, this, std::placeholders::_1, std::placeholders::_2,self_shared));//将读到的数据全部发回去std::cout << "server has received:" << _data << std::endl;boost::asio::async_write(_socket,boost::asio::buffer(_data, bytes_transferred),std::bind(&Session::handle_write, this, std::placeholders::_1,self_shared));}else{std::cout << "error code:" << ec.value() << " error message:" << ec.message() << std::endl;//delete this;_server->ClearSession(_uuid);}
}void Session::handle_write(const boost::system::error_code& ec, std::shared_ptr<Session> self_shared)
{if (ec.value() == 0){memset(_data, 0, max_length);_socket.async_read_some(boost::asio::buffer(_data, max_length),std::bind(&Session::handle_read, this, std::placeholders::_1, std::placeholders::_2,self_shared));}else{std::cout << "error code:" << ec.value() << " error message:" << ec.message() << std::endl;//delete this;_server->ClearSession(_uuid);}
}

  在handle_read和handle_write函数中，都取消了之前直接delete的做法而是采用将当前对象从Server的map中清除出去，如果map中没有找到当前对象就当作无事发生。这样写的好处是最大程度上保证了session对象的生命周期和当前所在函数的生命周期至少是一致的，不会发生当前正在使用一个对象，但是这个对象已经在其他函数内部被释放了造成异常的现象。