微服务即时通讯系统（5）用户管理子服务，网关子服务
- 用户管理子服务（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);
}
- 用户昵称加密码的方式进行注册接口：先从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);
}
- 用户昵称加密码登录接口设计：先从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);
}
- 手机号验证码发送接口：从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("获取短信验证码处理完成！");
}
- 手机号注册接口实现：先从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);
}
- 获取用户个人信息接口：先从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);
}
- 修改用户头像接口：从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);
}
- 修改用户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);
}
- 网关子服务（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);
});
- 获取手机验证码接口：得到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");
}
- 获取用户身份信息接口：在获取用户信息接口这里，我们得到了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");
}
- 好友添加接口实现：在上述的接口中，都是简单的对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);
}
- 好友添加处理事件结果接口：上面我们将好友申请发送以后，接下来就是事件的处理了，我们添加好友的结果无非就两种，第一种是对方同意，然后你的好友列表多出一位新朋友，同时也建立起新的会话列表，如果对方没有同意，则你就会收到对方拒绝你加好友的消息，除此之外，无事发生。我们这边也是这个逻辑，通过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");
}
- 最后一个接口，新消息转发接口：先将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");
}
相关文章：
微服务即时通讯系统（5）用户管理子服务，网关子服务
用户管理子服务（user文件） 用户管理子服务也是这个项目中的一个业务最多的子服务，接口多，但是主要涉及的数据表只有user表，Redis的键值对和ES的一个搜索引擎，主要功能是对用户的个人信息进行修改管理&#…...
postgreSQL安装后启动有The application server could not be contacted问题
不得不说pgsql是真的麻烦,找问题找了几个小时才解决.直接步入主题吧 首先问题如下 安装后,双击启动就出现上述问题 首先删除路径为 c:\Users\your_name\AppData\Roaming\pgAdmin 之内的所有文件和文件夹, 如果找不到AppData,就把这个点开 接着找到你安装pgsql的路径,我的是D…...
架构05-架构安全性
零、文章目录 架构05-架构安全性 1、软件架构安全的重要性 **系统安全：**不仅包括防御黑客攻击，还包括安全备份与恢复、安全审计、防治病毒等。**关注重点：**认证、授权、凭证、保密、传输安全、验证。 2、认证（Authenticatio…...
虚幻引擎---材质篇
一、基础知识 虚幻引擎中的材质（Materials） 定义了场景中对象的表面属性，包括颜色、金属度、粗糙度、透明度等等；可以在材质编辑器中可视化地创建和编辑材质；虚幻引擎的渲染管线的着色器是用高级着色语言（…...
NPM镜像详解
NPM镜像详解 什么是NPM镜像 NPM镜像（NPM Mirror）是一个完整的NPM包的副本服务器。由于npm的官方registry服务器部署在国外，国内访问可能会比较慢，因此使用镜像可以加快包的下载速度。 常用的NPM镜像源 npm官方镜像 https://reg…...
从智能合约到去中心化AI：Web3的技术蓝图
Web3正在成为互联网发展的重要方向，其核心理念是去中心化、用户主权和自治。随着区块链技术、智能合约以及人工智能（AI）等技术的发展，Web3不仅重新定义了数据存储和交易方式，还为更智能化、去中心化的数字生态系统铺平…...
STM32进阶 定时器3 通用定时器 案例1：LED呼吸灯——PWM脉冲
功能 它有基本定时器所有功能，还增加以下功能 TIM2、TIM3、TIM4、TIM5 多种时钟源： 外部时钟源模式1： 每个定时器有四个输入通道 只有通道1和通道2的信号可以作为时钟信号源 通道1 和通道2 的信号经过输入滤液和边缘检测器 外部时钟源…...
开源即时通讯与闭源即时通讯该怎么选择，其优势是什么？
在选择即时通讯软件时，应根据企业的经营领域来选择适合自身需求的开源或闭源方案。不同领域对开源和闭源即时通讯的理念存在差异，因此总结两个点简要分析这两种选择，有助于做出更明智的决策。 一、开源与闭源的根本区别在于软件的源代码是否…...
930[water]
算法...
2024论文翻译 | Multi-Review Fusion-in-Context
摘要 接地气的文本生成，包括长篇问答和摘要等任务，需要同时进行内容选择和内容整合。当前的端到端方法由于其不透明性，难以控制和解释。因此，近期的研究提出了一个模块化方法，每个步骤都有独立的组件。具体来说&#…...
（78）MPSK基带调制通信系统瑞利平坦衰落信道传输性能的MATLAB仿真
文章目录 前言一、MATLAB仿真1.仿真代码2.仿真结果 二、子函数与完整代码总结 前言 本文给出瑞利平坦衰落信道上的M-PSK通信系统性能仿真的MATLAB源代码与仿真结果。其中，调制方式M-PSK包括BPSK、QPSK、8-PSK、16-PSK、32-PSK等方式。 一、MATLAB仿真 1.仿真代码 …...
【机器学习】机器学习的基本分类-监督学习-决策树-CART（Classification and Regression Tree）
CART（Classification and Regression Tree） CART（分类与回归树）是一种用于分类和回归任务的决策树算法，提出者为 Breiman 等人。它的核心思想是通过二分法递归地将数据集划分为子集，从而构建一棵树。CART …...
【金猿CIO展】复旦大学附属中山医院计算机网络中心副主任张俊钦：推进数据安全风险评估，防范化解数据安全风险，筑牢医疗数据安全防线...
张俊钦 本文由复旦大学附属中山医院计算机网络中心副主任张俊钦撰写并投递参与“数据猿年度金猿策划活动——2024大数据产业年度优秀CIO榜单及奖项”评选。 大数据产业创新服务媒体 ——聚焦数据 改变商业 数据要素时代，医疗数据已成为医院运营与决策的重要基石…...
工业机器视觉-基于深度学习的水表表盘读数识别
字轮数字识别、指针读数识别（角度换算）、根据指针角度进行读数修正、根据最高位指针(x0.1)读数对字轮数字进行修正、得到最终读数。 基于深度学习的目标检测技术和OpenCV图像处理技术，可识别所有类型的表盘机械读数。...
基于ZooKeeper搭建Hadoop高可用集群
ZooKeeper搭建Hadoop高可用集群 在之前安装的Hadoop3.3.6集群中HDFS NameNode 和 YARN ResourceManager 都是单节点，集群不具有高可用性。 HDFS 高可用架构 HDFS 高可用架构主要组件： Active NameNode 和 Standby NameNode： 两台 NameNode…...
力扣88题：合并两个有序数组
力扣88题：合并两个有序数组 题目描述 给定两个按非递减顺序排列的整数数组 nums1 和 nums2，以及它们的长度 m 和 n，要求将 nums2 合并到 nums1，使得合并后的数组仍按非递减顺序排列。 输入与输出 示例 1： 输入&am…...
python 笔记之线程同步和死锁
同步： 共享数据： 如果多个线程共同对某个数据修改，则可能出现不可预测的结果，为了保证数据的正确性，需要对多个数据进行同步 同步：一个一个的完成，一个做完另一个才能进来 效率会降低 使用Thre…...
SpringBoot小知识(4)：高级配置知识与bean的绑定
一、EnableConfigurationProperties ConfigurationProperties注解在我们之前讲过，他是从配置中读取参数封装给实体类的一个注解。 那么EnableConfigurationProperties是个啥呢？ EnableConfigurationProperties 是 Spring Framework 中用于启用基于配置文…...
Python毕业设计选题：基于大数据的淘宝电子产品数据分析的设计与实现-django+spark+spider
开发语言：Python框架：djangoPython版本：python3.7.7数据库：mysql 5.7数据库工具：Navicat11开发软件：PyCharm 系统展示 管理员登录 管理员功能界面 电子产品管理 系统管理 数据可视化分析看板展示 摘要 本…...
Lua面向对象实现
Lua中的面向对象是通过表（table）来模拟类实现的，通过setmetatable(table,metatable)方法，将一个表设置为当前表的元表，之后在调用当前表没有的方法或者键时，会再查询元表中的方法和键，以此来实现…...
Flask RESTful 示例
目录 1. 环境准备2. 安装依赖3. 修改main.py4. 运行应用5. API使用示例获取所有任务获取单个任务创建新任务更新任务删除任务 中文乱码问题： 下面创建一个简单的Flask RESTful API示例。首先，我们需要创建环境，安装必要的依赖，然后…...
C++：std::is_convertible
C++标志库中提供is_convertible，可以测试一种类型是否可以转换为另一只类型： template <class From, class To> struct is_convertible; 使用举例： #include <iostream> #include <string>using namespace std;struct A { }; struct B : A { };int main…...
前端导出带有合并单元格的列表
// 导出async function exportExcel(fileName "共识调整.xlsx") {// 所有数据const exportData await getAllMainData();// 表头内容let fitstTitleList [];const secondTitleList [];allColumns.value.forEach(column > {if (!column.children) {fitstTitleL…...
Axios请求超时重发机制
Axios 超时重新请求实现方案 在 Axios 中实现超时重新请求可以通过以下几种方式： 1. 使用拦截器实现自动重试 import axios from axios;// 创建axios实例 const instance axios.create();// 设置超时时间 instance.defaults.timeout 5000;// 最大重试次数 cons…...
select、poll、epoll 与 Reactor 模式
在高并发网络编程领域，高效处理大量连接和 I/O 事件是系统性能的关键。select、poll、epoll 作为 I/O 多路复用技术的代表，以及基于它们实现的 Reactor 模式，为开发者提供了强大的工具。本文将深入探讨这些技术的底层原理、优缺点。 一、I…...
实战三：开发网页端界面完成黑白视频转为彩色视频
一、需求描述 设计一个简单的视频上色应用，用户可以通过网页界面上传黑白视频，系统会自动将其转换为彩色视频。整个过程对用户来说非常简单直观，不需要了解技术细节。 效果图 二、实现思路 总体思路： 用户通过Gradio界面上…...
认识CMake并使用CMake构建自己的第一个项目
1.CMake的作用和优势 跨平台支持：CMake支持多种操作系统和编译器，使用同一份构建配置可以在不同的环境中使用 简化配置：通过CMakeLists.txt文件，用户可以定义项目结构、依赖项、编译选项等，无需手动编写复杂的构建脚本…...
深入浅出WebGL：在浏览器中解锁3D世界的魔法钥匙
WebGL：在浏览器中解锁3D世界的魔法钥匙 引言：网页的边界正在消失 在数字化浪潮的推动下，网页早已不再是静态信息的展示窗口。如今，我们可以在浏览器中体验逼真的3D游戏、交互式数据可视化、虚拟实验室，甚至沉浸式的V…...
MySQL体系架构解析（三）：MySQL目录与启动配置全解析
MySQL中的目录和文件 bin目录 在 MySQL 的安装目录下有一个特别重要的 bin 目录，这个目录下存放着许多可执行文件。与其他系统的可执行文件类似，这些可执行文件都是与服务器和客户端程序相关的。 启动MySQL服务器程序 在 UNIX 系统中，用…...
RabbitMQ 各类交换机
为什么要用交换机？ 交换机用来路由消息。如果直发队列，这个消息就被处理消失了，那别的队列也需要这个消息怎么办？那就要用到交换机 交换机类型 1，fanout：广播 特点 广播所有消息：将消息…...