• 支持语音与视频即时通讯项目杂记（一）

        

    第一部分解释服务端的实现。

    （服务端结构）

       下面一个用于实现TCP服务器的代码，包括消息服务器（TcpMsgServer）和文件中转服务器（TcpFileServer）。

    首先，TcpServer是TcpMsgServer和TcpFileServer的基类，它负责创建QTcpServer对象并监听端口。通过StartListen()函数可以启动监听，传入指定的端口号进行监听。CloseListen()函数用于关闭监听。

    TcpMsgServer是消息服务器，继承自TcpServer类。它通过重写SltNewConnection()函数来处理新客户端连接的逻辑。当有新的客户端连接到服务器时，会创建一个ClientSocket对象来管理该客户端连接。在SltConnected()函数中，对连接进行验证后，将客户端对象添加到容器m_clients中，并建立与该客户端的信号与槽连接。在SltDisConnected()函数中，处理客户端下线的情况，从容器中移除对应的客户端对象，并断开相关的信号与槽连接。SltMsgToClient()函数用于消息转发控制，根据收到的消息类型、目标客户端ID和消息内容，找到对应的客户端对象，并调用其SltSendMessage()函数将消息发送给客户端。

    TcpFileServer是文件中转服务器，同样继承自TcpServer类。它也重写了SltNewConnection()函数来处理新的客户端连接。在SltConnected()函数中，将连接上的客户端对象添加到容器m_clients中。SltDisConnected()函数处理客户端断连的情况，从容器中移除对应的客户端对象，并断开相关的信号与槽连接。SltClientDownloadFile()函数处理客户端请求下载文件的情况，根据收到的消息中的来源ID和文件名，在容器m_clients中找到对应的客户端对象，调用其StartTransferFile()函数开始文件传输过程。

    在代码中，TcpMsgServer和TcpFileServer都采用了容器来管理连接的客户端对象，以便进行消息转发和文件传输等操作。

    1. #include "tcpserver.h"
    2. #include "clientsocket.h"
    3. #include "myapp.h"
    4. #include "databasemagr.h"
    5.  
    6. #include 
    7.  
    8. /
    9. /// 服务器类，是TcpMsgServer和TcpFileServer的基类
    10. TcpServer::TcpServer(QObject *parent) :
    11.     QObject(parent)
    12. {
    13.     m_tcpServer = new QTcpServer(this);
    14.  
    15.     connect(m_tcpServer, SIGNAL(newConnection()), this, SLOT(SltNewConnection()));
    16. }
    17.  
    18. TcpServer::~TcpServer()
    19. {
    20.     if (m_tcpServer->isListening()) m_tcpServer->close();
    21. }
    22.  
    23. ///启动监听
    24. bool TcpServer::StartListen(int port)
    25. {
    26.     if (m_tcpServer->isListening()) m_tcpServer->close();
    27.     bool bOk = m_tcpServer->listen(QHostAddress::Any, port);
    28.     return bOk;
    29. }
    30.  
    31. ///关闭监听
    32. void TcpServer::CloseListen()
    33. {
    34.     m_tcpServer->close();
    35. }
    36.  
    37.  
    38. /
    39. /// 消息服务器
    40. TcpMsgServer::TcpMsgServer(QObject *parent) :
    41.     TcpServer(parent)
    42. {
    43. }
    44.  
    45. TcpMsgServer::~TcpMsgServer()
    46. {
    47.     qDebug() << "tcp server close";
    48.     foreach (ClientSocket *client, m_clients) {
    49.         m_clients.removeOne(client);
    50.         client->Close();
    51.     }
    52. }
    53.  
    54. /// 新客户端连接处理
    55. void TcpMsgServer::SltNewConnection()
    56. {
    57.     ClientSocket *client = new ClientSocket(this, m_tcpServer->nextPendingConnection());
    58.     connect(client, SIGNAL(signalConnected()), this, SLOT(SltConnected()));
    59.     connect(client, SIGNAL(signalDisConnected()), this, SLOT(SltDisConnected()));
    60. }
    61.  
    62. ///通过验证后，才可以加入容器进行管理
    63. void TcpMsgServer::SltConnected()
    64. {
    65.     ClientSocket *client = (ClientSocket *)this->sender();
    66.     if (NULL == client) return;
    67.  
    68.     connect(client, SIGNAL(signalMsgToClient(quint8,int,QJsonValue)),
    69.             this, SLOT(SltMsgToClient(quint8,int,QJsonValue)));
    70.     connect(client, SIGNAL(signalDownloadFile(QJsonValue)), this, SIGNAL(signalDownloadFile(QJsonValue)));
    71.     m_clients.push_back(client);
    72.  
    73.     qDebug() << "TcpMsgServer::SltConnected. last m_nId=" + QString::number(m_clients[m_clients.size()-1]->GetUserId());
    74. }
    75.  
    76. ///有客户端下线
    77. void TcpMsgServer::SltDisConnected()
    78. {
    79.     //找到断连的socket
    80.     ClientSocket *client = (ClientSocket *)this->sender();
    81.     if (NULL == client) return;
    82.  
    83.     //移除对应socket
    84.     for (int i = 0; i < m_clients.size(); i++) {
    85.         if (client == m_clients.at(i))
    86.         {
    87.             m_clients.remove(i);
    88.             return;
    89.         }
    90.     }
    91.  
    92.     disconnect(client, SIGNAL(signalConnected()), this, SLOT(SltConnected()));
    93.     disconnect(client, SIGNAL(signalDisConnected()), this, SLOT(SltDisConnected()));
    94.     disconnect(client, SIGNAL(signalMsgToClient(quint8,int,QJsonValue)),
    95.                this, SLOT(SltMsgToClient(quint8,int,QJsonValue)));
    96.     disconnect(client, SIGNAL(signalDownloadFile(QJsonValue)), this, SIGNAL(signalDownloadFile(QJsonValue)));
    97. }
    98.  
    99. ///消息转发控制
    100. void TcpMsgServer::SltMsgToClient(const quint8 &type, const int &id, const QJsonValue &json)
    101. {
    102.     // 查找要发送过去的id
    103.     for (int i = 0; i < m_clients.size(); i++) {
    104.         if (id == m_clients.at(i)->GetUserId())
    105.         {
    106.             qDebug()<<"TcpMsgServer::SltMsgToClient. send to:"+QString::number(id);
    107.  
    108.             m_clients.at(i)->SltSendMessage(type, json);
    109.             return;
    110.         }
    111.     }
    112. }
    113.  
    114. ///传送文件到指定ID的客户端
    115. void TcpMsgServer::SltTransFileToClient(const int &userId, const QJsonValue &json)
    116. {
    117.     // 查找要发送过去的id
    118.     for (int i = 0; i < m_clients.size(); i++) {
    119.         if (userId == m_clients.at(i)->GetUserId())
    120.         {
    121.             m_clients.at(i)->SltSendMessage(SendFile, json);
    122.             return;
    123.         }
    124.     }
    125. }
    126.  
    127. //
    128. /// 文件中转服务器，客户端先把待转发的文件保存在服务器
    129. /// 服务器接受完成后，通知其他客户端来下载
    130. TcpFileServer::TcpFileServer(QObject *parent) :
    131.     TcpServer(parent)
    132. {
    133. }
    134.  
    135. TcpFileServer::~TcpFileServer()
    136. {
    137.     qDebug() << "tcp server close";
    138.     foreach (ClientFileSocket *client, m_clients) {
    139.         m_clients.removeOne(client);
    140.         client->Close();
    141.     }
    142. }
    143.  
    144. ///客户端与文件服务器新建连接
    145. void TcpFileServer::SltNewConnection()
    146. {
    147.     //新建槽函数与socket
    148.     ClientFileSocket *client = new ClientFileSocket(this, m_tcpServer->nextPendingConnection());
    149.     connect(client, SIGNAL(signalConnected()), this, SLOT(SltConnected()));
    150.     connect(client, SIGNAL(signalDisConnected()), this, SLOT(SltDisConnected()));
    151. }
    152.  
    153. /// socket管理
    154. void TcpFileServer::SltConnected()
    155. {
    156.     //连接时将Client放入vector m_clients
    157.     ClientFileSocket *client = (ClientFileSocket *)this->sender();
    158.     if (NULL == client) return;
    159.  
    160.     m_clients.push_back(client);
    161. }
    162.  
    163. /// 客户端断连
    164. void TcpFileServer::SltDisConnected()
    165. {
    166.     ClientFileSocket *client = (ClientFileSocket *)this->sender();
    167.     if (NULL == client) return;
    168.  
    169.     for (int i = 0; i < m_clients.size(); i++) {
    170.         if (client == m_clients.at(i))
    171.         {
    172.             m_clients.remove(i);
    173.             return;
    174.         }
    175.     }
    176.  
    177.     disconnect(client, SIGNAL(signalConnected()), this, SLOT(SltConnected()));
    178.     disconnect(client, SIGNAL(signalDisConnected()), this, SLOT(SltDisConnected()));
    179. }
    180.  
    181. /// 客户端请求下载文件
    182. void TcpFileServer::SltClientDownloadFile(const QJsonValue &json)
    183. {
    184.     // 根据ID寻找连接的socket
    185.     if (json.isObject()) {
    186.         QJsonObject jsonObj = json.toObject();
    187.         qint32 nId = jsonObj.value("from").toInt();//
    188.         qint32 nWid = jsonObj.value("id").toInt();;//
    189.         QString fileName = jsonObj.value("msg").toString();
    190.         qDebug() << "get file" << jsonObj << m_clients.size();
    191.         for (int i = 0; i < m_clients.size(); i++) {
    192.             if (m_clients.at(i)->CheckUserId(nId, nWid))
    193.             {
    194.                 m_clients.at(i)->StartTransferFile(fileName);
    195.                 return;
    196.             }
    197.         }
    198.     }
    199. }
    200.

           当服务端端通过accpt收到一个请求后，创建一个ClientSocket，处理客户端消息。
            下面是一个Qt中的客户端socket管理类，用于与服务端进行通信。其中包含两个类，一个是ClientSocket，用于处理普通消息，另一个是ClientFileSocket，用于处理文件传输。

    在ClientSocket中，包含了一些信号和槽函数，用于处理连接、数据接收、关闭等操作。同时还有一些私有函数，用于解析不同类型的消息，并且把解析后的数据发送到前台界面进行展示。

    在ClientFileSocket中，主要有两个功能：文件接收和文件发送。对于文件接收，分别记录了已经接收到的数据大小、文件名大小、要接收的文件等信息；对于文件发送，记录了文件大小、已经发送的数据大小、剩余数据大小、要发送的文件等信息。同时还有一些私有函数，用于初始化socket、处理接收到的数据、更新发送进度等操作。

    总的来说，这个类是一个很重要的网络通信模块，可以实现与服务端的双向交互，包括文字、图片、文件等。

    1. #ifndef CLIENTSOCKET_H
    2. #define CLIENTSOCKET_H
    3.  
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8.  
    9. /// 服务端socket管理类
    10. class ClientSocket : public QObject
    11. {
    12.     Q_OBJECT
    13. public:
    14.     explicit ClientSocket(QObject *parent = 0, QTcpSocket *tcpSocket = NULL);
    15.     ~ClientSocket();
    16.  
    17.     int GetUserId() const;
    18.     void Close();
    19. signals:
    20.     void signalConnected();
    21.     void signalDisConnected();
    22.     void signalDownloadFile(const QJsonValue &json);
    23.     void signalMsgToClient(const quint8 &type, const int &id, const QJsonValue &dataVal);
    24. public slots:
    25.  
    26. private:
    27.     QTcpSocket *m_tcpSocket;
    28.     int         m_nId;
    29.  
    30. public slots:
    31.     // 消息回发
    32.     void SltSendMessage(const quint8 &type, const QJsonValue &json);
    33.  
    34. private slots:
    35.     void SltConnected();
    36.     void SltDisconnected();
    37.     void SltReadyRead();
    38.  
    39. private:
    40.     // 消息解析和抓转发处理
    41.     void ParseLogin(const QJsonValue &dataVal);
    42.     void ParseUserOnline(const QJsonValue &dataVal);
    43.     void ParseLogout(const QJsonValue &dataVal);
    44.     void ParseUpdateUserHead(const QJsonValue &dataVal);
    45.  
    46.     void ParseReister(const QJsonValue &dataVal);
    47.     void ParseAddFriend(const QJsonValue &dataVal);
    48.     void ParseAddGroup(const QJsonValue &dataVal);
    49.     void ParseCreateGroup(const QJsonValue &dataVal);
    50.  
    51.     void ParseGetMyFriend(const QJsonValue &dataVal);
    52.     void ParseGetMyGroups(const QJsonValue &dataVal);
    53.  
    54.     void ParseRefreshFriend(const QJsonValue &dataVal);
    55.     void ParseRefreshGroups(const QJsonValue &dataVal);
    56.  
    57.     void ParseFriendMessages(const QByteArray &reply);
    58.     void ParseGroupMessages(const QByteArray &reply);
    59. };

    1. ClientSocket::ClientSocket(QObject *parent, QTcpSocket *tcpSocket) :
    2.     QObject(parent)
    3. {
    4.     qRegisterMetaType("QAbstractSocket::SocketError");
    5.  
    6.  
    7.     m_nId = -1;
    8.  
    9.     if (tcpSocket == NULL) m_tcpSocket = new QTcpSocket(this);
    10.     m_tcpSocket = tcpSocket;
    11.  
    12.     connect(m_tcpSocket, SIGNAL(readyRead()), this, SLOT(SltReadyRead()));//处理客户端信息
    13.     connect(m_tcpSocket, SIGNAL(connected()), this, SLOT(SltConnected()));//处理登录成功信号
    14.     connect(m_tcpSocket, SIGNAL(disconnected()), this, SLOT(SltDisconnected()));//处理登出信号
    15. }

    处理客户端消息，根据消息类型进行不同的处理：

    1. void ClientSocket::SltReadyRead()
    2. {
    3.     // 读取socket数据
    4.     QByteArray reply = m_tcpSocket->readAll();
    5.     QJsonParseError jsonError;
    6.     // 转化为 JSON 文档
    7.     QJsonDocument doucment = QJsonDocument::fromJson(reply, &jsonError);
    8.     // 解析未发生错误
    9.     if (!doucment.isNull() && (jsonError.error == QJsonParseError::NoError)) {
    10.         // JSON 文档为对象
    11.         if (doucment.isObject()) {
    12.             // 转化为对象
    13.             QJsonObject jsonObj = doucment.object();
    14.             int nType = jsonObj.value("type").toInt();
    15.             QJsonValue dataVal = jsonObj.value("data");
    16.  
    17.             switch (nType) {
    18.             case Register:
    19.             {
    20.                 ParseReister(dataVal);
    21.             }
    22.                 break;
    23.             case Login:
    24.             {
    25.                 ParseLogin(dataVal);
    26.             }
    27.                 break;
    28.             case UserOnLine:
    29.             {
    30.                 ParseUserOnline(dataVal);
    31.             }
    32.                 break;
    33.             case Logout:
    34.             {
    35.                 ParseLogout(dataVal);
    36.                 Q_EMIT signalDisConnected();
    37.                 m_tcpSocket->abort();
    38.             }
    39.                 break;
    40.             case UpdateHeadPic:
    41.             {
    42.                 ParseUpdateUserHead(dataVal);
    43.             }
    44.                 break;
    45.             case AddFriend:
    46.             {
    47.                 ParseAddFriend(dataVal);
    48.             }
    49.                 break;
    50.             case AddGroup:
    51.             {
    52.                 ParseAddGroup(dataVal);
    53.             }
    54.                 break;
    55.             case CreateGroup:
    56.             {
    57.                 ParseCreateGroup(dataVal);
    58.             }
    59.                 break;
    60.             case GetMyFriends:
    61.             {
    62.                 ParseGetMyFriend(dataVal);
    63.             }
    64.                 break;
    65.             case GetMyGroups:
    66.             {
    67.                 ParseGetMyGroups(dataVal);
    68.             }
    69.                 break;
    70.  
    71.             case RefreshFriends:
    72.             {
    73.                 ParseRefreshFriend(dataVal);
    74.             }
    75.                 break;
    76.             case RefreshGroups:
    77.             {
    78.                 ParseRefreshGroups(dataVal);
    79.             }
    80.                 break;
    81.             case SendMsg:
    82.             case SendFile:
    83.             case SendPicture:
    84.             {
    85.                 ParseFriendMessages(reply);
    86.             }
    87.                 break;
    88.             case SendGroupMsg:
    89.             {
    90.                 ParseGroupMessages(reply);
    91.             }
    92.                 break;
    93.             case SendFace:
    94.             {
    95.                 ParseGroupMessages(reply);
    96.             }
    97.                 break;
    98.             case SendFileOk:
    99.             {
    100.  
    101.             }
    102.                 break;
    103.             case GetFile:
    104.             {
    105.                 Q_EMIT signalDownloadFile(dataVal);
    106.             }
    107.                 break;
    108.             default:
    109.                 break;
    110.             }
    111.         }
    112.     }
    113. }

    登录的处理：

    1. void ClientSocket::ParseLogin(const QJsonValue &dataVal)
    2. {
    3.     // data 的 value 也是JSON对象
    4.     if (dataVal.isObject()) {
    5.         QJsonObject dataObj = dataVal.toObject();
    6.         QString strName = dataObj.value("name").toString();
    7.         QString strPwd = dataObj.value("passwd").toString();
    8.         QJsonObject jsonObj = DataBaseMagr::Instance()->CheckUserLogin(strName, strPwd);
    9.  
    10.         m_nId = jsonObj.value("id").toInt();
    11.         qDebug() << "login" << jsonObj;
    12.         //验证成功才向server发送信号说明可以将socket加入容器管理
    13.         if (m_nId > 0) Q_EMIT signalConnected();
    14.         // 发送查询结果至客户端
    15.         SltSendMessage(Login, jsonObj);;
    16.     }
    17. }

    余略.....

  • 相关阅读:
    无序点云排序
    订单号传递规则
    PMP每日一练 | 考试不迷路-9.14（包含敏捷+多选）
    alsa pcm接口之在unix环境的传输方法
    Elasticsearch：如何在不更新证书的情况下为集群之间建立互信
    矩阵分析与应用+张贤达
    postman的简单使用
    互联网数据的重要性
    3D城市模型可视化：开启智慧都市探索之旅
    基于docker实现JMeter分布式压测
  • 原文地址：https://blog.csdn.net/wh_xia_jun/article/details/131848447