Qt插件开辟总结6--插件间依靠

一、媒介

插件大抵可分为：功能性插件、界面插件；一个软件由一堆插件堆起来，一定难以克制插件间相互引用，比方：插件A调用了插件C中的功能，那么插件A就依靠插件C，以是在步调启动加载插件时，就应该先加载插件C，再加载插件A。
假如插件A是用于初始化的模块，插件C是用于检测软件序列合法性的模块，假如先加载插件A，并直接调勤奋能模块，那么检测软件序列合法性这部分功能就是缺失的，以是必须要检测插件间的依靠关系，并分列插件加载序次，才气使得软件功能正常。
但是插件依靠，不能形成死锁，比方：有向环

• 图1：先加载插件B和插件C，再加载插件A，即可；
  
• 图2：先加载插件C，再加载插件B，再加载插件A，即可；
  
• 图3：先加载插件C，再加载插件B，再加载插件A，即可；
  
• 图4：加载插件A必要插件B，加载插件B必要插件C，加载插件C必要插件A，就形成死锁了；
  

---

二、根本计谋

插件元数据中有一项：dependencies，这个就是用来标识该插件依靠的插件，比方：插件A依靠插件B、插件C

1. {
2.     "author" : "Wang_JC",
3.     "date" : "2022/02/16",
4.     "name" : "pluginA",
5.     "version" : "1.0.0",
6.     "des" : "这是一个插件A",
7.     "dependencies" : ["pluginB:1.0.0","pluginC:1.0.0"],
8.     "menu" : "menuFile",
9.     "action" : ["action_A1","action_A2","action_A3"],
10.     "widget" : "tabWidget"
11. }

复制代码

我们在主步调中嗅探、自动加载插件：

在加载插件的时间，我们可以读取插件元数据中的插件依靠信息，然后检测依靠；假如存在依靠，那就暂不加载；假如不存在，那就直接加载。

检测插件是否存在依靠：可以遍历当前插件依靠项

比及自动加载插件全部竣事后，我们再查抄依靠插件栈内是否有还未加载的插件，有的话，再手动加载一下：

---

三、效果展示

弄了4个插件：A、B、C、D，依靠关系如下：

• 插件A：依靠插件B和插件C
  
• 插件B：无依靠
  
• 插件C：无依靠
  
• 插件D：无依靠
  

以是加载插件时，插件B和插件C必须要在插件A之间加载，插件D无所谓

---

四、关键代码

4.1、主步调

1. #ifndef MAINWINDOW_H
2. #define MAINWINDOW_H
4. #include <QMainWindow>
5. #include <QDebug>
6. #include "PluginManager.h"
7. #include <QDir>
8. #include <QMenuBar>
9. #include <QToolBar>
10. #include <QTabWidget>
11. #include <QWidget>
12. #include <QHBoxLayout>
13. #include <QLabel>
15. #include "./Widget/speeddashbroad.h"
17. QT_BEGIN_NAMESPACE
18. namespace Ui { class MainWindow; }
19. QT_END_NAMESPACE
21. class MainWindow : public QMainWindow
22. {
23.     Q_OBJECT
25. public:
26.     MainWindow(QWidget *parent = nullptr);
27.     ~MainWindow();
29.     void Init_UI();
31.     void recvMsgFromManager(PluginMetaData metaData);
33.     QMenuBar* menuBar;
34.     QMenu* menuFile;
35.     QMenu* menuEdit;
36.     QMenu* menuView;
37.     QMenu* menuTool;
39.     QTabWidget* tabWidget;
41. public:
42.     SpeedDashBroad* sdb;
44. signals:
45.     void sendMsgToManager(PluginMetaData);
47. private slots:
48.     void slot_PluginAction_MenuBar(QString menu,QStringList actionList);    //添加插件菜单栏Action
49.     void slot_PluginsAction_trigger(bool isChecked);    //响应插件Action
51.     void slot_PluginWidget(QPluginLoader*,QString);    //添加插件widget
54. private:
55.     Ui::MainWindow *ui;
56. };
57. #endif // MAINWINDOW_H

复制代码

1. #include "mainwindow.h"
2. #include "ui_mainwindow.h"
4. MainWindow::MainWindow(QWidget *parent)
5.     : QMainWindow(parent)
6.     , ui(new Ui::MainWindow)
7. {
8.     ui->setupUi(this);
9.     Init_UI();
11.     //传递主程序指针给插件管理器
12.     PluginManager::instance()->m_mainWin = this;
13.     //绑定主程序和插件管理器消息信号槽
14.     connect(this,&MainWindow::sendMsgToManager,PluginManager::instance(),&PluginManager::recMsgFromPlugin);
16.     //嗅探到的所有插件
17.     qDebug()<<"嗅探插件: "<<PluginManager::instance()->CK_allPluginsName().keys();
19.     //加载所有插件
20.     foreach(QString pluginName , PluginManager::instance()->CK_allPluginsName().keys()) {
21.         PluginManager::instance()->loadPlugin(PluginManager::instance()->CK_allPluginsName().value(pluginName));
22.     }
24.     //加载所有插件
25. //    PluginManager::instance()->loadAllPlugins();
27.     //加载存在依赖稍候处理的插件
28.     while(!PluginManager::instance()->m_remainPlugin.isEmpty()) {
29.         QString plugin_filePath = PluginManager::instance()->m_remainPlugin.pop();
30.         qDebug()<<endl<<endl<<"加载存在依赖稍候处理的插件: "<<plugin_filePath;
32.         PluginManager::instance()->loadPlugin(plugin_filePath);
33.     }
35.     //加载其中某个插件
36. //    PluginManager::instance()->loadPlugin(PluginManager::instance()->CK_allPluginsName().value("pluginA"));
37. //    PluginManager::instance()->loadPlugin(PluginManager::instance()->CK_allPluginsName().value("pluginB"));
38. //    PluginManager::instance()->loadPlugin(PluginManager::instance()->CK_allPluginsName().value("pluginC"));
39. //    PluginManager::instance()->loadPlugin(PluginManager::instance()->CK_allPluginsName().value("pluginD"));
41. //    QPluginLoader *loader1 = PluginManager::instance()->getPlugin("pluginA");
42. //    PluginInterface* pluginInterface1 = qobject_cast<PluginInterface *>(loader1->instance());
43. //    pluginInterface1->showSomeThing("新增接口API");
45. //    QPluginLoader *loader2 = PluginManager::instance()->getPlugin("pluginB");
46. //    PluginInterface* pluginInterface2 = qobject_cast<PluginInterface *>(loader2->instance());
47. //    pluginInterface2->showSomeThing("新增接口API");
49. //    //通信测试
50. //    //================================================================================
51. //    QPluginLoader *loader1 = PluginManager::instance()->getPlugin("pluginA");
52. //    if(loader1) {
53. //        PluginInterface *pluginA = dynamic_cast<PluginInterface*>(loader1->instance());
54. //        if(pluginA) {
55. //            PluginMetaData m;
56. //            m.dest = "pluginB";
57. //            m.from = "pluginA";
58. //            m.msg = "插件A发给插件B的消息";
59. //            pluginA->sendMsgToManager(m);
60. //        }
61. //    }
63. //    QPluginLoader *loader2 = PluginManager::instance()->getPlugin("pluginB");
64. //    if(loader2) {
65. //        PluginInterface *pluginB = dynamic_cast<PluginInterface*>(loader2->instance());
66. //        if(pluginB) {
67. //            PluginMetaData m;
68. //            m.dest = "pluginA";
69. //            m.from = "pluginB";
70. //            m.msg = "插件B发给插件A的消息";
71. //            pluginB->sendMsgToManager(m);
72. //        }
73. //    }
75. //    //------------------------------
76. //    if(loader2) {
77. //        PluginInterface *pluginB = dynamic_cast<PluginInterface*>(loader2->instance());
78. //        if(pluginB) {
79. //            PluginMetaData m1;
80. //            m1.dest = "mainWin";
81. //            m1.from = "pluginB";
82. //            m1.msg = "插件B发给主程序的消息";
83. //            pluginB->sendMsgToManager(m1);
84. //        }
85. //    }
87. //    //------------------------------
88. //    PluginMetaData m2;
89. //    m2.dest = "pluginA";
90. //    m2.from = "mainWin";
91. //    m2.msg = "主程序发给插件A的消息";
92. //    this->sendMsgToManager(m2);
94. }
96. MainWindow::~MainWindow()
97. {
98.     delete ui;
99. }
101. void MainWindow::Init_UI()
102. {
103.     QWidget* p = takeCentralWidget();   //删除中央窗体
104.     if (p) {
105.         delete p;
106.     }
107.     setDockNestingEnabled(true);        //允许嵌套dock
109.     //-------------------------------------------------
111.     menuBar = new QMenuBar(this);
113.     menuFile = new QMenu("文件", this);
114.     menuBar->addMenu(menuFile);
115.     this->setMenuBar(menuBar);
117.     menuEdit = new QMenu("编辑", this);
118.     menuBar->addMenu(menuEdit);
119.     this->setMenuBar(menuBar);
121.     menuView = new QMenu("视图", this);
122.     menuBar->addMenu(menuView);
123.     this->setMenuBar(menuBar);
125.     menuTool = new QMenu("工具", this);
126.     menuBar->addMenu(menuTool);
127.     this->setMenuBar(menuBar);
129.     connect(PluginManager::instance(),&PluginManager::sig_actions,this,&MainWindow::slot_PluginAction_MenuBar);
131.     //-------------------------------------------------
133.     tabWidget = new QTabWidget(this);
134.     tabWidget->setMinimumSize(1000, 800);   // 设置最小宽高
135.     setCentralWidget(tabWidget);            // 指定为中心窗口
137.     connect(PluginManager::instance(),&PluginManager::sig_widget,this,&MainWindow::slot_PluginWidget);
139.     //-------------------------------------------------
141.     sdb = new SpeedDashBroad;
142.     tabWidget->addTab(sdb,"表盘");
143. }
145. void MainWindow::slot_PluginAction_MenuBar(QString menu,QStringList actionList)
146. {
147.     QAction * action = nullptr;
148.     if(menu == QString::fromLocal8Bit("menuFile")) {
149.         for(int i=0; i<actionList.size(); ++i) {
150.             action = new QAction(QIcon(), actionList.at(i), this);
151.             menuFile->addAction(action);
152.             connect(action,&QAction::triggered,this,&MainWindow::slot_PluginsAction_trigger);
153.         }
154.     }
155.     if(menu == QString::fromLocal8Bit("menuEdit")) {
156.         for(int i=0; i<actionList.size(); ++i) {
157.             action = new QAction(QIcon(), actionList.at(i), this);
158.             menuEdit->addAction(action);
159.             connect(action,&QAction::triggered,this,&MainWindow::slot_PluginsAction_trigger);
160.         }
161.     }
162.     if(menu == QString::fromLocal8Bit("menuView")) {
163.         for(int i=0; i<actionList.size(); ++i) {
164.             action = new QAction(QIcon(), actionList.at(i), this);
165.             menuView->addAction(action);
166.             connect(action,&QAction::triggered,this,&MainWindow::slot_PluginsAction_trigger);
167.         }
168.     }
169.     if(menu == QString::fromLocal8Bit("menuTool")) {
170.         for(int i=0; i<actionList.size(); ++i) {
171.             action = new QAction(QIcon(), actionList.at(i), this);
172.             menuTool->addAction(action);
173.             connect(action,&QAction::triggered,this,&MainWindow::slot_PluginsAction_trigger);
174.         }
175.     }
176. }
178. void MainWindow::recvMsgFromManager(PluginMetaData metaData)
179. {
180.     qDebug()<<"主程序接收到消息："<<metaData.msg;
181. }
183. void MainWindow::slot_PluginsAction_trigger(bool isChecked)
184. {
185.     QAction* action = qobject_cast<QAction*>(sender());
186.     for(int i=0; i<PluginManager::instance()->_actionMap.size(); ++i) { //遍历插件管理器action映射表
187.         if(PluginManager::instance()->_actionMap.at(i).action == action->text()) {  //映射表中匹配到Action对应的方法
188.             PluginInterface* plugin = qobject_cast<PluginInterface *>(PluginManager::instance()->_actionMap.at(i).plugin->instance());  //获取该action对应的接口指针
189.             if(plugin) {
190.                 for(int j=0; j<plugin->_actionName.size(); ++j) {   //遍历该接口指针内的action名字
191.                     if(plugin->_actionName[j] == action->text()) {
192.                         plugin->_actionFunction[j](true);
193.                         break;
194.                     }
195.                 }
196.             }
197.             break;
198.         }
199.     }
200. }
202. void MainWindow::slot_PluginWidget(QPluginLoader* loader,QString widget)
203. {
204.     if(widget == QString::fromLocal8Bit("tabWidget")) {
205.         PluginInterface* pluginInterface = qobject_cast<PluginInterface *>(loader->instance());
206.         QString pluginName = pluginInterface->_Plugin_Name;
207.         QWidget* widget = pluginInterface->_widget;
209.         if(widget) {
210.             tabWidget->addTab(widget,pluginName);
211.         }
212.     }
214.     //也可以预留布局接入点，插件UI嵌入，看自己需求
215.     if(widget == QString::fromLocal8Bit("xxxLayout")) {
217.     }
219. }

复制代码

---

4.2、插件管理器

1. #ifndef PLUGINMANAGER_H
2. #define PLUGINMANAGER_H
4. #include "../Plugin_Interface/PluginInterface.h"
5. #include <QObject>
6. #include <QPluginLoader>
7. #include <QVariant>
8. #include <QAction>
9. #include <QStack>
11. class MainWindow;
13. typedef struct manager_action_map
14. {
15.     QString action;
16.     QPluginLoader* plugin;
17. }MANAGER_ACTION_MAP;
19. class PluginManager : public QObject
20. {
21.     Q_OBJECT
22. public:
23.     explicit PluginManager(QObject *parent = nullptr);
24.     ~PluginManager();
26.     static PluginManager *instance(){
27.          if(m_instance==nullptr)
28.              m_instance=new PluginManager();
29.          return m_instance;
30.      }
32.     MainWindow* m_mainWin;
34.     QStack<QString> m_remainPlugin;
36. public:
37.     QList<MANAGER_ACTION_MAP> _actionMap;
38.     void deal_metaData(QPluginLoader* loader,QJsonObject& json);
40. public:
41.     //扫描JSON文件中的插件元数据
42.     void scanMetaData(const QString &filepath,QJsonObject& json);
44.      //加载所有插件
45.      void loadAllPlugins();
47.      //加载其中某个插件
48.      void loadPlugin(const QString &filepath);
50.      //卸载所有插件
51.      void unloadAllPlugins();
53.      //卸载某个插件
54.      void unloadPlugin(const QString &filepath);
56.      //获取所有插件名称
57.      QList<QVariant> allPluginsName();
59.      //获取所有插件
60.      QList<QPluginLoader *> allPlugins();
62.      //获取某个插件名称
63.      QVariant getPluginName(QPluginLoader *loader);
65.      //根据名称获得插件
66.      QPluginLoader* getPlugin(const QString &name);
68.      //获取库中所有插件名称
69.      QHash<QString,QString> CK_allPluginsName();
71. signals:
72.      void sig_actions(QString,QStringList);
73.      void sig_widget(QPluginLoader*,QString);
75. public slots:
76.      void recMsgFromPlugin(PluginMetaData);
78.      void slot_test();
80. private:
81.      static PluginManager *m_instance;
83.      class PluginsManagerPrivate;
84.      PluginsManagerPrivate *managerPrivate;
86. };
88. #endif // PLUGINMANAGER_H

复制代码

1. #include "PluginManager.h"
2. #include <QDir>
3. #include <QCoreApplication>
4. #include <QJsonArray>
5. #include <QDebug>
6. #include "mainwindow.h"
8. PluginManager* PluginManager::m_instance=nullptr;
10. class PluginManager::PluginsManagerPrivate
11. {
12. public:
13.     PluginsManagerPrivate()
14.     {
15.         m_names.clear();
16.         m_versions.clear();
17.         m_dependencies.clear();
18.         m_loaders.clear();
20.         m_dependencies_temp.clear();
21.     }
22.     ~PluginsManagerPrivate(){}
24.     QHash<QString, QVariant> m_names;               //插件路径--插件名称
25.     QHash<QString, QVariant> m_versions;            //插件路径--插件版本
26.     QHash<QString, QVariantList> m_dependencies;    //插件路径--插件额外依赖的其他插件
27.     QHash<QString, QPluginLoader *> m_loaders;      //插件路径--QPluginLoader实例
29.     QHash<QString, QVariantList> m_dependencies_temp;
31.     bool check(const QString &filepath)             //插件依赖检测
32.     {
33.         //qDebug()<<QString("=============== bool check(%1) ===============").arg(filepath);
34.         bool status = true;
36.         foreach (QVariant item, m_dependencies_temp.value(filepath)) {
37.             QString dependencyPluginInfo = item.toString();
38.             // 依赖的插件名称、版本、路径
39.             QStringList List = dependencyPluginInfo.split(':');
40.             QString name_str = List[0];
41.             QString version_str = List[1];
42.             QString path = m_names.key(name_str);
44.             qDebug()<<"=== 插件依赖信息 ===";
45.             qDebug()<<"name_str: "<<name_str;
46.             qDebug()<<"version_str: "<<version_str;
47.             qDebug()<<"path: "<<path;
49.             QVariant name = QVariant(name_str);
50.             QVariant version = QVariant(version_str);
52.             /********** 检测插件是否依赖于其他插件 **********/
53.             // 先检测插件名称
54.             if (!m_names.values().contains(name)) {
55.                 qDebug() << "=== 插件" << filepath <<"  缺少依赖插件:" << name.toString();
56.                 status = false;
57.                 continue;
58.             }
60.             // 再检测插件版本
61.             if (m_versions.value(path) != version) {
62.                 qDebug() << "=== 依赖插件: " << name.toString() << "当前版本为: "
63.                          << m_versions.value(m_names.key(name)).toString() << "但是需要依赖插件版本为: " << version.toString();
64.                 status = false;
65.                 continue;
66.             }
68.             // 然后，检测被依赖的插件是否还依赖于另外的插件
69.             if (!check(path)) {
70.                 qDebug() << "=== 依赖插件:" << name.toString() << "又依赖: " << path;
71.                 status = false;
72.                 continue;
73.             }
74.         }
77.         //qDebug()<<"status: "<<status;
78.         return status;
79.     }
81. };
83. PluginManager::PluginManager(QObject *parent) : QObject(parent)
84. {
85.     managerPrivate = new PluginsManagerPrivate;
86. }
87. PluginManager::~PluginManager()
88. {
89.     delete managerPrivate;
90. }
92. void PluginManager::loadAllPlugins()
93. {
94.     QDir pluginsDir(qApp->applicationDirPath());    //pluginsDir: "../build-xxx-debug/debug"
95.     if(pluginsDir.dirName().toLower() == "debug" ||
96.             pluginsDir.dirName().toLower() == "release") {
97.         pluginsDir.cdUp();  //pluginsDir: "../build-xxx-debug"
98.         pluginsDir.cdUp();  //pluginsDir: "../"
99.     }
100.     pluginsDir.cd("plugins");
102.     QFileInfoList pluginsInfo = pluginsDir.entryInfoList(QDir::Files | QDir::NoDotAndDotDot);
104.     //加载插件
105.     for(QFileInfo fileinfo : pluginsInfo)
106.         loadPlugin(fileinfo.absoluteFilePath());
107. }
109. void PluginManager::scanMetaData(const QString &filepath,QJsonObject& json)
110. {
111.     //判断是否为库（后缀有效性）
112.     if(!QLibrary::isLibrary(filepath))
113.         return;
115.     if(managerPrivate->m_names.keys().contains(filepath)) {
116.         //qDebug()<<QString("插件: %1 已加载，退出！！！").arg(filepath);
117.         return;
118.     }
120.     //获取元数据
121.     QPluginLoader *loader = new QPluginLoader(filepath);
123.     //qDebug()<<loader->metaData().keys();
124.     json = loader->metaData().value("MetaData").toObject();
125. //    for(int i=0; i<json.keys().size(); ++i) {
126. //        qDebug()<<json.keys().at(i)<< " : "<<json.value(json.keys().at(i));
127. //    }
129.     managerPrivate->m_names.insert(filepath, json.value("name").toVariant());
130.     managerPrivate->m_versions.insert(filepath, json.value("version").toVariant());
131.     managerPrivate->m_dependencies.insert(filepath, json.value("dependencies").toArray().toVariantList());
132.     //qDebug()<<"dependencies: "<<json.value("dependencies").toArray().toVariantList();
133.     //qDebug()<<"managerPrivate->m_dependencies: "<<managerPrivate->m_dependencies.values();
135.     delete loader;
136.     loader = nullptr;
137. }
139. void PluginManager::loadPlugin(const QString &filepath)
140. {
141.     //库文件类型检测
142.     if(!QLibrary::isLibrary(filepath))
143.         return;
145.     //读取当前插件依赖
146.     qDebug()<<"===========================================================================";
147.     QPluginLoader *loader_temp = new QPluginLoader(filepath);
148.     QJsonObject json_temp = loader_temp->metaData().value("MetaData").toObject();
149.     managerPrivate->m_dependencies_temp.insert(filepath, json_temp.value("dependencies").toArray().toVariantList());
150.     //qDebug()<<"managerPrivate->m_dependencies_temp: "<<managerPrivate->m_dependencies_temp;
151.     delete loader_temp;
152.     loader_temp = nullptr;
154.     qDebug()<<"@@@ 当前加载插件: "<<filepath;
156.     //检测依赖
157.     if(!managerPrivate->check(filepath)) {
158.         qDebug()<<"当前插件存在依赖，入栈，稍候处理: "<<filepath;
159.         m_remainPlugin.push(filepath);
161.         //清空当前插件依赖
162.         managerPrivate->m_dependencies_temp.clear();
164.         return;
165.     }
167.     //清空当前插件依赖
168.     managerPrivate->m_dependencies_temp.clear();
170.     //检测当前插件是否已加载
171.     if(managerPrivate->m_loaders.keys().contains(filepath)) {
172.         qDebug()<<"当前插件已加载！！！";
173.         return;
174.     }
176.     //加载插件
177.     QPluginLoader *loader = new QPluginLoader(filepath);
178.     if(loader->load()) {
179.         PluginInterface *plugin = qobject_cast<PluginInterface *>(loader->instance());
180.         if(plugin) {
181.             //检测元信息
182.             QJsonObject json;
183.             scanMetaData(filepath,json);
184.             deal_metaData(loader,json);
186.             managerPrivate->m_loaders.insert(filepath, loader);
187.             connect(loader->instance(),SIGNAL(sendMsgToManager(PluginMetaData)),
188.                     this,SLOT(recMsgFromPlugin(PluginMetaData)));
190.             //绑定
191.             if(plugin->_Plugin_Name == QString::fromLocal8Bit("PluginA")) {
192.                 //qDebug()<<"plugin->_Plugin_Name: "<<plugin->_Plugin_Name;
193.                 connect(loader->instance(),SIGNAL(sig_test()),
194.                         this,SLOT(slot_test()));
195.             }
197.             plugin->Info(QString(" %1 加载成功！").arg(plugin->_Plugin_Name));
199.         }else {
200.             delete loader;
201.             loader = nullptr;
202.         }
203.     }else{
204.         qDebug()<<"loadPlugin:"<<filepath<<loader->errorString();
205.     }
206. }
208. void PluginManager::unloadAllPlugins()
209. {
210.     for(QString filepath : managerPrivate->m_loaders.keys())
211.         unloadPlugin(filepath);
212. }
214. void PluginManager::unloadPlugin(const QString &filepath)
215. {
216.     if(!managerPrivate->m_loaders.keys().contains(filepath)) {
217.         return;
218.     }
220.     QPluginLoader *loader = managerPrivate->m_loaders.value(filepath);
221.     //卸载插件，并从内部数据结构中移除
222.     if(loader->unload()) {
223.         PluginInterface *plugin = qobject_cast<PluginInterface *>(loader->instance());
224.         if(plugin) {
225.             plugin->Info("插件卸载成功！");
226.             managerPrivate->m_loaders.remove(filepath);
227.             delete loader;
228.             loader = nullptr;
229.         }
230.     }
231. }
233. QList<QPluginLoader *> PluginManager::allPlugins()
234. {
235.     return managerPrivate->m_loaders.values();
236. }
238. QList<QVariant> PluginManager::allPluginsName()
239. {
240.     return managerPrivate->m_names.values();
241. }
243. QVariant PluginManager::getPluginName(QPluginLoader *loader)
244. {
245.     if(loader)
246.         return managerPrivate->m_names.value(managerPrivate->m_loaders.key(loader));
247.     else
248.         return "";
249. }
251. QPluginLoader *PluginManager::getPlugin(const QString &name)
252. {
253.     return managerPrivate->m_loaders.value(managerPrivate->m_names.key(name));
254. }
256. void PluginManager::recMsgFromPlugin(PluginMetaData metaData)
257. {
258.     //和主程序通信
259.     //------------------------------------------------------------
260.     if(metaData.dest == QString::fromLocal8Bit("mainWin")) {
261.         if(m_mainWin) {
262.             m_mainWin->recvMsgFromManager(metaData);
263.         }
264.         return;
265.     }
267.     //和插件通信
268.     //------------------------------------------------------------
269.     auto loader = getPlugin(metaData.dest); //目标插件
270.     if(loader) {
271.         auto interface = qobject_cast<PluginInterface*>(loader->instance());
272.         if(interface) {
273.             interface->recMsgFromManager(metaData); //转发给对应的插件
274.         }
275.     }
277. }
279. void PluginManager::slot_test()
280. {
281.     //qDebug()<<"触发槽函数: PluginManager::slot_test()";
282. }
284. QHash<QString,QString> PluginManager::CK_allPluginsName()
285. {
286.     QDir pluginsDir(qApp->applicationDirPath());    //pluginsDir: "../build-xxx-debug/debug"
287.     if(pluginsDir.dirName().toLower() == "debug" ||
288.             pluginsDir.dirName().toLower() == "release") {
289.         pluginsDir.cdUp();  //pluginsDir: "../build-xxx-debug"
290.         pluginsDir.cdUp();  //pluginsDir: "../"
291.     }
292.     pluginsDir.cd("plugins");
294.     QFileInfoList pluginsInfo = pluginsDir.entryInfoList(QDir::Files | QDir::NoDotAndDotDot);
296.     //库中插件
297.     QHash<QString,QString> pluginNames;
298.     for(QFileInfo fileinfo : pluginsInfo){
299.         if(fileinfo.fileName().contains(".dll")) {
300.             QString pluginName = fileinfo.fileName().mid(0,fileinfo.fileName().size()-4);
301.             QString pluginPath = fileinfo.filePath();
302.             pluginNames.insert(pluginName,pluginPath);
303.         }
304.     }
306.     return pluginNames;
307. }
309. void PluginManager::deal_metaData(QPluginLoader* loader,QJsonObject& json)
310. {
311.     QString name;
312.     if(json.keys().contains("name")) {
313.         QJsonValue JValue = json.value("name").toString();
314.         name = JValue.toString();
315.     }
316.     //------------------------------------------------------------
317.     QString menu;
318.     QStringList actionList;
319.     if(json.keys().contains("menu")) {
320.         QJsonValue JValue = json.value("menu").toString();
321.         menu = JValue.toString();
322.     }
323.     if(json.keys().contains("action")) {
324.        QJsonArray JArray = json.value("action").toArray();
325.        for(int i=0;i<JArray.size();++i) {
326.            actionList << JArray.at(i).toString();
328.            MANAGER_ACTION_MAP manager_action_map;
329.            manager_action_map.action = JArray.at(i).toString();
330.            manager_action_map.plugin = loader;
331.            _actionMap.push_back(manager_action_map);
332.        }
333.     }
335.     QStringList dependencies_List;
336.     if(json.keys().contains("dependencies")) {
337.        QJsonArray JArray = json.value("dependencies").toArray();
338.        for(int i=0;i<JArray.size();++i) {
339.            dependencies_List << JArray.at(i).toString();
340.        }
341.     }
342.     //qDebug()<<"dependencies_List: "<<dependencies_List;
344.     //------------------------------------------------------------
345.     if(!menu.isEmpty() && !actionList.empty()) {
346.         emit sig_actions(menu,actionList);
347.     }
348.     //------------------------------------------------------------
350.     //------------------------------------------------------------
351.     QString widget;
352.     if(json.keys().contains("widget")) {
353.         QJsonValue JValue = json.value("widget").toString();
354.         widget = JValue.toString();
356.         if(!widget.isEmpty()) {
357.             sig_widget(loader,widget);  //发送：插件对象、主界面预留接入点
358.         }
359.     }
360.     //------------------------------------------------------------
361. }

复制代码

---

4.3、插件A

pluginA.json

1. {
2.     "author" : "Wang_JC",
3.     "date" : "2022/02/16",
4.     "name" : "pluginA",
5.     "version" : "1.0.0",
6.     "des" : "这是一个插件A",
7.     "dependencies" : ["pluginB:1.0.0","pluginC:1.0.0"],
8.     "menu" : "menuFile",
9.     "action" : ["action_A1","action_A2","action_A3"],
10.     "widget" : "tabWidget"
11. }

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！qidao123.com:ToB企服之家，中国第一个企服评测及软件市场,开放入驻,技术点评得现金