【基于 WebSocket 的多用户网页五子棋】—— 整合封装服务器模块设计实现1️⃣

🌈欢迎来到实战项目专栏 ~~ 基于 WebSocket 的多用户网页五子棋

Websocketpp

我们先来看看服务器业务请求的流程

服务器的整合实现:

  • 网络通信接口设计:收到一个什么格式的数据,代表了什么样的请求,应该给什么样的业务处理和响应
  • 开始搭建服务器 :
    • 搭建websocket服务器,实现网络通信
    • 针对各种不同的请求进行不同的业务处理

客户端所存在的请求:

👀通信接口设计(Restful风格)

静态资源请求:

静态资源页面,在后台服务器上就是个html/css/js⽂件

静态资源请求的处理,其实就是将文件中的内容发送给客户端

cpp 复制代码
1. 注册⻚⾯请求
请求:GET /register.html HTTP/1.1
响应:
HTTP/1.1 200 OK
Content-Length: xxx
Content-Type: text/html

register.html⽂件的内容数据

2. 登录⻚⾯请求
请求:GET /login.html HTTP/1.1
3. ⼤厅⻚⾯请求
请求:GET /game_hall.html HTTP/1.1
4. 房间⻚⾯请求
请求:GET /game_room.html HTTP/1.1

注册用户:

cpp 复制代码
POST /reg HTTP/1.1
Content-Type: application/json
Content-Length: 32
{"username":"xiaobai", "password":"123123"}
cpp 复制代码
#成功时的响应
HTTP/1.1 200 OK
Content-Type: application/json
Content-Length: 15

{"result":true}

#失败时的响应
HTTP/1.1 400 Bad Request
Content-Type: application/json
Content-Length: 43

{"result":false, "reason": "⽤⼾名已经被占⽤"}

用户登录: 和注册用户仅仅只是请求的资源路径不一样

cpp 复制代码
POST /login HTTP/1.1
Content-Type: application/json
Content-Length: 32

{"username":"xiaobai", "password":"123123"}
cpp 复制代码
#成功时的响应
HTTP/1.1 200 OK
Content-Type: application/json
Content-Length: 15

{"result":true}

#失败时的响应
HTTP/1.1 400 Bad Request
Content-Type: application/json
Content-Length: 43

{"result":false, "reason": "⽤⼾名或密码错误"}

获取客户端信息

cpp 复制代码
GET /userinfo HTTP/1.1
Content-Type: application/json
Content-Length: 0
cpp 复制代码
#成功时的响应
HTTP/1.1 200 OK
Content-Type: application/json
Content-Length: 58

{"id":1, "username":"xiaobai", "score":1000, "total_count":4, "win_count":2}

#失败时的响应
HTTP/1.1 401 Unauthorized
Content-Type: application/json
Content-Length: 43

{"result":false, "reason": "⽤⼾还未登录"}

websocket长连接协议切换请求(进入游戏大厅)

cpp 复制代码
/* ws://localhost:9000/hall */
GET /hall HTTP/1.1
Connection: Upgrade
Upgrade: WebSocket
.....
cpp 复制代码
HTTP/1.1 101 Switching
......

WebSocket握手成功后的回复:表示游戏大厅已经进入成功

cpp 复制代码
{
	"optype": "hall_ready",
	"uid": 1
}

开始对战匹配

cpp 复制代码
{
	"optype": "match_start"
}
cpp 复制代码
/*后台正确处理后回复*/
{
	"optype": "match_start", //表⽰成功加⼊匹配队列
	"result": true
}
/*后台处理出错回复*/
{
	"optype": "match_start"
	"result": false,
	"reason": "具体原因...."
}
cpp 复制代码
/*匹配成功了给客⼾端的回复*/
{
	"optype": "match_success",//表⽰成匹配成功
	"result": true
}

等等

👀开始搭建服务器

搭建websock服务器,实现网络通信

注意:成员按声明顺序初始化,与初始化列表书写顺序无关

紧接着是动态的读取请求方法和URI

  • get_con_from_hdl获取到connection
  • conn->get_request()去拿到req
  • 再通过req获取请求方法和uri即可
cpp 复制代码
#ifndef SERVER_HPP
#define SERVER_HPP

#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:
    //注意:C++ 成员按声明顺序初始化,与初始化列表书写顺序无关。
    //依赖关系:_rm 依赖 _ut/_om;_sm 依赖 _wssrv;_mm 依赖 _rm/_ut/_om。
    //因此声明顺序必须为:_web_root -> _ut -> _om -> _rm -> _wssrv -> _sm -> _mm。
    std::string _web_root;//静态资源根目录
    user_table _ut;
    online_manager _om;
    RoomManager _rm;
    wserver_t _wssrv;
    session_manager _sm;
    Matcher _mm;
private:
    void file_handler(wserver_t::connection_ptr &conn)
    {
        //处理静态资源请求
        
    }
    void reg(wserver_t::connection_ptr &conn)
    {
        //用户注册功能处理
    }
    void login(wserver_t::connection_ptr &conn)
    {
        //用户登录功能处理
    }
    void info(wserver_t::connection_ptr &conn)
    {
        //用户信息功能处理
    }
    void http_callback(websocketpp::connection_hdl hdl)
    {
        //读取请求方法和URI
        wserver_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();
        std::string pathname = _web_root + uri;
        std::string body;
        FileUtil::read(pathname, body);

        conn->set_status(websocketpp::http::status_code::ok);
        conn->set_body(body);
    }
    void wsopen_callback(websocketpp::connection_hdl hdl)
    {

    }
    void wsclose_callback(websocketpp::connection_hdl hdl)
    {

    }
    void wsmsg_callback(websocketpp::connection_hdl hdl, wserver_t::message_ptr msg)
    {
        
    }
public:
    //进行成员初始化,以及设置回调函数
    gobang_server(const std::string & host, 
        const std::string & username, 
        const std::string & password, 
        const std::string & dbname, 
        uint16_t port = 3306,
        const std::string &wwwroot = WWWROOT):
        _web_root(wwwroot),
        _ut(host, username, password, dbname, port),
        _om(),
        _rm(&_ut, &_om),
        _wssrv(),
        _sm(&_wssrv),
        _mm(&_rm, &_ut, &_om)
    {
        _wssrv.set_access_channels(websocketpp::log::alevel::none);
        _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) // 启动服务器
    {
        _wssrv.listen(port);
        _wssrv.start_accept();
        _wssrv.run();
    }
};

针对各种不同的请求进行不同的业务处理

静态资源请求的处理

  • 获取到请求uri - 资源路径,了解客户端请求的页面文件名称
  • 组合出文件的实际路径:相对根目录 + uri
  • 如果请求的是一个根目录/,增加一个后缀 :login.html
  • 读取文件内容(文件不存在,读取文件内容失败,返回404)
  • 设置响应正文
cpp 复制代码
//处理静态资源请求
void file_handler(wserver_t::connection_ptr &conn)
{
    // 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.如果请求的是一个根目录`/`,增加一个后缀:login.html
    if(realpath.back() == '/')
        realpath += "login.html";
    // 4.读取文件内容(文件不存在,读取文件内容失败,返回404)
    std::string body;
    Json::Value resp_json;
    bool ret = FileUtil::read(realpath, body);
    if(!ret)
    {
        body += "<html>";
        body += "<head>";
        body += "<meta charset="UTF-8"/>";
        body += "</head>";
        body += "<body>";
        body += "<h1>404 Not Found</h1>";
        body += "</body>";
        body += "</html>";
        conn->set_status(websocketpp::http::status_code::not_found);
        conn->set_body(body);
        return;
    }
    // 5.设置响应正文
    conn->set_body(body);
    conn->set_status(websocketpp::http::status_code::ok);
}

写到这里我们回去修改一下http_callback

  • 针对三个功能请求 进行分别特判、其他一律认为是静态资源请求
cpp 复制代码
void http_callback(websocketpp::connection_hdl hdl)
{
    //读取请求方法和URI
    wserver_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️⃣用户注册后台处理 & 前端处理

后台处理大体思路是:

  • 获取请求正文
  • 对正文进行json反序列化,得到用户名和密码
  • 开始讨论:请求的正文格式错误、用户或者密码为空、数据库中用户名已存在等问题
  • 最后才是注册成功!
  • 由于上述多个操作均是设置响应 json,干脆单独拎出来单独作为一个函数
cpp 复制代码
void http_resp(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;
    JsonUtil::serialize(resp_json, resp_body);
    conn->set_body(resp_body);
    conn->set_status(code);
    conn->append_header("Content-Type", "application/json");
    return;
}
void reg(wserver_t::connection_ptr &conn)
{
    //用户注册功能处理  
    //1.获取请求正文
    websocketpp::http::parser::request req = conn->get_request();
    std::string req_body = conn->get_request_body();
    //2.对正文进行json反序列化,得到用户名和密码
    Json::Value login_info; // 用户登录信息
    Json::Value resp_json; // 响应json
    bool ret = JsonUtil::unserialize(req_body, login_info);
    if(!ret)
    {
        //  失败:返回注册失败 ------ 400
        return http_resp(false, websocketpp::http::status_code::bad_request, "请求的正文格式错误");
    }
    if(login_info["username"].isNull() || login_info["password"].isNull())
    {
        //用户或者密码为空
        return http_resp(false, websocketpp::http::status_code::bad_request, "请输入用户名/密码");
    }
    }
    //  进行数据库的用户新增操作
    ret = _ut.insert(login_info);
    if(!ret)
    {
        return http_resp(false, websocketpp::http::status_code::bad_request, "用户名已存在");
    }
    //  成功:返回注册成功 ------ 200
    return http_resp(true, websocketpp::http::status_code::ok, "注册成功");
}

前端处理:

给按钮添加点击事件,调用注册函数reg

封装实现注册函数

  • 获取两个输入框空间中的数据,组织成为一个json串
  • 通过ajax向后台发送用户注册请求
  • 如果请求成功,则跳转到登录页面
  • 如果请求失败,清空两个输入框内容,并提示错误原因
html 复制代码
<div class="row">
    <button id="submit" onclick="reg()">提交</button>
</div>

<script> 
    //1.给按钮添加点击事件,调用注册函数
    //2.封装实现注册函数
    function reg()
    {
        //1.获取两个输入框空间中的数据,组织成为一个json串
        var reg_info = {
            username: document.getElementById("user_name").value,
            password: document.getElementById("password").value
        };
        //2.通过ajax向后台发送用户注册请求
        $.ajax({
            url: "reg",
            type: "POST",
            data: JSON.stringify(reg_info),
            contentType: "application/json",
            success: function(res) {
                if (res.result == false) 
                {
                    //4.如果请求失败,清空两个输入框内容,并提示错误原因
                    document.getElementById("user_name").value = "";
                    document.getElementById("password").value = "";
                    alert(res.reason);
                }
                else 
                {
                    //3.如果请求成功,则跳转到登录页面
                    alert("用户注册成功");
                    window.location.href = "/login.html";
                }
            },
            error: function(xhr, status, error) {
                document.getElementById("user_name").value = "";
                document.getElementById("password").value = "";
                alert(JSON.stringify(xhr));
            }
        });
    }
</script>

接下来进行前后端联合调试:前端输入用户密码进行注册后,确实能够跳转到登录页面!

3️⃣用户登录后台处理 & 前端处理

  • 获取请求正文并且进行反序列化得到用户名 + 密码
  • 对正文进行json反序列化,得到用户名和密码
  • 校验正文完整性 ,进行数据库的用户信息验证
  • 验证成功,给客户端创建session
  • 设置响应头部:Set-Cookie,将sessionid通过cookie返回
cpp 复制代码
void login(wserver_t::connection_ptr &conn)
{
    //用户登录功能处理
    //获取请求正文并且进行反序列化得到用户名 + 密码
    websocketpp::http::parser::request req = conn->get_request();
    std::string req_body = conn->get_request_body();
    //2.对正文进行json反序列化,得到用户名和密码
    Json::Value login_info; // 用户登录信息
    bool ret = JSONUtil::deserialize(req_body, login_info);
    if(!ret)
    {
        DBG_LOG("反序列化登录信息失败");
        return http_resp(conn, false, websocketpp::http::status_code::bad_request, "请求的正文格式错误");
    }
    //校验正文完整性,进行数据库的用户信息验证
    if(login_info["username"].isNull() || login_info["password"].isNull())
    {
        //用户或者密码为空
        DBG_LOG("登录用户名密码不完整");
        return http_resp(conn, false, websocketpp::http::status_code::bad_request, "请输入用户名/密码");
    }
    ret = _ut.login(login_info);
    if(!ret)
    {
        //验证失败返回400
        DBG_LOG("用户名密码错误");
        return http_resp(conn, false, websocketpp::http::status_code::bad_request, "用户名或密码错误");
    }

    //验证成功,给客户端创建session
    uint16_t uid = login_info["id"].asUInt64();
    session_ptr ssp = _sm.create_session(uid, LOGIN);
    if(!ssp)
    {
        DBG_LOG("创建session失败");
        return http_resp(conn, false, websocketpp::http::status_code::internal_server_error, "创建session失败");
    }
    _sm.set_session_expire_time(ssp->ssid(), SESSION_TIMEOUT);
    //设置响应头部:Set-Cookie,将sessionid通过cookie返回
    std::string cookie_ssid = "SSID=" + std::to_string(ssp->ssid());
    conn->append_header("Set-Cookie", cookie_ssid);
    return http_resp(conn, true, websocketpp::http::status_code::ok, "登录成功");
}

前端实现:此处实现的逻辑和上个模块一致

cpp 复制代码
<div class="row">
    <button id="submit" onclick="login()">提交</button>
</div>

<script src="./js/jquery.min.js"></script>
<script>
    //1. 给按钮添加点击事件,调用登录请求函数
    //2. 封装登录请求函数
    function login() {
        //   1.获取输入框中的用户名和密码,并组织json对象
        var login_info = {
            username: document.getElementById("user_name").value,
            password: document.getElementById("password").value
        };
        //2.通过ajax向后台发送登录验证登录
        $.ajax({
            url: "/login",
            type: "post",
            data: JSON.stringify(login_info),
            contentType: "application/json",
            success: function (result) {
                //3.如果验证通过,则跳转到游戏大厅页面
                alert("登录成功");
                window.location.href = "/game_hall.html";
            },
            error: function (xhr) {
                //4.如果验证失败,则提示错误信息,并清空输入框
                alert(JSON.stringify(xhr));
                document.getElementById("user_name").value = "";
                document.getElementById("password").value = "";
            }
        });
    }
</script>

4️⃣用户信息获取后台处理 & 前端页面

我们知道cookie格式是:

cpp 复制代码
Cookie:name=value; name2=value2;

所以我们要以;对cookie的内容作分割,取出里面的内容,再逐个以=进行分割,判断name是否为ssid,是则进行取出!

cpp 复制代码
bool get_cookie_value(const std::string &cookie_str, const std::string &key, std::string &value)
{
    //Cookie格式:SSID=XXX; PATH=XXX;
    //1.以";"分割,得到各个单个的cookie信息
    std::vector<std::string> cookies;
    StringUtil::split(cookie_str, ";", cookies);
    for(auto &str: cookie_arr)
    {
        //2.对单个cookie字符串,以"="分割,得到key和value
        std::vector<std::string> tmp_arr;
        StringUtil::split(str, "=", tmp_arr);
        if(tmp_arr.size() == 2)
        {
            if(tmp_arr[0] == key)
            {
                value = tmp_arr[1];
                return true;
            }
        }
    }
    return false;
}

对于用户信息功能处理模块:

  • 获取请求信息中的 Cookie(在头部字段)
  • 从Cookie中获取sessionid
  • 在session管理中查找对应的会话信息
  • 从数据库中取出用户信息,进行序列化发送给客户端
  • 刷新session的过期时间
cpp 复制代码
void info(wserver_t::connection_ptr &conn)
{
    //用户信息功能处理
    //1.获取请求信息中的Cookie, 从Cookie中获取sessionid
    std::string cookie_str = conn->get_request_header("Cookie");
    if(cookie_str.empty())
    {
        //  如果没有Cookie,返回错误:没有cookie信息,让客户端重新登录
        return http_resp(conn, false, websocketpp::http::status_code::bad_request, "找不到cookie信息,请先登录");
    }
    //1.5.从Cookie中获取sessionid
    std::string ssid_str;
    bool ret = get_cookie_value(cookie_str, "SSID", ssid_str);
    if(!ret)
    {
        //  如果没有Cookie,返回错误:没有ssid信息,让客户端重新登录
        return http_resp(conn, false, 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, false, websocketpp::http::status_code::bad_request, "登录已过期,请重新登录");
    }
    //3.从数据库中取出用户信息,进行序列化发送给客户端
    Json::Value user_info;
    uint64_t uid = ssp->get_user();
    bool ret = _ut.select_by_id(uid, user_info);
    if(!ret)
    {
        //获取用户信息失败,返回错误
        return http_resp(conn, false, websocketpp::http::status_code::internal_server_error, "找不到用户信息,请重新登录");
    }
    std::string body;
    JSONUtil::serialize(user_info, body);
    conn->set_body(body);
    conn->set_status(websocketpp::http::status_code::ok);
    conn->append_header("Content-Type", "application/json");
    //4.刷新session的过期时间
    _sm.set_session_expire_time(ssp->ssid(), SESSION_TIMEOUT);
}

前端页面编写:

  • 页面加载立即调用 get_user_info()
  • ajax 发 GET /info,success 里把返回的 username/score/total_count/win_count 拼成 HTML 写进 screen;
  • error 里 alert 并跳回 /login.html
html 复制代码
<script>
    function get_user_info() {
        $.ajax({
            url: "/info",
            type: "GET",
            success: function (res) {
                var info_html = "<p>" + "玩家: " + res.username + " 积分:" + res.score + 
                    "</br>" + "比赛场次: " + res.total_count + " 获胜场次: " + res.win_count + "</p>";
                var screen_div = document.getElementById("screen");
                screen_div.innerHTML = info_html;
            },
            error: function (xhr) {
                alert(JSON.stringify(xhr));
                location.href = "/login.html";
            }
        });
    }
    get_user_info();
</script>

5️⃣长连接分类

websocket长连接建立成功之后的处理函数分为:

  • 建立游戏大厅长连接
  • 建立游戏房间长连接
  • 二者是通过获取正文的uri来进行区分的

所以我们干脆把二者的单拎出来各自实现!

先是游戏大厅长连接的实现:

  • 登录验证 --- 判断当前客户端是否已经登录成功(获取请求信息中的Cookie,从Cookie中获取sessionid,在session管理中查找对应的会话信息)
  • 判断当前客户端是否重复登录
  • 如果通过,则将客户端加入游戏大厅
  • 给客户端响应游戏大厅连接建立成功
  • 因为是长连接了 ------ 将session设置为永久存在
cpp 复制代码
void ws_resp(wserver_t::connection_ptr conn, Json::Value &resp)
{
    std::string body;
    JSONUtil::serialize(resp, body);
    conn->send(body);
}

void wsopen_game_hall(wserver_t::connection_ptr conn)
{
    //游戏大厅长连接建立成功之后的处理函数
    //1.登录验证 --------- 判断当前客户端是否已经登录成功
    //获取请求信息中的Cookie, 从Cookie中获取sessionid
    std::string cookie_str = conn->get_request_header("Cookie");
    Json::Value err_resp;
    if(cookie_str.empty())
    {
        //如果没有Cookie,返回错误:没有cookie信息,让客户端重新登录
        err_resp["optype"] = "hall_ready";
        err_resp["reason"] = "找不到cookie信息,需要重新登录登录";
        err_resp["result"] = false;
        return ws_resp(conn, err_resp);
    }
    //从Cookie中获取sessionid
    std::string ssid_str;
    bool ret = get_cookie_value(cookie_str, "SSID", ssid_str);
    if(!ret)
    {
        //  如果没有Cookie,返回错误:没有ssid信息,让客户端重新登录
        err_resp["optype"] = "hall_ready";
        err_resp["reason"] = "找不到ssid信息,需要重新登录登录";
        err_resp["result"] = false;
        return ws_resp(conn, err_resp);
    }
    //在session管理中查找对应的会话信息
    session_ptr ssp = _sm.get_session_by_ssid(std::stol(ssid_str));
    if(ssp.get() == nullptr)
    {
        //  没有找到session,则认为登录已经过期了,需要重新登录
        err_resp["optype"] = "hall_ready";
        err_resp["reason"] = "登录已过期,请重新登录";
        err_resp["result"] = false;
        return ws_resp(conn, err_resp);
    }
    //2.判断当前客户端是否重复登录
    if(_om.is_in_game_hall(ssp->get_user()) || _om.is_in_game_room(ssp->get_user()))
    {
        //如果重复登录,返回错误:重复登录,让客户端重新登录
        err_resp["optype"] = "hall_ready";
        err_resp["reason"] = "玩家重复登录";
        err_resp["result"] = false;
        return ws_resp(conn, err_resp);
    }
    //3.如果通过,则将客户端加入游戏大厅
    _om.enter_game_hall(ssp->get_user(), conn);
    //4.给客户端响应游戏大厅连接建立成功
    Json::Value resp;
    resp["optype"] = "hall_ready";
    resp["reason"] = "游戏大厅连接建立成功";
    resp["result"] = true;
    ws_resp(conn, resp);
    
    //5.因为是长连接了 ------ 将session设置为永久存在
    _sm.set_session_expire_time(ssp->ssid(), SESSION_FOREVER);
}

游戏大厅前端页面实现:

前端的几个回调函数都还没有实现!

cpp 复制代码
页面加载
  └─ GET /info (带cookie)
       ├─ 失败 → 跳转 login.html
       └─ 成功 → 渲染 screen 区域
                 └─ new WebSocket("/hall") → 后端 wsopen_callback
                      └─ 等待服务器推送(匹配结果等,由 onmessage 处理)
html 复制代码
<script src="./js/jquery.min.js"></script>
<script>
    var ws_url = "ws://" + location.host + "/hall";
    var ws_hdl = null;
    function get_user_info() {
        $.ajax({
            url: "/info",
            type: "GET",
            success: function (res) {
                var info_html = "<p>玩家: " + res.username + " 积分:" + res.score +
                    "</br>比赛场次: " + (res.win_count + res.lose_count) + " 获胜场次: " + res.win_count + "</p>";
                var screen_div = document.getElementById("screen");
                screen_div.innerHTML = info_html;

                ws_hdl = new WebSocket(ws_url);
                ws_hdl.onopen = ws_onopen;
                ws_hdl.onclose = ws_onclose;
                ws_hdl.onerror = ws_onerror;
                ws_hdl.onmessage = ws_onmessage;
            },
            error: function (xhr) {
                alert(JSON.stringify(xhr));
                location.href = "/login.html";
            }
        });
    }
    function ws_onopen() {
        console.log("WebSocket connection opened.");
    }
    function ws_onclose() {
        console.log("WebSocket connection closed.");
    }
    function ws_onerror() {
        console.error("WebSocket error: " + evt.data);
    }
    function ws_onmessage(evt) {
        console.log("WebSocket message received: " + evt.data);
    }
    get_user_info();
</script>

📢写在最后

接下来登场的是 第二部分

相关推荐
心之王者71615 小时前
Linux 进程信号:从产生、阻塞到捕捉与子进程回收
linux·服务器·网络
manageengine16 小时前
服务器 CPU 100% 怎么排查:8 条命令从现象定位到根因
运维·服务器·cpu
赤生云电竞16 小时前
云游戏边缘节点部署:机房选址与网络拓扑优化实践 —— 从80ms时延预算看节点落位与Spine-Leaf组网
服务器·游戏·spine
爱吃香菜的初学者16 小时前
二十五.Linux——epoll
linux·运维·服务器
无奈笑天下18 小时前
银河麒麟上DHCP无法获取IP地址问题处理
linux·运维·服务器·网络协议
如夏倾城19 小时前
BGP(Border Gateway Protocol 边界网关协议)
运维·服务器·网络·gateway·信息与通信
Lansonli19 小时前
大数据Spark(九十):Spark广播变量与累加器详解
服务器·前端·ajax
nice_lcj52019 小时前
【从零理解计算机网络 · 03】IP 与端口:数据怎么找到机器,又怎么找到进程
后端·网络协议·计算机网络·面试·ip地址·端口·127.0.0.1
Summer-Bright20 小时前
企业落地智能体,供应链签名还是空白:1862 个 MCP 服务器无认证裸奔
服务器·人工智能·github·mcp