欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页

MQTT客户端程序的编写

程序员文章站 2022-06-15 14:14:54
...

一、前言  

 在前面《MQTT服务器的搭建》一文中,我们介绍了EMQX。打开其帮助文档,我们可以看到:

MQTT客户端程序的编写

很开心,作为一个主流的Qt软件开发者,看到了熟悉的基于Qt框架的MQTT客户端。你可以直接下载下来,按照说明文档编译、运行和测试。当然,也可以看下面的介绍,咱们自己写一个简单的MQTT程序,实现发布和订阅消息即可。

二、QtMQTT 项目

1、库文件下载、编译和链接

Qt开发MQTT程序有两种方式,一个是Qt官方提供的基于MQTT的封装,一个是第三方(EMQ)开发的用于Qt调用MQTT的接口。我们只介绍第一种,基于Qt官方提供的封装来使用MQTT。

Qt官方虽然在2017年就已经提供了对MQTT的封装,但是并没有正式加入到Qt的标准库里面,所以需要自己下载源码进行编译。

Qt官方介绍文档地址:https://doc.qt.io/QtMQTT/qtmqtt-index.html

Qt官方在github上提供了源代码,地址:https://github.com/qt/qtmqtt

编译项目,可以得到我们需要的Qt5Mqtt.dll 及Qt5Mqtt.lib 库文件。

在Qt中,我们只需要在.pro文件中添加该库文件的链接路径即可。

其次,请记得将你的QtMqtt项目文件夹拷贝到 你指定的编译器下 include文件夹中(如果已经存在请忽略)。如下图

MQTT客户端程序的编写

 2、客户端项目程序编写

在自己编写之前,我们先看一下

/******************************************************************************
**
** Copyright (C) 2017 The Qt Company Ltd.
** Contact: https://www.qt.io/licensing/
**
** This file is part of the QtMqtt module.
**
** $QT_BEGIN_LICENSE:GPL$
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and The Qt Company. For licensing terms
** and conditions see https://www.qt.io/terms-conditions. For further
** information use the contact form at https://www.qt.io/contact-us.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3 or (at your option) any later version
** approved by the KDE Free Qt Foundation. The licenses are as published by
** the Free Software Foundation and appearing in the file LICENSE.GPL3
** included in the packaging of this file. Please review the following
** information to ensure the GNU General Public License requirements will
** be met: https://www.gnu.org/licenses/gpl-3.0.html.
**
** $QT_END_LICENSE$
**
******************************************************************************/

#ifndef QTMQTTCLIENT_H
#define QTMQTTCLIENT_H

#include <QtMqtt/qmqttglobal.h>
#include <QtMqtt/qmqttauthenticationproperties.h>
#include <QtMqtt/qmqttconnectionproperties.h>
#include <QtMqtt/qmqttpublishproperties.h>
#include <QtMqtt/qmqttsubscription.h>
#include <QtMqtt/qmqttsubscriptionproperties.h>
#include <QtMqtt/qmqtttopicfilter.h>

#include <QtCore/QIODevice>
#include <QtCore/QObject>
#include <QtCore/QSharedPointer>
#include <QtNetwork/QTcpSocket>

QT_BEGIN_NAMESPACE

class QMqttClientPrivate;

class /*Q_MQTT_EXPORT*/ QMqttClient : public QObject
{
public:
    enum TransportType {
        IODevice = 0,
        AbstractSocket,
        SecureSocket
    };
    enum ClientState {
        Disconnected = 0,
        Connecting,
        Connected
    };
    enum ClientError {
        // Protocol states
        NoError                = 0,
        InvalidProtocolVersion = 1,
        IdRejected             = 2,
        ServerUnavailable      = 3,
        BadUsernameOrPassword  = 4,
        NotAuthorized          = 5,
        // Qt states
        TransportInvalid       = 256,
        ProtocolViolation,
        UnknownError,
        Mqtt5SpecificError
    };
    enum ProtocolVersion {
        MQTT_3_1 = 3,
        MQTT_3_1_1 = 4,
        MQTT_5_0 = 5
    };

private:
    Q_OBJECT
    Q_ENUMS(ClientState)
    Q_ENUMS(ClientError)
    Q_PROPERTY(QString clientId READ clientId WRITE setClientId NOTIFY clientIdChanged)
    Q_PROPERTY(QString hostname READ hostname WRITE setHostname NOTIFY hostnameChanged)
    Q_PROPERTY(quint16 port READ port WRITE setPort NOTIFY portChanged)
    Q_PROPERTY(quint16 keepAlive READ keepAlive WRITE setKeepAlive NOTIFY keepAliveChanged)
    Q_PROPERTY(ProtocolVersion protocolVersion READ protocolVersion WRITE setProtocolVersion NOTIFY protocolVersionChanged)
    Q_PROPERTY(ClientState state READ state WRITE setState NOTIFY stateChanged)
    Q_PROPERTY(ClientError error READ error WRITE setError NOTIFY errorChanged)
    Q_PROPERTY(QString username READ username WRITE setUsername NOTIFY usernameChanged)
    Q_PROPERTY(QString password READ password WRITE setPassword NOTIFY passwordChanged)
    Q_PROPERTY(bool cleanSession READ cleanSession WRITE setCleanSession NOTIFY cleanSessionChanged)
    Q_PROPERTY(QString willTopic READ willTopic WRITE setWillTopic NOTIFY willTopicChanged)
    Q_PROPERTY(QByteArray willMessage READ willMessage WRITE setWillMessage NOTIFY willMessageChanged)
    Q_PROPERTY(quint8 willQoS READ willQoS WRITE setWillQoS NOTIFY willQoSChanged)
    Q_PROPERTY(bool willRetain READ willRetain WRITE setWillRetain NOTIFY willRetainChanged)
public:
    explicit QMqttClient(QObject *parent = nullptr);

    void setTransport(QIODevice *device, TransportType transport);
    QIODevice *transport() const;

    QMqttSubscription *subscribe(const QMqttTopicFilter &topic, quint8 qos = 0);
    QMqttSubscription *subscribe(const QMqttTopicFilter &topic,
                                 const QMqttSubscriptionProperties &properties, quint8 qos = 0);
    void unsubscribe(const QMqttTopicFilter &topic);
    void unsubscribe(const QMqttTopicFilter &topic, const QMqttUnsubscriptionProperties &properties);

    Q_INVOKABLE qint32 publish(const QMqttTopicName &topic, const QByteArray &message = QByteArray(),
                 quint8 qos = 0, bool retain = false);
    Q_INVOKABLE qint32 publish(const QMqttTopicName &topic, const QMqttPublishProperties &properties,
                               const QByteArray &message = QByteArray(),
                               quint8 qos = 0,
                               bool retain = false);

    bool requestPing();

    QString hostname() const;
    quint16 port() const;
    QString clientId() const;
    quint16 keepAlive() const;
    ProtocolVersion protocolVersion() const;

    Q_INVOKABLE void connectToHost();
#ifndef QT_NO_SSL
    Q_INVOKABLE void connectToHostEncrypted(const QString &sslPeerName = QString());
#endif
    Q_INVOKABLE void disconnectFromHost();

    ClientState state() const;
    ClientError error() const;

    QString username() const;
    QString password() const;
    bool cleanSession() const;

    QString willTopic() const;
    quint8 willQoS() const;
    QByteArray willMessage() const;
    bool willRetain() const;

    void setConnectionProperties(const QMqttConnectionProperties &prop);
    QMqttConnectionProperties connectionProperties() const;

    void setLastWillProperties(const QMqttLastWillProperties &prop);
    QMqttLastWillProperties lastWillProperties() const;

    QMqttServerConnectionProperties serverConnectionProperties() const;

    void authenticate(const QMqttAuthenticationProperties &prop);
Q_SIGNALS:
    void connected();
    void disconnected();
    void messageReceived(const QByteArray &message, const QMqttTopicName &topic = QMqttTopicName());
    void messageStatusChanged(qint32 id, QMqtt::MessageStatus s, const QMqttMessageStatusProperties &properties);
    void messageSent(qint32 id);
    void pingResponseReceived();
    void brokerSessionRestored();

    void hostnameChanged(QString hostname);
    void portChanged(quint16 port);
    void clientIdChanged(QString clientId);
    void keepAliveChanged(quint16 keepAlive);
    void protocolVersionChanged(ProtocolVersion protocolVersion);
    void stateChanged(ClientState state);
    void errorChanged(ClientError error);
    void usernameChanged(QString username);
    void passwordChanged(QString password);
    void cleanSessionChanged(bool cleanSession);

    void willTopicChanged(QString willTopic);
    void willQoSChanged(quint8 willQoS);
    void willMessageChanged(QByteArray willMessage);
    void willRetainChanged(bool willRetain);

    void authenticationRequested(const QMqttAuthenticationProperties &p);
    void authenticationFinished(const QMqttAuthenticationProperties &p);
public Q_SLOTS:
    void setHostname(const QString &hostname);
    void setPort(quint16 port);
    void setClientId(const QString &clientId);
    void setKeepAlive(quint16 keepAlive);
    void setProtocolVersion(ProtocolVersion protocolVersion);
    void setState(ClientState state);
    void setError(ClientError error);
    void setUsername(const QString &username);
    void setPassword(const QString &password);
    void setCleanSession(bool cleanSession);

    void setWillTopic(const QString &willTopic);
    void setWillQoS(quint8 willQoS);
    void setWillMessage(const QByteArray &willMessage);
    void setWillRetain(bool willRetain);

private:
    void connectToHost(bool encrypted, const QString &sslPeerName);
    Q_DISABLE_COPY(QMqttClient)
    Q_DECLARE_PRIVATE(QMqttClient)
};

Q_DECLARE_TYPEINFO(QMqttClient::TransportType, Q_PRIMITIVE_TYPE);
Q_DECLARE_TYPEINFO(QMqttClient::ClientState, Q_PRIMITIVE_TYPE);
Q_DECLARE_TYPEINFO(QMqttClient::ClientError, Q_PRIMITIVE_TYPE);

QT_END_NAMESPACE

Q_DECLARE_METATYPE(QMqttClient::TransportType)
Q_DECLARE_METATYPE(QMqttClient::ClientState)
Q_DECLARE_METATYPE(QMqttClient::ClientError)

#endif // QTMQTTCLIENT_H

重点关注QMqttClient中的信号函数和对应的槽函数,这将是我们使用QMqttClient实例化一个mqtt客户端对象后操作的重点。

SLOTS:

void setHostname(const QString &hostname);  //用于设置即将连接的Mqtt服务器。

void setPort(quint16 port); // 设置端口号(与Mqtt服务器一致)

void setUsername(const QString &username); //   设置用户名
void setPassword(const QString &password);  // 设置密码

 void connectToHost(bool encrypted, const QString &sslPeerName); // 连接到服务器,如果需要SSL加密,可以对应设置

SIGNALS: 

void connected();  // 当客户端与服务器连接上,此信号将被触发
void disconnected(); // 当客户端与服务器断开连接,此信号将被触发
void messageReceived(const QByteArray &message, const QMqttTopicName &topic = QMqttTopicName()); // 当有消息被接受到,此信号被触发。参数包含消息内容和对应的topic。显然,我们订阅一个主题后,异步接收消息就全靠这个信号了。
void pingResponseReceived();  // MQTT客户端与服务器之间会定时发送ping包,类似于心跳检测客户端与服务器之间的通信是否连接正常。当服务器端有ping包的确认消息返回,此消息被触发。

// 下面还有其他的一些状态改变触发的信号,不做详细解释

void hostnameChanged(QString hostname);
void portChanged(quint16 port);
void keepAliveChanged(quint16 keepAlive);
void protocolVersionChanged(ProtocolVersion protocolVersion);
void stateChanged(ClientState state);
void errorChanged(ClientError error);
void usernameChanged(QString username);
void passwordChanged(QString password);
void cleanSessionChanged(bool cleanSession);

  

 

记得将mqtt文件夹拷贝到项目文件目录下,如下图:

MQTT客户端程序的编写

好了,代码开干:

// mqttclientwindow.h

#ifndef MQTTCLIENTWINDOW_H
#define MQTTCLIENTWINDOW_H

#include <QWidget>
#include "mqtt/qmqttclient.h"

namespace Ui {
class MqttClientWindow;
}

class MqttClientWindow : public QWidget
{
    Q_OBJECT

public:
    explicit MqttClientWindow(QWidget *parent = nullptr);
    ~MqttClientWindow();
public slots:
    void on_pub_pushButton_clicked();

    void on_connect_pushButton_clicked();

    void on_sub_pushButton_clicked();

    void onMessageReceived(const QByteArray &message, const QMqttTopicName &topic = QMqttTopicName());
    void onPingResponseReceived();
    void onConnected();
    void onDisconnected();
private:
    Ui::MqttClientWindow *ui;
    QMqttClient* client;
};

#endif // MQTTCLIENTWINDOW_H
// mqttclientwindow.cpp

#include "mqttclientwindow.h"
#include "ui_mqttclientwindow.h"
#include <QDebug>
#include <QDateTime>
#include <QHostAddress>

MqttClientWindow::MqttClientWindow(QWidget *parent) :
    QWidget(parent),
    ui(new Ui::MqttClientWindow)
{
    ui->setupUi(this);
    client = new QMqttClient;
    QObject::connect(client,SIGNAL(connected()),this,SLOT(onConnected()));
    QObject::connect(client,SIGNAL(disconnected()),this,SLOT(onDisconnected()));
    QObject::connect(client, SIGNAL(messageReceived(const QByteArray&, const QMqttTopicName&)),this, SLOT(onMessageReceived(const QByteArray &, const QMqttTopicName &)));
    QObject::connect(client,SIGNAL(pingResponseReceived()), this, SLOT(onPingResponseReceived()));
}

MqttClientWindow::~MqttClientWindow()
{
    if(client->state() == QMqttClient::Connected){
        client->disconnectFromHost();
    }
    delete ui;
}

void MqttClientWindow::on_pub_pushButton_clicked()
{
    if(client->publish(ui->pub_topic_lineEdit->text(),ui->pub_message_lineEdit->text().toUtf8()) == -1){
        qDebug() <<" Could not publish message";
    }
}


void MqttClientWindow::on_connect_pushButton_clicked()
{
    //未连接服务器则连接
    if (client->state() == QMqttClient::Disconnected) {
        ui-> connect_pushButton->setText(tr("Disconnect"));
        client->setHostname("127.0.0.1");
        client->setPort(ui->port_lineEdit->text().trimmed().toUInt());
        client->setUsername("James");
        client->setPassword("james");
        ui->host_lineEdit->setEnabled(false);
        ui->port_lineEdit->setEnabled(false);
        client->connectToHost();
    } else {//断开连接
        ui->connect_pushButton->setText(tr("Connect"));
        ui->host_lineEdit->setEnabled(true);
        ui->port_lineEdit->setEnabled(true);
        client->disconnectFromHost();
    }
}


void MqttClientWindow::on_sub_pushButton_clicked()
{
    client->subscribe(ui->sub_lineEdit->text());
}


void MqttClientWindow::onMessageReceived(const QByteArray &message, const QMqttTopicName &topic)
{
    const QString content = QDateTime::currentDateTime().toString()
            + QLatin1String(" Received Topic: ")
            + topic.name()
            + QLatin1String(" Message: ")
            + message
            + QLatin1Char('\n');
    ui->sub_textEdit->append(content);
}

void MqttClientWindow::onPingResponseReceived()
{
    const QString content = QDateTime::currentDateTime().toString()
            + QLatin1String(" PingResponse")
            + QLatin1Char('\n');
    ui->sub_textEdit->append(content);
}


void MqttClientWindow::onConnected()
{
    ui->sub_textEdit->append("has connected to server");

}

void MqttClientWindow::onDisconnected()
{
    ui->sub_textEdit->append("has disConnected to server");
}

 

// main.cpp

#include "mqttclientwindow.h"
#include <QApplication>

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

    return a.exec();
}