Server 类实现
server.h
#ifndef MYSERVER_H
#define MYSERVER_H
#ifndef _WIN32_WINNT
#define _WIN32_WINNT 0x0600
#endif // !_WIN32_WINNT
#ifndef ASIO_STANDALONE
#define ASIO_STANDALONE
#endif//ASIO_STANDALONE
#include"Session.h"
#include <asio.hpp>
#include<thread>
#include<map>
class MyServer
{
public:
MyServer();
~MyServer();
void init();
void start();
void onStart();
void run();
void wait();
void stop();
void command();
void removeSession(int id);
private:
void do_accept();
void accept_handler(Session *session, const asio::error_code &error);
private:
asio::io_service *m_io_service;
asio::io_service::work *m_service_work;//
asio::ip::tcp::endpoint* m_endpoint;
asio::ip::tcp::acceptor * m_acceptor;
asio::ip::tcp::socket * m_socket;
std::thread * m_thread;
asio::error_code m_ec;
bool m_running;
int m_currentSessionId ;
std::map<int, Session*> m_sessionMap;
};
#endif//M
server.cpp
#include "MyServer.h"
#include <iostream>
using namespace std;
MyServer::MyServer():m_currentSessionId(0),m_running(false)
{
m_io_service= new asio::io_service();
m_service_work=new asio::io_service::work(*m_io_service);
m_endpoint=new asio::ip::tcp::endpoint(asio::ip::tcp::v4(),54545);
m_acceptor=new asio::ip::tcp::acceptor(*m_io_service,*m_endpoint);
m_socket=new asio::ip::tcp::socket(*m_io_service);
}
void MyServer::init(){
}
void MyServer::start(){
m_running=true;
m_thread = new std::thread(&MyServer::command, this);
run();
}
void MyServer::command()
{
int sid=0;
char cmd[128];
while(true){
std::cin>>sid>>cmd;
size_t len=std::strlen(cmd);
cmd[len]='\0';
if(sid==0){
std::cout<<"stop cmd!\n";
break;
}else{
Session *s=m_sessionMap.at(sid);
if(s) s->write(cmd);
else std::cout<<"fail to find session:id="<<sid<<std::endl;
}
}
}
void MyServer::onStart()
{
m_acceptor->listen();
cout<<"start listening!\n";
do_accept();
}
void MyServer::run(){
onStart();
m_io_service->run();
}
void MyServer::stop(){
m_running = false;
}
void MyServer::wait(){
m_thread->join();
}
void MyServer::do_accept(){
Session *session = new Session(m_io_service);
if (session)
{
//async_accept(socket,fun)--每次建立连接时,新建socket
m_acceptor->async_accept(*(session->getSocket()),std::bind(&MyServer::accept_handler, this, session, std::placeholders::_1));
}
else
{
cout<<"allocate client session failed\n";
}
}
void MyServer::accept_handler(Session *session, const asio::error_code &error)
{
if (session != NULL && !error)
{
m_currentSessionId++;
session->setId(m_currentSessionId);
printf("Client Session %d Connected\n", m_currentSessionId);
m_sessionMap[m_currentSessionId] = session;
session->read();
}
do_accept();
}
void MyServer::removeSession(int id){
Session *s=m_sessionMap.at(id);
delete s;
m_sessionMap.erase(id);
}
MyServer::~MyServer(){
map<int,Session*>::iterator it;
for(it=m_sessionMap.begin();it!=m_sessionMap.end();++it){
delete it->second;
}
delete m_service_work;
delete m_io_service;
delete m_endpoint;
delete m_acceptor;
delete m_socket;
}
session.h
#ifndef SESSION_H
#define SESSION_H
#ifndef _WIN32_WINNT
#define _WIN32_WINNT 0x0600
#endif // !_WIN32_WINNT
#ifndef ASIO_STANDALONE
#define ASIO_STANDALONE
#endif//ASIO_STANDALONE
#include<asio.hpp>
#include<iostream>
class Session
{
public:
explicit Session(asio::io_service* arg_ios);
~Session();
void start();
void reset();//重置会话
void read();//异步接收消息
void on_read(const asio::error_code &error, size_t bytes_transferred);
void write(char * data);
void on_write(char *data ,const asio::error_code &error, size_t bytes_transferred);
asio::ip::tcp::socket* Session::getSocket();
void setId(int id);
int getId();
private:
asio::ip::tcp::socket *m_socket;
int m_sessionId;
char * read_data;
};
#endif//SESSION_H
session.cpp
#include"Session.h"
Session::Session(asio::io_service* arg_ios)
{
m_socket=new asio::ip::tcp::socket(*arg_ios);
read_data=new char [128];
}
void Session::start()
{
}
void Session::reset(){
m_socket->close();
}
void Session::read()
{
m_socket->async_read_some(asio::buffer(read_data, 128),std::bind(&Session::on_read,this,std::placeholders::_1,std::placeholders::_2));
}
void Session::on_read(const asio::error_code &error, size_t bytes_transferred){
if (error || bytes_transferred == 0)
{
std::cout<<"session-id:"<<getId()<<" is closed!"<<std::endl;
return;
}else{
std::cout<<"session-id:"<<getId()<<" [msg]>>"<<read_data<<std::endl;
}
read();
}
void Session::write(char * data)
{
m_socket->async_write_some(asio::buffer(data, 128),std::bind(&Session::on_write,this,data,std::placeholders::_1,std::placeholders::_2));
}
void Session::on_write(char *data ,const asio::error_code &error, size_t bytes_transferred)
{
if (error || bytes_transferred == 0)
{
std::cout<<"session-id:"<<getId()<<" is closed!"<<std::endl;
return;
}else{
std::cout<<"send-by-session-id:"<<getId()<<" [msg]>>"<<read_data<<std::endl;
}
}
void Session::setId(int id){
m_sessionId=id;
}
int Session::getId(){
return m_sessionId;
}
asio::ip::tcp::socket* Session::getSocket()
{
return m_socket;
}
Session::~Session()
{
std::cout<<"session-"<<getId()<<" is release!\n";
}
main.cpp
#include <iostream>
#include "MyServer.h"
MyServer *s=NULL;
int main()
{
s=new MyServer();
s->start();
//system("pause");
return 0;
}