Qt编程：ExtensionSystem 插件框架详解-CSDN博客

本文链接：https://blog.csdn.net/WaitingHereFor/article/details/148702506

框架架构

ExtensionSystem 是 QtCreator 采用的微内核架构实现，核心设计思想是"核心小、功能插件化"。一种用于实现插件化架构的框架或系统，它允许软件通过加载外部插件来扩展其功能。这样的设计使得应用程序能够保持核心代码的简洁与稳定，同时提供灵活性以适应不同的需求和场景。

核心概念

插件（Plugin）：插件是实现了特定接口或继承自某个基类的独立模块，它可以向主程序添加新功能而不必修改主程序本身。
宿主应用（Host Application）：这是指使用插件框架的应用程序本身，它负责发现、加载和管理插件。
插件描述符（Plugin Descriptor）：通常是一个配置文件或元数据，用来描述插件的基本信息，如名称、版本、作者等，以及插件与其他组件之间的依赖关系。
插件生命周期（Plugin Lifecycle）：包括插件的安装、启动、停止和卸载等过程，良好的插件框架会提供相应的API来管理这些状态转换。
服务（Service）：某些插件框架支持插件之间或插件与宿主应用之间通过定义的服务进行交互。

主要特点

动态性：能够在不重启应用程序的情况下加载或卸载插件。
隔离性：每个插件在自己的环境中运行，减少了相互影响的风险。
可扩展性：易于增加新的功能模块，不需要对现有代码做大量改动。
模块化：促进代码的重用和维护。

1.1 层次结构

应用层
  └── 插件管理层 (PluginManager)
       ├── 插件接口层 (IPlugin)
       ├── 插件集合 (PluginCollection)
       └── 插件描述系统 (PluginSpec)

1.2 核心类关系

核心机制详解

2.1 插件加载流程

扫描阶段：
- 遍历插件目录查找所有动态库
- 解析每个插件的JSON元数据
- 创建PluginSpec对象存储插件信息

依赖解析：

// 示例依赖声明
"Dependencies": [
    {"Name": "Core", "Version": "1.0.0"},
    {"Name": "TextEditor", "Version": "3.2.0"}
]

使用拓扑排序确定加载顺序
自动处理循环依赖检测

加载顺序：
- 先加载无依赖的插件
- 按依赖层级逐层加载
- 同一层级按插件名称字母序加载

2.2 生命周期管理

bool MyPlugin::initialize(const QStringList &args, QString *err)
{
    // 1. 初始化阶段：注册基础服务
    addAutoReleasedObject(new MyService(this));
    
    // 2. 检查依赖插件是否可用
    auto core = PluginManager::getObject<CoreService>();
    if(!core) {
        *err = "Core service not available";
        return false;
    }
    return true;
}

void MyPlugin::extensionsInitialized()
{
    // 3. 所有插件初始化完成后执行
    connect(PluginManager::getObject<SignalEmitter>(),
            &SignalEmitter::ready,
            this, &MyPlugin::onSystemReady);
}

IPlugin::ShutdownFlag MyPlugin::aboutToShutdown()
{
    // 4. 关闭前清理
    saveSettings();
    return SynchronousShutdown;
}

高级特性

3.1 延迟初始化

// 在插件A中声明需要插件B的功能
void PluginA::initialize()
{
    auto dep = PluginManager::pluginSpec("PluginB");
    if(dep && dep->state() == PluginSpec::Running) {
        initDependentComponents();
    } else {
        connect(PluginManager::instance(), &PluginManager::pluginLoaded,
                this, [this](PluginSpec *spec){
                    if(spec->name() == "PluginB")
                        initDependentComponents();
                });
    }
}

3.2 对象池机制

// 注册服务对象
PluginManager::addObject(new DatabaseService);

// 获取服务对象（跨插件调用）
auto db = PluginManager::getObject<DatabaseService>();
db->executeQuery("SELECT...");

// 自动释放示例
PluginManager::addAutoReleasedObject(new TempService);

3.3 插件通信方式

直接调用（通过对象池）
信号槽连接

// 插件A发射信号
connect(this, &PluginA::dataReady,
        PluginManager::getObject<DataProcessor>(),
        &DataProcessor::handleData);

事件总线（扩展实现）

服务接口（推荐方式）

class IEditorService {
public:
    virtual QWidget *createEditor() = 0;
    virtual void saveContent() = 0;
};

插件开发实践

4.1 插件设计原则

单一职责：每个插件只解决一个特定问题
接口隔离：通过抽象接口进行交互
显式依赖：所有依赖必须在json中声明
异常安全：初始化失败时应不影响其他插件

4.2 性能优化

// 延迟加载示例
"MetaData": {
    "Required": false,
    "IsExperimental": true,
    "LoadPolicy": "OnDemand"  // 或"Always"
}

// 按需加载实现
void MainWindow::onActionTriggered()
{
    auto spec = PluginManager::pluginSpec("AdvancedFeature");
    if(spec->state() == PluginSpec::Stopped) {
        PluginManager::loadPlugin(spec);
    }
}

4.3 调试技巧

# 运行时查看插件加载信息
QT_DEBUG_PLUGINS=1 ./yourapp

# 常用调试点
- PluginManager::loadQueue()  # 查看加载顺序
- PluginSpec::errorString()   # 获取插件错误信息

扩展开发

5.1 自定义扩展点

// 定义扩展接口
class IThemeProvider {
public:
    virtual QColor themeColor() const = 0;
    virtual QString themeName() const = 0;
};

// 实现扩展
class DarkTheme : public IThemeProvider {
    QColor themeColor() const override { return Qt::darkGray; }
    QString themeName() const override { return "Dark"; }
};

// 注册扩展
PluginManager::addObject(new DarkTheme);

// 使用扩展
auto themes = PluginManager::getObjects<IThemeProvider>();

5.2 动态插件管理

// 运行时安装插件
void installPlugin(const QString &path) {
    PluginSpec *spec = PluginManager::loadPlugin(path);
    if(spec->state() == PluginSpec::Running) {
        spec->plugin()->initialize();
    }
}

// 热卸载插件（需谨慎）
void unloadPlugin(const QString &name) {
    if(auto spec = PluginManager::pluginSpec(name)) {
        spec->plugin()->aboutToShutdown();
        PluginManager::unloadPlugin(spec);
    }
}

该框架特别适合需要长期维护的大型Qt项目，通过良好的插件划分可以实现：

团队并行开发（不同团队负责不同插件）
灵活的部署方式（按需加载插件）
稳定的核心系统（核心与功能解耦）
便捷的第三方扩展（通过插件接口规范）

完整插件开发示例

下面将展示一个完整的基于ExtensionSystem的插件开发示例，包含主程序框架和两个插件（核心插件和功能插件）的实现。

工程结构

PluginDemo/
├── app/                    # 主程序
│   ├── main.cpp
│   └── app.pro
├── plugins/
│   ├── core/               # 核心插件
│   │   ├── coreplugin.cpp
│   │   ├── coreplugin.h
│   │   ├── coreplugin.json
│   │   └── core.pro
│   └── calculator/         # 计算器功能插件
│       ├── calculatorplugin.cpp
│       ├── calculatorplugin.h
│       ├── calculatorplugin.json
│       └── calculator.pro
└── PluginDemo.pro          # 总工程文件

1. 主程序实现

app.pro

QT += core widgets
CONFIG += c++11

TARGET = PluginDemo
DESTDIR = $$PWD/../bin

HEADERS += 
SOURCES += main.cpp

LIBS += -L$$PWD/../bin -lcore -lcalculator

main.cpp

#include <QApplication>
#include <extensionsystem/pluginmanager.h>
#include <QDebug>

using namespace ExtensionSystem;

int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    
    // 初始化插件管理器
    PluginManager pluginManager;
    pluginManager.setPluginPaths({QString("%1/../plugins").arg(QCoreApplication::applicationDirPath())});
    
    // 加载插件
    const auto plugins = pluginManager.loadPlugins();
    qDebug() << "Loaded plugins:";
    for (PluginSpec *spec : plugins) {
        qDebug() << " -" << spec->name() << spec->version();
    }
    
    // 执行插件初始化
    pluginManager.initializePlugins();
    
    // 获取计算器服务并演示
    QObject *calculator = pluginManager.getObject("CalculatorService");
    if (calculator) {
        QMetaObject::invokeMethod(calculator, "showCalculator");
    } else {
        qWarning() << "Calculator plugin not available!";
    }
    
    return a.exec();
}

2. 核心插件实现

core.pro

QT += core widgets
CONFIG += plugin c++11

TARGET = core
TEMPLATE = lib
DESTDIR = $$PWD/../../bin

HEADERS += coreplugin.h
SOURCES += coreplugin.cpp

DEFINES += COREPLUGIN_LIBRARY

coreplugin.h

#ifndef CORE_PLUGIN_H
#define CORE_PLUGIN_H

#include <extensionsystem/iplugin.h>

namespace Core {
class CorePlugin : public ExtensionSystem::IPlugin
{
    Q_OBJECT
    Q_PLUGIN_METADATA(IID "org.qt-project.PluginDemo.CorePlugin" FILE "coreplugin.json")
    
public:
    CorePlugin();
    ~CorePlugin() override;
    
    bool initialize(const QStringList &arguments, QString *errorString) override;
    void extensionsInitialized() override;
    ShutdownFlag aboutToShutdown() override;
};
} // namespace Core

#endif // CORE_PLUGIN_H

coreplugin.cpp

#include "coreplugin.h"
#include <QDebug>

namespace Core {

CorePlugin::CorePlugin() = default;
CorePlugin::~CorePlugin() = default;

bool CorePlugin::initialize(const QStringList &arguments, QString *errorString)
{
    Q_UNUSED(arguments)
    Q_UNUSED(errorString)
    
    qDebug() << "Core plugin initialized";
    return true;
}

void CorePlugin::extensionsInitialized()
{
    qDebug() << "Core plugin extensions initialized";
}

ExtensionSystem::IPlugin::ShutdownFlag CorePlugin::aboutToShutdown()
{
    qDebug() << "Core plugin about to shutdown";
    return SynchronousShutdown;
}

} // namespace Core

coreplugin.json

{
    "Name": "Core",
    "Version": "1.0.0",
    "Vendor": "PluginDemo",
    "Copyright": "(C) 2023 PluginDemo",
    "License": "MIT",
    "Dependencies": []
}

3. 计算器插件实现

calculator.pro

QT += core widgets gui
CONFIG += plugin c++11

TARGET = calculator
TEMPLATE = lib
DESTDIR = $$PWD/../../bin

HEADERS += calculatorplugin.h \
           calculatorservice.h
SOURCES += calculatorplugin.cpp \
           calculatorservice.cpp

DEFINES += CALCULATORPLUGIN_LIBRARY

calculatorplugin.h

#ifndef CALCULATOR_PLUGIN_H
#define CALCULATOR_PLUGIN_H

#include <extensionsystem/iplugin.h>

namespace Calculator {
class CalculatorService;

class CalculatorPlugin : public ExtensionSystem::IPlugin
{
    Q_OBJECT
    Q_PLUGIN_METADATA(IID "org.qt-project.PluginDemo.CalculatorPlugin" FILE "calculatorplugin.json")
    
public:
    CalculatorPlugin();
    ~CalculatorPlugin() override;
    
    bool initialize(const QStringList &arguments, QString *errorString) override;
    void extensionsInitialized() override;
    ShutdownFlag aboutToShutdown() override;
    
private:
    CalculatorService *m_service = nullptr;
};
} // namespace Calculator

#endif // CALCULATOR_PLUGIN_H

calculatorplugin.cpp

#include "calculatorplugin.h"
#include "calculatorservice.h"
#include <extensionsystem/pluginmanager.h>
#include <QDebug>

namespace Calculator {

CalculatorPlugin::CalculatorPlugin() = default;
CalculatorPlugin::~CalculatorPlugin() = default;

bool CalculatorPlugin::initialize(const QStringList &arguments, QString *errorString)
{
    Q_UNUSED(arguments)
    Q_UNUSED(errorString)
    
    m_service = new CalculatorService;
    ExtensionSystem::PluginManager::addObject(m_service);
    
    qDebug() << "Calculator plugin initialized";
    return true;
}

void CalculatorPlugin::extensionsInitialized()
{
    qDebug() << "Calculator plugin extensions initialized";
}

ExtensionSystem::IPlugin::ShutdownFlag CalculatorPlugin::aboutToShutdown()
{
    ExtensionSystem::PluginManager::removeObject(m_service);
    delete m_service;
    m_service = nullptr;
    
    qDebug() << "Calculator plugin about to shutdown";
    return SynchronousShutdown;
}

} // namespace Calculator

calculatorservice.h

#ifndef CALCULATOR_SERVICE_H
#define CALCULATOR_SERVICE_H

#include <QObject>
#include <QDialog>

class QLineEdit;
class QPushButton;

class CalculatorService : public QObject
{
    Q_OBJECT
public:
    explicit CalculatorService(QObject *parent = nullptr);
    ~CalculatorService() override;

public slots:
    void showCalculator();
    void calculate();

private:
    QDialog *m_dialog = nullptr;
    QLineEdit *m_input = nullptr;
    QLineEdit *m_result = nullptr;
};

#endif // CALCULATOR_SERVICE_H

calculatorservice.cpp

#include "calculatorservice.h"
#include <QVBoxLayout>
#include <QLabel>
#include <QRegExpValidator>

CalculatorService::CalculatorService(QObject *parent)
    : QObject(parent)
{
    m_dialog = new QDialog;
    m_dialog->setWindowTitle("Calculator");
    
    QVBoxLayout *layout = new QVBoxLayout(m_dialog);
    
    m_input = new QLineEdit;
    m_input->setValidator(new QRegExpValidator(QRegExp("[0-9+\\-*/() ]*"), m_input));
    
    m_result = new QLineEdit;
    m_result->setReadOnly(true);
    
    QPushButton *calcBtn = new QPushButton("Calculate");
    connect(calcBtn, &QPushButton::clicked, this, &CalculatorService::calculate);
    
    layout->addWidget(new QLabel("Expression:"));
    layout->addWidget(m_input);
    layout->addWidget(new QLabel("Result:"));
    layout->addWidget(m_result);
    layout->addWidget(calcBtn);
}

CalculatorService::~CalculatorService()
{
    delete m_dialog;
}

void CalculatorService::showCalculator()
{
    m_dialog->show();
}

void CalculatorService::calculate()
{
    QString expr = m_input->text();
    QScriptEngine engine;
    QScriptValue result = engine.evaluate(expr);
    
    if (engine.hasUncaughtException()) {
        m_result->setText("Error");
    } else {
        m_result->setText(result.toString());
    }
}

calculatorplugin.json

{
    "Name": "Calculator",
    "Version": "1.0.0",
    "Vendor": "PluginDemo",
    "Copyright": "(C) 2023 PluginDemo",
    "License": "MIT",
    "Dependencies": [
        {"Name": "Core", "Version": "1.0.0"}
    ]
}

4. 工程文件 (PluginDemo.pro)

TEMPLATE = subdirs
CONFIG += ordered

SUBDIRS = \
    app \
    plugins/core \
    plugins/calculator

app.depends = plugins/core plugins/calculator
plugins/calculator.depends = plugins/core