Qt-tcp通信

1  简介

参考视频：https://www.bilibili.com/video/BV1XW411x7NU?p=56

参考视频：https://www.bilibili.com/video/BV1XW411x7NU?p=66

测试1代码github：https://github.com/zhengcixi/Qt_Demo/tree/master/tcp

测试2代码github：https://github.com/zhengcixi/Qt_Demo/tree/master/tcp_file

说明：本文介绍Qt下实现tcp客户端和服务器通信的过程。

Linux下tcp客户端和服务器通信模型可参考我的另一篇博客：https://www.cnblogs.com/mrlayfolk/p/11968446.html。Qt下tcp通信的原理是一样的。

Qt的TCP通信模型如下：

（1）TCP服务器端

1）创建服务器套接字，使用QTcpServer()类；

2）将套接字设置为监听模式；

3）等待客户端连接请求，客户端连接上时会触发newConnection信号，可调用nextPendingConnection函数获取客户端的Socket信息；

4）和客户端进行通信，发送数据可使用write()函数，接收数据可使用read()或readAll函数()。

（2）TCP客户端

1）创建套接字；

2）连接服务器，使用connectToHost()函数；

3）和服务器进行通信，发送数据可使用write()函数，接收数据可使用read()或readAll函数()。

2  代码测试

2.1  基本的tcp通信测试

功能说明：分别创建两个窗口，一个用作TCP服务器端，一个用作TCP客户端，双方进行通信。窗口如下：

服务器窗口：                                                                             客户端窗口：

           

下面分别说明代码实现的步骤：

（1）服务器端

首先创建两个套接字指针。tcpserver用作服务器套接字，tcpsocket用作和客户端通信的通信套接字。

    QTcpServer *tcpserver = NULL;  //监听套接字
    QTcpSocket *tcpsocket = NULL;  //通信套接字

然后，创建套接字并启动监听。

    //监听套接字，指定父对象，自动回收空间
    tcpserver = new QTcpServer(this);
    //启动监听
    tcpserver->listen(QHostAddress::Any, 8888);

捕捉newConnect信号与槽函数，等待客户端连接：

    //等待连接
    connect(tcpserver, &QTcpServer::newConnection,
        [=]() {
            //取出建立好连接的套接字
            tcpsocket = tcpserver->nextPendingConnection();
            //获取对方的ip的端口
            QString ip = tcpsocket->peerAddress().toString();
            qint16 port = tcpsocket->peerPort();
            QString tmp = QString("[%1:%2]:成功连接").arg(ip).arg(port);
            //在当前对话框显示谁和我连接了
            ui->textEdit_recv->setText(tmp);
        }
    );

发送数据：

    //获取编辑区内容
    QString str = ui->textEdit_send->toPlainText();
    //给对方发送数据
    //QString -> char*
    tcpsocket->write(str.toUtf8().data());

接收数据：

            //接收数据
            connect(tcpsocket, &QTcpSocket::readyRead,
                [=](){
                    //从通信套接字中取出内容
                     QByteArray array = tcpsocket->readAll();
                     ui->textEdit_recv->append(array);
                }
            );

关闭连接：

    //主动和客户端断开连接
    tcpsocket->disconnectFromHost();
    tcpsocket->close();
    tcpsocket = NULL;

（2）客户端

客户端只需要创建一个套接字，用于和服务器建立连接并通信：

    QTcpSocket *tcpsocket = NULL;  //通信套接字
    //分配空间，指定父对象
    tcpsocket = new QTcpSocket(this);

和服务器端建立连接：

    //获取服务器ip和端口
    QString ip = ui->lineEdit_ip->text();
    qint16 port = ui->lineEdit_port->text().toInt();
    //主动和服务器建立连接
    tcpsocket->connectToHost(QHostAddress(ip), port);

发送数据：

    //获取编辑框内容
    QString str = ui->textEdit_send->toPlainText();
    //发送数据
    tcpsocket->write(str.toUtf8().data());

接收数据：

    connect(tcpsocket, &QTcpSocket::readyRead,
        [=](){
            //获取对方发送的内容
            QByteArray array = tcpsocket->readAll();
            //追加到编辑区中
            ui->textEdit_recv->append(array);
        }
    );

断开连接：

    //主动和对方断开连接
    tcpsocket->disconnectFromHost();
    tcpsocket->close();

（3）完整的工程代码：

工程所包含的文件有，serverwidget.cpp和serverwidget.h是服务器端的代码，clientwidget.cpp和clientwidget.h是客户端代码。

 serverwidget.cpp代码：

#include "serverwidget.h"
#include "ui_serverwidget.h"

ServerWidget::ServerWidget(QWidget *parent) :
    QWidget(parent),
    ui(new Ui::ServerWidget)
{
    ui->setupUi(this);
    setWindowTitle("服务器: 8888");

    //监听套接字，指定父对象，自动回收空间
    tcpserver = new QTcpServer(this);
    //启动监听
    tcpserver->listen(QHostAddress::Any, 8888);
    //等待连接
    connect(tcpserver, &QTcpServer::newConnection,
        [=]() {
            //取出建立好连接的套接字
            tcpsocket = tcpserver->nextPendingConnection();
            //获取对方的ip的端口
            QString ip = tcpsocket->peerAddress().toString();
            qint16 port = tcpsocket->peerPort();
            QString tmp = QString("[%1:%2]:成功连接").arg(ip).arg(port);
            //在当前对话框显示谁和我连接了
            ui->textEdit_recv->setText(tmp);

            //接收数据
            connect(tcpsocket, &QTcpSocket::readyRead,
                [=](){
                    //从通信套接字中取出内容
                     QByteArray array = tcpsocket->readAll();
                     ui->textEdit_recv->append(array);
                }
            );
        }
    );
}

ServerWidget::~ServerWidget()
{
    delete ui;
}


void ServerWidget::on_pushButton_close_clicked()
{
    if (NULL == tcpsocket) {
        return;
    }
    //主动和客户端断开连接
    tcpsocket->disconnectFromHost();
    tcpsocket->close();
    tcpsocket = NULL;
}

void ServerWidget::on_pushButton_send_clicked()
{
    if (NULL == tcpsocket) {
        return;
    }
    //获取编辑区内容
    QString str = ui->textEdit_send->toPlainText();
    //给对方发送数据
    //QString -> char*
    tcpsocket->write(str.toUtf8().data());
}

 serverwidget.h代码：

#ifndef SERVERWIDGET_H
#define SERVERWIDGET_H

#include <QWidget>
#include <QTcpServer>  //监听套接字
#include <QTcpSocket>  //通信套接字

namespace Ui {
class ServerWidget;
}

class ServerWidget : public QWidget
{
    Q_OBJECT

public:
    explicit ServerWidget(QWidget *parent = 0);
    ~ServerWidget();

private slots:
    void on_pushButton_send_clicked();

    void on_pushButton_close_clicked();

private:
    Ui::ServerWidget *ui;
    QTcpServer *tcpserver = NULL;  //监听套接字
    QTcpSocket *tcpsocket = NULL;  //通信套接字
};

#endif // SERVERWIDGET_H

clientwidget.cpp代码：

#include "clientwidget.h"
#include "ui_clientwidget.h"
#include <QHostAddress>

clientwidget::clientwidget(QWidget *parent) :
    QWidget(parent),
    ui(new Ui::clientwidget)
{
    ui->setupUi(this);
    setWindowTitle("客户端");
    //分配空间，指定父对象
    tcpsocket = new QTcpSocket(this);
    //建立连接
    connect(tcpsocket, &QTcpSocket::connected,
        [=]() {
            ui->textEdit_recv->setText("成功和服务器建立了连接");
        }
    );
    //接收数据
    connect(tcpsocket, &QTcpSocket::readyRead,
        [=](){
            //获取对方发送的内容
            QByteArray array = tcpsocket->readAll();
            //追加到编辑区中
            ui->textEdit_recv->append(array);
        }
    );
    //断开连接
    connect(tcpsocket, &QTcpSocket::disconnected,
        [=](){
            ui->textEdit_recv->append("和服务器断开了连接");
        }
    );
}

clientwidget::~clientwidget()
{
    delete ui;
}

void clientwidget::on_pushButton_send_clicked()
{
    //获取编辑框内容
    QString str = ui->textEdit_send->toPlainText();
    //发送数据
    tcpsocket->write(str.toUtf8().data());
}

void clientwidget::on_pushButton_close_clicked()
{
    //主动和对方断开连接
    tcpsocket->disconnectFromHost();
    tcpsocket->close();
}

void clientwidget::on_pushButton_connect_clicked()
{
    //获取服务器ip和端口
    QString ip = ui->lineEdit_ip->text();
    qint16 port = ui->lineEdit_port->text().toInt();
    //主动和服务器建立连接
    tcpsocket->connectToHost(QHostAddress(ip), port);
}

clientwidget.h代码：

#ifndef CLIENTWIDGET_H
#define CLIENTWIDGET_H

#include <QWidget>
#include <QTcpSocket>

namespace Ui {
class clientwidget;
}

class clientwidget : public QWidget
{
    Q_OBJECT

public:
    explicit clientwidget(QWidget *parent = 0);
    ~clientwidget();

private slots:
    void on_pushButton_send_clicked();

    void on_pushButton_close_clicked();

    void on_pushButton_connect_clicked();

private:
    Ui::clientwidget *ui;
    QTcpSocket *tcpsocket = NULL;
};

#endif // CLIENTWIDGET_H

main.cpp代码，启动两个窗口：

#include "serverwidget.h"
#include <QApplication>
#include "clientwidget.h"

int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    ServerWidget w;
    clientwidget w2;
    w.show();
    w2.show();

    return a.exec();
}

运行进行测试：

2.2  使用tcp传输文件

功能：客户端连接到服务器，服务器端再传输文件给客户端，当文件传输完成时，服务器端等待客户端返回成功接收的信息，然后服务器端关闭客户端的连接。

通信模型如下：

 有几点需要说明一下：

（1）服务器端传输文件之前，先传输了一个文件头信息，这个信息是我们自己封装的，格式为：“文件名##文件字节数”，这样客户端就可以根据文件头信息获取文件的信息了，创建相应的文件。

（2）发送文件数据时，如果文件太大，可以一个一个缓冲区的发送，缓冲区的大小是自己设置的，代码中设置的4kb；

代码说明如下：

（1）工程文件有：

clientwidget.cpp和clientwidget.h是客户端的代码，serverwidget.cpp和serverwidget.h是服务器端的代码。

（2）直接给出代码，代码中有注释：

clientwidget.h代码：

#ifndef CLIENTWIDGET_H
#define CLIENTWIDGET_H

#include <QWidget>
#include <QTcpSocket>
#include <QFile>

namespace Ui {
class clientWidget;
}

class clientWidget : public QWidget
{
    Q_OBJECT

public:
    explicit clientWidget(QWidget *parent = 0);
    ~clientWidget();

private slots:
    void on_pushButton_connect_clicked();

private:
    Ui::clientWidget *ui;

    QTcpSocket *tcpsocket = NULL;  //通信套接字
    QFile file;  //文件对象
    QString filename; //文件名
    qint64 filesize = 0;  //文件大小
    qint64 recvsize = 0;  //已发送文件大小
    bool isStart; //开始接收文件标志位
};

#endif // CLIENTWIDGET_H

clientwidget.cpp代码

#include "clientwidget.h"
#include "ui_clientwidget.h"
#include <QDebug>
#include <QMessageBox>
#include <QHostAddress>
#include <QIODevice>

clientWidget::clientWidget(QWidget *parent) :
    QWidget(parent),
    ui(new Ui::clientWidget)
{
    ui->setupUi(this);
    setWindowTitle("客户端");

    isStart = true;
    ui->progressBar->setValue(0);  //当前值

    tcpsocket = new QTcpSocket(this);
    connect(tcpsocket, &QTcpSocket::readyRead,
        [=](){
            //取出接收的内容
            qDebug() << "isstart:" << isStart;
            QByteArray buf = tcpsocket->readAll();
            if (isStart == true) {  //接收到头部信息
                isStart = false;
                //解析头部信息  初始化
                filename = QString(buf).section("##", 0, 0);  //文件名
                filesize = QString(buf).section("##", 1, 1).toInt();  //文件大小
                recvsize = 0;   //已经接收文件大小
                qDebug() << "fileName" << filename << "filesize" << filesize;
                //打开文件
                file.setFileName(filename);
                bool isOK = file.open(QIODevice::WriteOnly);
                if (false == isOK) {
                    qDebug() << "open error!!!";
                    //关闭连接
                    tcpsocket->disconnectFromHost();
                    tcpsocket->close();
                    return;
                }
                //弹出对话框，显示接收文件信息
                QString str = QString("接收的文件：[%1:%2kb]").arg(filename).arg(filesize/1024);
                QMessageBox::information(this, "文件信息", str);
                //设置进度条
                ui->progressBar->setMinimum(0);
                ui->progressBar->setMaximum(filesize/1024);
                ui->progressBar->setValue(0);
                QString str1 = QString("开始接收文件%1，大小为%2bytes").arg(filename).arg(filesize);
                ui->textEdit->append(str1);
            } else { //真正的文件信息
                qDebug() << "start write data";
                qint64 len = file.write(buf);
                if (len > 0) {
                    recvsize += len;
                    qDebug() << len;
                }
                qDebug() << "recvsize" << recvsize << "filesize" << filesize;
                //更新进度条
                ui->progressBar->setValue(recvsize/1024);
                if (recvsize == filesize) {  //文件接收完成
                    qDebug() << "recvsize" << recvsize << "filesize" << filesize;
                    //先向服务器发送接收文件完成的信息
                    tcpsocket->write("file done");
                    QMessageBox::information(this, "完成", "文件接收完成");
                    file.close();
                    tcpsocket->disconnectFromHost();
                    tcpsocket->close();
                }
            }
        }
    );
    connect(tcpsocket, &QTcpSocket::connected,
        [=](){
            ui->textEdit->clear();
            ui->textEdit->append("已经和服务器建立了连接，等待服务器传输文件...");
            ui->pushButton_connect->setEnabled(false);
        }
    );
    connect(tcpsocket, &QTcpSocket::disconnected,
        [=](){
            ui->textEdit->append("已经和服务器断开了连接");
            ui->pushButton_connect->setEnabled(true);
        }
    );
}

clientWidget::~clientWidget()
{
    delete ui;
}

void clientWidget::on_pushButton_connect_clicked()
{
    //获取服务器的ip和端口
    QString ip = ui->lineEdit_ip->text();
    quint16 port = ui->lineEdit_port->text().toInt();
    //主动和服务器建立连接
    tcpsocket->connectToHost(QHostAddress(ip), port);
    isStart = true;
    //设置进度条
    ui->progressBar->setValue(0);
}

serverwidget.h代码：

#ifndef SERVERWIDGET_H
#define SERVERWIDGET_H

#include <QWidget>
#include <QTcpServer>
#include <QTcpSocket>
#include <QFile>
#include <QTimer>

namespace Ui {
class ServerWidget;
}

class ServerWidget : public QWidget
{
    Q_OBJECT

public:
    explicit ServerWidget(QWidget *parent = 0);
    ~ServerWidget();
    void sendData(); //发送文件数据


private slots:
    void on_pushButton_send_clicked();

    void on_pushButton_choose_clicked();

private:
    Ui::ServerWidget *ui;

    QTcpServer *tcpserver = NULL;  //监听套接字
    QTcpSocket *tcpsocket = NULL;  //通信套接字
    QFile file;  //文件对象
    QString filename; //文件名
    qint64 filesize;  //文件大小
    qint64 sendsize;  //已发送文件大小
    QTimer timer;  //定时器

};

#endif // SERVERWIDGET_H

serverwidget.cpp代码：

#include "serverwidget.h"
#include "ui_serverwidget.h"
#include <QFileDialog>
#include <QDebug>
#include <QFileInfo>
#include <QTimer>

ServerWidget::ServerWidget(QWidget *parent) :
    QWidget(parent),
    ui(new Ui::ServerWidget)
{
    ui->setupUi(this);
    setWindowTitle("服务器");

    //监听套接字
    tcpserver = new QTcpServer(this);
    //启动监听
    tcpserver->listen(QHostAddress::Any, 8888);

    //两个按钮都不能使用
    ui->pushButton_choose->setEnabled(false);
    ui->pushButton_send->setEnabled(false);

    //如果客户端成功和服务器连接
    connect(tcpserver, &QTcpServer::newConnection,
        [=](){
            //取出建立好连接的套接字
            tcpsocket = tcpserver->nextPendingConnection();
            //获取对方的IP和端口
            QString ip = tcpsocket->peerAddress().toString();
            quint16 port = tcpsocket->peerPort();
            QString str = QString("[%1:%2] 成功连接").arg(ip).arg(port);
            ui->textEdit->append(str); //显示到编辑区
            //成功连接后，才能选择文件
            ui->pushButton_choose->setEnabled(true);
            ui->pushButton_send->setEnabled(false);
            connect(tcpsocket, &QTcpSocket::readyRead,
                [=]() {
                    //取客户端的消息
                    QByteArray buf = tcpsocket->readAll();
                    if (QString(buf) == "file done") {  //文件接收完毕
                        ui->textEdit->append("文件接收完成");
                        file.close();
                        //断开客户端端口
                        tcpsocket->disconnectFromHost();
                        tcpsocket->close();
                        ui->pushButton_choose->setEnabled(false);
                        ui->pushButton_send->setEnabled(false);
                    }
                }
            );
        }
    );
    //定时器事件
    connect(&timer, &QTimer::timeout,
        [=](){
            //关闭定时器
            timer.stop();
            //发送数据
            sendData();
        }
    );

}

ServerWidget::~ServerWidget()
{
    delete ui;
}

//发送文件按钮
void ServerWidget::on_pushButton_send_clicked()
{
    //发送文件头信息
    QString head = QString("%1##%2").arg(filename).arg(filesize);
    qint64 len = tcpsocket->write(head.toUtf8());
    if (len > 0) {  //头部信息发送成功
        //防止TCP粘包问题，需要通过定时器样式
        timer.start(2000);
    } else {
        qDebug() << "send header data error!!!";
        file.close();
        ui->pushButton_choose->setEnabled(true);
        ui->pushButton_send->setEnabled(false);
    }
}

//选择文件按钮
void ServerWidget::on_pushButton_choose_clicked()
{
    //打开文件
    QString filepath = QFileDialog::getOpenFileName(this, "open", "../");
    if (false == filepath.isEmpty()) {  //选择文件路径有效
        filename.clear();
        filesize = 0;
        sendsize = 0;
        //获取文件信息 文件名 文件大小
        QFileInfo info(filepath);
        filename = info.fileName();
        filesize = info.size();
        //只读方式打开文件
        file.setFileName(filepath);
        bool isOK = file.open(QIODevice::ReadOnly);
        if (false == isOK) {
            qDebug() << "open file error!!!";
        }
        QString str = QString("已选择文件：%1").arg(filepath);
        ui->textEdit->append(str);
        //设置按钮属性
        ui->pushButton_choose->setEnabled(false);
        ui->pushButton_send->setEnabled(true);
    } else {
        qDebug() << "选择的文件路径无效！！！";
    }
}

//发送文件数据
void ServerWidget::sendData()
{
    ui->textEdit->append("正在发送文件...");
    qint64 len = 0;
    do {
        //每次发送数据的大小
        char buf[4*1024] = {0};
        //往文件中读数据
        len = file.read(buf, sizeof(buf));
        if (len <= 0) {
            break;
        }
        //发送数据，读多少，发多少
        len = tcpsocket->write(buf, len);
        //发送数据大小累加
        sendsize += len;
        qDebug() << "have send:" << len;
    } while (len > 0);
}

main.cpp代码：

#include "serverwidget.h"
#include <QApplication>
#include "clientwidget.h"

int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    ServerWidget w;
    clientWidget w2;
    w.show();
    w2.show();

    return a.exec();
}

运行测试：

遇到的问题：

（1）服务器端发送头部信息之后，会定时一段时间，然后再发送文件，主要是为了解决粘包现象（如果不这么做，服务器端发送头部信息和文件时会封装在同一个包中，这样客户端就不能将其区分出来）。视频中的定时时间是20ms，但是如果我们发送的文件太小，测试发现客户端只会接收到一次readyRead信号，无法接收到文件，所以最好把定时器的时间设置大一些。

存在的bug：

（1）服务器端发送数据时，发送了头部之后，等待定时器时间到达之后，就会发送文件，是不会管客户端是否准备好了接收，那么当客户端还未准备好接收，但是服务器端已经把文件发送完毕了，这种情况下客户端是不能正确收到文件的。演示效果如下：

也就是说，我们必须在接收到头部信息之后，服务器发送文件之前客户端把文件创建好。