微服务即时通讯系统(5)用户管理子服务,网关子服务

server/2024/12/26 18:21:13/
  1. 用户管理子服务(user文件)

   用户管理子服务也是这个项目中的一个业务最多的子服务,接口多,但是主要涉及的数据表只有user表,Redis的键值对和ES的一个搜索引擎,主要功能是对用户的个人信息进行修改管理,对用户的登录进行管理,用户注册进行管理

用户管理子服务的所有接口

   service UserService {

 rpc UserRegister(UserRegisterReq) returns (UserRegisterRsp);

 rpc UserLogin(UserLoginReq) returns (UserLoginRsp);

 rpc GetPhoneVerifyCode(PhoneVerifyCodeReq) returns 

(PhoneVerifyCodeRsp);

 rpc PhoneRegister(PhoneRegisterReq) returns 

(PhoneRegisterRsp);

 rpc PhoneLogin(PhoneLoginReq) returns (PhoneLoginRsp);

 rpc GetUserInfo(GetUserInfoReq) returns (GetUserInfoRsp);

 rpc GetMultiUserInfo(GetMultiUserInfoReq) returns 

(GetMultiUserInfoRsp);

 rpc SetUserAvatar(SetUserAvatarReq) returns 

(SetUserAvatarRsp);

 rpc SetUserNickname(SetUserNicknameReq) returns 

(SetUserNicknameRsp);

 rpc SetUserDescription(SetUserDescriptionReq) returns 

(SetUserDescriptionRsp);

 rpc SetUserPhoneNumber(SetUserPhoneNumberReq) returns 

(SetUserPhoneNumberRsp);

}

  1. 用户昵称加密码的方式进行注册接口:先从request里面接收用户的nickname和密码,然后对nickname和密码进行检查,看看是不是符合长度要求,如果符合,为其生成用户ID后添加到user数据库和ES的user搜索引擎里面,设置response为成功,如果不符合,则不添加,并且设置response为失败,添加失败信息,结束

virtual void UserRegister(::google::protobuf::RpcController* controller,

            const ::zhou::UserRegisterReq* request,

            ::zhou::UserRegisterRsp* response,

            ::google::protobuf::Closure* done) {

            LOG_DEBUG("收到用户注册请求!");

            brpc::ClosureGuard rpc_guard(done);

            //定义一个错误处理函数,当出错的时候被调用

            auto err_response = [this, response](const std::string &rid,

                const std::string &errmsg) -> void {

                response->set_request_id(rid);

                response->set_success(false);

                response->set_errmsg(errmsg);

                return;

            };

            //1. 从请求中取出昵称和密码

            std::string nickname = request->nickname();

            std::string password = request->password();

            //2. 检查昵称是否合法(只能包含字母,数字,连字符-,下划线_,长度限制 3~15 之间)

            bool ret = nickname_check(nickname);

            if (ret == false) {

                LOG_ERROR("{} - 用户名长度不合法!", request->request_id());

                return err_response(request->request_id(), "用户名长度不合法!");

            }

            //3. 检查密码是否合法(只能包含字母,数字,长度限制 6~15 之间)

            ret = password_check(password);

            if (ret == false) {

                LOG_ERROR("{} - 密码格式不合法!", request->request_id());

                return err_response(request->request_id(), "密码格式不合法!");

            }

            //4. 根据昵称在数据库进行判断是否昵称已存在

            auto user = _mysql_user->select_by_nickname(nickname);

            if (user) {

                LOG_ERROR("{} - 用户名被占用- {}!", request->request_id(), nickname);

                return err_response(request->request_id(), "用户名被占用!");

            }

            //5. 向数据库新增数据

            std::string uid = uuid();

            user = std::make_shared<User>(uid, nickname, password);

            ret = _mysql_user->insert(user);

            if (ret == false) {

                LOG_ERROR("{} - Mysql数据库新增数据失败!", request->request_id());

                return err_response(request->request_id(), "Mysql数据库新增数据失败!");

            }

            //6. 向 ES 服务器中新增用户信息

            ret = _es_user->appendData(uid, "", nickname, "", "");

            if (ret == false) {

                LOG_ERROR("{} - ES搜索引擎新增数据失败!", request->request_id());

                return err_response(request->request_id(), "ES搜索引擎新增数据失败!");

            }

            //7. 组织响应,进行成功与否的响应即可。

            response->set_request_id(request->request_id());

            response->set_success(true);

        }

  1. 用户昵称加密码登录接口设计:先从request里面获取nickname和密码,然后进行判断是否合法,然后从Redis的状态键值对里面判断用户是否已经登录,然后从数据库中获取nickname对应的密码,如果不存在则设置response为失败,检查密码是否和传入的密码相同,如果是则登录成功,为用户创建一个登录会话ID,对Redis的状态键值对和会话键值对进行添加,然后对response设置对应的回话ID,然后返回

 virtual void UserLogin(::google::protobuf::RpcController* controller,

            const ::zhou::UserLoginReq* request,

            ::zhou::UserLoginRsp* response,

            ::google::protobuf::Closure* done){

            LOG_DEBUG("收到用户登录请求!");

            brpc::ClosureGuard rpc_guard(done);

            auto err_response = [this, response](const std::string &rid,

                const std::string &errmsg) -> void {

                response->set_request_id(rid);

                response->set_success(false);

                response->set_errmsg(errmsg);

                return;

            };

            //1. 从请求中取出昵称和密码

            std::string nickname = request->nickname();

            std::string password = request->password();

            //2. 通过昵称获取用户信息,进行密码是否一致的判断

            auto user = _mysql_user->select_by_nickname(nickname);

            if (!user || password != user->password()) {

                LOG_ERROR("{} - 用户名或密码错误 - {}-{}!", request->request_id(), nickname, password);

                return err_response(request->request_id(), "用户名或密码错误!");

            }

            //3. 根据 redis 中的登录标记信息是否存在判断用户是否已经登录。

            bool ret = _redis_status->exists(user->user_id());

            if (ret == true) {

                LOG_ERROR("{} - 用户已在其他地方登录 - {}!", request->request_id(), nickname);

                return err_response(request->request_id(), "用户已在其他地方登录!");

            }

            //4. 构造会话 ID,生成会话键值对,向 redis 中添加会话信息以及登录标记信息

            std::string ssid = uuid();

            _redis_session->append(ssid, user->user_id());

            //5. 添加用户登录信息

            _redis_status->append(user->user_id());

            //5. 组织响应,返回生成的会话 ID

            response->set_request_id(request->request_id());

            response->set_login_session_id(ssid);

            response->set_success(true);

        }

  1. 手机号验证码发送接口:从request里面获取电话号码,判断电话号码是否合法,然后生成四位随机验证码和事件ID,将事件ID和验证码一起放入Redis的验证码键值对缓存里面,然后调用验证码发送的SDK服务向对应的手机号发送验证码,对response进行设置此次发送事件的ID,结束

virtual void GetPhoneVerifyCode(::google::protobuf::RpcController* controller,

            const ::zhou::PhoneVerifyCodeReq* request,

            ::zhou::PhoneVerifyCodeRsp* response,

            ::google::protobuf::Closure* done){

            LOG_DEBUG("收到短信验证码获取请求!");

            brpc::ClosureGuard rpc_guard(done);

            auto err_response = [this, response](const std::string &rid,

                const std::string &errmsg) -> void {

                response->set_request_id(rid);

                response->set_success(false);

                response->set_errmsg(errmsg);

                return;

            };

            // 1. 从请求中取出手机号码

            std::string phone = request->phone_number();

            // 2. 验证手机号码格式是否正确(必须以 1 开始,第二位 3~9 之间,后边 9 个数字字符)

            bool ret = phone_check(phone);

            if (ret == false) {

                LOG_ERROR("{} - 手机号码格式错误 - {}!", request->request_id(), phone);

                return err_response(request->request_id(), "手机号码格式错误!");

            }

            // 3. 生成 4 位随机验证码

            std::string code_id = uuid();

            std::string code = vcode();

            // 4. 基于短信平台 SDK 发送验证码

            ret = _dms_client->send(phone, code);

            if (ret == false) {

                LOG_ERROR("{} - 短信验证码发送失败 - {}!", request->request_id(), phone);

                return err_response(request->request_id(), "短信验证码发送失败!");

            }

            // 5. 构造验证码 ID,添加到 redis 验证码映射键值索引中

            _redis_codes->append(code_id, code);

            // 6. 组织响应,返回生成的验证码 ID

            response->set_request_id(request->request_id());

            response->set_success(true);

            response->set_verify_code_id(code_id);

            LOG_DEBUG("获取短信验证码处理完成!");

        }

  1. 手机号注册接口实现:先从request里面获取验证码事件ID和验证码,手机号,用户名,然后从Redis里面的验证码键值对里面取出对应的验证码,判断是否一致,如果一致则进行注册,就是向use表和ES所对应的搜索引擎里面添加对应数据(用户名和手机号码),然后设置response成功,结束,(5)并且手机号登录接口就是在nickname加密码登录的逻辑下加入了手机号判断和验证码判断,其余都一样,就不在赘述

 virtual void PhoneRegister(::google::protobuf::RpcController* controller,

            const ::zhou::PhoneRegisterReq* request,

            ::zhou::PhoneRegisterRsp* response,

            ::google::protobuf::Closure* done){

            LOG_DEBUG("收到手机号注册请求!");

            brpc::ClosureGuard rpc_guard(done);

            auto err_response = [this, response](const std::string &rid,

                const std::string &errmsg) -> void {

                response->set_request_id(rid);

                response->set_success(false);

                response->set_errmsg(errmsg);

                return;

            };

            // 1. 从请求中取出手机号码和验证码,验证码ID

            std::string phone = request->phone_number();

            std::string code_id = request->verify_code_id();

            std::string code = request->verify_code();

            // 2. 检查注册手机号码是否合法

            bool ret = phone_check(phone);

            if (ret == false) {

                LOG_ERROR("{} - 手机号码格式错误 - {}!", request->request_id(), phone);

                return err_response(request->request_id(), "手机号码格式错误!");

            }

            // 3. 从 redis 数据库中进行验证码 ID-验证码一致性匹配

            auto vcode = _redis_codes->code(code_id);

            if (vcode != code) {

                LOG_ERROR("{} - 验证码错误 - {}-{}!", request->request_id(), code_id, code);

                return err_response(request->request_id(), "验证码错误!");

            }

            // 4. 通过数据库查询判断手机号是否已经注册过

            auto user = _mysql_user->select_by_phone(phone);

            if (user) {

                LOG_ERROR("{} - 该手机号已注册过用户 - {}!", request->request_id(), phone);

                return err_response(request->request_id(), "该手机号已注册过用户!");

            }

            // 5. 向数据库新增用户信息

            std::string uid = uuid();

            user = std::make_shared<User>(uid, phone);

            ret = _mysql_user->insert(user);

            if (ret == false) {

                LOG_ERROR("{} - 向数据库添加用户信息失败 - {}!", request->request_id(), phone);

                return err_response(request->request_id(), "向数据库添加用户信息失败!");

            }

            // 6. 向 ES 服务器中新增用户信息

            ret = _es_user->appendData(uid, phone, uid, "", "");

            if (ret == false) {

                LOG_ERROR("{} - ES搜索引擎新增数据失败!", request->request_id());

                return err_response(request->request_id(), "ES搜索引擎新增数据失败!");

            }

            //7. 组织响应,进行成功与否的响应即可。

            response->set_request_id(request->request_id());

            response->set_success(true);

        }

  1. 获取用户个人信息接口:先从request里面获取用户的uid,然后从user表中查询获取用户的nickname,description,phone,头像ID,然后根据头像ID向文件子服务发起请求,获取头像文件数据,然后将这些放入response中,结束。批量获取用户信息的接口就是在这个接口的基础上取出的是用户ID列表,然后再根据用户ID列表获取用户信息列表,得到用户头像列表,然后下载用户头像,后面就不对这个接口进行赘述

 virtual void GetUserInfo(::google::protobuf::RpcController* controller,

            const ::zhou::GetUserInfoReq* request,

            ::zhou::GetUserInfoRsp* response,

            ::google::protobuf::Closure* done){

            LOG_DEBUG("收到获取单个用户信息请求!");

            brpc::ClosureGuard rpc_guard(done);

            auto err_response = [this, response](const std::string &rid,

                const std::string &errmsg) -> void {

                response->set_request_id(rid);

                response->set_success(false);

                response->set_errmsg(errmsg);

                return;

            };

            // 1. 从请求中取出用户 ID

            std::string uid = request->user_id();

            // 2. 通过用户 ID,从数据库中查询用户信息

            auto user = _mysql_user->select_by_id(uid);

            if (!user) {

                LOG_ERROR("{} - 未找到用户信息 - {}!", request->request_id(), uid);

                return err_response(request->request_id(), "未找到用户信息!");

            }

            // 3. 根据用户信息中的头像 ID,从文件服务器获取头像文件数据,组织完整用户信息

            UserInfo *user_info = response->mutable_user_info();

            user_info->set_user_id(user->user_id());

            user_info->set_nickname(user->nickname());

            user_info->set_description(user->description());

            user_info->set_phone(user->phone());

           

            if (!user->avatar_id().empty()) {

                //从信道管理对象中,获取到连接了文件管理子服务的channel

                auto channel = _mm_channels->choose(_file_service_name);

                if (!channel) {

                    LOG_ERROR("{} - 未找到文件管理子服务节点 - {} - {}!",

                        request->request_id(), _file_service_name, uid);

                    return err_response(request->request_id(), "未找到文件管理子服务节点!");

                }

                //进行文件子服务的rpc请求,进行头像文件下载

                zhou::FileService_Stub stub(channel.get());

                zhou::GetSingleFileReq req;

                zhou::GetSingleFileRsp rsp;

                req.set_request_id(request->request_id());

                req.set_file_id(user->avatar_id());

                brpc::Controller cntl;

                stub.GetSingleFile(&cntl, &req, &rsp, nullptr);

                if (cntl.Failed() == true || rsp.success() == false) {

                    LOG_ERROR("{} - 文件子服务调用失败:{}!", request->request_id(), cntl.ErrorText());

                    return err_response(request->request_id(), "文件子服务调用失败!");

                }

                user_info->set_avatar(rsp.file_data().file_content());

            }

            // 4. 组织响应,返回用户信息

            response->set_request_id(request->request_id());

            response->set_success(true);

        }

  1. 修改用户头像接口:从request里面取出用户ID和头像数据,然后通过文件子服务将头像数据进行上传,得到头像ID,再对user表里面的用户ID对应的数据进行头像ID的修改,然后再对ES表中搜索引擎的数据进行修改,结束

 virtual void SetUserAvatar(::google::protobuf::RpcController* controller,

            const ::zhou::SetUserAvatarReq* request,

            ::zhou::SetUserAvatarRsp* response,

            ::google::protobuf::Closure* done){

            LOG_DEBUG("收到用户头像设置请求!");

            brpc::ClosureGuard rpc_guard(done);

            auto err_response = [this, response](const std::string &rid,

                const std::string &errmsg) -> void {

                response->set_request_id(rid);

                response->set_success(false);

                response->set_errmsg(errmsg);

                return;

            };

            // 1. 从请求中取出用户 ID 与头像数据

            std::string uid = request->user_id();

            // 2. 从数据库通过用户 ID 进行用户信息查询,判断用户是否存在

            auto user = _mysql_user->select_by_id(uid);

            if (!user) {

                LOG_ERROR("{} - 未找到用户信息 - {}!", request->request_id(), uid);

                return err_response(request->request_id(), "未找到用户信息!");

            }

            // 3. 上传头像文件到文件子服务,

            auto channel = _mm_channels->choose(_file_service_name);

            if (!channel) {

                LOG_ERROR("{} - 未找到文件管理子服务节点 - {}!", request->request_id(), _file_service_name);

                return err_response(request->request_id(), "未找到文件管理子服务节点!");

            }

            zhou::FileService_Stub stub(channel.get());

            zhou::PutSingleFileReq req;

            zhou::PutSingleFileRsp rsp;

            req.set_request_id(request->request_id());

            req.mutable_file_data()->set_file_name("");

            req.mutable_file_data()->set_file_size(request->avatar().size());

            req.mutable_file_data()->set_file_content(request->avatar());

            brpc::Controller cntl;

            stub.PutSingleFile(&cntl, &req, &rsp, nullptr);

            if (cntl.Failed() == true || rsp.success() == false) {

                LOG_ERROR("{} - 文件子服务调用失败:{}!", request->request_id(), cntl.ErrorText());

                return err_response(request->request_id(), "文件子服务调用失败!");

            }

            std::string avatar_id = rsp.file_info().file_id();

            // 4. 将返回的头像文件 ID 更新到数据库中

            user->avatar_id(avatar_id);

            bool ret = _mysql_user->update(user);

            if (ret == false) {

                LOG_ERROR("{} - 更新数据库用户头像ID失败 :{}!", request->request_id(), avatar_id);

                return err_response(request->request_id(), "更新数据库用户头像ID失败!");

            }

            // 5. 更新 ES 服务器中用户信息

            ret = _es_user->appendData(user->user_id(), user->phone(),

                user->nickname(), user->description(), user->avatar_id());

            if (ret == false) {

                LOG_ERROR("{} - 更新搜索引擎用户头像ID失败 :{}!", request->request_id(), avatar_id);

                return err_response(request->request_id(), "更新搜索引擎用户头像ID失败!");

            }

            // 6. 组织响应,返回更新成功与否

            response->set_request_id(request->request_id());

            response->set_success(true);

        }

  1. 修改用户nickname接口:从request里面获取用户ID和nickname,然后在从数据库中对用户ID进行查询,获取对应的用户数据,将用户数据里面的nickname进行修改,然后也对ES搜索引擎中对应用户ID的nickname进行修改,结束,同样的,用户description修改的接口也是一样的,而手机号的修改接口,是在此基础上先判断手机号是否正确,然后查询手机号是否已经被绑定,然后再进行验证码判断,如果都没问题就想数据库和ES里面更新数据,所以后面就不再赘述

 virtual void SetUserNickname(::google::protobuf::RpcController* controller,

            const ::zhou::SetUserNicknameReq* request,

            ::zhou::SetUserNicknameRsp* response,

            ::google::protobuf::Closure* done){

            LOG_DEBUG("收到用户昵称设置请求!");

            brpc::ClosureGuard rpc_guard(done);

            auto err_response = [this, response](const std::string &rid,

                const std::string &errmsg) -> void {

                response->set_request_id(rid);

                response->set_success(false);

                response->set_errmsg(errmsg);

                return;

            };

            // 1. 从请求中取出用户 ID 与新的昵称

            std::string uid = request->user_id();

            std::string new_nickname = request->nickname();

            // 2. 判断昵称格式是否正确

            bool ret = nickname_check(new_nickname);

            if (ret == false) {

                LOG_ERROR("{} - 用户名长度不合法!", request->request_id());

                return err_response(request->request_id(), "用户名长度不合法!");

            }

            // 3. 从数据库通过用户 ID 进行用户信息查询,判断用户是否存在

            auto user = _mysql_user->select_by_id(uid);

            if (!user) {

                LOG_ERROR("{} - 未找到用户信息 - {}!", request->request_id(), uid);

                return err_response(request->request_id(), "未找到用户信息!");

            }

            // 4. 将新的昵称更新到数据库中

            user->nickname(new_nickname);

            ret = _mysql_user->update(user);

            if (ret == false) {

                LOG_ERROR("{} - 更新数据库用户昵称失败 :{}!", request->request_id(), new_nickname);

                return err_response(request->request_id(), "更新数据库用户昵称失败!");

            }

            // 5. 更新 ES 服务器中用户信息

            ret = _es_user->appendData(user->user_id(), user->phone(),

                user->nickname(), user->description(), user->avatar_id());

            if (ret == false) {

                LOG_ERROR("{} - 更新搜索引擎用户昵称失败 :{}!", request->request_id(), new_nickname);

                return err_response(request->request_id(), "更新搜索引擎用户昵称失败!");

            }

            // 6. 组织响应,返回更新成功与否

            response->set_request_id(request->request_id());

            response->set_success(true);

        }

  1. 网关子服务(gateway文件)

   网关子服务的作用是对客户端发来的请求(httplib库进行实现)序列化为rpc请求进行转发,发送到对应的微服务器,然后将接收到的微服务器处理好的响应序列化为http报文返回客户端,并且对于需要服务端主动传输到客户端的通知采用websocket来管理链接进行传输

先介绍对于长连接管理的类:

主要含有的成员变量是这三个

std::mutex _mutex;

        std::unordered_map<std::string, server_t::connection_ptr> _uid_connections;

        std::unordered_map<server_t::connection_ptr, Client> _conn_clients;

其中的uid_connect是管理用户ID和对应的socket的链接

_conn_connect是通过链接来找到对应客户端的

下面是对websocket关键初始化的动作的代码解释

_ws_server.set_open_handler(std::bind(&GatewayServer::onOpen, this, std::placeholders::_1));

                _ws_server.set_close_handler(std::bind(&GatewayServer::onClose, this, std::placeholders::_1));

                auto wscb = std::bind(&GatewayServer::onMessage, this,

                    std::placeholders::_1, std::placeholders::_2);

                _ws_server.set_message_handler(wscb);

Open函数只是简单的显示连接的产生,这里不做赘述

Close函数是长连接断开后,也就是客户端下线后,将Redis里面的状态键值对和会话键值对进行删除然后移除管理的长连接

void onClose(websocketpp::connection_hdl hdl) {

                //长连接断开时做的清理工作

                //0. 通过连接对象,获取对应的用户ID与登录会话ID

                auto conn = _ws_server.get_con_from_hdl(hdl);

                std::string uid, ssid;

                bool ret = _connections->client(conn, uid, ssid);

                if (ret == false) {

                    LOG_WARN("长连接断开,未找到长连接对应的客户端信息!");

                    return ;

                }

                //1. 移除登录会话信息

                _redis_session->remove(ssid);

                //2. 移除登录状态信息

                _redis_status->remove(uid);

                //3. 移除长连接管理数据

                _connections->remove(conn);

                LOG_DEBUG("{} {} {} 长连接断开,清理缓存数据!", ssid, uid, (size_t)conn.get());

            }

而当websocket接收到消息以后就会实现对长连接的管理和保活,就是将其添加到Redis上面的两个键值对中和connect类里面,实现长连接和客户端的对应,长连接保活主要是通过对客户端定期检查,判断客户端的链接情况是否正常,如果正常则进行ping,维护长连接,如果有问题,则断开

auto conn = _ws_server.get_con_from_hdl(hdl);

                //2. 针对消息内容进行反序列化 -- ClientAuthenticationReq -- 提取登录会话ID

                ClientAuthenticationReq request;

                bool ret = request.ParseFromString(msg->get_payload());

                if (ret == false) {

                    LOG_ERROR("长连接身份识别失败:正文反序列化失败!");

                    _ws_server.close(hdl, websocketpp::close::status::unsupported_data, "正文反序列化失败!");

                    return;

                }

                //3. 在会话信息缓存中,查找会话信息

                std::string ssid = request.session_id();

                auto uid = _redis_session->uid(ssid);

                //4. 会话信息不存在则关闭连接

                if (!uid) {

                    LOG_ERROR("长连接身份识别失败:未找到会话信息 {}!", ssid);

                    _ws_server.close(hdl, websocketpp::close::status::unsupported_data, "未找到会话信息!");

                    return;

                }

                //5. 会话信息存在,则添加长连接管理

                _connections->insert(conn, *uid, ssid);

                LOG_DEBUG("新增长连接管理:{}-{}-{}", ssid, *uid, (size_t)conn.get());

                keepAlive(conn);

            }

void keepAlive(server_t::connection_ptr conn) {

                if (!conn || conn->get_state() != websocketpp::session::state::value::open) {

                    LOG_DEBUG("非正常连接状态,结束连接保活");

                    return;

                }

                conn->ping("");

                _ws_server.set_timer(60000, std::bind(&GatewayServer::keepAlive, this, conn));

            }

下面是httplib的请求路径和对应函数,虽然看上去接口众多,但是多数的接口逻辑都是一样的,都是将http报文序列化为对应的微服务器的请求报文,然后进行rpc调用,获得对应微服务器的响应以后将响应序列化为对应的http响应报文,不过部分会影响其他用户的操作,比如添加好友的行为,就会采用websocket的链接管理对被影响的用户发送对应的通知

_http_server.Post(GET_PHONE_VERIFY_CODE  , (httplib::Server::Handler)std::bind(&GatewayServer::GetPhoneVerifyCode         , this, std::placeholders::_1, std::placeholders::_2));

                _http_server.Post(USERNAME_REGISTER      , (httplib::Server::Handler)std::bind(&GatewayServer::UserRegister               , this, std::placeholders::_1, std::placeholders::_2));

                _http_server.Post(USERNAME_LOGIN         , (httplib::Server::Handler)std::bind(&GatewayServer::UserLogin                  , this, std::placeholders::_1, std::placeholders::_2));

                _http_server.Post(PHONE_REGISTER         , (httplib::Server::Handler)std::bind(&GatewayServer::PhoneRegister              , this, std::placeholders::_1, std::placeholders::_2));

                _http_server.Post(PHONE_LOGIN            , (httplib::Server::Handler)std::bind(&GatewayServer::PhoneLogin                 , this, std::placeholders::_1, std::placeholders::_2));

                _http_server.Post(GET_USERINFO           , (httplib::Server::Handler)std::bind(&GatewayServer::GetUserInfo                , this, std::placeholders::_1, std::placeholders::_2));

                _http_server.Post(SET_USER_AVATAR        , (httplib::Server::Handler)std::bind(&GatewayServer::SetUserAvatar              , this, std::placeholders::_1, std::placeholders::_2));

                _http_server.Post(SET_USER_NICKNAME      , (httplib::Server::Handler)std::bind(&GatewayServer::SetUserNickname            , this, std::placeholders::_1, std::placeholders::_2));

                _http_server.Post(SET_USER_DESC          , (httplib::Server::Handler)std::bind(&GatewayServer::SetUserDescription         , this, std::placeholders::_1, std::placeholders::_2));

                _http_server.Post(SET_USER_PHONE         , (httplib::Server::Handler)std::bind(&GatewayServer::SetUserPhoneNumber         , this, std::placeholders::_1, std::placeholders::_2));

                _http_server.Post(FRIEND_GET_LIST        , (httplib::Server::Handler)std::bind(&GatewayServer::GetFriendList              , this, std::placeholders::_1, std::placeholders::_2));

                _http_server.Post(FRIEND_APPLY           , (httplib::Server::Handler)std::bind(&GatewayServer::FriendAdd                  , this, std::placeholders::_1, std::placeholders::_2));

                _http_server.Post(FRIEND_APPLY_PROCESS   , (httplib::Server::Handler)std::bind(&GatewayServer::FriendAddProcess           , this, std::placeholders::_1, std::placeholders::_2));

                _http_server.Post(FRIEND_REMOVE          , (httplib::Server::Handler)std::bind(&GatewayServer::FriendRemove               , this, std::placeholders::_1, std::placeholders::_2));

                _http_server.Post(FRIEND_SEARCH          , (httplib::Server::Handler)std::bind(&GatewayServer::FriendSearch               , this, std::placeholders::_1, std::placeholders::_2));

                _http_server.Post(FRIEND_GET_PENDING_EV  , (httplib::Server::Handler)std::bind(&GatewayServer::GetPendingFriendEventList  , this, std::placeholders::_1, std::placeholders::_2));

                _http_server.Post(CSS_GET_LIST           , (httplib::Server::Handler)std::bind(&GatewayServer::GetChatSessionList         , this, std::placeholders::_1, std::placeholders::_2));

                _http_server.Post(CSS_CREATE             , (httplib::Server::Handler)std::bind(&GatewayServer::ChatSessionCreate          , this, std::placeholders::_1, std::placeholders::_2));

                _http_server.Post(CSS_GET_MEMBER         , (httplib::Server::Handler)std::bind(&GatewayServer::GetChatSessionMember       , this, std::placeholders::_1, std::placeholders::_2));

                _http_server.Post(MSG_GET_RANGE          , (httplib::Server::Handler)std::bind(&GatewayServer::GetHistoryMsg              , this, std::placeholders::_1, std::placeholders::_2));

                _http_server.Post(MSG_GET_RECENT         , (httplib::Server::Handler)std::bind(&GatewayServer::GetRecentMsg               , this, std::placeholders::_1, std::placeholders::_2));

                _http_server.Post(MSG_KEY_SEARCH         , (httplib::Server::Handler)std::bind(&GatewayServer::MsgSearch                  , this, std::placeholders::_1, std::placeholders::_2));

                _http_server.Post(NEW_MESSAGE            , (httplib::Server::Handler)std::bind(&GatewayServer::NewMessage                 , this, std::placeholders::_1, std::placeholders::_2));

                _http_server.Post(FILE_GET_SINGLE        , (httplib::Server::Handler)std::bind(&GatewayServer::GetSingleFile              , this, std::placeholders::_1, std::placeholders::_2));

                _http_server.Post(FILE_GET_MULTI         , (httplib::Server::Handler)std::bind(&GatewayServer::GetMultiFile               , this, std::placeholders::_1, std::placeholders::_2));

                _http_server.Post(FILE_PUT_SINGLE        , (httplib::Server::Handler)std::bind(&GatewayServer::PutSingleFile              , this, std::placeholders::_1, std::placeholders::_2));

                _http_server.Post(FILE_PUT_MULTI         , (httplib::Server::Handler)std::bind(&GatewayServer::PutMultiFile               , this, std::placeholders::_1, std::placeholders::_2));

                _http_server.Post(SPEECH_RECOGNITION     , (httplib::Server::Handler)std::bind(&GatewayServer::SpeechRecognition          , this, std::placeholders::_1, std::placeholders::_2));

                _http_thread = std::thread([this, http_port](){

                    _http_server.listen("0.0.0.0", http_port);

                });

  1. 获取手机验证码接口:得到httplib包request报头,然后自己实例化一个phoneVerifyCodeReq报头,这结构体在PROTOBUF文件里序列化的,可以直接使用,目的就是为了进行微服务器之间的网络传输,然后通过request报头来初始化我们自己定义的那个通过rpc调用的请求,然后再获取用户子服务的信道,对信道进行,将请求和响应放入,调用对应的验证码发送接口,实现验证码的发送,得到对应的响应后,再将这个用来微服务调用的响应初始化httplib的response报文,返回给客户端,便结束了从客户端接收响应后传到对应的微服务处理器,然后接收微服务处理器响应,在将响应转发给客户端的过程。后面的userRegister,UserLogin,PhoneRegister,PhoneLogind这四个接口都是这样的逻辑,就不在赘述

void GetPhoneVerifyCode(const httplib::Request &request, httplib::Response &response) {

                //1. 取出http请求正文,将正文进行反序列化

                PhoneVerifyCodeReq req;

                PhoneVerifyCodeRsp rsp;

                auto err_response = [&req, &rsp, &response](const std::string &errmsg) -> void {

                    rsp.set_success(false);

                    rsp.set_errmsg(errmsg);

                    response.set_content(rsp.SerializeAsString(), "application/x-protbuf");

                };

                bool ret = req.ParseFromString(request.body);

                if (ret == false) {

                    LOG_ERROR("获取短信验证码请求正文反序列化失败!");

                    return err_response("获取短信验证码请求正文反序列化失败!");

                }

                //2. 将请求转发给用户子服务进行业务处理

                auto channel = _mm_channels->choose(_user_service_name);

                if (!channel) {

                    LOG_ERROR("{} 未找到可提供业务处理的用户子服务节点!", req.request_id());

                    return err_response("未找到可提供业务处理的用户子服务节点!");

                }

                zhou::UserService_Stub stub(channel.get());

                brpc::Controller cntl;

                stub.GetPhoneVerifyCode(&cntl, &req, &rsp, nullptr);

                if (cntl.Failed()) {

                    LOG_ERROR("{} 用户子服务调用失败!", req.request_id());

                    return err_response("用户子服务调用失败!");

                }

                //3. 得到用户子服务的响应后,将响应内容进行序列化作为http响应正文

                response.set_content(rsp.SerializeAsString(), "application/x-protbuf");

            }

  1. 获取用户身份信息接口:在获取用户信息接口这里,我们得到了httplib的报文以后,就不能再直接原封不动的将报文转发到对应的用户子服务处理器了,应该要判断是否用户是处于上线状态,已经用户是否有权利查看这个用户的身份信息,发现有这样的权力以后再将报文转发到对应的用户子服务的接口,同理,后面的SetUserAvatar,SetUserName,SetUserDiscription,SetUserNumberPhone,GetFriendList都是这个逻辑,故后面不在赘述

void GetFriendList(const httplib::Request &request, httplib::Response &response) {

                //1. 取出http请求正文,将正文进行反序列化

                GetFriendListReq req;

                GetFriendListRsp rsp;

                auto err_response = [&req, &rsp, &response](const std::string &errmsg) -> void {

                    rsp.set_success(false);

                    rsp.set_errmsg(errmsg);

                    response.set_content(rsp.SerializeAsString(), "application/x-protbuf");

                };

                bool ret = req.ParseFromString(request.body);

                if (ret == false) {

                    LOG_ERROR("获取好友列表请求正文反序列化失败!");

                    return err_response("获取好友列表请求正文反序列化失败!");

                }

                //2. 客户端身份识别与鉴权

                std::string ssid = req.session_id();

                auto uid = _redis_session->uid(ssid);

                if (!uid) {

                    LOG_ERROR("{} 获取登录会话关联用户信息失败!", ssid);

                    return err_response("获取登录会话关联用户信息失败!");

                }

                req.set_user_id(*uid);

                //2. 将请求转发给好友子服务进行业务处理

                auto channel = _mm_channels->choose(_friend_service_name);

                if (!channel) {

                    LOG_ERROR("{} 未找到可提供业务处理的用户子服务节点!", req.request_id());

                    return err_response("未找到可提供业务处理的用户子服务节点!");

                }

                zhou::FriendService_Stub stub(channel.get());

                brpc::Controller cntl;

                stub.GetFriendList(&cntl, &req, &rsp, nullptr);

                if (cntl.Failed()) {

                    LOG_ERROR("{} 好友子服务调用失败!", req.request_id());

                    return err_response("好友子服务调用失败!");

                }

                //3. 得到用户子服务的响应后,将响应内容进行序列化作为http响应正文

                response.set_content(rsp.SerializeAsString(), "application/x-protbuf");

            }

  1. 好友添加接口实现:在上述的接口中,都是简单的对httplib请求进行序列化解析后转发给对应的微服务器,然后从微服务器中得到对应的响应再转发给客户端的过程,并没有对websocket的连接使用,也就是并没有在没有接收到请求的情况下将响应发出的行为,但是加好友是一个双向的过程,不仅需要发送者接收到对应的响应,也需要被申请者接受到发送者的好友申请,下面是对好友添加接口逻辑的描述和代码实现,首先还是得将http报文转变为我们设计的PROTOBUF的结构,然后再将报文通过好友子服务进行处理,得到对应的PROTOBUF报文响应,然后将响应转发给对应的客户端的对象,但是不同的是,如果发送成功后,我门还需要从websocket管理里面取出被申请者ID对应的长连接,然后主动实例化一个结构体通过websocket的长连接管理将包含着新朋友添加通知的消息告诉对应的被申请人,这个通知的结构为User_info,也就是申请者的个人信息

void FriendAdd(const httplib::Request &request, httplib::Response &response) {

                // 好友申请的业务处理中,好友子服务其实只是在数据库创建了申请事件

                // 网关需要做的事情:当好友子服务将业务处理完毕后,如果处理是成功的--需要通知被申请方

                // 1. 正文的反序列化,提取关键要素:登录会话ID

                FriendAddReq req;

                FriendAddRsp rsp;

                auto err_response = [&req, &rsp, &response](const std::string &errmsg) -> void {

                    rsp.set_success(false);

                    rsp.set_errmsg(errmsg);

                    response.set_content(rsp.SerializeAsString(), "application/x-protbuf");

                };

                bool ret = req.ParseFromString(request.body);

                if (ret == false) {

                    LOG_ERROR("申请好友请求正文反序列化失败!");

                    return err_response("申请好友请求正文反序列化失败!");

                }

                // 2. 客户端身份识别与鉴权

                std::string ssid = req.session_id();

                auto uid = _redis_session->uid(ssid);

                if (!uid) {

                    LOG_ERROR("{} 获取登录会话关联用户信息失败!", ssid);

                    return err_response("获取登录会话关联用户信息失败!");

                }

                req.set_user_id(*uid);

                // 3. 将请求转发给好友子服务进行业务处理

                auto channel = _mm_channels->choose(_friend_service_name);

                if (!channel) {

                    LOG_ERROR("{} 未找到可提供业务处理的用户子服务节点!", req.request_id());

                    return err_response("未找到可提供业务处理的用户子服务节点!");

                }

                zhou::FriendService_Stub stub(channel.get());

                brpc::Controller cntl;

                stub.FriendAdd(&cntl, &req, &rsp, nullptr);

                if (cntl.Failed()) {

                    LOG_ERROR("{} 好友子服务调用失败!", req.request_id());

                    return err_response("好友子服务调用失败!");

                }

                // 4. 若业务处理成功 --- 且获取被申请方长连接成功,则向被申请放进行好友申请事件通知

                auto conn = _connections->connection(req.respondent_id());

                if (rsp.success() && conn) {

                    LOG_DEBUG("找到被申请人 {} 长连接,对其进行好友申请通知", req.respondent_id());

                    auto user_rsp = _GetUserInfo(req.request_id(), *uid);

                    if (!user_rsp) {

                        LOG_ERROR("{} 获取当前客户端用户信息失败!", req.request_id());

                        return err_response("获取当前客户端用户信息失败!");

                    }

                    NotifyMessage notify;

                    notify.set_notify_type(NotifyType::FRIEND_ADD_APPLY_NOTIFY);

                    notify.mutable_friend_add_apply()->mutable_user_info()->CopyFrom(user_rsp->user_info());

                    conn->send(notify.SerializeAsString(), websocketpp::frame::opcode::value::binary);

                }

  1. 好友添加处理事件结果接口:上面我们将好友申请发送以后,接下来就是事件的处理了,我们添加好友的结果无非就两种,第一种是对方同意,然后你的好友列表多出一位新朋友,同时也建立起新的会话列表,如果对方没有同意,则你就会收到对方拒绝你加好友的消息,除此之外,无事发生。我们这边也是这个逻辑,通过request里面取出申请人和被申请人的ID以及结果(是否同意添加联系人),然后通过ID得到对应的身份信息以及对应的长连接,先向申请人通过长连接通知申请结果(同意或者拒绝),如果是同意,则需要为双方创建一个会话,会话的头像就是双方的头像,会话的名字就是双方的名字,然后再将这个会话放入通知里面,通过双方对应的链接传输这个通知,使得客户端建立相应会话。在好友删除接口中,除了对relation里面的二者关系进行删除,还要对message表里面二者发送的所有信息进行删除,然后再删除对应的回话表和会话成员表,最后向被删除者发送一个通知,让被删除者得知消息,虽然有点残忍,但是我觉得知道还是比不知道好,后面的许多接口都是和前面的流程差不多,都是将http报文转换成对应的PROTOBUF报文,然后再进行鉴权后转发给对应的微服务器,微服务器对于每一个请求报文的处理在前面讲述完成,也不在此讲述,接收到对应微服务器的响应报文以后再进行转换成http报文以后转发给客户端

void FriendAddProcess(const httplib::Request &request, httplib::Response &response) {

                //好友申请的处理-----

                FriendAddProcessReq req;

                FriendAddProcessRsp rsp;

                auto err_response = [&req, &rsp, &response](const std::string &errmsg) -> void {

                    rsp.set_success(false);

                    rsp.set_errmsg(errmsg);

                    response.set_content(rsp.SerializeAsString(), "application/x-protbuf");

                };

                bool ret = req.ParseFromString(request.body);

                if (ret == false) {

                    LOG_ERROR("好友申请处理请求正文反序列化失败!");

                    return err_response("好友申请处理请求正文反序列化失败!");

                }

                // 2. 客户端身份识别与鉴权

                std::string ssid = req.session_id();

                auto uid = _redis_session->uid(ssid);

                if (!uid) {

                    LOG_ERROR("{} 获取登录会话关联用户信息失败!", ssid);

                    return err_response("获取登录会话关联用户信息失败!");

                }

                req.set_user_id(*uid);

                // 3. 将请求转发给好友子服务进行业务处理

                auto channel = _mm_channels->choose(_friend_service_name);

                if (!channel) {

                    LOG_ERROR("{} 未找到可提供业务处理的用户子服务节点!", req.request_id());

                    return err_response("未找到可提供业务处理的用户子服务节点!");

                }

                zhou::FriendService_Stub stub(channel.get());

                brpc::Controller cntl;

                stub.FriendAddProcess(&cntl, &req, &rsp, nullptr);

                if (cntl.Failed()) {

                    LOG_ERROR("{} 好友子服务调用失败!", req.request_id());

                    return err_response("好友子服务调用失败!");

                }

               

                if (rsp.success()) {

                    auto process_user_rsp = _GetUserInfo(req.request_id(), *uid);

                    if (!process_user_rsp) {

                        LOG_ERROR("{} 获取用户信息失败!", req.request_id());

                        return err_response("获取用户信息失败!");

                    }

                    auto apply_user_rsp = _GetUserInfo(req.request_id(), req.apply_user_id());

                    if (!process_user_rsp) {

                        LOG_ERROR("{} 获取用户信息失败!", req.request_id());

                        return err_response("获取用户信息失败!");

                    }

                    auto process_conn = _connections->connection(*uid);

                    if (process_conn) LOG_DEBUG("找到处理人的长连接!");

                    else LOG_DEBUG("未找到处理人的长连接!");

                    auto apply_conn = _connections->connection(req.apply_user_id());

                    if (apply_conn) LOG_DEBUG("找到申请人的长连接!");

                    else LOG_DEBUG("未找到申请人的长连接!");

                    //4. 将处理结果给申请人进行通知

                    if (apply_conn) {

                        NotifyMessage notify;

                        notify.set_notify_type(NotifyType::FRIEND_ADD_PROCESS_NOTIFY);

                        auto process_result = notify.mutable_friend_process_result();

                        process_result->mutable_user_info()->CopyFrom(process_user_rsp->user_info());

                        process_result->set_agree(req.agree());

                        apply_conn->send(notify.SerializeAsString(),

                            websocketpp::frame::opcode::value::binary);

                        LOG_DEBUG("对申请人进行申请处理结果通知!");

                    }

                    //5. 若处理结果是同意 --- 会伴随着单聊会话的创建 -- 因此需要对双方进行会话创建的通知

                    if (req.agree() && apply_conn) { //对申请人的通知---会话信息就是处理人信息

                        NotifyMessage notify;

                        notify.set_notify_type(NotifyType::CHAT_SESSION_CREATE_NOTIFY);

                        auto chat_session = notify.mutable_new_chat_session_info();

                        chat_session->mutable_chat_session_info()->set_single_chat_friend_id(*uid);

                        chat_session->mutable_chat_session_info()->set_chat_session_id(rsp.new_session_id());

                        chat_session->mutable_chat_session_info()->set_chat_session_name(process_user_rsp->user_info().nickname());

                        chat_session->mutable_chat_session_info()->set_avatar(process_user_rsp->user_info().avatar());

                        apply_conn->send(notify.SerializeAsString(), websocketpp::frame::opcode::value::binary);

                        LOG_DEBUG("对申请人进行会话创建通知!");

                    }

                    if (req.agree() && process_conn) { //对处理人的通知 --- 会话信息就是申请人信息

                        NotifyMessage notify;

                        notify.set_notify_type(NotifyType::CHAT_SESSION_CREATE_NOTIFY);

                        auto chat_session = notify.mutable_new_chat_session_info();

                        chat_session->mutable_chat_session_info()->set_single_chat_friend_id(req.apply_user_id());

                        chat_session->mutable_chat_session_info()->set_chat_session_id(rsp.new_session_id());

                        chat_session->mutable_chat_session_info()->set_chat_session_name(apply_user_rsp->user_info().nickname());

                        chat_session->mutable_chat_session_info()->set_avatar(apply_user_rsp->user_info().avatar());

                        process_conn->send(notify.SerializeAsString(), websocketpp::frame::opcode::value::binary);

                        LOG_DEBUG("对处理人进行会话创建通知!");

                    }

                }

                //6. 对客户端进行响应

                response.set_content(rsp.SerializeAsString(), "application/x-protbuf");

            }

  1. 最后一个接口,新消息转发接口:先将http报文序列化为对应的消息转发接口的报文,然后调用消息转发子服务,将报文进行处理,得到消息转发子服务传来的响应以后,说明消息已经被永久化到数据库和ES搜索引擎里面,就对被发送消息的用户发送一个通知,通知就是有一条新消息,通知的发送也是通过用户ID找到对应的长连接,进行发送通知。

void NewMessage(const httplib::Request &request, httplib::Response &response) {

                NewMessageReq req;

                NewMessageRsp rsp;//这是给客户端的响应

                GetTransmitTargetRsp target_rsp;//这是请求子服务的响应

                auto err_response = [&req, &rsp, &response](const std::string &errmsg) -> void {

                    rsp.set_success(false);

                    rsp.set_errmsg(errmsg);

                    response.set_content(rsp.SerializeAsString(), "application/x-protbuf");

                };

                bool ret = req.ParseFromString(request.body);

                if (ret == false) {

                    LOG_ERROR("新消息请求正文反序列化失败!");

                    return err_response("新消息请求正文反序列化失败!");

                }

                // 2. 客户端身份识别与鉴权

                std::string ssid = req.session_id();

                auto uid = _redis_session->uid(ssid);

                if (!uid) {

                    LOG_ERROR("{} 获取登录会话关联用户信息失败!", ssid);

                    return err_response("获取登录会话关联用户信息失败!");

                }

                req.set_user_id(*uid);

                // 3. 将请求转发给好友子服务进行业务处理

                auto channel = _mm_channels->choose(_transmite_service_name);

                if (!channel) {

                    LOG_ERROR("{} 未找到可提供业务处理的用户子服务节点!", req.request_id());

                    return err_response("未找到可提供业务处理的用户子服务节点!");

                }

                zhou::MsgTransmitService_Stub stub(channel.get());

                brpc::Controller cntl;

                stub.GetTransmitTarget(&cntl, &req, &target_rsp, nullptr);

                if (cntl.Failed()) {

                    LOG_ERROR("{} 消息转发子服务调用失败!", req.request_id());

                    return err_response("消息转发子服务调用失败!");

                }

                // 4. 若业务处理成功 --- 且获取被申请方长连接成功,则向被申请放进行好友申请事件通知

                if (target_rsp.success()){

                    for (int i = 0; i < target_rsp.target_id_list_size(); i++) {

                        std::string notify_uid = target_rsp.target_id_list(i);

                        if (notify_uid == *uid) continue; //不通知自己

                        auto conn = _connections->connection(notify_uid);

                        if (!conn) { continue;}

                        NotifyMessage notify;

                        notify.set_notify_type(NotifyType::CHAT_MESSAGE_NOTIFY);

                        auto msg_info = notify.mutable_new_message_info();

                        msg_info->mutable_message_info()->CopyFrom(target_rsp.message());

                        conn->send(notify.SerializeAsString(), websocketpp::frame::opcode::value::binary);

                    }

                }

                // 5. 向客户端进行响应

                rsp.set_request_id(req.request_id());

                rsp.set_success(target_rsp.success());

                rsp.set_errmsg(target_rsp.errmsg());

                response.set_content(rsp.SerializeAsString(), "application/x-protbuf");

            }


http://www.ppmy.cn/server/147607.html

相关文章

解析类漏洞:从前端数据逃逸到后端执行

导语 在网络安全领域&#xff0c;理解漏洞的根本机制是渗透测试和漏洞研究的基石。很多web top10漏洞的本质其实就是解析类漏洞。这种漏洞的核心在于利用系统解析器或引擎对特定输入数据的处理方式&#xff0c;从而实现代码执行。本文将介绍解析类漏洞的概念&#xff0c;探讨它…

Android 消息队列之MQTT的使用:物联网通讯,HTTP太重了,使用MQTT;断网重连、注册、订阅、发送数据和接受数据,实现双向通讯。

目录&#xff1a; 问题MQTT是什么以及为什么使用如何使用&#xff1a;第一阶段、基础功能如何使用&#xff1a;第二阶段、增加断网重连如何使用&#xff1a;第三阶段、封装 一、问题 在开发的时候&#xff0c;我们一般都使用Http和后台进行通讯&#xff0c;比如我们是开发物联…

无线网络技术的发展与技术

无线网络技术在过去几十年中取得了巨大的进步&#xff0c;从最初的2G到如今的5G&#xff0c;无线通信已经深刻改变了我们的生活和工作方式。 本文将详细介绍无线网络技术的演进历程和相关的技术细节&#xff0c;包括无线传输原理、频谱利用、多址技术、调制与解调技术等&#…

react 路由鉴权

权限路由一般两种 1中接口中返回菜单 2 接口中返回权限&#xff0c;前端做匹配 一般都是那种结合&#xff0c;react中没有vue那种钩子函数如何做&#xff1f; 在项目中写一个高阶函数&#xff0c;在高阶函数中判断权限、是否登录等操作app.tsx或者man.tsx中使用 《AuthRouter》…

十五、linux之搭建JavaEE环境

1 概述 如果需要在 Linux 下进行 JavaEE 的开发&#xff0c;我们需要安装如下软件 2 安装 JDK 安装步骤 mkdir /opt/jdk mkdir /opt/jdk通过 xftp6 上传到 /opt/jdk 下 cd /opt/jdk 解压 tar -zxvf jdk-8u261-linux-x64.tar.gz tar -zxvf jdk-8u261-linux-x64.tar.…

加密算法学习笔记

可逆与不可逆 可逆 对称加密与非对称加密 不可逆 解释:一旦加密就不能反向解密得到密码原文 种类: Hash散列算法, 散列算法, 摘要算法等&#xff08;哈希算法又称散列算法&#xff09; 用途&#xff1a;一般用于效验下载文件正确性&#xff0c;一般在网站上下载文件都能见到…

开发手札:Win+Mac下工程多开联调

最近完成一个Windows/Android/IOS三端多人网络协同项目V1.0版本&#xff0c;进入测试流程了。为了方便自测&#xff0c;需要用unity将一个工程打开多次&#xff0c;分别是Win/IOS/Android版本&#xff0c;进行多角色联调。 在Win开发机上&#xff0c;以Windows版本为主版…

华为NPU服务器昇腾Ascend 910B2部署通义千问Qwen2.5——基于mindie镜像一路试错版(三)

文章目录 前言纯模型推理启动服务后面干什么?这可咋整啊?愁死了!总结前言 这是咱这个系列的第三个文章了。 毕竟,这是我好几天摸索出的经验,能帮助各位在几个小时内领会,我觉得也算是我的功劳一件了。 所以,一是希望大家耐心看下去,耐心操作下去;而是恳请各位多多关…