恋恋风辰的官方博客

用户登录加载聊天资源
Posted on 2026-02-13 14:03:16 by 恋恋风辰 | In C++ | 原文链接

前情回顾

前面我们实现了聊天资源的下载和上传，以及异步通知断点下载等功能。

今天主要实现登录后聊天信息的加载，之前把文本信息的加载实现了，现在需要实现用户登录后图片信息的加载。

这个功能做完，聊天的基本功能就都收尾了，有意思的是好像一个圆圈，我们又回到了最初的原点，从登录逻辑出发，补充聊天资源加载

登录流程回顾

image-20260209150133552

点击登录按钮后，通过HttpMgr发送登录请求

  1. void LoginDialog::on_login_btn_clicked()
  2. {
  3.     qDebug()<<"login btn clicked";
  4.     if(checkUserValid() == false){
  5.         return;
  6.     }
  8.     if(checkPwdValid() == false){
  9.         return ;
  10.     }
  12.     enableBtn(false);
  13.     auto email = ui->email_edit->text();
  14.     auto pwd = ui->pass_edit->text();
  15.     //发送http请求登录
  16.     QJsonObject json_obj;
  17.     json_obj["email"] = email;
  18.     json_obj["passwd"] = xorString(pwd);
  19.     HttpMgr::GetInstance()->PostHttpReq(QUrl(gate_url_prefix+"/user_login"),
  20.                                         json_obj, ReqId::ID_LOGIN_USER,Modules::LOGINMOD);
  21. }

HttpMgr内部封装了PostHttpReq接口，这是异步http请求，会提前构造好一个reply，以及注册一个回调函数，将来GateServer将登录信息返回后会出发这个回调函数

  1. void HttpMgr::PostHttpReq(QUrl url, QJsonObject json, ReqId req_id, Modules mod)
  2. {
  3.     //创建一个HTTP POST请求，并设置请求头和请求体
  4.     QByteArray data = QJsonDocument(json).toJson();
  5.     //通过url构造请求
  6.     QNetworkRequest request(url);
  7.     request.setHeader(QNetworkRequest::ContentTypeHeader, "application/json");
  8.     request.setHeader(QNetworkRequest::ContentLengthHeader, QByteArray::number(data.length()));
  9.     //发送请求，并处理响应, 获取自己的智能指针，构造伪闭包并增加智能指针引用计数
  10.     auto self = shared_from_this();
  11.     QNetworkReply * reply = _manager.post(request, data);
  12.     //设置信号和槽等待发送完成
  13.     QObject::connect(reply, &QNetworkReply::finished, [reply, self, req_id, mod](){
  14.         //处理错误的情况
  15.         if(reply->error() != QNetworkReply::NoError){
  16.             qDebug() << reply->errorString();
  17.             //发送信号通知完成
  18.             emit self->sig_http_finish(req_id, "", ErrorCodes::ERR_NETWORK, mod);
  19.             reply->deleteLater();
  20.             return;
  21.         }
  23.         //无错误则读回请求
  24.         QString res = reply->readAll();
  26.         //发送信号通知完成
  27.         emit self->sig_http_finish(req_id, res, ErrorCodes::SUCCESS,mod);
  28.         reply->deleteLater();
  29.         return;
  30.     });
  31. }

我们查看下GateServer的处理流程

  1. bool LogicSystem::HandlePost(std::string path, std::shared_ptr<HttpConnection> con) {
  2.     if (_post_handlers.find(path) == _post_handlers.end()) {
  3.         return false;
  4.     }
  6.     _post_handlers[path](con);
  7.     return true;
  8. }

服务器会根据客户端传递的url进行分析，然后去_post_handlers中根据path查找并调用回调函数

回调函数在LogicSystem中提前注册到_post_handlers中

  1. void LogicSystem::RegPost(std::string url, HttpHandler handler) {
  2.     _post_handlers.insert(make_pair(url, handler));
  3. }

在构造函数中调用RegPost注册消息

  1.     //用户登录逻辑
  2.     RegPost("/user_login", [](std::shared_ptr<HttpConnection> connection) {
  3.         auto body_str = boost::beast::buffers_to_string(connection->_request.body().data());
  4.         std::cout << "receive body is " << body_str << std::endl;
  5.         connection->_response.set(http::field::content_type, "text/json");
  6.         Json::Value root;
  7.         Json::Reader reader;
  8.         Json::Value src_root;
  9.         bool parse_success = reader.parse(body_str, src_root);
  10.         if (!parse_success) {
  11.             std::cout << "Failed to parse JSON data!" << std::endl;
  12.             root["error"] = ErrorCodes::Error_Json;
  13.             std::string jsonstr = root.toStyledString();
  14.             beast::ostream(connection->_response.body()) << jsonstr;
  15.             return true;
  16.         }
  18.         auto email = src_root["email"].asString();
  19.         auto pwd = src_root["passwd"].asString();
  20.         UserInfo userInfo;
  21.         //查询数据库判断用户名和密码是否匹配
  22.         bool pwd_valid = MysqlMgr::GetInstance()->CheckPwd(email, pwd, userInfo);
  23.         if (!pwd_valid) {
  24.             std::cout << " user pwd not match" << std::endl;
  25.             root["error"] = ErrorCodes::PasswdInvalid;
  26.             std::string jsonstr = root.toStyledString();
  27.             beast::ostream(connection->_response.body()) << jsonstr;
  28.             return true;
  29.         }
  31.         //查询StatusServer找到合适的连接
  32.         auto reply = StatusGrpcClient::GetInstance()->GetChatServer(userInfo.uid);
  33.         if (reply.error()) {
  34.             std::cout << " grpc get chat server failed, error is " << reply.error()<< std::endl;
  35.             root["error"] = ErrorCodes::RPCFailed;
  36.             std::string jsonstr = root.toStyledString();
  37.             beast::ostream(connection->_response.body()) << jsonstr;
  38.             return true;
  39.         }
  41.         std::cout << "succeed to load userinfo uid is " << userInfo.uid << std::endl;
  42.         root["error"] = 0;
  43.         root["email"] = email;
  44.         root["uid"] = userInfo.uid;
  45.         root["token"] = reply.token();
  46.         root["chathost"] = reply.host();
  47.         root["chatport"] = reply.port();
  48.         auto& gCfgMgr = ConfigMgr::Inst();
  49.         std::string res_port = gCfgMgr["ResServer"]["Port"];
  50.         std::string res_host = gCfgMgr["ResServer"]["Host"];
  51.         root["reshost"] = res_host;
  52.         root["resport"] = res_port;
  54.         std::string jsonstr = root.toStyledString();
  55.         beast::ostream(connection->_response.body()) << jsonstr;
  56.         return true;
  57.         });

所以GateServer会触发上面的lambda表达式处理

在lambda表达式中调用GRPC连接池，向StatusServer发送请求，获取可用的聊天服务器地址，将聊天服务器地址返回给GateServer，GateServer再将地址返回给客户端, rpc封装

  1. GetChatServerRsp StatusGrpcClient::GetChatServer(int uid)
  2. {
  3.     ClientContext context;
  4.     GetChatServerRsp reply;
  5.     GetChatServerReq request;
  6.     request.set_uid(uid);
  7.     auto stub = pool_->getConnection();
  8.     Status status = stub->GetChatServer(&context, request, &reply);
  9.     Defer defer([&stub, this]() {
  10.         pool_->returnConnection(std::move(stub));
  11.         });
  12.     if (status.ok()) {    
  13.         return reply;
  14.     }
  15.     else {
  16.         reply.set_error(ErrorCodes::RPCFailed);
  17.         return reply;
  18.     }
  19. }

客户端收到GateServer回复后，客户端会根据消息ID为ReqId::ID_LOGIN_USER发送sig_http_finish信号通知

该信号连接了

  1. HttpMgr::HttpMgr()
  2. {
  3.     //连接http请求和完成信号，信号槽机制保证队列消费
  4.     connect(this, &HttpMgr::sig_http_finish, this, &HttpMgr::slot_http_finish);
  5. }

分别对应三个请求的处理

  1. void HttpMgr::slot_http_finish(ReqId id, QString res, ErrorCodes err, Modules mod)
  2. {
  3.     if(mod == Modules::REGISTERMOD){
  4.         //发送信号通知指定模块http响应结束
  5.         emit sig_reg_mod_finish(id, res, err);
  6.     }
  8.     if(mod == Modules::RESETMOD){
  9.         //发送信号通知指定模块http响应结束
  10.         emit sig_reset_mod_finish(id, res, err);
  11.     }
  13.     if(mod == Modules::LOGINMOD){
  14.         emit sig_login_mod_finish(id, res, err);
  15.     }
  16. }

对于登录请求，主要逻辑在sig_login_mod_finish信号发出看，该信号在LoginDialog中连接

  1.  //连接登录回包信号
  2.     connect(HttpMgr::GetInstance().get(), &HttpMgr::sig_login_mod_finish, this,
  3.             &LoginDialog::slot_login_mod_finish);

进而出发槽函数

  1. void LoginDialog::slot_login_mod_finish(ReqId id, QString res, ErrorCodes err)
  2. {
  3.     if(err != ErrorCodes::SUCCESS){
  4.         showTip(tr("网络请求错误"),false);
  5.         return;
  6.     }
  8.     // 解析 JSON 字符串,res需转化为QByteArray
  9.     QJsonDocument jsonDoc = QJsonDocument::fromJson(res.toUtf8());
  10.     //json解析错误
  11.     if(jsonDoc.isNull()){
  12.         showTip(tr("json解析错误"),false);
  13.         return;
  14.     }
  16.     //json解析错误
  17.     if(!jsonDoc.isObject()){
  18.         showTip(tr("json解析错误"),false);
  19.         return;
  20.     }
  23.     //调用对应的逻辑,根据id回调。
  24.     _handlers[id](jsonDoc.object());
  26.     return;
  27. }

槽函数中根据id获取提前注册好的回调函数

  1. _handlers[id](jsonDoc.object());

之前的注册逻辑

  1. void LoginDialog::initHttpHandlers()
  2. {
  3.     //注册获取登录回包逻辑
  4.     _handlers.insert(ReqId::ID_LOGIN_USER, [this](QJsonObject jsonObj){
  5.         int error = jsonObj["error"].toInt();
  6.         if(error != ErrorCodes::SUCCESS){
  7.             showTip(tr("参数错误"),false);
  8.             enableBtn(true);
  9.             return;
  10.         }
  11.         auto email = jsonObj["email"].toString();
  13.         //发送信号通知tcpMgr发送长链接
  14.         _si = std::make_shared<ServerInfo>();
  16.         _si->_uid = jsonObj["uid"].toInt();
  17.         _si->_chat_host = jsonObj["chathost"].toString();
  18.         _si->_chat_port = jsonObj["chatport"].toString();
  19.         _si->_token = jsonObj["token"].toString();
  21.         _si->_res_host = jsonObj["reshost"].toString();
  22.         _si->_res_port = jsonObj["resport"].toString();
  25.         qDebug()<< "email is " << email << " uid is " << _si->_uid <<" chat host is "
  26.                 << _si->_chat_host << " chat port is "
  27.                 << _si->_chat_port << " token is " << _si->_token
  28.                 << " res host is " << _si->_res_host
  29.                 << " res port is " << _si->_res_port;
  30.         emit sig_connect_tcp(_si);
  31.        // qDebug() << "send thread is " << QThread::currentThread();
  32.        // emit sig_test();
  33.     });
  34. }

所以当消息到来时会出发上面的lambda表达式，进而发出sig_connect_tcp信号, 该信号链接槽函数slot_tcp_connect

  1.  //连接tcp连接请求的信号和槽函数
  2.     connect(this, &LoginDialog::sig_connect_tcp, TcpMgr::GetInstance().get(), &TcpMgr::slot_tcp_connect);

槽函数内根据host地址链接指定的tcpserver

  1. void TcpMgr::slot_tcp_connect(std::shared_ptr<ServerInfo> si)
  2. {
  3.     qDebug()<< "receive tcp connect signal";
  4.     // 尝试连接到服务器
  5.     qDebug() << "Connecting to chat server...";
  6.     _host = si->_chat_host;
  7.     _port = static_cast<uint16_t>(si->_chat_port.toUInt());
  8.     _socket.connectToHost(_host, _port);
  9. }

_socket 是QTcpSocket类型，发出连接请求后，如果和服务器建立好连接后，会触发链接成功的回调, 在TcpMgr的构造函数中提前注册了消息和回调函数

  1. TcpMgr::TcpMgr():_host(""),_port(0),_b_recv_pending(false),_message_id(0),_message_len(0),_bytes_sent(0),_pending(false)
  2. {
  3.     registerMetaType();
  4.     QObject::connect(&_socket, &QTcpSocket::connected, this, [&]() {
  5.            qDebug() << "Connected to server!";
  6.            // 连接建立后发送消息
  7.             emit sig_con_success(true);
  8.        });
  10.        QObject::connect(&_socket, &QTcpSocket::readyRead, this, [&]() {
  11.            // 当有数据可读时，读取所有数据
  12.            // 读取所有数据并追加到缓冲区
  13.            _buffer.append(_socket.readAll());
  15.            forever {
  16.                 //先解析头部
  17.                if(!_b_recv_pending){
  18.                    // 检查缓冲区中的数据是否足够解析出一个消息头（消息ID + 消息长度）
  19.                    if (_buffer.size() < static_cast<int>(sizeof(quint16) * 2)) {
  20.                        return; // 数据不够，等待更多数据
  21.                    }
  23.                    // ✅ 每次都重新创建stream
  24.                    QDataStream stream(_buffer);
  25.                    stream.setVersion(QDataStream::Qt_5_0);
  26.                    stream >> _message_id >> _message_len;
  27.                    _buffer.remove(0, sizeof(quint16) * 2);  // 使用remove代替mid赋值
  28.                    qDebug() << "Message ID:" << _message_id << ", Length:" << _message_len;
  30.                }
  32.                 //buffer剩余长读是否满足消息体长度，不满足则退出继续等待接受
  33.                if(_buffer.size() < _message_len){
  34.                     _b_recv_pending = true;
  35.                     return;
  36.                }
  38.                _b_recv_pending = false;
  39.                // 读取消息体
  40.                QByteArray messageBody = _buffer.mid(0, _message_len);
  41.                qDebug() << "receive body msg is " << messageBody ;
  43.                _buffer = _buffer.mid(_message_len);
  44.                handleMsg(ReqId(_message_id),_message_len, messageBody);
  45.            }
  47.        });
  49.        //5.15 之后版本
  50. //       QObject::connect(&_socket, QOverload<QAbstractSocket::SocketError>::of(&QTcpSocket::errorOccurred), [&](QAbstractSocket::SocketError socketError) {
  51. //           Q_UNUSED(socketError)
  52. //           qDebug() << "Error:" << _socket.errorString();
  53. //       });
  55.        // 处理错误（适用于Qt 5.15之前的版本）
  56.         QObject::connect(&_socket, static_cast<void (QTcpSocket::*)(QTcpSocket::SocketError)>(&QTcpSocket::error),
  57.                             this,
  58.                             [&](QTcpSocket::SocketError socketError) {
  59.                qDebug() << "Error:" << _socket.errorString() ;
  60.                switch (socketError) {
  61.                    case QTcpSocket::ConnectionRefusedError:
  62.                        qDebug() << "Connection Refused!";
  63.                        emit sig_con_success(false);
  64.                        break;
  65.                    case QTcpSocket::RemoteHostClosedError:
  66.                        qDebug() << "Remote Host Closed Connection!";
  67.                        break;
  68.                    case QTcpSocket::HostNotFoundError:
  69.                        qDebug() << "Host Not Found!";
  70.                        emit sig_con_success(false);
  71.                        break;
  72.                    case QTcpSocket::SocketTimeoutError:
  73.                        qDebug() << "Connection Timeout!";
  74.                        emit sig_con_success(false);
  75.                        break;
  76.                    case QTcpSocket::NetworkError:
  77.                        qDebug() << "Network Error!";
  78.                        break;
  79.                    default:
  80.                        qDebug() << "Other Error!";
  81.                        break;
  82.                }
  83.          });
  85.         // 处理连接断开
  86.         QObject::connect(&_socket, &QTcpSocket::disconnected, this,[&]() {
  87.             qDebug() << "Disconnected from server.";
  88.             //并且发送通知到界面
  89.             emit sig_connection_closed();
  90.         });
  91.         //连接发送信号用来发送数据
  92.         QObject::connect(this, &TcpMgr::sig_send_data, this, &TcpMgr::slot_send_data);
  94.         //连接发送信号
  95.         QObject::connect(&_socket, &QTcpSocket::bytesWritten, this, [this](qint64 bytes) {
  96.                      //更新发送数据
  97.                     _bytes_sent += bytes;
  98.                     //未发送完整
  99.                     if (_bytes_sent < _current_block.size()) {
  100.                         //继续发送
  101.                         auto data_to_send = _current_block.mid(_bytes_sent);
  102.                         _socket.write(data_to_send);
  103.                         return;
  104.                     }
  106.                     //发送完全，则查看队列是否为空
  107.                     if (_send_queue.isEmpty()) {
  108.                         //队列为空，说明已经将所有数据发送完成，将pending设置为false，这样后续要发送数据时可以继续发送
  109.                         _current_block.clear();
  110.                         _pending = false;
  111.                         _bytes_sent = 0;
  112.                         return;
  113.                     }
  115.                     //队列不为空，则取出队首元素
  116.                     _current_block = _send_queue.dequeue();
  117.                     _bytes_sent = 0;
  118.                     _pending = true;
  119.                     qint64 w2 = _socket.write(_current_block);
  120.                     qDebug() << "[TcpMgr] Dequeued and write() returned" << w2;
  121.             });
  124.         //关闭socket
  125.         connect(this, &TcpMgr::sig_close, this, &TcpMgr::slot_tcp_close);
  126.         //注册消息
  127.         initHandlers();
  129. }

当客户端和服务器建立连接后，会出发下面的lambda表达式

  1.   QObject::connect(&_socket, &QTcpSocket::connected, this, [&]() {
  2.            qDebug() << "Connected to server!";
  3.            // 连接建立后发送消息
  4.             emit sig_con_success(true);
  5.        });

从而发出sig_con_success信号, 信号连接了槽函数slot_tcp_con_finish

  1. //连接tcp管理者发出的连接成功信号
  2.     connect(TcpMgr::GetInstance().get(), &TcpMgr::sig_con_success, this, &LoginDialog::slot_tcp_con_finish);

槽函数里链接资源服务器

  1. void LoginDialog::slot_tcp_con_finish(bool bsuccess)
  2. {
  3.     if(bsuccess){
  4.         showTip(tr("聊天服务连接成功，正在连接资源服务器..."),true);
  5.         emit sig_connect_res_server(_si);
  6.     }else{
  7.         showTip(tr("网络异常"), false);
  8.     }
  9. }

该信号连接了槽函数

  1.  //连接tcp连接资源服务器请求的信号和槽函数
  2.     connect(this, &LoginDialog::sig_connect_res_server,
  3.             FileTcpMgr::GetInstance().get(), &FileTcpMgr::slot_tcp_connect);

链接资源服务器的逻辑和之前链接ChatServer类似

  1. void FileTcpMgr::slot_tcp_connect(std::shared_ptr<ServerInfo> si)
  2. {
  3.     qDebug() << "receive tcp connect signal";
  4.     // 尝试连接到服务器
  5.     qDebug() << "Connecting to server...";
  6.     _host = si->_res_host;
  7.     _port = static_cast<uint16_t>(si->_res_port.toUInt());
  8.     _socket.connectToHost(_host, _port);
  9. }

当客户端链接资源服务器成功了，就会出发lambda表达式

  1.     QObject::connect(&_socket, &QTcpSocket::connected, this, [&]() {
  2.         qDebug() << "Connected to server!";
  3.         emit sig_con_success(true);
  4.         });

信号sig_con_success和槽函数链接

  1.  connect(FileTcpMgr::GetInstance().get(), &FileTcpMgr::sig_con_success, this, &LoginDialog::slot_res_con_finish);

进而触发这个函数,内部发送登录请求给ChatServer

  1. void LoginDialog::slot_res_con_finish(bool bsuccess)
  2. {
  3.        if(bsuccess){
  4.           showTip(tr("聊天服务连接成功，正在登录..."),true);
  5.           QJsonObject jsonObj;
  6.           jsonObj["uid"] = _si->_uid;
  7.           jsonObj["token"] = _si->_token;
  9.           QJsonDocument doc(jsonObj);
  10.           QByteArray jsonData = doc.toJson(QJsonDocument::Indented);
  12.           //发送tcp请求给chat server
  13.          emit TcpMgr::GetInstance()->sig_send_data(ReqId::ID_CHAT_LOGIN, jsonData);
  15.        }else{
  16.           showTip(tr("网络异常"),false);
  17.           enableBtn(true);
  18.        }
  19. }

这里略去ChatServer的处理，客户端收到ID_CHAT_LOGIN_RSP回复后，出发lambda表达式

  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 desc = jsonObj["desc"].toString();
  36.         auto user_info = std::make_shared<UserInfo>(uid, name, nick, icon, sex,"",desc);
  38.         UserMgr::GetInstance()->SetUserInfo(user_info);
  39.         UserMgr::GetInstance()->SetToken(jsonObj["token"].toString());
  40.         if(jsonObj.contains("apply_list")){
  41.             UserMgr::GetInstance()->AppendApplyList(jsonObj["apply_list"].toArray());
  42.         }
  44.         //添加好友列表
  45.         if (jsonObj.contains("friend_list")) {
  46.             UserMgr::GetInstance()->AppendFriendList(jsonObj["friend_list"].toArray());
  47.         }
  49.         emit sig_swich_chatdlg();
  50.     });

将用户信息，以及好友列表，申请列表等数据组织好后存储UserMgr中，然后发送信号sig_swich_chatdlg跳转到登录界面

链接信号

  1.     //连接创建聊天界面信号
  2.     connect(TcpMgr::GetInstance().get(),&TcpMgr::sig_swich_chatdlg, this, &MainWindow::SlotSwitchChat);

跳转逻辑

  1. void MainWindow::SlotSwitchChat()
  2. {
  3.     _chat_dlg = new ChatDialog();
  4.     _chat_dlg->setWindowFlags(Qt::CustomizeWindowHint|Qt::FramelessWindowHint);
  5.     setCentralWidget(_chat_dlg);
  6.     _chat_dlg->show();
  7.     _login_dlg->hide();
  8.     this->setMinimumSize(QSize(1050,900));
  9.     this->setMaximumSize(QWIDGETSIZE_MAX, QWIDGETSIZE_MAX);
  10.     _ui_status = CHAT_UI;
  11.     _chat_dlg->loadChatList();
  12. }

至此完成登录界面加载以及聊天记录加载，聊天记录加载具体流程看下面

加载聊天记录

其中加载聊天记录核心逻辑

  1. void ChatDialog::loadChatList()
  2. {
  3.     showLoadingDlg(true);
  4.     //发送请求逻辑
  5.     QJsonObject jsonObj;
  6.     auto uid = UserMgr::GetInstance()->GetUid();
  7.     jsonObj["uid"] = uid;
  8.     int last_chat_thread_id = UserMgr::GetInstance()->GetLastChatThreadId();
  9.     jsonObj["thread_id"] = last_chat_thread_id;
  12.     QJsonDocument doc(jsonObj);
  13.     QByteArray jsonData = doc.toJson(QJsonDocument::Compact);
  15.     //发送tcp请求给chat server
  16.     emit TcpMgr::GetInstance()->sig_send_data(ReqId::ID_LOAD_CHAT_THREAD_REQ, jsonData);
  17. }

发送ID_LOAD_CHAT_THREAD_REQ逻辑给ChatServer，略去服务器处理流程，客户端会受到会话列表的回复数据

  1. _handlers.insert(ID_LOAD_CHAT_THREAD_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 thread json parse failed " << err;
  18.             return;
  19.         }
  21.         int err = jsonObj["error"].toInt();
  22.         if (err != ErrorCodes::SUCCESS) {
  23.             qDebug() << "get chat thread rsp failed, error is " << err;
  24.             return;
  25.         }
  27.         qDebug() << "Receive chat thread rsp Success";
  29.         auto thread_array = jsonObj["threads"].toArray();
  30.         std::vector<std::shared_ptr<ChatThreadInfo>> chat_threads;
  31.         for (const QJsonValue& value : thread_array) {
  32.             auto cti = std::make_shared<ChatThreadInfo>();
  33.             cti->_thread_id = value["thread_id"].toInt();
  34.             cti->_type = value["type"].toString();
  35.             cti->_user1_id = value["user1_id"].toInt();
  36.             cti->_user2_id = value["user2_id"].toInt();
  37.             chat_threads.push_back(cti);
  38.         }
  40.         bool load_more = jsonObj["load_more"].toBool();
  41.         int next_last_id = jsonObj["next_last_id"].toInt();
  42.         //发送信号通知界面
  43.         emit sig_load_chat_thread(load_more, next_last_id, chat_threads);
  44.     });

解析会话列表，按照会话id请求每个会话具体内容

  1. void ChatDialog::slot_load_chat_thread(bool load_more, int last_thread_id,
  2.     std::vector<std::shared_ptr<ChatThreadInfo>> chat_threads)
  3. {
  4.     for (auto& cti : chat_threads) {
  5.         //先处理单聊，群聊跳过，以后添加
  6.         if (cti->_type == "group") {
  7.             continue;
  8.         }
  10.         auto uid = UserMgr::GetInstance()->GetUid();
  11.         auto other_uid = 0;
  12.         if (uid == cti->_user1_id) {
  13.             other_uid = cti->_user2_id;
  14.         }
  15.         else {
  16.             other_uid = cti->_user1_id;
  17.         }
  19.         auto chat_thread_data = std::make_shared<ChatThreadData>(other_uid, cti->_thread_id, 0);
  20.         UserMgr::GetInstance()->AddChatThreadData(chat_thread_data, other_uid);
  22.         auto* chat_user_wid = new ChatUserWid();
  23.         chat_user_wid->SetChatData(chat_thread_data);
  24.         QListWidgetItem* item = new QListWidgetItem;
  25.         //qDebug()<<"chat_user_wid sizeHint is " << chat_user_wid->sizeHint();
  26.         item->setSizeHint(chat_user_wid->sizeHint());
  27.         ui->chat_user_list->addItem(item);
  28.         ui->chat_user_list->setItemWidget(item, chat_user_wid);
  29.         _chat_thread_items.insert(cti->_thread_id, item);
  30.     }
  32.     UserMgr::GetInstance()->SetLastChatThreadId(last_thread_id);
  34.     if (load_more) {
  35.         //发送请求逻辑
  36.         QJsonObject jsonObj;
  37.         auto uid = UserMgr::GetInstance()->GetUid();
  38.         jsonObj["uid"] = uid;
  39.         jsonObj["thread_id"] = last_thread_id;
  42.         QJsonDocument doc(jsonObj);
  43.         QByteArray jsonData = doc.toJson(QJsonDocument::Compact);
  45.         //发送tcp请求给chat server
  46.         emit TcpMgr::GetInstance()->sig_send_data(ReqId::ID_LOAD_CHAT_THREAD_REQ, jsonData);
  47.         return;
  48.     }
  50.     showLoadingDlg(false);
  51.     //继续加载聊天数据
  52.     loadChatMsg();
  53. }

如果load_more为true,说明有会话没加载完，需要继续加载，等到所有会话信息加载成功后,load_more为false,则将当前会话的消息列表添加到聊天界面。如果会话列表加载完成了，则继续加载会话内部的多个消息。

  1. void ChatDialog::loadChatMsg() {
  3.     //发送聊天记录请求
  4.     _cur_load_chat = UserMgr::GetInstance()->GetCurLoadData();
  5.     if (_cur_load_chat == nullptr) {
  6.         return;
  7.     }
  9.     showLoadingDlg(true);
  11.     //发送请求给服务器
  12.         //发送请求逻辑
  13.     QJsonObject jsonObj;
  14.     jsonObj["thread_id"] = _cur_load_chat->GetThreadId();
  15.     jsonObj["message_id"] = _cur_load_chat->GetLastMsgId();
  17.     QJsonDocument doc(jsonObj);
  18.     QByteArray jsonData = doc.toJson(QJsonDocument::Compact);
  20.     //发送tcp请求给chat server
  21.     emit TcpMgr::GetInstance()->sig_send_data(ReqId::ID_LOAD_CHAT_MSG_REQ, jsonData);
  22. }

回包消息处理

  1.  _handlers.insert(ID_LOAD_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() << "parse create private chat json parse failed " << err;
  18.             return;
  19.         }
  21.         int err = jsonObj["error"].toInt();
  22.         if (err != ErrorCodes::SUCCESS) {
  23.             qDebug() << "get create private chat failed, error is " << err;
  24.             return;
  25.         }
  27.         qDebug() << "Receive create private chat rsp Success";
  29.         int thread_id = jsonObj["thread_id"].toInt();
  30.         int last_msg_id = jsonObj["last_message_id"].toInt();
  31.         bool load_more = jsonObj["load_more"].toBool();
  33.         std::vector<std::shared_ptr<ChatDataBase>> chat_datas;
  34.         for (const QJsonValue& data : jsonObj["chat_datas"].toArray()) {
  35.             auto send_uid = data["sender"].toInt();
  36.             auto msg_id = data["msg_id"].toInt();
  37.             auto thread_id = data["thread_id"].toInt();
  38.             auto unique_id = data["unique_id"].toInt();
  39.             auto msg_content = data["msg_content"].toString();
  40.             QString chat_time = data["chat_time"].toString();
  41.             int status = data["status"].toInt();
  42.             int msg_type = data["msg_type"].toInt();
  43.             int recv_id = data["receiver"].toInt();
  44.             if (msg_type == int(ChatMsgType::TEXT)) {
  45.                 auto chat_data = std::make_shared<TextChatData>(msg_id, thread_id, ChatFormType::PRIVATE,
  46.                     ChatMsgType::TEXT, msg_content, send_uid, status, chat_time);
  47.                     chat_datas.push_back(chat_data);
  48.                     continue;
  49.             }
  51.             if (msg_type == int(ChatMsgType::PIC)) {
  52.                 auto uid = UserMgr::GetInstance()->GetUid();
  53.                 QString storageDir = QStandardPaths::writableLocation(QStandardPaths::AppDataLocation);
  54.                 QString img_path_str = storageDir + "/user/" + QString::number(uid) + "/chatimg/" + QString::number(send_uid);
  55.                 QString img_path = img_path_str + "/" + msg_content;
  56.                 //文件不存在，则创建空白图片占位，同时组织数据准备发送
  57.                 if (QFile::exists(img_path) == false) {
  59.                     CreatePlaceholderImgMsgL(img_path_str, msg_content,
  60.                         msg_id, thread_id, send_uid, recv_id, status, chat_time,
  61.                         chat_datas);
  62.                     continue;
  63.                 }
  64.                 //如果文件存在
  65.                 //如果文件存在则直接构建MsgInfo
  66.                 // 获取文件大小
  67.                 QFileInfo fileInfo(img_path);
  68.                 qint64 file_size = fileInfo.size();
  69.                 //从文件路径加载QPixmap
  70.                 QPixmap pixmap(img_path);
  71.                 //如果图片加载失败，也是创建占位符，然后组织发送
  72.                 if (pixmap.isNull()) {
  73.                     CreatePlaceholderImgMsgL(img_path_str, msg_content,
  74.                         msg_id, thread_id, send_uid, recv_id, status, chat_time,
  75.                         chat_datas);
  76.                         continue;
  77.                 }
  79.                 //说明图片加载正确，构建真实图片
  80.                 auto  file_info = std::make_shared<MsgInfo>(MsgType::IMG_MSG, img_path_str,
  81.                     pixmap, msg_content, file_size, "");
  82.                 file_info->_msg_id = msg_id;
  83.                 file_info->_sender = send_uid;
  84.                 file_info->_receiver = recv_id;
  85.                 file_info->_thread_id = thread_id;
  86.                 //设置文件传输的类型
  87.                 file_info->_transfer_type = TransferType::Download;
  88.                 //设置文件传输状态
  89.                 file_info->_transfer_state = TransferState::None;
  90.                 //放入chat_datas列表
  91.                 auto chat_data = std::make_shared<ImgChatData>(file_info,"", thread_id, ChatFormType::PRIVATE,
  92.                     ChatMsgType::PIC, send_uid, status, chat_time);
  93.                 chat_datas.push_back(chat_data);
  94.                 continue;
  95.             }          
  96.         }
  98.         //发送信号通知界面
  99.         emit sig_load_chat_msg(thread_id, last_msg_id, load_more, chat_datas);
  100.         });

这里加载了thread会话信息，以及每个会话的消息列表，如果消息列表没有加载完全，则继续发送信号sig_load_chat_msg信号继续加载消息。

最终在此处将所有会话的所有消息加载完成

  1. void ChatDialog::slot_load_chat_msg(int thread_id, int msg_id, bool load_more, 
  2.     std::vector<std::shared_ptr<ChatDataBase>> msglists)
  3. {
  4.     _cur_load_chat->SetLastMsgId(msg_id);
  5.     //加载聊天信息
  6.     for (auto& chat_msg : msglists) {
  7.         _cur_load_chat->AppendMsg(chat_msg->GetMsgId(), chat_msg);
  8.     }
  10.     //还有未加载完的消息，就继续加载
  11.     if (load_more) {
  12.         //发送请求给服务器
  13.             //发送请求逻辑
  14.         QJsonObject jsonObj;
  15.         jsonObj["thread_id"] = _cur_load_chat->GetThreadId();
  16.         jsonObj["message_id"] = _cur_load_chat->GetLastMsgId();
  18.         QJsonDocument doc(jsonObj);
  19.         QByteArray jsonData = doc.toJson(QJsonDocument::Compact);
  21.         //发送tcp请求给chat server
  22.         emit TcpMgr::GetInstance()->sig_send_data(ReqId::ID_LOAD_CHAT_MSG_REQ, jsonData);
  23.         return;
  24.     }
  26.     //获取下一个chat_thread
  27.     _cur_load_chat = UserMgr::GetInstance()->GetNextLoadData();
  28.     //都加载完了
  29.     if(!_cur_load_chat){
  30.         //更新聊天界面信息
  31.         SetSelectChatItem();
  32.         SetSelectChatPage();
  33.         showLoadingDlg(false);
  34.         return;
  35.     }
  37.     //继续加载下一个聊天
  38.     //发送请求给服务器
  39.     //发送请求逻辑
  40.     QJsonObject jsonObj;
  41.     jsonObj["thread_id"] = _cur_load_chat->GetThreadId();
  42.     jsonObj["message_id"] = _cur_load_chat->GetLastMsgId();
  44.     QJsonDocument doc(jsonObj);
  45.     QByteArray jsonData = doc.toJson(QJsonDocument::Compact);
  47.     //发送tcp请求给chat server
  48.     emit TcpMgr::GetInstance()->sig_send_data(ReqId::ID_LOAD_CHAT_MSG_REQ, jsonData);
  49. }

资源消息加载

核心的资源消息加载是在ID_LOAD_CHAT_MSG_RSP回报的逻辑里

  1. _handlers.insert(ID_LOAD_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() << "parse create private chat json parse failed " << err;
  18.             return;
  19.         }
  21.         int err = jsonObj["error"].toInt();
  22.         if (err != ErrorCodes::SUCCESS) {
  23.             qDebug() << "get create private chat failed, error is " << err;
  24.             return;
  25.         }
  27.         qDebug() << "Receive create private chat rsp Success";
  29.         int thread_id = jsonObj["thread_id"].toInt();
  30.         int last_msg_id = jsonObj["last_message_id"].toInt();
  31.         bool load_more = jsonObj["load_more"].toBool();
  33.         std::vector<std::shared_ptr<ChatDataBase>> chat_datas;
  34.         for (const QJsonValue& data : jsonObj["chat_datas"].toArray()) {
  35.             auto send_uid = data["sender"].toInt();
  36.             auto msg_id = data["msg_id"].toInt();
  37.             auto thread_id = data["thread_id"].toInt();
  38.             auto unique_id = data["unique_id"].toInt();
  39.             auto msg_content = data["msg_content"].toString();
  40.             QString chat_time = data["chat_time"].toString();
  41.             int status = data["status"].toInt();
  42.             int msg_type = data["msg_type"].toInt();
  43.             int recv_id = data["receiver"].toInt();
  44.             if (msg_type == int(ChatMsgType::TEXT)) {
  45.                 auto chat_data = std::make_shared<TextChatData>(msg_id, thread_id, ChatFormType::PRIVATE,
  46.                     ChatMsgType::TEXT, msg_content, send_uid, status, chat_time);
  47.                     chat_datas.push_back(chat_data);
  48.                     continue;
  49.             }
  51.             if (msg_type == int(ChatMsgType::PIC)) {
  52.                 auto uid = UserMgr::GetInstance()->GetUid();
  53.                 QString storageDir = QStandardPaths::writableLocation(QStandardPaths::AppDataLocation);
  54.                 QString img_path_str = storageDir + "/user/" + QString::number(uid) + "/chatimg/" + QString::number(send_uid);
  55.                 QString img_path = img_path_str + "/" + msg_content;
  56.                 //文件不存在，则创建空白图片占位，同时组织数据准备发送
  57.                 if (QFile::exists(img_path) == false) {
  59.                     CreatePlaceholderImgMsgL(img_path_str, msg_content,
  60.                         msg_id, thread_id, send_uid, recv_id, status, chat_time,
  61.                         chat_datas);
  62.                     continue;
  63.                 }
  64.                 //如果文件存在
  65.                 //如果文件存在则直接构建MsgInfo
  66.                 // 获取文件大小
  67.                 QFileInfo fileInfo(img_path);
  68.                 qint64 file_size = fileInfo.size();
  69.                 //从文件路径加载QPixmap
  70.                 QPixmap pixmap(img_path);
  71.                 //如果图片加载失败，也是创建占位符，然后组织发送
  72.                 if (pixmap.isNull()) {
  73.                     CreatePlaceholderImgMsgL(img_path_str, msg_content,
  74.                         msg_id, thread_id, send_uid, recv_id, status, chat_time,
  75.                         chat_datas);
  76.                         continue;
  77.                 }
  79.                 //说明图片加载正确，构建真实图片
  80.                 auto  file_info = std::make_shared<MsgInfo>(MsgType::IMG_MSG, img_path_str,
  81.                     pixmap, msg_content, file_size, "");
  82.                 file_info->_msg_id = msg_id;
  83.                 file_info->_sender = send_uid;
  84.                 file_info->_receiver = recv_id;
  85.                 file_info->_thread_id = thread_id;
  86.                 //设置文件传输的类型
  87.                 file_info->_transfer_type = TransferType::Download;
  88.                 //设置文件传输状态
  89.                 file_info->_transfer_state = TransferState::None;
  90.                 //放入chat_datas列表
  91.                 auto chat_data = std::make_shared<ImgChatData>(file_info,"", thread_id, ChatFormType::PRIVATE,
  92.                     ChatMsgType::PIC, send_uid, status, chat_time);
  93.                 chat_datas.push_back(chat_data);
  94.                 continue;
  95.             }          
  96.         }
  98.         //发送信号通知界面
  99.         emit sig_load_chat_msg(thread_id, last_msg_id, load_more, chat_datas);
  100.         });

核心逻辑是这部分

  1.             if (msg_type == int(ChatMsgType::TEXT)) {
  2.                 auto chat_data = std::make_shared<TextChatData>(msg_id, thread_id, ChatFormType::PRIVATE,
  3.                     ChatMsgType::TEXT, msg_content, send_uid, status, chat_time);
  4.                     chat_datas.push_back(chat_data);
  5.                     continue;
  6.             }
  8.             if (msg_type == int(ChatMsgType::PIC)) {
  9.                 auto uid = UserMgr::GetInstance()->GetUid();
  10.                 QString storageDir = QStandardPaths::writableLocation(QStandardPaths::AppDataLocation);
  11.                 QString img_path_str = storageDir + "/user/" + QString::number(uid) + "/chatimg/" + QString::number(send_uid);
  12.                 QString img_path = img_path_str + "/" + msg_content;
  13.                 //文件不存在，则创建空白图片占位，同时组织数据准备发送
  14.                 if (QFile::exists(img_path) == false) {
  16.                     CreatePlaceholderImgMsgL(img_path_str, msg_content,
  17.                         msg_id, thread_id, send_uid, recv_id, status, chat_time,
  18.                         chat_datas);
  19.                     continue;
  20.                 }
  21.                 //如果文件存在
  22.                 //如果文件存在则直接构建MsgInfo
  23.                 // 获取文件大小
  24.                 QFileInfo fileInfo(img_path);
  25.                 qint64 file_size = fileInfo.size();
  26.                 //从文件路径加载QPixmap
  27.                 QPixmap pixmap(img_path);
  28.                 //如果图片加载失败，也是创建占位符，然后组织发送
  29.                 if (pixmap.isNull()) {
  30.                     CreatePlaceholderImgMsgL(img_path_str, msg_content,
  31.                         msg_id, thread_id, send_uid, recv_id, status, chat_time,
  32.                         chat_datas);
  33.                         continue;
  34.                 }
  36.                 //说明图片加载正确，构建真实图片
  37.                 auto  file_info = std::make_shared<MsgInfo>(MsgType::IMG_MSG, img_path_str,
  38.                     pixmap, msg_content, file_size, "");
  39.                 file_info->_msg_id = msg_id;
  40.                 file_info->_sender = send_uid;
  41.                 file_info->_receiver = recv_id;
  42.                 file_info->_thread_id = thread_id;
  43.                 //设置文件传输的类型
  44.                 file_info->_transfer_type = TransferType::Download;
  45.                 //设置文件传输状态
  46.                 file_info->_transfer_state = TransferState::None;
  47.                 //放入chat_datas列表
  48.                 auto chat_data = std::make_shared<ImgChatData>(file_info,"", thread_id, ChatFormType::PRIVATE,
  49.                     ChatMsgType::PIC, send_uid, status, chat_time);
  50.                 chat_datas.push_back(chat_data);
  51.                 continue;
  52.             }
热门评论
点击查看更多评论 没有更多评论了,点击收起 展开评论

热门文章

  1. 使用hexo搭建个人博客
    喜欢(533) 浏览(14716)

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

  3. MarkDown在线编辑器
    喜欢(514) 浏览(16776)

  4. 聊天项目(28) 分布式服务通知好友申请
    喜欢(507) 浏览(7564)

  5. vscode搭建windows C++开发环境
    喜欢(596) 浏览(102638)

最新评论

  1. 解决博客回复区被脚本注入的问题 secondtonone1:走到现在我忽然明白一个道理，无论工作也好生活也罢，最重要的是开心，即使一份安稳的工作不能给我带来事业上的积累也要合理的舍弃，所以我还是想去做喜欢的方向。
  2. 处理网络粘包问题 zyouth: //消息的长度小于头部规定的长度，说明数据未收全，则先将部分消息放到接收节点里 if (bytes_transferred < data_len) { memcpy(_recv_msg_node->_data + _recv_msg_node->_cur_len, _data + copy_len, bytes_transferred); _recv_msg_node->_cur_len += bytes_transferred; ::memset(_data, 0, MAX_LENGTH); _socket.async_read_some(boost::asio::buffer(_data, MAX_LENGTH), std::bind(&CSession::HandleRead, this, std::placeholders::_1, std::placeholders::_2, shared_self)); //头部处理完成 _b_head_parse = true; return; } 把_b_head_parse = true;放在_socket.async_read_some前面是不是更好
  3. C++ 线程池原理和实现 mzx2023:两种方法解决，一种是改排序算法，就是当线程耗尽的时候，使用普通递归，另一种是当在线程池commit的时候，判断线程是否耗尽，耗尽的话就直接当前线程执行task
  4. 利用指针和容器实现文本查询 越今朝:应该添加一个过滤功能以解决部分单词无法被查询的问题: eg: "I am a teacher."中的teacher无法被查询，因为在示例代码中teacher.被解释为一个单词从而忽略了teacher本身。
  5. 无锁并发队列 TenThousandOne:_head  和 _tail  替换为原子变量。那里pop的逻辑，val = _data[h] 可以移到循环外面吗

其他链接

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

个人公众号

个人微信