恋恋风辰的官方博客

聊天项目(29) 好友认证和聊天通信
Posted on 2024-08-24 11:52:40 by 恋恋风辰 | In C++ | 原文链接

好友认证

服务器响应

服务器接受客户端发送过来的好友认证请求

  1. void LogicSystem::AuthFriendApply(std::shared_ptr<CSession> session, const short& msg_id, const string& msg_data) {
  3.     Json::Reader reader;
  4.     Json::Value root;
  5.     reader.parse(msg_data, root);
  7.     auto uid = root["fromuid"].asInt();
  8.     auto touid = root["touid"].asInt();
  9.     auto back_name = root["back"].asString();
  10.     std::cout << "from " << uid << " auth friend to " << touid << std::endl;
  12.     Json::Value  rtvalue;
  13.     rtvalue["error"] = ErrorCodes::Success;
  14.     auto user_info = std::make_shared<UserInfo>();
  16.     std::string base_key = USER_BASE_INFO + std::to_string(touid);
  17.     bool b_info = GetBaseInfo(base_key, touid, user_info);
  18.     if (b_info) {
  19.         rtvalue["name"] = user_info->name;
  20.         rtvalue["nick"] = user_info->nick;
  21.         rtvalue["icon"] = user_info->icon;
  22.         rtvalue["sex"] = user_info->sex;
  23.         rtvalue["uid"] = touid;
  24.     }
  25.     else {
  26.         rtvalue["error"] = ErrorCodes::UidInvalid;
  27.     }
  30.     Defer defer([this, &rtvalue, session]() {
  31.         std::string return_str = rtvalue.toStyledString();
  32.         session->Send(return_str, ID_AUTH_FRIEND_RSP);
  33.         });
  35.     //先更新数据库
  36.     MysqlMgr::GetInstance()->AuthFriendApply(uid, touid);
  38.     //更新数据库添加好友
  39.     MysqlMgr::GetInstance()->AddFriend(uid, touid,back_name);
  41.     //查询redis 查找touid对应的server ip
  42.     auto to_str = std::to_string(touid);
  43.     auto to_ip_key = USERIPPREFIX + to_str;
  44.     std::string to_ip_value = "";
  45.     bool b_ip = RedisMgr::GetInstance()->Get(to_ip_key, to_ip_value);
  46.     if (!b_ip) {
  47.         return;
  48.     }
  50.     auto& cfg = ConfigMgr::Inst();
  51.     auto self_name = cfg["SelfServer"]["Name"];
  52.     //直接通知对方有认证通过消息
  53.     if (to_ip_value == self_name) {
  54.         auto session = UserMgr::GetInstance()->GetSession(touid);
  55.         if (session) {
  56.             //在内存中则直接发送通知对方
  57.             Json::Value  notify;
  58.             notify["error"] = ErrorCodes::Success;
  59.             notify["fromuid"] = uid;
  60.             notify["touid"] = touid;
  61.             std::string base_key = USER_BASE_INFO + std::to_string(uid);
  62.             auto user_info = std::make_shared<UserInfo>();
  63.             bool b_info = GetBaseInfo(base_key, uid, user_info);
  64.             if (b_info) {
  65.                 notify["name"] = user_info->name;
  66.                 notify["nick"] = user_info->nick;
  67.                 notify["icon"] = user_info->icon;
  68.                 notify["sex"] = user_info->sex;
  69.             }
  70.             else {
  71.                 notify["error"] = ErrorCodes::UidInvalid;
  72.             }
  75.             std::string return_str = notify.toStyledString();
  76.             session->Send(return_str, ID_NOTIFY_AUTH_FRIEND_REQ);
  77.         }
  79.         return ;
  80.     }
  83.     AuthFriendReq auth_req;
  84.     auth_req.set_fromuid(uid);
  85.     auth_req.set_touid(touid);
  87.     //发送通知
  88.     ChatGrpcClient::GetInstance()->NotifyAuthFriend(to_ip_value, auth_req);
  89. }

将请求注册到map里，在LogicSystem::RegisterCallBacks中添加

  1. _fun_callbacks[ID_AUTH_FRIEND_REQ] = std::bind(&LogicSystem::AuthFriendApply, this,
  2.     placeholders::_1, placeholders::_2, placeholders::_3);

因为上面的逻辑调用了grpc发送通知，所以实现grpc发送认证通知的逻辑

  1. AuthFriendRsp ChatGrpcClient::NotifyAuthFriend(std::string server_ip, const AuthFriendReq& req) {
  2.     AuthFriendRsp rsp;
  3.     rsp.set_error(ErrorCodes::Success);
  5.     Defer defer([&rsp, &req]() {
  6.         rsp.set_fromuid(req.fromuid());
  7.         rsp.set_touid(req.touid());
  8.         });
  10.     auto find_iter = _pools.find(server_ip);
  11.     if (find_iter == _pools.end()) {
  12.         return rsp;
  13.     }
  15.     auto& pool = find_iter->second;
  16.     ClientContext context;
  17.     auto stub = pool->getConnection();
  18.     Status status = stub->NotifyAuthFriend(&context, req, &rsp);
  19.     Defer defercon([&stub, this, &pool]() {
  20.         pool->returnConnection(std::move(stub));
  21.         });
  23.     if (!status.ok()) {
  24.         rsp.set_error(ErrorCodes::RPCFailed);
  25.         return rsp;
  26.     }
  28.     return rsp;
  29. }

这里注意，stub之所以能发送通知，是因为proto里定义了认证通知等服务，大家记得更新proto和我的一样，这事完整的proto

  1. syntax = "proto3";
  3. package message;
  5. service VarifyService {
  6.   rpc GetVarifyCode (GetVarifyReq) returns (GetVarifyRsp) {}
  7. }
  9. message GetVarifyReq {
  10.   string email = 1;
  11. }
  13. message GetVarifyRsp {
  14.   int32 error = 1;
  15.   string email = 2;
  16.   string code = 3;
  17. }
  19. message GetChatServerReq {
  20.   int32 uid = 1;
  21. }
  23. message GetChatServerRsp {
  24.   int32 error = 1;
  25.   string host = 2;
  26.   string port = 3;
  27.   string token = 4;
  28. }
  30. message LoginReq{
  31.     int32 uid = 1;
  32.     string token= 2;
  33. }
  35. message LoginRsp {
  36.     int32 error = 1;
  37.     int32 uid = 2;
  38.     string token = 3;
  39. }
  41. service StatusService {
  42.     rpc GetChatServer (GetChatServerReq) returns (GetChatServerRsp) {}
  43.     rpc Login(LoginReq) returns(LoginRsp);
  44. }
  46. message AddFriendReq {
  47.     int32  applyuid = 1;
  48.     string name = 2;
  49.     string desc = 3;
  50.     string icon = 4;
  51.     string nick = 5;
  52.     int32  sex = 6;
  53.     int32  touid = 7;
  54. }
  56. message AddFriendRsp {
  57.     int32 error = 1;
  58.     int32 applyuid = 2;
  59.     int32 touid = 3;
  60. }
  62. message RplyFriendReq {
  63.     int32 rplyuid = 1;
  64.     bool  agree = 2;
  65.     int32 touid = 3;
  66. }
  68. message RplyFriendRsp {
  69.     int32 error = 1;
  70.     int32 rplyuid = 2;
  71.     int32 touid = 3;
  72. }
  74. message SendChatMsgReq{
  75.         int32 fromuid = 1;
  76.         int32 touid = 2;
  77.         string message = 3;
  78. }
  80. message SendChatMsgRsp{
  81.         int32 error = 1;
  82.         int32 fromuid = 2;
  83.         int32 touid = 3;
  84. }
  86. message AuthFriendReq{
  87.     int32 fromuid = 1;
  88.     int32 touid = 2;
  89. }
  91. message AuthFriendRsp{
  92.     int32 error = 1;
  93.     int32 fromuid = 2;
  94.     int32 touid = 3;
  95. }
  97. message TextChatMsgReq {
  98.     int32 fromuid = 1;
  99.     int32 touid = 2;
  100.     repeated TextChatData textmsgs = 3;
  101. }
  103. message TextChatData{
  104.     string msgid = 1;
  105.     string msgcontent = 2;
  106. }
  108. message TextChatMsgRsp {
  109.     int32 error = 1;
  110.     int32 fromuid = 2;
  111.     int32 touid = 3; 
  112.     repeated TextChatData textmsgs = 4;
  113. }
  115. service ChatService {
  116.     rpc NotifyAddFriend(AddFriendReq) returns (AddFriendRsp) {}
  117.     rpc RplyAddFriend(RplyFriendReq) returns (RplyFriendRsp) {}
  118.     rpc SendChatMsg(SendChatMsgReq) returns (SendChatMsgRsp) {}
  119.     rpc NotifyAuthFriend(AuthFriendReq) returns (AuthFriendRsp) {}
  120.     rpc NotifyTextChatMsg(TextChatMsgReq) returns (TextChatMsgRsp){}
  121. }

为了方便生成grpcpb文件，我写了一个start.bat批处理文件

  1. @echo off
  2. set PROTOC_PATH=D:\cppsoft\grpc\visualpro\third_party\protobuf\Debug\protoc.exe
  3. set GRPC_PLUGIN_PATH=D:\cppsoft\grpc\visualpro\Debug\grpc_cpp_plugin.exe
  4. set PROTO_FILE=message.proto
  6. echo Generating gRPC code...
  7. %PROTOC_PATH% -I="." --grpc_out="." --plugin=protoc-gen-grpc="%GRPC_PLUGIN_PATH%" "%PROTO_FILE%"
  9. echo Generating C++ code...
  10. %PROTOC_PATH% --cpp_out=. "%PROTO_FILE%"
  12. echo Done.

执行这个批处理文件就能生成最新的pb文件了。

接下来实现grpc服务对认证的处理

  1. Status ChatServiceImpl::NotifyAuthFriend(ServerContext* context, const AuthFriendReq* request,
  2.     AuthFriendRsp* reply) {
  3.     //查找用户是否在本服务器
  4.     auto touid = request->touid();
  5.     auto fromuid = request->fromuid();
  6.     auto session = UserMgr::GetInstance()->GetSession(touid);
  8.     Defer defer([request, reply]() {
  9.         reply->set_error(ErrorCodes::Success);
  10.         reply->set_fromuid(request->fromuid());
  11.         reply->set_touid(request->touid());
  12.         });
  14.     //用户不在内存中则直接返回
  15.     if (session == nullptr) {
  16.         return Status::OK;
  17.     }
  19.     //在内存中则直接发送通知对方
  20.     Json::Value  rtvalue;
  21.     rtvalue["error"] = ErrorCodes::Success;
  22.     rtvalue["fromuid"] = request->fromuid();
  23.     rtvalue["touid"] = request->touid();
  25.     std::string base_key = USER_BASE_INFO + std::to_string(fromuid);
  26.     auto user_info = std::make_shared<UserInfo>();
  27.     bool b_info = GetBaseInfo(base_key, fromuid, user_info);
  28.     if (b_info) {
  29.         rtvalue["name"] = user_info->name;
  30.         rtvalue["nick"] = user_info->nick;
  31.         rtvalue["icon"] = user_info->icon;
  32.         rtvalue["sex"] = user_info->sex;
  33.     }
  34.     else {
  35.         rtvalue["error"] = ErrorCodes::UidInvalid;
  36.     }
  38.     std::string return_str = rtvalue.toStyledString();
  40.     session->Send(return_str, ID_NOTIFY_AUTH_FRIEND_REQ);
  41.     return Status::OK;
  42. }

所以A认证B为好友，A所在的服务器会给A回复一个ID_AUTH_FRIEND_RSP的消息，B所在的服务器会给B回复一个ID_NOTIFY_AUTH_FRIEND_REQ消息。

客户端响应

客户端需要响应服务器发过来的ID_AUTH_FRIEND_RSP和ID_NOTIFY_AUTH_FRIEND_REQ消息

客户端响应ID_AUTH_FRIEND_RSP，在initHandlers中添加

  1. _handlers.insert(ID_AUTH_FRIEND_RSP, [this](ReqId id, int len, QByteArray data) {
  2.     Q_UNUSED(len);
  3.     qDebug() << "handle id is " << id << " data is " << data;
  4.     // 将QByteArray转换为QJsonDocument
  5.     QJsonDocument jsonDoc = QJsonDocument::fromJson(data);
  7.     // 检查转换是否成功
  8.     if (jsonDoc.isNull()) {
  9.         qDebug() << "Failed to create QJsonDocument.";
  10.         return;
  11.     }
  13.     QJsonObject jsonObj = jsonDoc.object();
  15.     if (!jsonObj.contains("error")) {
  16.         int err = ErrorCodes::ERR_JSON;
  17.         qDebug() << "Auth Friend Failed, err is Json Parse Err" << err;
  18.         return;
  19.     }
  21.     int err = jsonObj["error"].toInt();
  22.     if (err != ErrorCodes::SUCCESS) {
  23.         qDebug() << "Auth Friend Failed, err is " << err;
  24.         return;
  25.     }
  27.     auto name = jsonObj["name"].toString();
  28.     auto nick = jsonObj["nick"].toString();
  29.     auto icon = jsonObj["icon"].toString();
  30.     auto sex = jsonObj["sex"].toInt();
  31.     auto uid = jsonObj["uid"].toInt();
  32.     auto rsp = std::make_shared<AuthRsp>(uid, name, nick, icon, sex);
  33.     emit sig_auth_rsp(rsp);
  35.     qDebug() << "Auth Friend Success " ;
  36.   });

在initHandlers中添加ID_NOTIFY_AUTH_FRIEND_REQ

  1. _handlers.insert(ID_NOTIFY_AUTH_FRIEND_REQ, [this](ReqId id, int len, QByteArray data) {
  2.     Q_UNUSED(len);
  3.     qDebug() << "handle id is " << id << " data is " << data;
  4.     // 将QByteArray转换为QJsonDocument
  5.     QJsonDocument jsonDoc = QJsonDocument::fromJson(data);
  7.     // 检查转换是否成功
  8.     if (jsonDoc.isNull()) {
  9.         qDebug() << "Failed to create QJsonDocument.";
  10.         return;
  11.     }
  13.     QJsonObject jsonObj = jsonDoc.object();
  14.     if (!jsonObj.contains("error")) {
  15.         int err = ErrorCodes::ERR_JSON;
  16.         qDebug() << "Auth Friend Failed, err is " << err;
  17.         return;
  18.     }
  20.     int err = jsonObj["error"].toInt();
  21.     if (err != ErrorCodes::SUCCESS) {
  22.         qDebug() << "Auth Friend Failed, err is " << err;
  23.         return;
  24.     }
  26.     int from_uid = jsonObj["fromuid"].toInt();
  27.     QString name = jsonObj["name"].toString();
  28.     QString nick = jsonObj["nick"].toString();
  29.     QString icon = jsonObj["icon"].toString();
  30.     int sex = jsonObj["sex"].toInt();
  32.     auto auth_info = std::make_shared<AuthInfo>(from_uid,name,
  33.                                                 nick, icon, sex);
  35.     emit sig_add_auth_friend(auth_info);
  36.     });

客户端ChatDialog中添加对sig_add_auth_friend响应，实现添加好友到聊天列表中

  1. void ChatDialog::slot_add_auth_friend(std::shared_ptr<AuthInfo> auth_info) {
  2.     qDebug() << "receive slot_add_auth__friend uid is " << auth_info->_uid
  3.         << " name is " << auth_info->_name << " nick is " << auth_info->_nick;
  5.     //判断如果已经是好友则跳过
  6.     auto bfriend = UserMgr::GetInstance()->CheckFriendById(auth_info->_uid);
  7.     if(bfriend){
  8.         return;
  9.     }
  11.     UserMgr::GetInstance()->AddFriend(auth_info);
  13.     int randomValue = QRandomGenerator::global()->bounded(100); // 生成0到99之间的随机整数
  14.     int str_i = randomValue % strs.size();
  15.     int head_i = randomValue % heads.size();
  16.     int name_i = randomValue % names.size();
  18.     auto* chat_user_wid = new ChatUserWid();
  19.     auto user_info = std::make_shared<UserInfo>(auth_info);
  20.     chat_user_wid->SetInfo(user_info);
  21.     QListWidgetItem* item = new QListWidgetItem;
  22.     //qDebug()<<"chat_user_wid sizeHint is " << chat_user_wid->sizeHint();
  23.     item->setSizeHint(chat_user_wid->sizeHint());
  24.     ui->chat_user_list->insertItem(0, item);
  25.     ui->chat_user_list->setItemWidget(item, chat_user_wid);
  26.     _chat_items_added.insert(auth_info->_uid, item);
  27. }

客户端ChatDialog中添加对sig_auth_rsp响应, 实现添加好友到聊天列表中

  1. void ChatDialog::slot_auth_rsp(std::shared_ptr<AuthRsp> auth_rsp)
  2. {
  3.     qDebug() << "receive slot_auth_rsp uid is " << auth_rsp->_uid
  4.         << " name is " << auth_rsp->_name << " nick is " << auth_rsp->_nick;
  6.     //判断如果已经是好友则跳过
  7.     auto bfriend = UserMgr::GetInstance()->CheckFriendById(auth_rsp->_uid);
  8.     if(bfriend){
  9.         return;
  10.     }
  12.     UserMgr::GetInstance()->AddFriend(auth_rsp);
  13.     int randomValue = QRandomGenerator::global()->bounded(100); // 生成0到99之间的随机整数
  14.     int str_i = randomValue % strs.size();
  15.     int head_i = randomValue % heads.size();
  16.     int name_i = randomValue % names.size();
  18.     auto* chat_user_wid = new ChatUserWid();
  19.     auto user_info = std::make_shared<UserInfo>(auth_rsp);
  20.     chat_user_wid->SetInfo(user_info);
  21.     QListWidgetItem* item = new QListWidgetItem;
  22.     //qDebug()<<"chat_user_wid sizeHint is " << chat_user_wid->sizeHint();
  23.     item->setSizeHint(chat_user_wid->sizeHint());
  24.     ui->chat_user_list->insertItem(0, item);
  25.     ui->chat_user_list->setItemWidget(item, chat_user_wid);
  26.     _chat_items_added.insert(auth_rsp->_uid, item);
  27. }

因为认证对方为好友后，需要将申请页面的添加按钮变成已添加，所以ApplyFriendPage响应sig_auth_rsp信号

  1. void ApplyFriendPage::slot_auth_rsp(std::shared_ptr<AuthRsp> auth_rsp) {
  2.     auto uid = auth_rsp->_uid;
  3.     auto find_iter = _unauth_items.find(uid);
  4.     if (find_iter == _unauth_items.end()) {
  5.         return;
  6.     }
  8.     find_iter->second->ShowAddBtn(false);
  9. }

同意并认证对方为好友后，也需要将对方添加到联系人列表，ContactUserList响应sig_auth_rsp信号

  1. void ContactUserList::slot_auth_rsp(std::shared_ptr<AuthRsp> auth_rsp)
  2. {
  3.     qDebug() << "slot auth rsp called";
  4.     bool isFriend = UserMgr::GetInstance()->CheckFriendById(auth_rsp->_uid);
  5.     if(isFriend){
  6.         return;
  7.     }
  8.     // 在 groupitem 之后插入新项
  9.     int randomValue = QRandomGenerator::global()->bounded(100); // 生成0到99之间的随机整数
  10.     int str_i = randomValue%strs.size();
  11.     int head_i = randomValue%heads.size();
  13.     auto *con_user_wid = new ConUserItem();
  14.     con_user_wid->SetInfo(auth_rsp->_uid ,auth_rsp->_name, heads[head_i]);
  15.     QListWidgetItem *item = new QListWidgetItem;
  16.     //qDebug()<<"chat_user_wid sizeHint is " << chat_user_wid->sizeHint();
  17.     item->setSizeHint(con_user_wid->sizeHint());
  19.     // 获取 groupitem 的索引
  20.     int index = this->row(_groupitem);
  21.     // 在 groupitem 之后插入新项
  22.     this->insertItem(index + 1, item);
  24.     this->setItemWidget(item, con_user_wid);
  26. }

登录加载好友

因为添加好友后，如果客户端重新登录，服务器LoginHandler需要加载好友列表，所以服务器要返回好友列表

  1. void LogicSystem::LoginHandler(shared_ptr<CSession> session, const short &msg_id, const string &msg_data) {
  2.     Json::Reader reader;
  3.     Json::Value root;
  4.     reader.parse(msg_data, root);
  5.     auto uid = root["uid"].asInt();
  6.     auto token = root["token"].asString();
  7.     std::cout << "user login uid is  " << uid << " user token  is "
  8.         << token << endl;
  10.     Json::Value  rtvalue;
  11.     Defer defer([this, &rtvalue, session]() {
  12.         std::string return_str = rtvalue.toStyledString();
  13.         session->Send(return_str, MSG_CHAT_LOGIN_RSP);
  14.         });
  16.     //从redis获取用户token是否正确
  17.     std::string uid_str = std::to_string(uid);
  18.     std::string token_key = USERTOKENPREFIX + uid_str;
  19.     std::string token_value = "";
  20.     bool success = RedisMgr::GetInstance()->Get(token_key, token_value);
  21.     if (!success) {
  22.         rtvalue["error"] = ErrorCodes::UidInvalid;
  23.         return ;
  24.     }
  26.     if (token_value != token) {
  27.         rtvalue["error"] = ErrorCodes::TokenInvalid;
  28.         return ;
  29.     }
  31.     rtvalue["error"] = ErrorCodes::Success;
  33.     std::string base_key = USER_BASE_INFO + uid_str;
  34.     auto user_info = std::make_shared<UserInfo>();
  35.     bool b_base = GetBaseInfo(base_key, uid, user_info);
  36.     if (!b_base) {
  37.         rtvalue["error"] = ErrorCodes::UidInvalid;
  38.         return;
  39.     }
  40.     rtvalue["uid"] = uid;
  41.     rtvalue["pwd"] = user_info->pwd;
  42.     rtvalue["name"] = user_info->name;
  43.     rtvalue["email"] = user_info->email;
  44.     rtvalue["nick"] = user_info->nick;
  45.     rtvalue["desc"] = user_info->desc;
  46.     rtvalue["sex"] = user_info->sex;
  47.     rtvalue["icon"] = user_info->icon;
  49.     //从数据库获取申请列表
  50.     std::vector<std::shared_ptr<ApplyInfo>> apply_list;
  51.     auto b_apply = GetFriendApplyInfo(uid,apply_list);
  52.     if (b_apply) {
  53.         for (auto & apply : apply_list) {
  54.             Json::Value obj;
  55.             obj["name"] = apply->_name;
  56.             obj["uid"] = apply->_uid;
  57.             obj["icon"] = apply->_icon;
  58.             obj["nick"] = apply->_nick;
  59.             obj["sex"] = apply->_sex;
  60.             obj["desc"] = apply->_desc;
  61.             obj["status"] = apply->_status;
  62.             rtvalue["apply_list"].append(obj);
  63.         }
  64.     }
  66.     //获取好友列表
  67.     std::vector<std::shared_ptr<UserInfo>> friend_list;
  68.     bool b_friend_list = GetFriendList(uid, friend_list);
  69.     for (auto& friend_ele : friend_list) {
  70.         Json::Value obj;
  71.         obj["name"] = friend_ele->name;
  72.         obj["uid"] = friend_ele->uid;
  73.         obj["icon"] = friend_ele->icon;
  74.         obj["nick"] = friend_ele->nick;
  75.         obj["sex"] = friend_ele->sex;
  76.         obj["desc"] = friend_ele->desc;
  77.         obj["back"] = friend_ele->back;
  78.         rtvalue["friend_list"].append(obj);
  79.     }
  81.     auto server_name = ConfigMgr::Inst().GetValue("SelfServer", "Name");
  82.     //将登录数量增加
  83.     auto rd_res = RedisMgr::GetInstance()->HGet(LOGIN_COUNT, server_name);
  84.     int count = 0;
  85.     if (!rd_res.empty()) {
  86.         count = std::stoi(rd_res);
  87.     }
  89.     count++;
  90.     auto count_str = std::to_string(count);
  91.     RedisMgr::GetInstance()->HSet(LOGIN_COUNT, server_name, count_str);
  92.     //session绑定用户uid
  93.     session->SetUserId(uid);
  94.     //为用户设置登录ip server的名字
  95.     std::string  ipkey = USERIPPREFIX + uid_str;
  96.     RedisMgr::GetInstance()->Set(ipkey, server_name);
  97.     //uid和session绑定管理,方便以后踢人操作
  98.     UserMgr::GetInstance()->SetUserSession(uid, session);
  100.     return;
  101. }

客户端在initHandlers中加载聊天列表

  1. _handlers.insert(ID_CHAT_LOGIN_RSP, [this](ReqId id, int len, QByteArray data){
  2.     Q_UNUSED(len);
  3.     qDebug()<< "handle id is "<< id ;
  4.     // 将QByteArray转换为QJsonDocument
  5.     QJsonDocument jsonDoc = QJsonDocument::fromJson(data);
  7.     // 检查转换是否成功
  8.     if(jsonDoc.isNull()){
  9.        qDebug() << "Failed to create QJsonDocument.";
  10.        return;
  11.     }
  13.     QJsonObject jsonObj = jsonDoc.object();
  14.     qDebug()<< "data jsonobj is " << jsonObj ;
  16.     if(!jsonObj.contains("error")){
  17.         int err = ErrorCodes::ERR_JSON;
  18.         qDebug() << "Login Failed, err is Json Parse Err" << err ;
  19.         emit sig_login_failed(err);
  20.         return;
  21.     }
  23.     int err = jsonObj["error"].toInt();
  24.     if(err != ErrorCodes::SUCCESS){
  25.         qDebug() << "Login Failed, err is " << err ;
  26.         emit sig_login_failed(err);
  27.         return;
  28.     }
  30.     auto uid = jsonObj["uid"].toInt();
  31.     auto name = jsonObj["name"].toString();
  32.     auto nick = jsonObj["nick"].toString();
  33.     auto icon = jsonObj["icon"].toString();
  34.     auto sex = jsonObj["sex"].toInt();
  35.     auto user_info = std::make_shared<UserInfo>(uid, name, nick, icon, sex);
  37.     UserMgr::GetInstance()->SetUserInfo(user_info);
  38.     UserMgr::GetInstance()->SetToken(jsonObj["token"].toString());
  39.     if(jsonObj.contains("apply_list")){
  40.         UserMgr::GetInstance()->AppendApplyList(jsonObj["apply_list"].toArray());
  41.     }
  43.     //添加好友列表
  44.     if (jsonObj.contains("friend_list")) {
  45.         UserMgr::GetInstance()->AppendFriendList(jsonObj["friend_list"].toArray());
  46.     }
  48.     emit sig_swich_chatdlg();
  49. });

好友聊天

客户端发送聊天消息

客户端发送聊天消息，在输入框输入消息后，点击发送回执行下面的槽函数

  1. void ChatPage::on_send_btn_clicked()
  2. {
  3.     if (_user_info == nullptr) {
  4.         qDebug() << "friend_info is empty";
  5.         return;
  6.     }
  8.     auto user_info = UserMgr::GetInstance()->GetUserInfo();
  9.     auto pTextEdit = ui->chatEdit;
  10.     ChatRole role = ChatRole::Self;
  11.     QString userName = user_info->_name;
  12.     QString userIcon = user_info->_icon;
  14.     const QVector<MsgInfo>& msgList = pTextEdit->getMsgList();
  15.     QJsonObject textObj;
  16.     QJsonArray textArray;
  17.     int txt_size = 0;
  19.     for(int i=0; i<msgList.size(); ++i)
  20.     {
  21.         //消息内容长度不合规就跳过
  22.         if(msgList[i].content.length() > 1024){
  23.             continue;
  24.         }
  26.         QString type = msgList[i].msgFlag;
  27.         ChatItemBase *pChatItem = new ChatItemBase(role);
  28.         pChatItem->setUserName(userName);
  29.         pChatItem->setUserIcon(QPixmap(userIcon));
  30.         QWidget *pBubble = nullptr;
  32.         if(type == "text")
  33.         {   
  34.             //生成唯一id
  35.             QUuid uuid = QUuid::createUuid();
  36.             //转为字符串
  37.             QString uuidString = uuid.toString();
  39.             pBubble = new TextBubble(role, msgList[i].content);
  40.             if(txt_size + msgList[i].content.length()> 1024){
  41.                 textObj["fromuid"] = user_info->_uid;
  42.                 textObj["touid"] = _user_info->_uid;
  43.                 textObj["text_array"] = textArray;
  44.                 QJsonDocument doc(textObj);
  45.                 QByteArray jsonData = doc.toJson(QJsonDocument::Compact);
  46.                 //发送并清空之前累计的文本列表
  47.                 txt_size = 0;
  48.                 textArray = QJsonArray();
  49.                 textObj = QJsonObject();
  50.                 //发送tcp请求给chat server
  51.                 emit TcpMgr::GetInstance()->sig_send_data(ReqId::ID_TEXT_CHAT_MSG_REQ, jsonData);
  52.             }
  54.             //将bubble和uid绑定，以后可以等网络返回消息后设置是否送达
  55.             //_bubble_map[uuidString] = pBubble;
  56.             txt_size += msgList[i].content.length();
  57.             QJsonObject obj;
  58.             QByteArray utf8Message = msgList[i].content.toUtf8();
  59.             obj["content"] = QString::fromUtf8(utf8Message);
  60.             obj["msgid"] = uuidString;
  61.             textArray.append(obj);
  62.             auto txt_msg = std::make_shared<TextChatData>(uuidString, obj["content"].toString(),
  63.                 user_info->_uid, _user_info->_uid);
  64.             emit sig_append_send_chat_msg(txt_msg);
  65.         }
  66.         else if(type == "image")
  67.         {
  68.              pBubble = new PictureBubble(QPixmap(msgList[i].content) , role);
  69.         }
  70.         else if(type == "file")
  71.         {
  73.         }
  74.         //发送消息
  75.         if(pBubble != nullptr)
  76.         {
  77.             pChatItem->setWidget(pBubble);
  78.             ui->chat_data_list->appendChatItem(pChatItem);
  79.         }
  81.     }
  83.     qDebug() << "textArray is " << textArray ;
  84.     //发送给服务器
  85.     textObj["text_array"] = textArray;
  86.     textObj["fromuid"] = user_info->_uid;
  87.     textObj["touid"] = _user_info->_uid;
  88.     QJsonDocument doc(textObj);
  89.     QByteArray jsonData = doc.toJson(QJsonDocument::Compact);
  90.     //发送并清空之前累计的文本列表
  91.     txt_size = 0;
  92.     textArray = QJsonArray();
  93.     textObj = QJsonObject();
  94.     //发送tcp请求给chat server
  95.     emit TcpMgr::GetInstance()->sig_send_data(ReqId::ID_TEXT_CHAT_MSG_REQ, jsonData);
  96. }

TcpMgr响应发送信号

  1. void TcpMgr::slot_send_data(ReqId reqId, QByteArray dataBytes)
  2. {
  3.     uint16_t id = reqId;
  5.     // 计算长度（使用网络字节序转换）
  6.     quint16 len = static_cast<quint16>(dataBytes.length());
  8.     // 创建一个QByteArray用于存储要发送的所有数据
  9.     QByteArray block;
  10.     QDataStream out(&block, QIODevice::WriteOnly);
  12.     // 设置数据流使用网络字节序
  13.     out.setByteOrder(QDataStream::BigEndian);
  15.     // 写入ID和长度
  16.     out << id << len;
  18.     // 添加字符串数据
  19.     block.append(dataBytes);
  21.     // 发送数据
  22.     _socket.write(block);
  23.     qDebug() << "tcp mgr send byte data is " << block ;
  24. }

服务器响应

服务器响应客户端发送过来文本消息，在initHandlers中添加处理文本消息的逻辑

  1. void LogicSystem::DealChatTextMsg(std::shared_ptr<CSession> session, const short& msg_id, const string& msg_data) {
  2.     Json::Reader reader;
  3.     Json::Value root;
  4.     reader.parse(msg_data, root);
  6.     auto uid = root["fromuid"].asInt();
  7.     auto touid = root["touid"].asInt();
  9.     const Json::Value  arrays = root["text_array"];
  11.     Json::Value  rtvalue;
  12.     rtvalue["error"] = ErrorCodes::Success;
  13.     rtvalue["text_array"] = arrays;
  14.     rtvalue["fromuid"] = uid;
  15.     rtvalue["touid"] = touid;
  17.     Defer defer([this, &rtvalue, session]() {
  18.         std::string return_str = rtvalue.toStyledString();
  19.         session->Send(return_str, ID_TEXT_CHAT_MSG_RSP);
  20.         });
  23.     //查询redis 查找touid对应的server ip
  24.     auto to_str = std::to_string(touid);
  25.     auto to_ip_key = USERIPPREFIX + to_str;
  26.     std::string to_ip_value = "";
  27.     bool b_ip = RedisMgr::GetInstance()->Get(to_ip_key, to_ip_value);
  28.     if (!b_ip) {
  29.         return;
  30.     }
  32.     auto& cfg = ConfigMgr::Inst();
  33.     auto self_name = cfg["SelfServer"]["Name"];
  34.     //直接通知对方有认证通过消息
  35.     if (to_ip_value == self_name) {
  36.         auto session = UserMgr::GetInstance()->GetSession(touid);
  37.         if (session) {
  38.             //在内存中则直接发送通知对方
  39.             std::string return_str = rtvalue.toStyledString();
  40.             session->Send(return_str, ID_NOTIFY_TEXT_CHAT_MSG_REQ);
  41.         }
  43.         return ;
  44.     }
  47.     TextChatMsgReq text_msg_req;
  48.     text_msg_req.set_fromuid(uid);
  49.     text_msg_req.set_touid(touid);
  50.     for (const auto& txt_obj : arrays) {
  51.         auto content = txt_obj["content"].asString();
  52.         auto msgid = txt_obj["msgid"].asString();
  53.         std::cout << "content is " << content << std::endl;
  54.         std::cout << "msgid is " << msgid << std::endl;
  55.         auto *text_msg = text_msg_req.add_textmsgs();
  56.         text_msg->set_msgid(msgid);
  57.         text_msg->set_msgcontent(content);
  58.     }
  61.     //发送通知 todo...
  62.     ChatGrpcClient::GetInstance()->NotifyTextChatMsg(to_ip_value, text_msg_req, rtvalue);
  63. }

服务器实现发送消息的rpc客户端

  1. TextChatMsgRsp ChatGrpcClient::NotifyTextChatMsg(std::string server_ip, 
  2.     const TextChatMsgReq& req, const Json::Value& rtvalue) {
  4.     TextChatMsgRsp rsp;
  5.     rsp.set_error(ErrorCodes::Success);
  7.     Defer defer([&rsp, &req]() {
  8.         rsp.set_fromuid(req.fromuid());
  9.         rsp.set_touid(req.touid());
  10.         for (const auto& text_data : req.textmsgs()) {
  11.             TextChatData* new_msg = rsp.add_textmsgs();
  12.             new_msg->set_msgid(text_data.msgid());
  13.             new_msg->set_msgcontent(text_data.msgcontent());
  14.         }
  16.         });
  18.     auto find_iter = _pools.find(server_ip);
  19.     if (find_iter == _pools.end()) {
  20.         return rsp;
  21.     }
  23.     auto& pool = find_iter->second;
  24.     ClientContext context;
  25.     auto stub = pool->getConnection();
  26.     Status status = stub->NotifyTextChatMsg(&context, req, &rsp);
  27.     Defer defercon([&stub, this, &pool]() {
  28.         pool->returnConnection(std::move(stub));
  29.         });
  31.     if (!status.ok()) {
  32.         rsp.set_error(ErrorCodes::RPCFailed);
  33.         return rsp;
  34.     }
  36.     return rsp;
  37. }

服务器实现rpc服务端处理消息通知

  1. Status ChatServiceImpl::NotifyTextChatMsg(::grpc::ServerContext* context,
  2.     const TextChatMsgReq* request, TextChatMsgRsp* reply) {
  3.     //查找用户是否在本服务器
  4.     auto touid = request->touid();
  5.     auto session = UserMgr::GetInstance()->GetSession(touid);
  6.     reply->set_error(ErrorCodes::Success);
  8.     //用户不在内存中则直接返回
  9.     if (session == nullptr) {
  10.         return Status::OK;
  11.     }
  13.     //在内存中则直接发送通知对方
  14.     Json::Value  rtvalue;
  15.     rtvalue["error"] = ErrorCodes::Success;
  16.     rtvalue["fromuid"] = request->fromuid();
  17.     rtvalue["touid"] = request->touid();
  19.     //将聊天数据组织为数组
  20.     Json::Value text_array;
  21.     for (auto& msg : request->textmsgs()) {
  22.         Json::Value element;
  23.         element["content"] = msg.msgcontent();
  24.         element["msgid"] = msg.msgid();
  25.         text_array.append(element);
  26.     }
  27.     rtvalue["text_array"] = text_array;
  29.     std::string return_str = rtvalue.toStyledString();
  31.     session->Send(return_str, ID_NOTIFY_TEXT_CHAT_MSG_REQ);
  32.     return Status::OK;
  33. }

客户端响应通知

客户端响应服务器返回的消息，包括两种：

  1. A给B发送文本消息，A所在的服务器会给A发送ID_TEXT_CHAT_MSG_RSP消息。
  2. B所在的服务器会通知B，告诉B有来自A的消息，通知消息为ID_NOTIFY_TEXT_CHAT_MSG_REQ

所以在tcpmgr的initHandlers中添加响应ID_TEXT_CHAT_MSG_RSP消息

  1. _handlers.insert(ID_TEXT_CHAT_MSG_RSP, [this](ReqId id, int len, QByteArray data) {
  2.     Q_UNUSED(len);
  3.     qDebug() << "handle id is " << id << " data is " << data;
  4.     // 将QByteArray转换为QJsonDocument
  5.     QJsonDocument jsonDoc = QJsonDocument::fromJson(data);
  7.     // 检查转换是否成功
  8.     if (jsonDoc.isNull()) {
  9.         qDebug() << "Failed to create QJsonDocument.";
  10.         return;
  11.     }
  13.     QJsonObject jsonObj = jsonDoc.object();
  15.     if (!jsonObj.contains("error")) {
  16.         int err = ErrorCodes::ERR_JSON;
  17.         qDebug() << "Chat Msg Rsp Failed, err is Json Parse Err" << err;
  18.         return;
  19.     }
  21.     int err = jsonObj["error"].toInt();
  22.     if (err != ErrorCodes::SUCCESS) {
  23.         qDebug() << "Chat Msg Rsp Failed, err is " << err;
  24.         return;
  25.     }
  27.     qDebug() << "Receive Text Chat Rsp Success " ;
  28.     //ui设置送达等标记 todo...
  29.   });

在TcpMgr的initHandlers中添加ID_NOTIFY_TEXT_CHAT_MSG_REQ

  1. _handlers.insert(ID_NOTIFY_TEXT_CHAT_MSG_REQ, [this](ReqId id, int len, QByteArray data) {
  2.     Q_UNUSED(len);
  3.     qDebug() << "handle id is " << id << " data is " << data;
  4.     // 将QByteArray转换为QJsonDocument
  5.     QJsonDocument jsonDoc = QJsonDocument::fromJson(data);
  7.     // 检查转换是否成功
  8.     if (jsonDoc.isNull()) {
  9.         qDebug() << "Failed to create QJsonDocument.";
  10.         return;
  11.     }
  13.     QJsonObject jsonObj = jsonDoc.object();
  15.     if (!jsonObj.contains("error")) {
  16.         int err = ErrorCodes::ERR_JSON;
  17.         qDebug() << "Notify Chat Msg Failed, err is Json Parse Err" << err;
  18.         return;
  19.     }
  21.     int err = jsonObj["error"].toInt();
  22.     if (err != ErrorCodes::SUCCESS) {
  23.         qDebug() << "Notify Chat Msg Failed, err is " << err;
  24.         return;
  25.     }
  27.     qDebug() << "Receive Text Chat Notify Success " ;
  28.     auto msg_ptr = std::make_shared<TextChatMsg>(jsonObj["fromuid"].toInt(),
  29.             jsonObj["touid"].toInt(),jsonObj["text_array"].toArray());
  30.     emit sig_text_chat_msg(msg_ptr);
  31.   });

客户端ChatDialog添加对sig_text_chat_msg的响应

  1. void ChatDialog::slot_text_chat_msg(std::shared_ptr<TextChatMsg> msg)
  2. {
  3.     auto find_iter = _chat_items_added.find(msg->_from_uid);
  4.     if(find_iter != _chat_items_added.end()){
  5.         qDebug() << "set chat item msg, uid is " << msg->_from_uid;
  6.         QWidget *widget = ui->chat_user_list->itemWidget(find_iter.value());
  7.         auto chat_wid = qobject_cast<ChatUserWid*>(widget);
  8.         if(!chat_wid){
  9.             return;
  10.         }
  11.         chat_wid->updateLastMsg(msg->_chat_msgs);
  12.         //更新当前聊天页面记录
  13.         UpdateChatMsg(msg->_chat_msgs);
  14.         UserMgr::GetInstance()->AppendFriendChatMsg(msg->_from_uid,msg->_chat_msgs);
  15.         return;
  16.     }
  18.     //如果没找到，则创建新的插入listwidget
  20.     auto* chat_user_wid = new ChatUserWid();
  21.     //查询好友信息
  22.     auto fi_ptr = UserMgr::GetInstance()->GetFriendById(msg->_from_uid);
  23.     chat_user_wid->SetInfo(fi_ptr);
  24.     QListWidgetItem* item = new QListWidgetItem;
  25.     //qDebug()<<"chat_user_wid sizeHint is " << chat_user_wid->sizeHint();
  26.     item->setSizeHint(chat_user_wid->sizeHint());
  27.     chat_user_wid->updateLastMsg(msg->_chat_msgs);
  28.      UserMgr::GetInstance()->AppendFriendChatMsg(msg->_from_uid,msg->_chat_msgs);
  29.     ui->chat_user_list->insertItem(0, item);
  30.     ui->chat_user_list->setItemWidget(item, chat_user_wid);
  31.     _chat_items_added.insert(msg->_from_uid, item);
  33. }

效果展示

https://cdn.llfc.club/1724470182274.jpg

源码连接

https://gitee.com/secondtonone1/llfcchat

视频连接

https://www.bilibili.com/video/BV1ib421J745/?vd_source=8be9e83424c2ed2c9b2a3ed1d01385e9

热门评论
点击查看更多评论 没有更多评论了,点击收起 展开评论

热门文章

  1. Linux环境搭建和编码
    喜欢(594) 浏览(8788)

  2. windows环境搭建和vscode配置
    喜欢(587) 浏览(2073)

  3. 解密定时器的实现细节
    喜欢(566) 浏览(2812)

  4. C++ 类的继承封装和多态
    喜欢(588) 浏览(3910)

  5. slice介绍和使用
    喜欢(521) 浏览(2103)

最新评论

  1. 泛型算法的定制操作 secondtonone1:lambda和bind是C11新增的利器，善于利用这两个机制可以极大地提升编程安全性和效率。
  2. 类和对象 陈宇航:支持！！！！
  3. C++ 虚函数表原理和类成员内存分布 WangQi888888:class Test{ int m; int b; }中b成员是int，为什么在内存中只占了1个字节。不应该是4个字节吗？是不是int应该改为char。这样的话就会符合图上说明的情况
  4. 解决博客回复区被脚本注入的问题 secondtonone1:走到现在我忽然明白一个道理，无论工作也好生活也罢，最重要的是开心，即使一份安稳的工作不能给我带来事业上的积累也要合理的舍弃，所以我还是想去做喜欢的方向。
  5. asio多线程模型IOServicePool Lion:线程池一定要继承单例模式吗

其他链接

  1. GitHub
  2. 个人博客
  3. 博客园
  4. CSDN

个人公众号

个人微信