QT + Tcp客户端,服务器(支持多客户端)

已于 2024-06-03 10:24:17 修改
阅读量1.7k 收藏 17
点赞数 12
分类专栏： QT 文章标签： qt tcp/ip 服务器
于 2024-05-07 17:00:32 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_32863863/article/details/138537148
版权

环境

Qt 5.4.2

功能

QT Tcp 服务器,多客户端通信

服务器源码

在这里插入图片描述

  1. TcpServerApp.pro
    QT += network

  2. mainwindow

mainwindow.h

#include "tcpserver.h"

class MainWindow : public QMainWindow
{
    Q_OBJECT
public:
    explicit MainWindow(QWidget *parent = 0);
    ~MainWindow();
private:
    Ui::MainWindow *ui;
private:
     QTreeWidgetItem *pServerItem;
     QTreeWidgetItem *pClientItem;
     QStandardItemModel* pClientModel;
     TcpServer  tcpServer;
private:
    void InitTreeView();
    void InitServerCfg();
    void InitClientCfg();
private slots:
    void slot_incomingConnect(QString socketID);
    void slot_readMessage(QString socketId,QString message);
    void slot_disconnected(QString socketId);
    void slot_itemDoubleClicked(QTreeWidgetItem *item, int column);
    void slot_curStateChanged(QString identify,int state);
    void on_pushButton_Start_clicked();
    void on_pushButton_Close_clicked();
    void on_pushButton_Send_clicked();
    void on_pushButton_SendAll_clicked();
    void on_pushButton_CloseAll_clicked();
};

class MyCheckBox : public QCheckBox
{
    Q_OBJECT
public:
    explicit MyCheckBox(){}
    ~MyCheckBox(){}
public:
    void SetIdentify(QString identify) { sIdentify = identify;
     connect(this,SIGNAL(stateChanged(int)),this,SLOT(slot_stateChanged(int)));}
signals:
    void curStateChanged(QString identify,int state);
private slots:
    void slot_stateChanged(int state){emit curStateChanged(sIdentify,state);}
private:
    QString  sIdentify;
};
#endif // MAINWINDOW_H

mainwindow.cpp

MainWindow::MainWindow(QWidget *parent) :
    QMainWindow(parent),
    ui(new Ui::MainWindow)
{
    ui->setupUi(this);
    InitTreeView();
    InitServerCfg();
    InitClientCfg();
}

void MainWindow::InitTreeView()
{
    ui->treeWidget->setColumnCount(1);
    ui->treeWidget->setHeaderLabel(tr("TCP 服务器"));
    pServerItem = new QTreeWidgetItem(ui->treeWidget,QStringList(QString("服务器")));// 添加QTreeWidget主节点;
    pClientItem = new QTreeWidgetItem(ui->treeWidget,QStringList(QString("客户端")));
    QTreeWidgetItem *pServerItem_1 = new QTreeWidgetItem(pServerItem,QStringList(QString("配置管理")));
    QTreeWidgetItem *pClientItem_1 = new QTreeWidgetItem(pClientItem,QStringList(QString("配置管理")));
    connect(ui->treeWidget,SIGNAL(itemDoubleClicked(QTreeWidgetItem*,int)),this,SLOT(slot_itemDoubleClicked(QTreeWidgetItem*,int)));
    ui->treeWidget->setCurrentItem(pServerItem_1);
    ui->treeWidget->expandAll();
    ui->stackedWidget->setCurrentIndex(0);
}

void MainWindow::InitServerCfg()
{
    connect(&tcpServer,SIGNAL(incomingConnect(QString)),SLOT(slot_incomingConnect(QString)));
    connect(&tcpServer,SIGNAL(readMessage(QString,QString)),SLOT(slot_readMessage(QString,QString)));
    connect(&tcpServer,SIGNAL(disconnected(QString)),SLOT(slot_disconnected(QString)));
    ui->pushButton_Start->setEnabled(true);
    ui->pushButton_Close->setEnabled(false);
}

void MainWindow::InitClientCfg()
{
    pClientModel = new QStandardItemModel();
    ui->tableView_RecvAll->verticalHeader()->setVisible(false);
    ui->tableView_RecvAll->horizontalHeader()->setVisible(false);
    ui->tableView_RecvAll->setModel(pClientModel);
    pClientModel->setColumnCount(2);                                
    ui->tableView_RecvAll->horizontalHeader()->setSectionResizeMode(0, QHeaderView::Fixed);
    ui->tableView_RecvAll->horizontalHeader()->setSectionResizeMode(1, QHeaderView::Stretch);
    ui->tableView_RecvAll->setColumnWidth(0, 80);
    ui->tableView_RecvAll->setEditTriggers(QAbstractItemView::NoEditTriggers);
    MyCheckBox *pAllCheck = new MyCheckBox();
    pAllCheck->setText("全选");
    pAllCheck->SetIdentify("All");
    connect(pAllCheck,SIGNAL(curStateChanged(QString,int)),this,SLOT(slot_curStateChanged(QString,int)));
    pClientModel->setRowCount(1);
    ui->tableView_RecvAll->setRowHeight(0,40);
    ui->tableView_RecvAll->setIndexWidget(pClientModel->index(0,0),pAllCheck);
    pClientModel->setItem(0, 1, new QStandardItem("客户端" ) );
    ui->pushButton_SendAll->setEnabled(false);
    ui->pushButton_CloseAll->setEnabled(false);
}
void MainWindow::slot_incomingConnect(QString socketID)
{
    QTreeWidgetItem *pClientItem_N = new QTreeWidgetItem(pClientItem,QStringList(socketID));
    pClientModel->setRowCount(pClientModel->rowCount()+1);
    MyCheckBox *pOneCheck = new MyCheckBox();
    pOneCheck->SetIdentify(socketID);
    connect(pOneCheck,SIGNAL(curStateChanged(QString,int)),this,SLOT(slot_curStateChanged(QString,int)));
    ui->tableView_RecvAll->setIndexWidget(pClientModel->index(pClientModel->rowCount()-1,0),pOneCheck);
    pClientModel->setItem(pClientModel->rowCount()-1, 1, new QStandardItem(socketID) );
    ui->tableView_RecvAll->setRowHeight(pClientModel->rowCount()-1,40);
}
void MainWindow::slot_readMessage(QString socketId, QString message)
{
    QString sSocketID =  "客户端[" + socketId + "]";
    if(ui->label_Info->text() == sSocketID)
    {
        ui->textEdit_Recv->setText(message);
    }
}
void MainWindow::slot_disconnected(QString socketId)
{
    for(int i=0; i<pClientItem->childCount(); i++)
    {
        if(pClientItem->child(i)->text(0) == socketId)
        {
            pClientItem->removeChild(pClientItem->child(i));
            break;
        }
    }
    
    for(int i=1; i<pClientModel->rowCount(); i++)
    {
        if(socketId == pClientModel->item(i,1)->text())
        {
            pClientModel->removeRow(i);
        }
    }
    ui->treeWidget->setCurrentItem(pClientItem->child(0));
    ui->stackedWidget->setCurrentIndex(1);
}

void MainWindow::slot_itemDoubleClicked(QTreeWidgetItem *item, int column)
{
    if(NULL == item->parent()) { return; }
    if(item->parent() == pServerItem)
    {
        ui->stackedWidget->setCurrentIndex(0);
        return;
    }
    if("配置管理" == item->text(0))
    {
       ui->stackedWidget->setCurrentIndex(1);
       return;
    }
    QString sTitleMsg  = "客户端[" + item->text(0) + "]";
    ui->label_Info->setText(sTitleMsg);
    ui->stackedWidget->setCurrentIndex(2);
    ui->textEdit_Send->clear();
    ui->textEdit_Recv->setText(tcpServer.GetRecvMesg(item->text(0)));
}

void MainWindow::slot_curStateChanged(QString identify, int state)
{
   if("All" != identify) { return; }
   MyCheckBox *pCheckBox;
   
   for(int i=1; i<pClientModel->rowCount(); i++)
   {
       pCheckBox = (MyCheckBox*)ui->tableView_RecvAll->indexWidget(pClientModel->index(i,0));
       switch(state)
       {
        case 0: pCheckBox->setChecked(false); break;
        case 2: pCheckBox->setChecked(true);  break;
        default:break;
       }
   }
}

void MainWindow::on_pushButton_Start_clicked()
{
    ui->label_ServerSts->setText("");
    if(!tcpServer.listen(QHostAddress::Any,ui->spinBox_Port->value()))
    {
        ui->label_ServerSts->setText("Failed to bind port !");
        return;
    }

    ui->pushButton_Start->setEnabled(false);
    ui->pushButton_Close->setEnabled(true);
    ui->pushButton_SendAll->setEnabled(true);
    ui->pushButton_CloseAll->setEnabled(true);
}

void MainWindow::on_pushButton_Close_clicked()
{
    tcpServer.close();
    tcpServer.ClearClientAll();
    ui->pushButton_Start->setEnabled(true);
    ui->pushButton_Close->setEnabled(false);
    ui->pushButton_SendAll->setEnabled(false);
    ui->pushButton_CloseAll->setEnabled(false);
}
void MainWindow::on_pushButton_Send_clicked()
{
    QString sSocketID =  ui->label_Info->text();
    sSocketID = sSocketID.mid(sSocketID.indexOf("[")+1,sSocketID.lastIndexOf("]") - sSocketID.indexOf("[")-1);
    tcpServer.SendMessage(sSocketID,ui->textEdit_Send->toPlainText());
    ui->textEdit_Send->clear();
    ui->textEdit_Recv->setText(tcpServer.GetRecvMesg(sSocketID));
}

void MainWindow::on_pushButton_SendAll_clicked()
{
    if("" == ui->textEdit_RecvAll->toPlainText()) { return; }
    MyCheckBox *pCheckBox;
    for(int i=1; i<pClientModel->rowCount(); i++)
    {
        pCheckBox = (MyCheckBox*)ui->tableView_RecvAll->indexWidget(pClientModel->index(i,0));
        switch(pCheckBox->checkState())
        {
          case Qt::Checked :
          {
            tcpServer.SendMessage(pClientModel->item(i,1)->text(),ui->textEdit_RecvAll->toPlainText());
          }break;
          default:break;
        }
    }
}

void MainWindow::on_pushButton_CloseAll_clicked()
{
    MyCheckBox *pCheckBox;
    for(int i=1; i<pClientModel->rowCount(); i++)
    {
        pCheckBox = (MyCheckBox*)ui->tableView_RecvAll->indexWidget(pClientModel->index(i,0));
        switch(pCheckBox->checkState())
        {
          case Qt::Checked :
          {
            tcpServer.CloseSocket(pClientModel->item(i,1)->text());
          }break;
          default:break;
        }
    }
}
  1. tcpserver
    tcpserver.h
#include "tcpsocket.h"

class TcpServer : public QTcpServer
{
    Q_OBJECT
public:
    TcpServer();
    ~TcpServer();
    void ClearClientAll();
    void SendMessage(QString socketId,QString message);
    void CloseSocket(QString socketId);
    QString GetRecvMesg(QString socketId);
protected:
    void incomingConnection(int socketId);
private:
    QMap<QString,TcpSocket *> clientArray;
private slots:
    void slot_readMsg(QString socketId,QString message);
    void slot_disconnect(QString socketId);
signals:
    void incomingConnect(QString socketId);
    void readMessage(QString socketId,QString message);
    void disconnected(QString socketId);
};
#endif // TCPSERVER_H

tcpserver.cpp

#include "tcpserver.h"

void TcpServer::ClearClientAll()
{
    for (QString key : clientArray.keys())
    {
        clientArray[key]->close();
    }
    clientArray.clear();
}

void TcpServer::SendMessage(QString socketId, QString message)
{
    if(clientArray.contains(socketId))
    {
        clientArray[socketId]->SendMessage(message);
    }
}
void TcpServer::CloseSocket(QString socketId)
{
    if(clientArray.contains(socketId))
    {
        clientArray[socketId]->close();
    }
}

QString TcpServer::GetRecvMesg(QString socketId)
{
    if(clientArray.contains(socketId))
    {
        return clientArray[socketId]->GetRecvMesg();
    }
}

void TcpServer::incomingConnection(int socketId)
{
   TcpSocket *pTcpSocket = new TcpSocket();
   pTcpSocket->setSocketDescriptor(socketId);
   QString sClientInfo =  "ID:"+QString::number(socketId) + ",IP:" + pTcpSocket->peerAddress().toString() + ":"+ QString::number(pTcpSocket->peerPort());
   pTcpSocket->SetSocketID(sClientInfo);
   clientArray.insert(sClientInfo,pTcpSocket);
   connect(pTcpSocket,SIGNAL(readMsg(QString,QString)),SLOT(slot_readMsg(QString,QString)));
   connect(pTcpSocket,SIGNAL(disconnect(QString)),SLOT(slot_disconnect(QString)));
   emit incomingConnect(sClientInfo);
}

void TcpServer::slot_readMsg(QString socketId, QString message)
{
    emit readMessage(socketId,message);
}

void TcpServer::slot_disconnect(QString socketId)
{
   clientArray[socketId]->close();
   clientArray.remove(socketId);
   emit disconnected(socketId);
}
  1. tcpsocket
    tcpsocket.h
class TcpSocket : public QTcpSocket
{
    Q_OBJECT
public:
    TcpSocket();
    ~TcpSocket();
    void SetSocketID(QString socketID);
    void SendMessage(QString message);
    QString GetRecvMesg();
private:
    QString sSocketID;
    QStringList sRecvMesg;
private slots:
    void slot_readyRead();
    void slot_disconnected();
signals:
    void readMsg(QString socketId,QString message);
    void disconnect(QString socketId);
};

#endif // TCPSOCKET_H

tcpsocket.cpp

TcpSocket::TcpSocket()
{
    sSocketID = "";
    sRecvMesg.clear();
    connect(this,SIGNAL(readyRead()),this,SLOT(slot_readyRead()));
    connect(this,SIGNAL(disconnected()),this,SLOT(slot_disconnected()));
}

void TcpSocket::SetSocketID(QString socketID)
{
    sSocketID = socketID;
}

void TcpSocket::SendMessage(QString message)
{
    this->write(message.toLatin1());

    if(sRecvMesg.count() > 1024) { sRecvMesg.removeAt(0);}

    QString sReadMsg = QDateTime::currentDateTime().toString("yyyy-MM-dd hh:mm:ss:zzz") + ": S -> " + message;
    sRecvMesg.append(sReadMsg);
}

QString TcpSocket::GetRecvMesg()
{
    return sRecvMesg.join("\n");
}

void TcpSocket::slot_readyRead()
{
    if(sRecvMesg.count() > 1024) { sRecvMesg.removeAt(0);}
    QString sReadMsg = QDateTime::currentDateTime().toString("yyyy-MM-dd hh:mm:ss:zzz") + ": R -> " + QString(this->readAll());
    sRecvMesg.append(sReadMsg);
    emit readMsg(sSocketID,sRecvMesg.join("\n"));
}
void TcpSocket::slot_disconnected()
{
    emit disconnect(sSocketID);
}

客户端源码

在这里插入图片描述

  1. TcpClientApp.pro
    QT += network

  2. mainwindow
    mainwindow.h

class MainWindow : public QMainWindow
{
    Q_OBJECT
public:
    explicit MainWindow(QWidget *parent = 0);
    ~MainWindow();
private:
    Ui::MainWindow *ui;

private slots:
    void slot_connected();
    void slot_readyRead();
    void slot_disconnected();
    void on_pushButton_Connect_clicked();
    void on_pushButton_Send_clicked();
    void on_pushButton_Close_clicked();
private:
    QTcpSocket tcpSocket;
};
#endif // MAINWINDOW_H

mainwindow.cpp

#include "mainwindow.h"
#include "ui_mainwindow.h"

MainWindow::MainWindow(QWidget *parent) :
    QMainWindow(parent),
    ui(new Ui::MainWindow)
{
    ui->setupUi(this);

    connect(&tcpSocket,SIGNAL(connected()),this,SLOT(slot_connected()));
    connect(&tcpSocket,SIGNAL(readyRead()),this,SLOT(slot_readyRead()));
    connect(&tcpSocket,SIGNAL(disconnected()),this,SLOT(slot_disconnected()));
    ui->label_sts->setText("disconnected");
    ui->pushButton_Connect->setEnabled(true);
    ui->pushButton_Send->setEnabled(false);
    ui->pushButton_Close->setEnabled(false);
}

void MainWindow::slot_connected()
{
    ui->label_sts->setText("connected");
    ui->pushButton_Connect->setEnabled(false);
    ui->pushButton_Send->setEnabled(true);
    ui->pushButton_Close->setEnabled(true);
}

void MainWindow::slot_readyRead()
{
    QString sMessage = QDateTime::currentDateTime().toString("yyyy-MM-dd hh:mm:ss:zzz") + ": R -> " + QString(tcpSocket.readAll());
    if(ui->textEdit_Recv->document()->lineCount() > 1024)
    {
        ui->textEdit_Recv->clear();
    }
    ui->textEdit_Recv->append(sMessage);
}

void MainWindow::slot_disconnected()
{
    ui->label_sts->setText("disconnected");
    ui->pushButton_Connect->setEnabled(true);
    ui->pushButton_Send->setEnabled(false);
    ui->pushButton_Close->setEnabled(false);
}
void MainWindow::on_pushButton_Connect_clicked()
{
    tcpSocket.connectToHost(QHostAddress(ui->lineEdit_IP->text()),ui->spinBox_Port->value());
}
void MainWindow::on_pushButton_Send_clicked()
{
    tcpSocket.write(ui->textEdit_Send->toPlainText().toLatin1());
    if(ui->textEdit_Recv->document()->lineCount() > 1024)
    {
        ui->textEdit_Recv->clear();
    }
    QString sMessage = QDateTime::currentDateTime().toString("yyyy-MM-dd hh:mm:ss:zzz") + ": S -> " + ui->textEdit_Send->toPlainText();
    ui->textEdit_Recv->append(sMessage);
    ui->textEdit_Send->clear();
}

void MainWindow::on_pushButton_Close_clicked()
{
    tcpSocket.close();
}

运行结果

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

QT实现TCPServer连接多个客户端(附完整源码)
希望我的博客，能帮上你解决学习中工作中所遇到的问题
12-07 304
QT实现TCPServer连接多个客户端(附完整源码)
QT的TCP一个服务端连接多个客户端
10-10
使用QT编写tcp的简单服务端。能够同时连接多个客户端，很基础的实现，适合对Qt tcpsever 不太了解的小伙伴学习。代码仅供参考。
qt 服务器与多个客户端之间的tcp通信
11-01
qt的tcp通信，实现多个客户端与一个服务器之间的通信。 注意事项：客户端发送时格式“名称”+“：”+“要发送的消息”； 若是不加冒号，服务器程序会崩溃。按照指定格式发送消息。这样服务器回复消息时可以指定客户端，也可以对所有客户端发送消息
Qt 框架实现的TCP 客户端-服务器应用程序
最新发布
2301_80770606的博客
01-23 1402
用户输入服务器的IP地址和端口号。使用QTcpSocket的connectToHost方法尝试连接到服务器。连接成功后，客户端可以与服务器进行数据交互。
QT的TCP服务端与多客户端通信
如山石的系统虚拟化之路
06-25 1220
QT有自己的特色，大体流程各个语言都差不多，整体可以这样理解：客户端能找到服务端，然而，服务端一开始找不到客户端，如果想维护常连接，必须客户端发起，服务端对连接进行管理，从图中可知服务端需要管理这一个套接字池。
Qt5 基于TCP传输的发送/接收文件服务器（支持多客户端）
Maverick
08-26 9602
一、实现功能 1、服务器端选择待发送的文件，可以是多个 2、开启服务器，支持多客户端接入，能够实时显示每个客户端接入状态 3、等待所有客户端都处于已连接状态时，依次发送文件集给每个客户端，显示每个客户端发送进度 4、发送完成后等待接收客户端发回的文件，显示接收进度 5、关闭服务器 二、实现要点 先讲一下实现上述功能的几个关键点，明白的这几个要点，功能的大框架就搭好了，细节在下
QT实现TCPServer连接多个客户端
万小壮的博客
03-02 1万+
QT实现TCPServer连接多个客户端QT实现Server连接一个客户端本机IP地址的获取和显示侦听按钮的实现创建一个TCPServer对象，并且连接信号槽当新的客户端连接进来时读取客户端发送过来的数据和给客户端发送数据QT实现Server连接一个客户端当新的客户端连接进来时的处理多个客户端链接的时候的读写数据测试效果 QT实现Server连接一个客户端 在实现连接多个客户端之前首先需要知道连接一个客户端是怎么完成的，这里先放出代码的头文件，很多变量都是在这里定义的。 #ifndef MAINWINDOW
qt tcp 一个服务端对多个客户端
07-22
qt tcp 一个服务端对多个客户端,开发时收集的多个代码资料，方便大家一次下载
Qt学习之路十三—— 再谈TCP/IP（多客户端连接服务器）
热门推荐
技术小白的博客
06-04 3万+
一、TCP和UDP的区别这里我会用一个表格来显示这两者的区别比较项TCPUDP是否连接面向连接无连接传输是否可靠可靠不可靠流量控制提供不提供工作方式全双工可以是全双工应用场合大量数据少量数据速度慢快二、incomingConnection函数这个函数和之前讲过的newConnection信号功能差不多，只要有新的连接出现，就会自动调用这个函数。然后我们只需在这个函数中新建一个QTcpSocket对...
QT--多TCP客户端
贝勒里恩的博客
02-13 1801
1、tcpclient.h #ifndef TCPCLIENT_H #define TCPCLIENT_H #include <QWidget> #include <QPushButton> #include <QTextEdit> #include <QHBoxLayout> #include <QVBoxLayout> #inclu...
qt TCP多客户端通信
06-24
QT TCP一个服务端连接多个客户端通信，欢迎大家参考！
QTcpServer实现多客户端连接
08-27
QT QTcpServer实现多客户端连接。博客地址：https://blog.csdn.net/sinat_33859977/article/details/100110460
[Qt] TCP服务器客户端(可连接多个客户端,断线重联,指定格式解析))
11-13
编译环境:Qt5.9.5 功能介绍: 1.服务器可以连接多个客户端 2.客户端与服务器断开自动重联 3.按字节解析 4.按照1~10个字节循环返回给客户端
QT 支持多客户端链接TCP服务器，外带数据库连接池
11-14
支持多客户端链接的 tcp服务器，数据封包处理，外加SQL 连接池
QT 多线程TCP服务器与客户端
12-05
多线程通信，QT5.11.1，多线程TCP服务器，多线程连接客户端。QThread
Tcp通信（基于QT5.13 + TCP + 服务端 + 客户端）
07-06
在本文中，我们将深入探讨如何使用QT5.13.0框架实现TCP通信，包括创建一个服务端和客户端，以及如何使多个客户端与一个服务端进行有效通信。首先，我们来了解一下TCP（传输控制协议）的基本概念。 TCP是一种面向...
Qt编写网络调试助手（TCP客户端+TCP服务端+UDP服务端）终极版
05-15
时隔半年，对网络调试助手工具进行所有代码重写，这次目录结果整齐的一逼，代码整齐的一逼，非常完善了，打死也不再改版了。这次真的打死也不再改版了。...9：四种模式，tcp服务器、tcp客户端、udp服务器、udp客户端。
Qt编写TCP客户端与服务器端
11-10
Qt编写TCP通讯程序 客户端与服务器端超级详细教程，适合于可快速理解开发
评论 15
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值