Qt应用程序插件开发学习笔记

开发环境：Qt Creator 11.0.2, Qt 6.2.4, MinGw 11.2.0 64-bit

代码：

//Application.pro

TEMPLATE = subdirs

SUBDIRS += \
    MyApp \
    MyPlugin

//MyApp.pro

QT       += core gui

greaterThan(QT_MAJOR_VERSION, 4): QT += widgets

CONFIG += c++17

# You can make your code fail to compile if it uses deprecated APIs.
# In order to do so, uncomment the following line.
#DEFINES += QT_DISABLE_DEPRECATED_BEFORE=0x060000    # disables all the APIs deprecated before Qt 6.0.0

SOURCES += \
    main.cpp \
    application.cpp \
    pluginloader.cpp

HEADERS += \
    Observer.h \
    PluginInterface.h \
    application.h \
    pluginloader.h

FORMS += \
    application.ui

# Default rules for deployment.
qnx: target.path = /tmp/$${TARGET}/bin
else: unix:!android: target.path = /opt/$${TARGET}/bin
!isEmpty(target.path): INSTALLS += target

//application.h

#ifndef APPLICATION_H
#define APPLICATION_H

#include <QWidget>
#include "Observer.h"
#include "PluginInterface.h"

QT_BEGIN_NAMESPACE
namespace Ui { class Application; }
QT_END_NAMESPACE

class Application : public QWidget, public Observer
{
    Q_OBJECT

public:
    Application(QWidget *parent = nullptr);
    ~Application();

    void dataAvailable(const QString& data) override; // 实现 Observer 接口方法

private slots:
    void pushButtonLoadPlugin_clicked();

private:
    Ui::Application *ui;
    QList<QSharedPointer<PluginInterface>> plugins; // 存储加载的插件
};
#endif // APPLICATION_H

//Observer.h

#ifndef OBSERVER_H
#define OBSERVER_H

#include <QString>

class Observer {
public:
    virtual void dataAvailable(const QString& data) = 0;
};

#endif // OBSERVER_H

//PluginInterface.h

#ifndef PLUGININTERFACE_H
#define PLUGININTERFACE_H

#include <QObject>
#include "Observer.h"

class PluginInterface {
public:
    virtual ~PluginInterface() = default;
    virtual void doSomething() = 0;
    virtual void addObserver(Observer* observer) = 0;
    virtual void removeObserver(Observer* observer) = 0;
    virtual void notifyObservers(const QString& data) = 0;
};
QT_BEGIN_NAMESPACE
Q_DECLARE_INTERFACE(PluginInterface, "com.example.plugin")
QT_END_NAMESPACE
#endif // PLUGININTERFACE_H

//pluginloader.h

#ifndef PLUGINLOADER_H
#define PLUGINLOADER_H

#include <QString>
#include <QSharedPointer>
#include <QList>
#include <QDir>
#include <QPluginLoader>
#include <QDebug>
#include "PluginInterface.h"

class PluginLoader {
public:
    static QList<QSharedPointer<PluginInterface>> loadPlugins(const QString& pluginsDirectory);
};

#endif // PLUGINLOADER_H

//application.cpp

#include "application.h"
#include "ui_application.h"
#include "pluginloader.h"

Application::Application(QWidget *parent)
    : QWidget(parent)
    , ui(new Ui::Application)
{
    ui->setupUi(this);
    connect(ui->pushButtonLoadPlugin, &QPushButton::clicked, this, &Application::pushButtonLoadPlugin_clicked);
    qDebug() << QCoreApplication::applicationDirPath();
}

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

void Application::dataAvailable(const QString &data)
{
    qDebug() << "Received data from plugin:" << data;
    // 在这里处理插件通知的数据
}

void Application::pushButtonLoadPlugin_clicked()
{
    qDebug() << "加载插件";
    QString pluginsDirectory = "C:/Users/Simon/Documents/build-Application-Desktop_Qt_6_2_4_MinGW_64_bit-Debug/plugins"; // 插件DLL文件所在目录
    plugins = PluginLoader::loadPlugins(pluginsDirectory);
    // 将当前应用程序作为观察者注册给加载的插件
    for (const QSharedPointer<PluginInterface>& plugin : plugins) {
        plugin->addObserver(this);
        plugin->doSomething(); // 触发插件操作，会通知应用程序
    }
}

//main.cpp

#include "application.h"

#include <QApplication>

int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    Application w;
    w.show();
    return a.exec();
}

//pluginloader.cpp

#include "pluginloader.h"


QList<QSharedPointer<PluginInterface> > PluginLoader::loadPlugins(const QString &pluginsDirectory)
{
    QList<QSharedPointer<PluginInterface>> plugins;

    QDir pluginsDir(pluginsDirectory);
    pluginsDir.setNameFilters(QStringList() << "*.dll");
    QStringList fileList = pluginsDir.entryList(QDir::Files);



    for (const QString& fileName : fileList) {

        qDebug() << fileName;

        QPluginLoader pluginLoader(pluginsDir.filePath(fileName));

        if (pluginLoader.load()) {
            QObject *pluginInstance = pluginLoader.instance();

            if (pluginInstance) {
                PluginInterface *pluginInterface = qobject_cast<PluginInterface *>(pluginInstance);

                if (pluginInterface) {
                    QSharedPointer<PluginInterface> sharedPlugin = QSharedPointer<PluginInterface>(pluginInterface);
                    plugins.append(sharedPlugin);
                } else {
                    qWarning() << "Failed to cast plugin instance to PluginInterface in" << fileName;
                }
            } else {
                qWarning() << "Failed to load plugin instance from" << fileName;
            }
        } else {
            qWarning() << "Failed to load plugin" << fileName << ":" << pluginLoader.errorString();
        }
    }

    return plugins;
}

//MyPlugin.pro

QT += gui

TEMPLATE = lib
CONFIG += plugin

CONFIG += c++17
INCLUDEPATH    += ../MyApp
DESTDIR         = ../plugins
# You can make your code fail to compile if it uses deprecated APIs.
# In order to do so, uncomment the following line.
#DEFINES += QT_DISABLE_DEPRECATED_BEFORE=0x060000    # disables all the APIs deprecated before Qt 6.0.0

SOURCES += \
    myplugin.cpp

HEADERS += \
    myplugin.h

DISTFILES += MyPlugin.json

# Default rules for deployment.
unix {
    target.path = $$[QT_INSTALL_PLUGINS]/generic
}
!isEmpty(target.path): INSTALLS += target

//myplugin.h

#ifndef MYPLUGIN_H
#define MYPLUGIN_H

#include <QObject>
#include "PluginInterface.h"

class MyPlugin : public QObject, public PluginInterface
{
    Q_OBJECT
    Q_PLUGIN_METADATA(IID "com.example.plugin" FILE "MyPlugin.json")
    Q_INTERFACES(PluginInterface)
public:
    void doSomething() override;
    void addObserver(Observer* observer) override;
    void removeObserver(Observer* observer) override;
    void notifyObservers(const QString& data) override;
private:
    void notifyDataAvailable(const QString& data);

    QString pluginData;
    Observer* observer; // 观察者指针
};

#endif // MYPLUGIN_H

//myplugin.cpp

#include "myplugin.h"
#include <QThread>

void MyPlugin::doSomething() {
    // 模拟插件操作
    QThread::sleep(3);
    pluginData = "Data from plugin";
    notifyDataAvailable(pluginData);
}

void MyPlugin::addObserver(Observer* newObserver) {
    observer = newObserver;
}

void MyPlugin::removeObserver(Observer* /* observer */) {
    observer = nullptr;
}

void MyPlugin::notifyObservers(const QString& data) {
    if (observer) {
        observer->dataAvailable(data);
    }
}

void MyPlugin::notifyDataAvailable(const QString &data)
{
    if (observer) {
        observer->dataAvailable(data);
    }
}

// MyPlugin.json

{
    "Keys" : [ ]
}

总结：

1. 定义接口（PluginInterface）： 首先定义了一个插件接口 PluginInterface，其中包含了纯虚函数来定义插件的行为和观察者模式的相关操作。

2. 定义观察者接口（Observer）： 定义了观察者接口 Observer，其中包含一个纯虚函数 dataAvailable，用于接收插件通知和数据。

3. 插件类（MyPlugin）： 实现了一个插件类 MyPlugin，它继承了 QObject 和 PluginInterface，并在其中实现了接口函数。在 doSomething 方法中，模拟插件的操作，然后通过 notifyDataAvailable 方法通知观察者。

4. 应用程序类（Application）： 创建了一个应用程序类 Application，它继承了 QWidget 和 Observer。在应用程序中，加载插件，将自己注册为观察者，然后在 dataAvailable 方法中处理插件的数据通知。

5. 插件加载（PluginLoader）： 实现了一个插件加载器 PluginLoader，用于加载插件并返回一个包含插件实例的列表。

6. 手动通知： 在插件的 doSomething 方法中，通过调用 notifyDataAvailable 方法来手动通知观察者数据可用。此法之所以不选择使用 Qt 的信号槽机制来实现类似的通知，是为了实现应用程序和插件松耦合且回避信号槽机制引入的多重继承问题。

7. 松耦合设计： 这个设计通过观察者模式实现了插件和应用程序之间的松耦合通信。插件不需要直接知道应用程序的细节，而是通过接口和观察者来进行通信。

8. 使用观察者模式： 通过观察者模式，插件在执行操作后可以通知主应用程序数据的可用性，然后应用程序可以根据需要对数据进行处理。

9. 运行和测试： 成功地运行和测试了代码，获得了预期的结果，展示了观察者模式在插件开发中的应用。

这个设计思路很好地展示了如何将观察者模式用于插件开发，以及如何通过接口和观察者模式实现插件和应用程序之间的通信。这是一个很有价值的学习和实践过程，可以将这些思想和知识应用到实际项目中。