恋恋风辰的官方博客

聊天项目(28) 分布式服务通知好友申请
Posted on 2024-08-05 18:55:55 by 恋恋风辰 | In C++ | 原文链接

简介

本文介绍如何实现用户查找和好友申请功能。查找和申请好友会涉及前后端通信和rpc服务间调用。所以目前先从客户端入手，搜索用户后发送查找好友申请请求给服务器，服务器收到后判断是否存在，如果不存在则显示未找到，如果存在则显示查找到的结果

点击查询

客户端点击搜索列表的添加好友item后，先弹出一个模态对话框，上面有loading动作表示加载，直到服务器返回结果

  1. void SearchList::slot_item_clicked(QListWidgetItem *item)
  2. {
  3.     QWidget *widget = this->itemWidget(item); //获取自定义widget对象
  4.     if(!widget){
  5.         qDebug()<< "slot item clicked widget is nullptr";
  6.         return;
  7.     }
  9.     // 对自定义widget进行操作， 将item 转化为基类ListItemBase
  10.     ListItemBase *customItem = qobject_cast<ListItemBase*>(widget);
  11.     if(!customItem){
  12.         qDebug()<< "slot item clicked widget is nullptr";
  13.         return;
  14.     }
  16.     auto itemType = customItem->GetItemType();
  17.     if(itemType == ListItemType::INVALID_ITEM){
  18.         qDebug()<< "slot invalid item clicked ";
  19.         return;
  20.     }
  22.     if(itemType == ListItemType::ADD_USER_TIP_ITEM){
  23.         if(_send_pending){
  24.             return;
  25.         }
  27.         if (!_search_edit) {
  28.             return;
  29.         }
  31.         waitPending(true);
  32.         auto search_edit = dynamic_cast<CustomizeEdit*>(_search_edit);
  33.         auto uid_str = search_edit->text();
  34.         QJsonObject jsonObj;
  35.         jsonObj["uid"] = uid_str;
  37.         QJsonDocument doc(jsonObj);
  38.         QByteArray jsonData = doc.toJson(QJsonDocument::Compact);
  39.         emit TcpMgr::GetInstance()->sig_send_data(ReqId::ID_SEARCH_USER_REQ,
  40.                                                   jsonData);
  41.         return;
  42.     }
  44.     //清楚弹出框
  45.     CloseFindDlg();
  47. }

_send_pending为新增的成员变量，如果为true则表示发送阻塞.构造函数中将其设置为false。

waitPending函数为根据pending状态展示加载框

  1. void SearchList::waitPending(bool pending)
  2. {
  3.     if(pending){
  4.         _loadingDialog = new LoadingDlg(this);
  5.         _loadingDialog->setModal(true);
  6.         _loadingDialog->show();
  7.         _send_pending = pending;
  8.     }else{
  9.         _loadingDialog->hide();
  10.         _loadingDialog->deleteLater();
  11.         _send_pending = pending;
  12.     }
  13. }

当我们发送数据后服务器会处理，返回ID_SEARCH_USER_RSP包，所以客户端要实现对ID_SEARCH_USER_RSP包的处理

  1.     _handlers.insert(ID_SEARCH_USER_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() << "Login Failed, err is Json Parse Err" << err ;
  18.             emit sig_login_failed(err);
  19.             return;
  20.         }
  22.         int err = jsonObj["error"].toInt();
  23.         if(err != ErrorCodes::SUCCESS){
  24.             qDebug() << "Login Failed, err is " << err ;
  25.             emit sig_login_failed(err);
  26.             return;
  27.         }
  29.       auto search_info = std::make_shared<SearchInfo>(jsonObj["uid"].toInt(),
  30.               jsonObj["name"].toString(), jsonObj["nick"].toString(),
  31.               jsonObj["desc"].toString(), jsonObj["sex"].toInt(), jsonObj["icon"].toString());
  33.        emit sig_user_search(search_info);
  34.     });

将搜索到的结果封装为search_info发送给SearchList类做展示, search_list中连接信号和槽

  1. //连接搜索条目
  2. connect(TcpMgr::GetInstance().get(), &TcpMgr::sig_user_search, this, &SearchList::slot_user_search);

slot_user_search槽函数弹出搜索结果

  1. void SearchList::slot_user_search(std::shared_ptr<SearchInfo> si)
  2. {
  3.     waitPending(false);
  4.     if(si == nullptr){
  5.         _find_dlg = std::make_shared<FindFailDlg>(this);
  6.     }else{
  7.         //此处分两种情况，一种是搜多到已经是自己的朋友了，一种是未添加好友
  8.         //查找是否已经是好友 todo...
  9.         _find_dlg = std::make_shared<FindSuccessDlg>(this);
  10.         std::dynamic_pointer_cast<FindSuccessDlg>(_find_dlg)->SetSearchInfo(si);
  11.     }
  13.     _find_dlg->show();
  14. }

FindSuccessDlg是找到的结果展示，FindFailDlg是未找到结果展示。以下为FindSuccessDlg的ui布局

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

具体声明如下

  1. class FindSuccessDlg : public QDialog
  2. {
  3.     Q_OBJECT
  5. public:
  6.     explicit FindSuccessDlg(QWidget *parent = nullptr);
  7.     ~FindSuccessDlg();
  8.     void SetSearchInfo(std::shared_ptr<SearchInfo> si);
  10. private:
  11.     Ui::FindSuccessDlg *ui;
  12.     std::shared_ptr<SearchInfo> _si;
  13.     QWidget * _parent;
  15. private slots:
  16.     void on_add_friend_btn_clicked();
  17. };

具体实现如下

  1. FindSuccessDlg::FindSuccessDlg(QWidget *parent) :
  2.     QDialog(parent), _parent(parent),
  3.     ui(new Ui::FindSuccessDlg)
  4. {
  5.     ui->setupUi(this);
  6.     // 设置对话框标题
  7.     setWindowTitle("添加");
  8.     // 隐藏对话框标题栏
  9.     setWindowFlags(windowFlags() | Qt::FramelessWindowHint);
  10.     // 获取当前应用程序的路径
  11.     QString app_path = QCoreApplication::applicationDirPath();
  12.     QString pix_path = QDir::toNativeSeparators(app_path +
  13.                              QDir::separator() + "static"+QDir::separator()+"head_1.jpg");
  14.     QPixmap head_pix(pix_path);
  15.     head_pix = head_pix.scaled(ui->head_lb->size(),
  16.             Qt::KeepAspectRatio, Qt::SmoothTransformation);
  17.     ui->head_lb->setPixmap(head_pix);
  18.     ui->add_friend_btn->SetState("normal","hover","press");
  19.     this->setModal(true);
  20. }
  22. FindSuccessDlg::~FindSuccessDlg()
  23. {
  24.     qDebug()<<"FindSuccessDlg destruct";
  25.     delete ui;
  26. }
  28. void FindSuccessDlg::SetSearchInfo(std::shared_ptr<SearchInfo> si)
  29. {
  30.     ui->name_lb->setText(si->_name);
  31.     _si = si;
  32. }
  34. void FindSuccessDlg::on_add_friend_btn_clicked()
  35. {
  36.     //todo... 添加好友界面弹出
  37.     this->hide();
  38.     //弹出加好友界面
  39.     auto applyFriend = new ApplyFriend(_parent);
  40.     applyFriend->SetSearchInfo(_si);
  41.     applyFriend->setModal(true);
  42.     applyFriend->show();
  43. }

类似的FindFailDlg也是这种思路，大家自己实现即可。

服务器查询逻辑

chatserver服务器要根据客户端发送过来的用户id进行查找,chatserver服务器需先注册ID_SEARCH_USER_REQ和回调函数

  1. void LogicSystem::RegisterCallBacks() {
  2.     _fun_callbacks[MSG_CHAT_LOGIN] = std::bind(&LogicSystem::LoginHandler, this,
  3.         placeholders::_1, placeholders::_2, placeholders::_3);
  5.     _fun_callbacks[ID_SEARCH_USER_REQ] = std::bind(&LogicSystem::SearchInfo, this,
  6.         placeholders::_1, placeholders::_2, placeholders::_3);
  7. }

SearchInfo根据用户uid查询具体信息

  1. void LogicSystem::SearchInfo(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);
  5.     auto uid_str = root["uid"].asString();
  6.     std::cout << "user SearchInfo uid is  " << uid_str << endl;
  8.     Json::Value rtvalue;
  10.     Defer deder([this, &rtvalue, session]() {
  11.         std::string return_str = rtvalue.toStyledString();
  12.         session->Send(return_str, ID_SEARCH_USER_RSP);
  13.         });
  15.     bool b_digit = isPureDigit(uid_str);
  16.     if (b_digit) {
  17.         GetUserByUid(uid_str, rtvalue);
  18.     }
  19.     else {
  20.         GetUserByName(uid_str, rtvalue);
  21.     }
  22. }

到此客户端和服务器搜索查询的联调功能已经解决了。

客户端添加好友

当Client1搜索到好友后，点击添加弹出信息界面，然后点击确定即可向对方Client2申请添加好友，这个请求要先发送到Client1所在的服务器Server1，服务器收到后判断Client2所在服务器，如果Client2在Server1则直接在Server1中查找Client2的连接信息，没找到说明Client2未在内存中，找到了则通过Session发送tcp给对方。如果Client2不在Server1而在Server2上，则需要让Server1通过grpc接口通知Server2,Server2收到后继续判断Client2是否在线，如果在线则通知。

如下图，Client1想和Client2以及Client3分别通信，需要先将请求发给Client1所在的Server1，再考虑是否rpc调用。

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

客户端在ApplySure槽函数中添加好友请求

  1. void ApplyFriend::SlotApplySure()
  2. {
  3.     qDebug() << "Slot Apply Sure called" ;
  4.     QJsonObject jsonObj;
  5.     auto uid = UserMgr::GetInstance()->GetUid();
  6.     jsonObj["uid"] = uid;
  7.     auto name = ui->name_ed->text();
  8.     if(name.isEmpty()){
  9.         name = ui->name_ed->placeholderText();
  10.     }
  12.     jsonObj["applyname"] = name;
  13.     auto bakname = ui->back_ed->text();
  14.     if(bakname.isEmpty()){
  15.          bakname = ui->back_ed->placeholderText();
  16.     }
  17.     jsonObj["bakname"] = bakname;
  18.     jsonObj["touid"] = _si->_uid;
  20.     QJsonDocument doc(jsonObj);
  21.     QByteArray jsonData = doc.toJson(QJsonDocument::Compact);
  23.     //发送tcp请求给chat server
  24.     emit TcpMgr::GetInstance()->sig_send_data(ReqId::ID_ADD_FRIEND_REQ, jsonData);
  26.     this->hide();
  27.     deleteLater();
  28. }

另一个客户端会收到服务器通知添加好友的请求,所以在TcpMgr里监听这个请求

  1.     _handlers.insert(ID_NOTIFY_ADD_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();
  15.         if (!jsonObj.contains("error")) {
  16.             int err = ErrorCodes::ERR_JSON;
  17.             qDebug() << "Login Failed, err is Json Parse Err" << err;
  19.             emit sig_user_search(nullptr);
  20.             return;
  21.         }
  23.         int err = jsonObj["error"].toInt();
  24.         if (err != ErrorCodes::SUCCESS) {
  25.             qDebug() << "Login Failed, err is " << err;
  26.             emit sig_user_search(nullptr);
  27.             return;
  28.         }
  30.          int from_uid = jsonObj["applyuid"].toInt();
  31.          QString name = jsonObj["name"].toString();
  32.          QString desc = jsonObj["desc"].toString();
  33.          QString icon = jsonObj["icon"].toString();
  34.          QString nick = jsonObj["nick"].toString();
  35.          int sex = jsonObj["sex"].toInt();
  37.         auto apply_info = std::make_shared<AddFriendApply>(
  38.                     from_uid, name, desc,
  39.                       icon, nick, sex);
  41.         emit sig_friend_apply(apply_info);
  42.         });

服务调用

服务器要处理客户端发过来的添加好友的请求，并决定是否调用rpc通知其他服务。

先将AddFriendApply函数注册到回调map里

  1. void LogicSystem::RegisterCallBacks() {
  2.     _fun_callbacks[MSG_CHAT_LOGIN] = std::bind(&LogicSystem::LoginHandler, this,
  3.         placeholders::_1, placeholders::_2, placeholders::_3);
  5.     _fun_callbacks[ID_SEARCH_USER_REQ] = std::bind(&LogicSystem::SearchInfo, this,
  6.         placeholders::_1, placeholders::_2, placeholders::_3);
  8.     _fun_callbacks[ID_ADD_FRIEND_REQ] = std::bind(&LogicSystem::AddFriendApply, this,
  9.         placeholders::_1, placeholders::_2, placeholders::_3);
  10. }

接下来实现AddFriendApply

  1. void LogicSystem::AddFriendApply(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);
  5.     auto uid = root["uid"].asInt();
  6.     auto applyname = root["applyname"].asString();
  7.     auto bakname = root["bakname"].asString();
  8.     auto touid = root["touid"].asInt();
  9.     std::cout << "user login uid is  " << uid << " applyname  is "
  10.         << applyname << " bakname is " << bakname << " touid is " << touid << endl;
  12.     Json::Value  rtvalue;
  13.     rtvalue["error"] = ErrorCodes::Success;
  14.     Defer defer([this, &rtvalue, session]() {
  15.         std::string return_str = rtvalue.toStyledString();
  16.         session->Send(return_str, ID_ADD_FRIEND_RSP);
  17.         });
  19.     //先更新数据库
  20.     MysqlMgr::GetInstance()->AddFriendApply(uid, touid);
  22.     //查询redis 查找touid对应的server ip
  23.     auto to_str = std::to_string(touid);
  24.     auto to_ip_key = USERIPPREFIX + to_str;
  25.     std::string to_ip_value = "";
  26.     bool b_ip = RedisMgr::GetInstance()->Get(to_ip_key, to_ip_value);
  27.     if (!b_ip) {
  28.         return;
  29.     }
  31.     auto& cfg = ConfigMgr::Inst();
  32.     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.             Json::Value  notify;
  40.             notify["error"] = ErrorCodes::Success;
  41.             notify["applyuid"] = uid;
  42.             notify["name"] = applyname;
  43.             notify["desc"] = "";
  44.             std::string return_str = notify.toStyledString();
  45.             session->Send(return_str, ID_NOTIFY_ADD_FRIEND_REQ);
  46.         }
  48.         return;
  49.     }
  51.     std::string base_key = USER_BASE_INFO + std::to_string(uid);
  52.     auto apply_info = std::make_shared<UserInfo>();
  53.     bool b_info = GetBaseInfo(base_key, uid, apply_info);
  55.     AddFriendReq add_req;
  56.     add_req.set_applyuid(uid);
  57.     add_req.set_touid(touid);
  58.     add_req.set_name(applyname);
  59.     add_req.set_desc("");
  60.     if (b_info) {
  61.         add_req.set_icon(apply_info->icon);
  62.         add_req.set_sex(apply_info->sex);
  63.         add_req.set_nick(apply_info->nick);
  64.     }
  66.     //发送通知
  67.     ChatGrpcClient::GetInstance()->NotifyAddFriend(to_ip_value, add_req);
  68. }

上面的函数中先更新数据库将申请写入数据库中

  1. bool MysqlMgr::AddFriendApply(const int& from, const int& to) {
  2.     return _dao.AddFriendApply(from, to);
  3. }

内部调用dao层面的添加好友请求

  1. bool MysqlDao::AddFriendApply(const int& from, const int& to) {
  2.     auto con = pool_->getConnection();
  3.     if (con == nullptr) {
  4.         return false;
  5.     }
  7.     Defer defer([this, &con]() {
  8.         pool_->returnConnection(std::move(con));
  9.         });
  11.     try {
  12.         std::unique_ptr<sql::PreparedStatement> pstmt(con->_con->prepareStatement("INSERT INTO friend_apply (from_uid, to_uid) values (?,?) "
  13.         "ON DUPLICATE KEY UPDATE from_uid = from_uid, to_uid = to_uid "));
  14.         pstmt->setInt(1, from);
  15.         pstmt->setInt(2, to);
  16.         //执行更新
  17.         int rowAffected = pstmt->executeUpdate();
  18.         if (rowAffected < 0) {
  19.             return false;
  20.         }
  22.         return true;
  23.     }
  24.     catch (sql::SQLException& e) {
  25.         std::cerr << "SQLException: " << e.what();
  26.         std::cerr << " (MySQL error code: " << e.getErrorCode();
  27.         std::cerr << ", SQLState: " << e.getSQLState() << " )" << std::endl;
  28.         return false;
  29.     }
  31.     return true;
  32. }

添加完成后判断要通知的对端是否在本服务器，如果在本服务器则直接通过uid查找session，判断用户是否在线，如果在线则直接通知对端。

如果不在本服务器，则需要通过rpc通知对端服务器。rpc的客户端这么写即可。

  1. AddFriendRsp ChatGrpcClient::NotifyAddFriend(std::string server_ip, const AddFriendReq& req) {
  2.     AddFriendRsp rsp;
  3.     Defer defer([&rsp, &req]() {
  4.         rsp.set_error(ErrorCodes::Success);
  5.         rsp.set_applyuid(req.applyuid());
  6.         rsp.set_touid(req.touid());
  7.         });
  9.     auto find_iter = _pools.find(server_ip);
  10.     if (find_iter == _pools.end()) {
  11.         return rsp;
  12.     }
  14.     auto& pool = find_iter->second;
  15.     ClientContext context;
  16.     auto stub = pool->getConnection();
  17.     Status status = stub->NotifyAddFriend(&context, req, &rsp);
  18.     Defer defercon([&stub, this, &pool]() {
  19.         pool->returnConnection(std::move(stub));
  20.         });
  22.     if (!status.ok()) {
  23.         rsp.set_error(ErrorCodes::RPCFailed);
  24.         return rsp;
  25.     }
  27.     return rsp;
  28. }

同样rpc的服务端也要实现，我们先将rpc客户端和服务端的逻辑都在ChatServer1写好，然后复制给ChatServer2即可。 rpc的服务实现如下

  1. Status ChatServiceImpl::NotifyAddFriend(ServerContext* context, const AddFriendReq* request,
  2.     AddFriendRsp* reply) {
  3.     //查找用户是否在本服务器
  4.     auto touid = request->touid();
  5.     auto session = UserMgr::GetInstance()->GetSession(touid);
  7.     Defer defer([request, reply]() {
  8.         reply->set_error(ErrorCodes::Success);
  9.         reply->set_applyuid(request->applyuid());
  10.         reply->set_touid(request->touid());
  11.         });
  13.     //用户不在内存中则直接返回
  14.     if (session == nullptr) {
  15.         return Status::OK;
  16.     }
  18.     //在内存中则直接发送通知对方
  19.     Json::Value  rtvalue;
  20.     rtvalue["error"] = ErrorCodes::Success;
  21.     rtvalue["applyuid"] = request->applyuid();
  22.     rtvalue["name"] = request->name();
  23.     rtvalue["desc"] = request->desc();
  24.     rtvalue["icon"] = request->icon();
  25.     rtvalue["sex"] = request->sex();
  26.     rtvalue["nick"] = request->nick();
  28.     std::string return_str = rtvalue.toStyledString();
  30.     session->Send(return_str, ID_NOTIFY_ADD_FRIEND_REQ);
  32.     return Status::OK;
  33. }

上面的代码也是判断要通知的客户端是否在内存中，如果在就通过session发送tcp请求。

将ChatServer1的代码拷贝给ChatServer2,重启两个服务，再启动两个客户端，一个客户端申请另一个客户端，通过查看客户端日志是能看到申请信息的。

申请显示

接下来被通知申请的客户端要做界面显示，我们实现被通知的客户端收到sig_friend_apply信号的处理逻辑。在ChatDialog的构造函数中连接信号和槽

  1.  //连接申请添加好友信号
  2.     connect(TcpMgr::GetInstance().get(), &TcpMgr::sig_friend_apply, this, &ChatDialog::slot_apply_friend);

实现申请好友的槽函数

  1. void ChatDialog::slot_apply_friend(std::shared_ptr<AddFriendApply> apply)
  2. {
  3.     qDebug() << "receive apply friend slot, applyuid is " << apply->_from_uid << " name is "
  4.         << apply->_name << " desc is " << apply->_desc;
  6.    bool b_already = UserMgr::GetInstance()->AlreadyApply(apply->_from_uid);
  7.    if(b_already){
  8.         return;
  9.    }
  11.    UserMgr::GetInstance()->AddApplyList(std::make_shared<ApplyInfo>(apply));
  12.     ui->side_contact_lb->ShowRedPoint(true);
  13.     ui->con_user_list->ShowRedPoint(true);
  14.     ui->friend_apply_page->AddNewApply(apply);
  15. }

这样就能显示新的申请消息和红点了。具体添加一个新的申请条目到申请好友页面的逻辑如下：

  1. void ApplyFriendPage::AddNewApply(std::shared_ptr<AddFriendApply> apply)
  2. {
  3.     //先模拟头像随机，以后头像资源增加资源服务器后再显示
  4.     int randomValue = QRandomGenerator::global()->bounded(100); // 生成0到99之间的随机整数
  5.     int head_i = randomValue % heads.size();
  6.     auto* apply_item = new ApplyFriendItem();
  7.     auto apply_info = std::make_shared<ApplyInfo>(apply->_from_uid,
  8.              apply->_name, apply->_desc,heads[head_i], apply->_name, 0, 0);
  9.     apply_item->SetInfo( apply_info);
  10.     QListWidgetItem* item = new QListWidgetItem;
  11.     //qDebug()<<"chat_user_wid sizeHint is " << chat_user_wid->sizeHint();
  12.     item->setSizeHint(apply_item->sizeHint());
  13.     item->setFlags(item->flags() & ~Qt::ItemIsEnabled & ~Qt::ItemIsSelectable);
  14.     ui->apply_friend_list->insertItem(0,item);
  15.     ui->apply_friend_list->setItemWidget(item, apply_item);
  16.     apply_item->ShowAddBtn(true);
  17.     //收到审核好友信号
  18.     connect(apply_item, &ApplyFriendItem::sig_auth_friend, [this](std::shared_ptr<ApplyInfo> apply_info) {
  19.         auto* authFriend = new AuthenFriend(this);
  20.         authFriend->setModal(true);
  21.         authFriend->SetApplyInfo(apply_info);
  22.         authFriend->show();
  23.         });
  24. }

测试效果, 收到对方请求后如下图

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

登录加载申请

当用户登录后，服务器需要将申请列表同步给客户端, 写在登录逻辑里。

  1.     //从数据库获取申请列表
  2.     std::vector<std::shared_ptr<ApplyInfo>> apply_list;
  3.     auto b_apply = GetFriendApplyInfo(uid,apply_list);
  4.     if (b_apply) {
  5.         for (auto & apply : apply_list) {
  6.             Json::Value obj;
  7.             obj["name"] = apply->_name;
  8.             obj["uid"] = apply->_uid;
  9.             obj["icon"] = apply->_icon;
  10.             obj["nick"] = apply->_nick;
  11.             obj["sex"] = apply->_sex;
  12.             obj["desc"] = apply->_desc;
  13.             obj["status"] = apply->_status;
  14.             rtvalue["apply_list"].append(obj);
  15.         }
  16.     }

获取好友申请信息函数

  1. bool LogicSystem::GetFriendApplyInfo(int to_uid, std::vector<std::shared_ptr<ApplyInfo>> &list) {
  2.     //从mysql获取好友申请列表
  3.     return MysqlMgr::GetInstance()->GetApplyList(to_uid, list, 0, 10);
  4. }

dao层面实现获取申请列表

  1. bool MysqlMgr::GetApplyList(int touid, 
  2.     std::vector<std::shared_ptr<ApplyInfo>>& applyList, int begin, int limit) {
  4.     return _dao.GetApplyList(touid, applyList, begin, limit);
  5. }
  7. bool MysqlDao::GetApplyList(int touid, std::vector<std::shared_ptr<ApplyInfo>>& applyList, int begin, int limit) {
  8.     auto con = pool_->getConnection();
  9.     if (con == nullptr) {
  10.         return false;
  11.     }
  13.     Defer defer([this, &con]() {
  14.         pool_->returnConnection(std::move(con));
  15.         });
  18.         try {
  19.         // 准备SQL语句, 根据起始id和限制条数返回列表
  20.         std::unique_ptr<sql::PreparedStatement> pstmt(con->_con->prepareStatement("select apply.from_uid, apply.status, user.name, "
  21.                 "user.nick, user.sex from friend_apply as apply join user on apply.from_uid = user.uid where apply.to_uid = ? "
  22.             "and apply.id > ? order by apply.id ASC LIMIT ? "));
  24.         pstmt->setInt(1, touid); // 将uid替换为你要查询的uid
  25.         pstmt->setInt(2, begin); // 起始id
  26.         pstmt->setInt(3, limit); //偏移量
  27.         // 执行查询
  28.         std::unique_ptr<sql::ResultSet> res(pstmt->executeQuery());
  29.         // 遍历结果集
  30.         while (res->next()) {    
  31.             auto name = res->getString("name");
  32.             auto uid = res->getInt("from_uid");
  33.             auto status = res->getInt("status");
  34.             auto nick = res->getString("nick");
  35.             auto sex = res->getInt("sex");
  36.             auto apply_ptr = std::make_shared<ApplyInfo>(uid, name, "", "", nick, sex, status);
  37.             applyList.push_back(apply_ptr);
  38.         }
  39.         return true;
  40.     }
  41.     catch (sql::SQLException& e) {
  42.         std::cerr << "SQLException: " << e.what();
  43.         std::cerr << " (MySQL error code: " << e.getErrorCode();
  44.         std::cerr << ", SQLState: " << e.getSQLState() << " )" << std::endl;
  45.         return false;
  46.     }
  47. }

好友认证界面

客户端需要实现好友认证界面，当点击同意对方好友申请后，弹出认证信息，点击确定后将认证同意的请求发给服务器，服务器再通知申请方，告知对方被申请人已经同意加好友了。认证界面和申请界面类似, 这个大家自己实现即可。

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

认证界面的函数和逻辑可以照抄申请好友的逻辑。

  1. AuthenFriend::AuthenFriend(QWidget *parent) :
  2.     QDialog(parent),
  3.     ui(new Ui::AuthenFriend),_label_point(2,6)
  4. {
  5.     ui->setupUi(this);
  6.     // 隐藏对话框标题栏
  7.     setWindowFlags(windowFlags() | Qt::FramelessWindowHint);
  8.     this->setObjectName("AuthenFriend");
  9.     this->setModal(true);
  10.     ui->lb_ed->setPlaceholderText("搜索、添加标签");
  11.     ui->back_ed->setPlaceholderText("燃烧的胸毛");
  13.     ui->lb_ed->SetMaxLength(21);
  14.     ui->lb_ed->move(2, 2);
  15.     ui->lb_ed->setFixedHeight(20);
  16.     ui->lb_ed->setMaxLength(10);
  17.     ui->input_tip_wid->hide();
  19.     _tip_cur_point = QPoint(5, 5);
  21.     _tip_data = { "同学","家人","菜鸟教程","C++ Primer","Rust 程序设计",
  22.                              "父与子学Python","nodejs开发指南","go 语言开发指南",
  23.                                 "游戏伙伴","金融投资","微信读书","拼多多拼友" };
  25.     connect(ui->more_lb, &ClickedOnceLabel::clicked, this, &AuthenFriend::ShowMoreLabel);
  26.     InitTipLbs();
  27.     //链接输入标签回车事件
  28.     connect(ui->lb_ed, &CustomizeEdit::returnPressed, this, &AuthenFriend::SlotLabelEnter);
  29.     connect(ui->lb_ed, &CustomizeEdit::textChanged, this, &AuthenFriend::SlotLabelTextChange);
  30.     connect(ui->lb_ed, &CustomizeEdit::editingFinished, this, &AuthenFriend::SlotLabelEditFinished);
  31.     connect(ui->tip_lb, &ClickedOnceLabel::clicked, this, &AuthenFriend::SlotAddFirendLabelByClickTip);
  33.     ui->scrollArea->horizontalScrollBar()->setHidden(true);
  34.     ui->scrollArea->verticalScrollBar()->setHidden(true);
  35.     ui->scrollArea->installEventFilter(this);
  36.     ui->sure_btn->SetState("normal","hover","press");
  37.     ui->cancel_btn->SetState("normal","hover","press");
  38.     //连接确认和取消按钮的槽函数
  39.     connect(ui->cancel_btn, &QPushButton::clicked, this, &AuthenFriend::SlotApplyCancel);
  40.     connect(ui->sure_btn, &QPushButton::clicked, this, &AuthenFriend::SlotApplySure);
  41. }
  43. AuthenFriend::~AuthenFriend()
  44. {
  45.     qDebug()<< "AuthenFriend destruct";
  46.     delete ui;
  47. }
  49. void AuthenFriend::InitTipLbs()
  50. {
  51.     int lines = 1;
  52.     for(int i = 0; i < _tip_data.size(); i++){
  54.         auto* lb = new ClickedLabel(ui->lb_list);
  55.         lb->SetState("normal", "hover", "pressed", "selected_normal",
  56.             "selected_hover", "selected_pressed");
  57.         lb->setObjectName("tipslb");
  58.         lb->setText(_tip_data[i]);
  59.         connect(lb, &ClickedLabel::clicked, this, &AuthenFriend::SlotChangeFriendLabelByTip);
  61.         QFontMetrics fontMetrics(lb->font()); // 获取QLabel控件的字体信息
  62.         int textWidth = fontMetrics.width(lb->text()); // 获取文本的宽度
  63.         int textHeight = fontMetrics.height(); // 获取文本的高度
  65.         if (_tip_cur_point.x() + textWidth + tip_offset > ui->lb_list->width()) {
  66.             lines++;
  67.             if (lines > 2) {
  68.                 delete lb;
  69.                 return;
  70.             }
  72.             _tip_cur_point.setX(tip_offset);
  73.             _tip_cur_point.setY(_tip_cur_point.y() + textHeight + 15);
  75.         }
  77.        auto next_point = _tip_cur_point;
  79.        AddTipLbs(lb, _tip_cur_point,next_point, textWidth, textHeight);
  81.        _tip_cur_point = next_point;
  82.     }
  84. }
  86. void AuthenFriend::AddTipLbs(ClickedLabel* lb, QPoint cur_point, QPoint& next_point, int text_width, int text_height)
  87. {
  88.     lb->move(cur_point);
  89.     lb->show();
  90.     _add_labels.insert(lb->text(), lb);
  91.     _add_label_keys.push_back(lb->text());
  92.     next_point.setX(lb->pos().x() + text_width + 15);
  93.     next_point.setY(lb->pos().y());
  94. }
  96. bool AuthenFriend::eventFilter(QObject *obj, QEvent *event)
  97. {
  98.     if (obj == ui->scrollArea && event->type() == QEvent::Enter)
  99.     {
  100.         ui->scrollArea->verticalScrollBar()->setHidden(false);
  101.     }
  102.     else if (obj == ui->scrollArea && event->type() == QEvent::Leave)
  103.     {
  104.         ui->scrollArea->verticalScrollBar()->setHidden(true);
  105.     }
  106.     return QObject::eventFilter(obj, event);
  107. }
  109. void AuthenFriend::SetApplyInfo(std::shared_ptr<ApplyInfo> apply_info)
  110. {
  111.     _apply_info = apply_info;
  112.     ui->back_ed->setPlaceholderText(apply_info->_name);
  113. }
  115. void AuthenFriend::ShowMoreLabel()
  116. {
  117.     qDebug()<< "receive more label clicked";
  118.     ui->more_lb_wid->hide();
  120.     ui->lb_list->setFixedWidth(325);
  121.     _tip_cur_point = QPoint(5, 5);
  122.     auto next_point = _tip_cur_point;
  123.     int textWidth;
  124.     int textHeight;
  125.     //重拍现有的label
  126.     for(auto & added_key : _add_label_keys){
  127.         auto added_lb = _add_labels[added_key];
  129.         QFontMetrics fontMetrics(added_lb->font()); // 获取QLabel控件的字体信息
  130.         textWidth = fontMetrics.width(added_lb->text()); // 获取文本的宽度
  131.         textHeight = fontMetrics.height(); // 获取文本的高度
  133.         if(_tip_cur_point.x() +textWidth + tip_offset > ui->lb_list->width()){
  134.             _tip_cur_point.setX(tip_offset);
  135.             _tip_cur_point.setY(_tip_cur_point.y()+textHeight+15);
  136.         }
  137.         added_lb->move(_tip_cur_point);
  139.         next_point.setX(added_lb->pos().x() + textWidth + 15);
  140.         next_point.setY(_tip_cur_point.y());
  142.         _tip_cur_point = next_point;
  144.     }
  146.     //添加未添加的
  147.     for(int i = 0; i < _tip_data.size(); i++){
  148.         auto iter = _add_labels.find(_tip_data[i]);
  149.         if(iter != _add_labels.end()){
  150.             continue;
  151.         }
  153.         auto* lb = new ClickedLabel(ui->lb_list);
  154.         lb->SetState("normal", "hover", "pressed", "selected_normal",
  155.             "selected_hover", "selected_pressed");
  156.         lb->setObjectName("tipslb");
  157.         lb->setText(_tip_data[i]);
  158.         connect(lb, &ClickedLabel::clicked, this, &AuthenFriend::SlotChangeFriendLabelByTip);
  160.         QFontMetrics fontMetrics(lb->font()); // 获取QLabel控件的字体信息
  161.         int textWidth = fontMetrics.width(lb->text()); // 获取文本的宽度
  162.         int textHeight = fontMetrics.height(); // 获取文本的高度
  164.         if (_tip_cur_point.x() + textWidth + tip_offset > ui->lb_list->width()) {
  166.             _tip_cur_point.setX(tip_offset);
  167.             _tip_cur_point.setY(_tip_cur_point.y() + textHeight + 15);
  169.         }
  171.          next_point = _tip_cur_point;
  173.         AddTipLbs(lb, _tip_cur_point, next_point, textWidth, textHeight);
  175.         _tip_cur_point = next_point;
  177.     }
  179.    int diff_height = next_point.y() + textHeight + tip_offset - ui->lb_list->height();
  180.    ui->lb_list->setFixedHeight(next_point.y() + textHeight + tip_offset);
  182.     //qDebug()<<"after resize ui->lb_list size is " <<  ui->lb_list->size();
  183.     ui->scrollcontent->setFixedHeight(ui->scrollcontent->height()+diff_height);
  184. }
  186. void AuthenFriend::resetLabels()
  187. {
  188.     auto max_width = ui->gridWidget->width();
  189.     auto label_height = 0;
  190.     for(auto iter = _friend_labels.begin(); iter != _friend_labels.end(); iter++){
  191.         //todo... 添加宽度统计
  192.         if( _label_point.x() + iter.value()->width() > max_width) {
  193.             _label_point.setY(_label_point.y()+iter.value()->height()+6);
  194.             _label_point.setX(2);
  195.         }
  197.         iter.value()->move(_label_point);
  198.         iter.value()->show();
  200.         _label_point.setX(_label_point.x()+iter.value()->width()+2);
  201.         _label_point.setY(_label_point.y());
  202.         label_height = iter.value()->height();
  203.     }
  205.     if(_friend_labels.isEmpty()){
  206.          ui->lb_ed->move(_label_point);
  207.          return;
  208.     }
  210.     if(_label_point.x() + MIN_APPLY_LABEL_ED_LEN > ui->gridWidget->width()){
  211.         ui->lb_ed->move(2,_label_point.y()+label_height+6);
  212.     }else{
  213.          ui->lb_ed->move(_label_point);
  214.     }
  215. }
  217. void AuthenFriend::addLabel(QString name)
  218. {
  219.     if (_friend_labels.find(name) != _friend_labels.end()) {
  220.         return;
  221.     }
  223.     auto tmplabel = new FriendLabel(ui->gridWidget);
  224.     tmplabel->SetText(name);
  225.     tmplabel->setObjectName("FriendLabel");
  227.     auto max_width = ui->gridWidget->width();
  228.     //todo... 添加宽度统计
  229.     if (_label_point.x() + tmplabel->width() > max_width) {
  230.         _label_point.setY(_label_point.y() + tmplabel->height() + 6);
  231.         _label_point.setX(2);
  232.     }
  233.     else {
  235.     }
  238.     tmplabel->move(_label_point);
  239.     tmplabel->show();
  240.     _friend_labels[tmplabel->Text()] = tmplabel;
  241.     _friend_label_keys.push_back(tmplabel->Text());
  243.     connect(tmplabel, &FriendLabel::sig_close, this, &AuthenFriend::SlotRemoveFriendLabel);
  245.     _label_point.setX(_label_point.x() + tmplabel->width() + 2);
  247.     if (_label_point.x() + MIN_APPLY_LABEL_ED_LEN > ui->gridWidget->width()) {
  248.         ui->lb_ed->move(2, _label_point.y() + tmplabel->height() + 2);
  249.     }
  250.     else {
  251.         ui->lb_ed->move(_label_point);
  252.     }
  254.     ui->lb_ed->clear();
  256.     if (ui->gridWidget->height() < _label_point.y() + tmplabel->height() + 2) {
  257.         ui->gridWidget->setFixedHeight(_label_point.y() + tmplabel->height() * 2 + 2);
  258.     }
  259. }
  261. void AuthenFriend::SlotLabelEnter()
  262. {
  263.     if(ui->lb_ed->text().isEmpty()){
  264.         return;
  265.     }
  267.     addLabel(ui->lb_ed->text());
  269.     ui->input_tip_wid->hide();
  270. }
  272. void AuthenFriend::SlotRemoveFriendLabel(QString name)
  273. {
  274.     qDebug() << "receive close signal";
  276.     _label_point.setX(2);
  277.     _label_point.setY(6);
  279.    auto find_iter = _friend_labels.find(name);
  281.    if(find_iter == _friend_labels.end()){
  282.        return;
  283.    }
  285.    auto find_key = _friend_label_keys.end();
  286.    for(auto iter = _friend_label_keys.begin(); iter != _friend_label_keys.end();
  287.        iter++){
  288.        if(*iter == name){
  289.            find_key = iter;
  290.            break;
  291.        }
  292.    }
  294.    if(find_key != _friend_label_keys.end()){
  295.       _friend_label_keys.erase(find_key);
  296.    }
  299.    delete find_iter.value();
  301.    _friend_labels.erase(find_iter);
  303.    resetLabels();
  305.    auto find_add = _add_labels.find(name);
  306.    if(find_add == _add_labels.end()){
  307.         return;
  308.    }
  310.    find_add.value()->ResetNormalState();
  311. }
  313. //点击标已有签添加或删除新联系人的标签
  314. void AuthenFriend::SlotChangeFriendLabelByTip(QString lbtext, ClickLbState state)
  315. {
  316.     auto find_iter = _add_labels.find(lbtext);
  317.     if(find_iter == _add_labels.end()){
  318.         return;
  319.     }
  321.     if(state == ClickLbState::Selected){
  322.         //编写添加逻辑
  323.         addLabel(lbtext);
  324.         return;
  325.     }
  327.     if(state == ClickLbState::Normal){
  328.         //编写删除逻辑
  329.         SlotRemoveFriendLabel(lbtext);
  330.         return;
  331.     }
  333. }
  335. void AuthenFriend::SlotLabelTextChange(const QString& text)
  336. {
  337.     if (text.isEmpty()) {
  338.         ui->tip_lb->setText("");
  339.         ui->input_tip_wid->hide();
  340.         return;
  341.     }
  343.     auto iter = std::find(_tip_data.begin(), _tip_data.end(), text);
  344.     if (iter == _tip_data.end()) {
  345.         auto new_text = add_prefix + text;
  346.         ui->tip_lb->setText(new_text);
  347.         ui->input_tip_wid->show();
  348.         return;
  349.     }
  350.     ui->tip_lb->setText(text);
  351.     ui->input_tip_wid->show();
  352. }
  354. void AuthenFriend::SlotLabelEditFinished()
  355. {
  356.     ui->input_tip_wid->hide();
  357. }
  359. void AuthenFriend::SlotAddFirendLabelByClickTip(QString text)
  360. {
  361.     int index = text.indexOf(add_prefix);
  362.     if (index != -1) {
  363.         text = text.mid(index + add_prefix.length());
  364.     }
  365.     addLabel(text);
  366.     //标签展示栏也增加一个标签, 并设置绿色选中
  367.     if (index != -1) {
  368.         _tip_data.push_back(text);
  369.     }
  371.     auto* lb = new ClickedLabel(ui->lb_list);
  372.     lb->SetState("normal", "hover", "pressed", "selected_normal",
  373.         "selected_hover", "selected_pressed");
  374.     lb->setObjectName("tipslb");
  375.     lb->setText(text);
  376.     connect(lb, &ClickedLabel::clicked, this, &AuthenFriend::SlotChangeFriendLabelByTip);
  377.     qDebug() << "ui->lb_list->width() is " << ui->lb_list->width();
  378.     qDebug() << "_tip_cur_point.x() is " << _tip_cur_point.x();
  380.     QFontMetrics fontMetrics(lb->font()); // 获取QLabel控件的字体信息
  381.     int textWidth = fontMetrics.width(lb->text()); // 获取文本的宽度
  382.     int textHeight = fontMetrics.height(); // 获取文本的高度
  383.     qDebug() << "textWidth is " << textWidth;
  385.     if (_tip_cur_point.x() + textWidth+ tip_offset+3 > ui->lb_list->width()) {
  387.         _tip_cur_point.setX(5);
  388.         _tip_cur_point.setY(_tip_cur_point.y() + textHeight + 15);
  390.     }
  392.     auto next_point = _tip_cur_point;
  394.      AddTipLbs(lb, _tip_cur_point, next_point, textWidth,textHeight);
  395.     _tip_cur_point = next_point;
  397.     int diff_height = next_point.y() + textHeight + tip_offset - ui->lb_list->height();
  398.     ui->lb_list->setFixedHeight(next_point.y() + textHeight + tip_offset);
  400.     lb->SetCurState(ClickLbState::Selected);
  402.     ui->scrollcontent->setFixedHeight(ui->scrollcontent->height()+ diff_height );
  403. }
  405. void AuthenFriend::SlotApplySure()
  406. {
  407.     qDebug() << "Slot Apply Sure ";
  408.     //添加发送逻辑
  409.     QJsonObject jsonObj;
  410.     auto uid = UserMgr::GetInstance()->GetUid();
  411.     jsonObj["fromuid"] = uid;
  412.     jsonObj["touid"] = _apply_info->_uid;
  413.     QString back_name = "";
  414.     if(ui->back_ed->text().isEmpty()){
  415.         back_name = ui->back_ed->placeholderText();
  416.     }else{
  417.         back_name = ui->back_ed->text();
  418.     }
  419.     jsonObj["back"] = back_name;
  421.     QJsonDocument doc(jsonObj);
  422.     QByteArray jsonData = doc.toJson(QJsonDocument::Compact);
  424.     //发送tcp请求给chat server
  425.     emit TcpMgr::GetInstance()->sig_send_data(ReqId::ID_AUTH_FRIEND_REQ, jsonData);
  427.     this->hide();
  428.     deleteLater();
  429. }
  431. void AuthenFriend::SlotApplyCancel()
  432. {
  433.     this->hide();
  434.     deleteLater();
  435. }

源码连接

https://gitee.com/secondtonone1/llfcchat

视频连接

https://www.bilibili.com/video/BV1Ex4y1s7cq/

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

热门文章

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

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

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

  4. slice介绍和使用
    喜欢(521) 浏览(2173)

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

最新评论

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

其他链接

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

个人公众号

个人微信