整合封装服务器模块设计实现
服务器模块，是对当前所实现的所有模块的⼀个整合，并进⾏服务器搭建的⼀个模块，最终封装实现出⼀个gobang_server的服务器模块类，向外提供搭建五⼦棋对战服务器的接⼝。通过实例化的对象可以简便的完成服务器的搭建。
服务器框架
首先，我将采用websocketpp来搭建服务器，那么需要清楚的是，搭建服务器的流程：
1.实例化出server对象
2.设置日志等级
3.初始化asio调度器
4.设置回调函数
5.设置监听端口
6.开始获取新连接
7.启动服务器
#ifndef __M_SRV_H__
#define __M_SRV_H__
#include "db.hpp"
#include "matcher.hpp"
#include "online.hpp"
#include "room.hpp"
#include "session.hpp"
#include "util.hpp"
#define WWWROOT "./wwwroot/"
class gobang_server
{
private:
std::string _web_root;//静态资源根目录 ./wwwroot/
wsserver_t _wssrv;
user_table _ut;
online_manager _om;
room_manager _rm;
matcher _mm;
session_manager _sm;
private:
//http请求处理回调函数
void http_callback(wsserver_t* srv,websocketpp::connection_hdl hdl)
{
}
// websocket连接成功的回调函数
void wsopen_callback(wsserver_t* srv,websocketpp::connection_hdl hdl)
{
}
// websocket关闭连接成功的回调函数
void wsclose_callback(wsserver_t* srv,websocketpp::connection_hdl hdl)
{
}
// websocket连接收到消息的回调函数
void wsmsg_callback(wsserver_t* srv,websocketpp::connection_hdl hdl,wsserver_t::message_ptr msg)
{
}
public:
gobang_server(onst std::string &host,
const std::string &user,
const std::string &pass,
const std::string &dbname,
uint16_t port = 3306,
const std::string &wwwroot = WWWROOT)
_web_root(wwwroot), _ut(host, user, pass, dbname, port),
_rm(&_ut, &_om), _sm(&_wssrv), _mm(&_rm, &_ut, &_om)
{
//设置日志等级
_wssrv.set_access_channels(websocketpp::log::alevel::none);/*禁止日志等级，不打印*/
//初始化asio调度器
_wssrv.init_asio();
_wssrv.set_reuse_addr(true);
//设置回调函数
_wssrv.set_http_handler(std::bind(&gobang_server::http_callback,this,std::placeholders::_1));
_wssrv.set_open_handler(std::bind(&gobang_server::wsopen_callback,this,std::placeholders::_1));
_wssrv.set_close_handler(std::bind(&gobang_server::wsclose_callback,this,std::placeholders::_1));
_wssrv.set_message_handler(std::bind(&gobang_server::wsmsg_callback,this,std::placeholders::_1,std::placeholders::_2));
}
void start(int port)
{
//1.设置监听端口
_wssrv.listen(8888);
//2.开始获取新连接
_wssrv.start_accept();
//3.启动服务器
_wssrv.run();
}
};
#endif1.http请求回调处理函数
需要用到HTTP请求进行短连接的是用户注册、用户登录和获取用户信息的功能请求处理，以及静态资源请求处理的方法。
①静态资源请求处理
当我们打开客户端，迎面而来的是登录页面，因此，在静态资源请求处理中，我们需要获取到登录页面的实际路径。
流程：首先需要获取HTTP请求的对象，通过请求对象，获取到HTTP请求中的uri，然后将uri和根目录路径进行组合，组合成为实际路径。然后通过read来读取文件内容，并将其返回响应。
/*静态资源请求处理*/
void file_handler(wsserver_t::connection_ptr& conn)
{
/*对于静态资源的请求，我们需要先获取HTTP请求对象，然后通过请求对象，获取HTTP请求中的uri*/
//1.获取到请求uri--资源路径，要了解客户端的页面文件名称
websocketpp::http::parser::request req = conn->get_request();
std::string uri = req.get_uri();
//2.组合出文件的实际路径 相对根目录+uri
std::string realpath = _web_root+uri;
//3.如果在实际路径中最后的字符是/，那么表示是目录的路径，需要再加上静态资源的路径
if(realpath.back()=='/')//目录
{
realpath+="login.html";//
}
//4.读取文件内容
std::string body;
bool ret = file_util::read(realpath,body);
//如果文件不存在，则读取失败，返回404
if(ret==false)
{
body += "";
body += "";
body += "";
body += "";
body += "";
body += " Not Found
";
body += "";
conn->set_status(websocketpp::http::status_code::not_found);
conn->set_body(body);
return;
}
//5.设置响应正文
conn->set_status(websocketpp::http::status_code::ok);
conn->set_body(body);
}②用户注册请求处理
用户注册请求处理，首先通过通信连接，获取到HTTP请求的正文，然后对正文进行反序列化，得到用户和密码。接着，对用户和密码进行完整性校验，若是完整，那么通过数据模块管理对象进行插入，完成注册，最后，将注册完成响应回给客户端。
其中的http_resp方法，是封装了响应信息的填充。包括了原因、结果，以及将其序列化后，返回给客户端。
void http_resp(wsserver_t::connection_ptr& conn,bool result,
websocketpp::http::status_code::value code,const std::string& reason)
{
Json::Value resp_json;
resp_json["result"] = result;
resp_json["reason"] = reason;
std::string resp_body;
json_util::serialize(resp_json,resp_body);
conn->set_status(code);
conn->set_body(resp_body);
conn->append_header("Content-Type", "application/json");
return;
}
/*用户注册请求处理*/
void reg(wsserver_t::connection_ptr& conn)
{
/*从前端页面中获取数据，然后新增进数据库中，并且成功，就代表注册成功*/
//1.获取正文内容
//先获取请求对象，然后通过连接获取请求正文
websocketpp::http::parser::request req = conn->get_request();
std::string req_body = conn->get_request_body();
//2.对正文内容进行反序列化，得到用户和密码
Json::Value login_info;
bool ret = json_util::unserialize(req_body,login_info);
if(ret==false)
{
DLOG("反序列化注册信息失败");
return http_resp(conn,false,websocketpp::http::status_code::bad_request,"请求正文格式错误");
}
//3.进行数据库的插入
if(login_info["username"].isNull() || login_info["password"].isNull())
{
DLOG("⽤⼾名密码不完整");
return http_resp(conn,false,websocketpp::http::status_code::bad_request,"请输入用户名/密码");
}
ret = _ut.insert(login_info);
if(ret==false)
{
DLOG("向数据库插⼊数据失败");
return http_resp(conn,false,websocketpp::http::status_code::bad_request,"用户名已经被占用");
}
return http_resp(conn,true,websocketpp::http::status_code::ok,"注册成功");
}注册请求前端页面
注册
注册
⽤⼾名
密码
③用户登录请求处理
流程：
首先获取到HTTP请求正文，然后将其反序列化后，得到用户的账号和密码。接着对账号密码进行校验，并查询到该用户的所有信息。然后为该用户创建session，session创建成功后，为HTTP响应中的cookie信息填入该session的sid。最后，将信息响应给客户端。
/*用户登录请求处理*/
void login(wsserver_t::connection_ptr& conn)
{
//1.获取正文信息，并进行反序列化，得到用户账号和密码
std::string resp_body = conn->get_request_body();
Json::Value login_info;
bool ret = json_util::unserialize(resp_body,login_info);
if(ret==false)
{
DLOG("反序列化登录信息失败");
return http_resp(conn,false,websocketpp::http::status_code::bad_request,"反序列化登录信息失败");
}
//2.对账户和密码进行校验，并且将该用户的信息全部填充到login_info中
ret = _ut.login(login_info);
if(ret==false)
{
DLOG("用户名或密码错误");
return http_resp(conn,false,websocketpp::http::status_code::bad_request,"用户名或密码错误");
}
//3.登录成功后，为用户创建session
uint64_t uid = login_info["id"].asUInt64();
session_ptr ssp = _sm.create_session(uid,LOGIN);
if(ssp.get()==nullptr)
{
DLOG("创建会话失败");
return http_resp(conn,false,websocketpp::http::status_code::bad_request,"创建会话失败");
}
//4.session创建成功后，设置响应头部：Set-Cookie,将session通过cookie返回
/*将在HTTP响应中，将其中的cookie信息填入：SSID=...*/
std::string cooike_ssid = "SSID="+std::to_string(ssp->ssid());
/*填入cookie信息*/
conn->append_header("Set-Cookie",cooike_ssid);
//登录完成，将信息响应回给客户端
return http_resp(conn,true,websocketpp::http::status_code::ok,"登录成功");
}登录请求前端页面：
登录
登录
用户名
密码
④获取用户信息请求处理
在登录账号，进入游戏大厅中后，游戏大厅需要显示该用户的所有信息。因此，在获取用户信息请求的处理中，首先通过HTTP请求中的cookie信息，找到对应的session的ssid，接着，通过ssid找到对应的session对话信息，从对话信息中找到用户id，接着，通过用户id，从数据库中查询到该用户的信息并存储在Json对象中，接着，将其序列化，最后响应回给客户端。最后一步，登录之后，需要刷新session的定时器的过期时间。
方法get_cookie_val是将cookie中提取ssid的方法，cookie中的每一个信息是以"; "作为分隔符的。
bool get_cookie_val(const std::string& cookie_str,const std::string& key,std::string& val)
{
std::string sep="; ";
std::vector cookie_arr;
string_util::split(cookie_str, sep, cookie_arr);
for(auto str:cookie_arr)
{
std::vector tmp_arr;
string_util::split(str,"=",tmp_arr);
if(tmp_arr.size()!=2){continue;}
if(tmp_arr[0]==key)
{
val = tmp_arr[1];
return true;
}
}
return false;
}
/*用户信息获取功能请求处理*/
void info(wsserver_t::connection_ptr& conn)
{
//⽤⼾信息获取功能请求的处理
Json::Value err_resp;
// 1. 获取请求信息中的Cookie，从Cookie中获取ssid
std::string cookie_str = conn->get_request_header("Cookie");
if (cookie_str.empty())
{
//如果没有cookie，返回错误：没有cookie信息，让客⼾端重新登录
return http_resp(conn, true,
websocketpp::http::status_code::bad_request, "找不到cookie信息，请重新登录");
}
// 1.5. 从cookie中取出ssid
std::string ssid_str;
bool ret = get_cookie_val(cookie_str, "SSID", ssid_str);
if (ret == false)
{
//cookie中没有ssid，返回错误：没有ssid信息，让客⼾端重新登录
return http_resp(conn, true,
websocketpp::http::status_code::bad_request, "找不到ssid信息，请重新登录");
}
// 2. 在session管理中查找对应的会话信息
session_ptr ssp = _sm.get_session_by_ssid(std::stol(ssid_str));
if (ssp.get() == nullptr)
{
//没有找到session，则认为登录已经过期，需要重新登录
return http_resp(conn, true,
websocketpp::http::status_code::bad_request, "登录过期，请重新登录");
}
// 3. 从数据库中取出⽤⼾信息，进⾏序列化发送给客⼾端
uint64_t uid = ssp->get_user();
Json::Value user_info;
ret = _ut.select_by_id(uid, user_info);
if (ret == false)
{
//获取⽤⼾信息失败，返回错误：找不到⽤⼾信息
return http_resp(conn, true,
websocketpp::http::status_code::bad_request, "找不到用户信息，请重新登录");
}
std::string body;
json_util::serialize(user_info, body);
conn->set_body(body);
conn->append_header("Content-Type", "application/json");
conn->set_status(websocketpp::http::status_code::ok);
// 4. 刷新session的过期时间
_ss.set_session_expire_time(ssp->ssid(), SESSION_TIMEOUT);
} HTTP请求回调处理函数
在回调函数中，通过HTTP请求中的方法和uri，来判断需要处理的业务是哪个，因此，首先需要获取客户端通信连接，然后通过通信连接获取HTTP请求对象，通过HTTP请求对象获取uri和方法。
然后通过方法和uri，来确定需要处理的业务是哪个：
void http_callback(websocketpp::connection_hdl hdl)
{
wsserver_t::connection_ptr conn = _wssrv.get_con_from_hdl(hdl);
websocketpp::http::parser::request req = conn->get_request();
std::string method = req.get_method();
std::string uri = req.get_uri();
if (method == "POST" && uri == "/reg")
{
return reg(conn);
}
else if (method == "POST" && uri == "/login")
{
return login(conn);
}
else if (method == "GET" && uri == "/info")
{
return info(conn);
}
else
{
return file_handler(conn);
}
}2.websocket连接成功的回调函数
websocket连接成功的回调函数，在websocket长连接建立成功后，主要处理的两个业务：
1.游戏大厅长连接的建立
2.游戏房间的长连接的建立
①游戏大厅长连接的建立
想要成功建立游戏大厅的长连接，首先需要通过通信连接，获取到session对话信息，获取session对话信息主要是需要获得该客户端的用户uid，然后将用户uid和通信连接加入到游戏大厅中。
对于通过通信连接获取session对话信息，则是通过通信连接，获取websocket请求中的cookie，然后从cookie中获取ssid，然后通过ssid在session管理中查找对应的session会话信息。
void ws_resp(wsserver_t::connection_ptr conn,Json::Value& resp)
{
std::string body;
json_util::serialize(resp,body);
conn->send(body);
}
//找到session对话信息
session_ptr get_session_by_cookie(wsserver_t::connection_ptr conn)
{
/*通过通信连接，获取websocket请求中的cookie，然后从cookie中获取ssid，
取出ssid后，通过ssid最终获取session对话信息*/
Json::Value err_resp;
//1.获取请求信息中的Cookie，从Cookie中获取ssid
std::string cookie_str = conn->get_request_header("Cookie");
if(cookie_str.empty())
{
err_resp["optype"]="hall_ready";
err_resp["reason"] = "没有找到cookie信息，需要重新登录";
err_resp["result"]=false;
//把错误信息响应回去
ws_resp(conn,err_resp);
return session_ptr();
}
//1.1 获取cookie信息成功后，取出ssid
std::string ssid_str;
bool ret = get_cookie_val(cookie_str,"SSID",ssid_str);
if(ret==false)
{
err_resp["optype"]="hall_ready";
err_resp["reason"] = "没有找到SSID信息，需要重新登录";
err_resp["result"]=false;
//把错误信息响应回去
ws_resp(conn,err_resp);
return session_ptr();
}
//2. 通过ssid在session管理中查找对应的会话信息
session_ptr ssp = _sm.get_session_by_ssid(std::stol(ssid_str));
if(ssp.get()==nullptr)
{
err_resp["optype"]="hall_ready";
err_resp["reason"] = "没有找到session信息，需要重新登录";
err_resp["result"]=false;
//把错误信息响应回去
ws_resp(conn,err_resp);
return session_ptr();
}
return ssp;
}
void wsopen_game_hall(wsserver_t::connection_ptr conn)
{
//游戏大厅长连接建立成功
Json::Value resp_json;
//1.登录验证--判断当前客户端是否已经成功登录
session_ptr ssp = get_session_by_cookie(conn);
if(ssp.get()==nullptr)
{
return;
}
//2.判断当前客户端是否异地登陆
if(_om.is_in_game_hall(ssp->get_user()) || _om.is_in_game_room(ssp->get_user()))
{
resp_json["optype"] = "hall_ready";
resp_json["reason"] = "玩家重复登录！";
resp_json["result"] = false;
return ws_resp(conn, resp_json);
}
//3. 将当前客⼾端以及连接加⼊到游戏⼤厅
_om.enter_game_hall(ssp->get_user(), conn);
//4. 给客⼾端响应游戏⼤厅连接建⽴成功
resp_json["optype"] = "hall_ready";
resp_json["result"] = true;
ws_resp(conn, resp_json);
//5. 记得将session设置为永久存在
_sm.set_session_expire_time(ssp->ssid(), SESSION_FOREVER);
}②游戏房间长连接的建立
与游戏大厅长连接的建立差不多，首先通过通信连接获取到该客户端的session，然后通过session获取到用户的uid，然后将当前用户添加到在线用户管理的房间当中。还需通过uid，获取到对应的房间信息，将房间信息响应给客户端。
void wsopen_game_room(wsserver_t::connection_ptr conn)
{
//游戏房间长连接建立成功
Json::Value resp_json;
//1.获取当前客户端的session
session_ptr ssp = get_session_by_cookie(conn);
if(ssp.get()==nullptr)
{
return;
}
//2.判断当前用户是否已经在在线用户管理的游戏房间或游戏大厅中--如果在，不能异地登陆/重复登录
if(_om.is_in_game_hall(ssp->get_user()) || _om.is_in_game_room(ssp->get_user()))
{
resp_json["optype"] = "room_ready";
resp_json["reason"] = "玩家重复登录";
resp_json["result"] = false;
return ws_resp(conn,resp_json);
}
//3.判断当前用户已经是否创建好了房间--房间管理
//根据用户id，获取所在的房间的信息
room_ptr rp= _rm.get_room_by_uid(ssp->get_user());
if(rp.get()==nullptr)
{
resp_json["optype"] = "room_ready";
resp_json["reason"] = "没有找到玩家房间的信息";
resp_json["result"] = false;
return ws_resp(conn,resp_json);
}
//4.将当前用户添加到在线用户管理的房间当中
_om.enter_game_room(ssp->get_user(),conn);
//5.将session设置为永久存在
_sm.set_session_expire_time(ssp->ssid(), SESSION_FOREVER);
//6.将房间准备响应回去
resp_json["optype"] = "room_ready";
resp_json["result"] = true;
resp_json["room_id"] = (Json::UInt64)rp->get_rid();
resp_json["uid"] = (Json::UInt64)ssp->get_user();
resp_json["white_id"] = (Json::UInt64)rp->get_white_user();
resp_json["black_id"] = (Json::UInt64)rp->get_black_user();
return ws_resp(conn,resp_json);
}websocket长连接建立成功的回调函数
通过通信连接，获取到websocket请求对象，进而获取到uri，通过uri来判断业务的请求。
/*游戏大厅长连接处理*/
void wsopen_callback(websocketpp::connection_hdl hdl)
{
//从uri中获取资源路径，从而得知是游戏房间的请求还是游戏大厅的请求
wsserver_t::connection_ptr conn = _wssrv.get_con_from_hdl(hdl);
websocketpp::http::parser::request req = conn->get_request();
std::string uri = req.get_uri();
if(uri=="/hall")
{
//获取的是游戏大厅的长连接
return wsopen_game_hall(conn);
}
else if(uri=="/room")
{
//获取的是游戏房间的长连接
return wsopen_game_room(conn);
}
}3.websocket关闭连接的回调函数
websocket连接关闭的回调函数，在websocket长连接关闭成功后，主要处理的两个业务：
1.游戏大厅长连接的关闭
2.游戏房间的长连接的关闭
①游戏大厅长连接的关闭
通过通信连接，获取session对话信息，通过session对话信息，获取uid，然后将玩家从游戏大厅中移除，最后重新设置session定时器定时删除。
//游戏大厅关闭长连接
void wsclose_game_hall(wsserver_t::connection_ptr conn)
{
//游戏⼤厅⻓连接断开的处理
//1. 登录验证--判断当前客⼾端是否已经成功登录
session_ptr ssp = get_session_by_cookie(conn);
if(ssp.get()==nullptr)
{
return;
}
//2.将玩家从大厅中移除
_om.exit_game_hall(ssp->get_user());
//2.将session恢复声明周期管理，设置定时删除
_sm.set_session_expire_time(ssp->ssid(),SESSION_TIMEOUT);
}②.游戏房间的长连接的关闭
通过通信连接，获取session对话信息，然后通过session对话信息，获取到uid，将玩家从在线用户管理中移除，重新设置定时器，最后将玩家从房间中移除。
//游戏房间关闭长连接
void wsclose_game_room(wsserver_t::connection_ptr conn)
{
//获取会话信息，识别客⼾端
session_ptr ssp = get_session_by_cookie(conn);
if(ssp.get()==nullptr)
{
return;
}
//2.将玩家从在线用户管理中移除
_om.exit_game_room(ssp->get_user());
//3.将session恢复声明周期管理，设置定时删除
_sm.set_session_expire_time(ssp->ssid(),SESSION_TIMEOUT);
//4.将玩家从房间移除
_rm.remove_room_user(ssp->get_user());
}websocket长连接关闭成功的回调函数
获取客户端的通信连接，通过通信连接获取到websocket请求对象，通过请求对象获取uri，通过uri判断业务的处理请求。
void wsclose_callback(websocketpp::connection_hdl hdl)
{
//从uri中获取资源路径，从而得知是游戏房间的请求还是游戏大厅的请求
wsserver_t::connection_ptr conn = _wssrv.get_con_from_hdl(hdl);
websocketpp::http::parser::request req = conn->get_request();
std::string uri = req.get_uri();
if(uri=="/hall")
{
//获取的是游戏大厅的长连接
return wsclose_game_hall(conn);
}
else if(uri=="/room")
{
//获取的是游戏房间的长连接
return wsclose_game_room(conn);
}
}4. websocket连接收到消息的回调函数
websocket连接收到消息，主要是两种业务处理请求：
1.游戏大厅中的匹配对战
2.房间中的下棋或聊天动作
① 在游戏大厅中开始进行匹配对战
首先需要获取两样东西，第一个是通过通信连接，获取session对话信息。第二个是获取请求的消息。
先是将请求消息进行反序列化，得到匹配对战的相关内容，根据内容，处理不同的情况：
情况一：开始匹配对战。
在这种情况下，通过session对话信息，获取uid，然后将玩家添加到匹配队列当中，然后将信息向客户端进行响应。
情况二：匹配中止。
在这种情况下，通过session对话信息，获取uid，然后i将玩家从匹配队列中移除，然后将信息向客户端进行相应。
情况三：未知消息的处理。
//在游戏大厅中开始进行匹配对战
void wsmsg_game_hall(wsserver_t::connection_ptr conn,wsserver_t::message_ptr msg)
{
Json::Value resp_json;
std::string resp_body;
//1.身份验证，看看当前客户端是哪个玩家
session_ptr ssp = get_session_by_cookie(conn);
if(ssp.get()==nullptr)
{
return;
}
//2.获取请求信息
std::string req_body = msg->get_payload();
Json::Value req_json;
bool ret = json_util::unserialize(req_body,req_json);
if(ret==false)
{
resp_json["result"] = false;
resp_json["reason"] = "请求信息解析失败";
return ws_resp(conn,resp_json);
}
//3.对于请求进行处理
if (!req_json["optype"].isNull() && req_json["optype"].asString()== "match_start")
{
//开始匹配对战：通过匹配模块，将玩家添加到对应的匹配队列当中
_mm.add(ssp->get_user());
resp_json["optype"] = "match_start";
resp_json["result"] = true;
return ws_resp(conn,resp_json);
}
else if(!req_json["optype"].isNull() && req_json["optype"].asString()== "match_stop")
{
// 停⽌对战匹配：通过匹配模块，将⽤⼾从匹配队列中移除
_mm.del(ssp->get_user());
resp_json["optype"] = "match_stop";
resp_json["result"] = true;
return ws_resp(conn,resp_json);
}
resp_json["optype"] = "unknow";
resp_json["reason"] = "请求类型未知";
resp_json["result"] = false;
return ws_resp(conn, resp_json);
}游戏大厅匹配前端技术：
游戏大厅
②游戏房间中进行下棋或聊天动作
首先，通过通信连接，获取session会话信息， 然后通过session会话信息，获取uid，通过uid，获取房间信息。将消息获取下来，进行反序列化，存储在Json对象中，最后，将Json对象交给房间管理模块，让其处理下棋或聊天动作。
//进入房间进行下棋对战或聊天
void wsmsg_game_room(wsserver_t::connection_ptr conn,wsserver_t::message_ptr msg)
{
Json::Value resp_json;
//1.获取session，识别客户端身份
session_ptr ssp = get_session_by_cookie(conn);
if(ssp.get()==nullptr)
{
DLOG("房间-没有找到会话信息");
return;
}
//2.获取客⼾端房间信息
room_ptr rp = _rm.get_room_by_uid(ssp->get_user());
if(rp.get()==nullptr)
{
resp_json["optype"] = "unknow";
resp_json["reason"] = "没有找到玩家的房间信息";
resp_json["result"] = false;
DLOG("房间-没有找到玩家房间信息");
return ws_resp(conn, resp_json);
}
//3.对消息进行反序列化
Json::Value req_json;
std::string req_body = msg->get_payload();
bool ret = json_util::unserialize(req_body,req_json);
if(ret==false)
{
resp_json["optype"] = "unknow";
resp_json["reason"] = "请求信息解析失败";
resp_json["result"] = false;
DLOG("房间-请求信息解析失败");
return ws_resp(conn, resp_json);
}
DLOG("房间：收到房间请求，开始处理....");
//4. 通过房间模块进⾏消息请求的处理
return rp->handle_request(req_json);
}游戏房间下棋聊天动作前端技术
游戏房间
等待玩家连接中...
你好！
你好！
leihoua~
websocket连接收到消息的回调函数
获取通信连接，通过通信连接获取websocket请求对象，通过请求对象获取uri，通过uri判断业务处理的请求。
void wsmsg_callback(websocketpp::connection_hdl hdl,wsserver_t::message_ptr msg)
{
wsserver_t::connection_ptr conn = _wssrv.get_con_from_hdl(hdl);
websocketpp::http::parser::request req = conn->get_request();
std::string uri = req.get_uri();
if (uri == "/hall")
{
//建⽴了游戏⼤厅的⻓连接
return wsmsg_game_hall(conn, msg);
}
else if (uri == "/room")
{
//建⽴了游戏房间的⻓连接
return wsmsg_game_room(conn, msg);
}
}