Qt5 - 插件管理(一)

最近第一次接触Qt的插件，也是第一次使用插件框架去实现一个独立的小软件，记录一下对Qt插件的理解。
我认为比较重要的概念，Qt中的插件，有两点，一是插件实质就是动态库，二是插件需要符合既定的接口标准，因为程序要识别插件，就必须制定一套接口标准供插件实现，这样在一堆动态库中加载到合法的插件。

Qt插件框架

参考了网上许多前辈的资料，自己也简单写了一个Qt插件管理框架demo，核心部分就是插件管理器(实质是一个QMap<插件名, 插件实例>的映射表)。主要功能有：

• 从指定目录中加载合法插件
• 直接加载指定插件
• 卸载插件
• 插件间消息交互/通信
  

1. 插件接口

起始插件接口就好像招标一样的，我把标书给出来，符合要求的厂家我才要。iPluginInterface就是标书，我的插件管理器要求每个合格的插件必须实现iPluginInterface中的接口，这样我才能保证能从插件中获取想要的信息。
对于插件接口的规定：

a. uniId，每个插件实例都需要有一个唯一的标识，这个标识是实例唯一，而不是插件唯一，是因为同一个插件在同一进程中可能会被加载多次(插件复用)，因此需要有一个针对每个插件实例的唯一编号，方便查找、操作对应的插件实例。
b. 插件名，因为uniId可能仅仅是一个编码，为了更直观地看出插件信息，规定了插件名。
c. 插件描述信息。
d. 因为我这里的插件接口是控件接口，所以我规定每个插件都会有一个主控件centerWidget。
e. 为了实现插件间的通信，以及尽可能使用Qt自身的信号与槽机制，接口声明了一个customConnect()、一个信号sg_iPluginInterface_signal()以及一个槽函数sl_iPluginInterface_slot()。以前写QT都一直以为信号与槽不能定义接口函数，这次学到并且实践了用接口(纯虚函数)定义信号和槽的方法。

/*** @file   iplugininterface.h* @brief  自定义插件框架接口* @note   1. 如果自定义插件需要使用此框架的插件管理器，插件必须实现此接口*         2. 为了支持静态插件加载，每个插件实现必须在构造函数中使用Q_INIT_RESOURCE静态导入资源*              TestPluginInstance1::TestPluginInstance1()*              {*              #ifdef BUILD_QT_STATIC*                  Q_INIT_RESOURCE(testplugin1);*              #endif**                  translate(":/translate/testplugin1.qm");*              }**         3. 导入多个静态插件时，建议在main()函数处统一导入，宏括号内是插件实现的类名*              #ifdef BUILD_QT_STATIC*              Q_IMPORT_PLUGIN(TestPluginInstance1)*              Q_IMPORT_PLUGIN(TestPluginInstance2)*              #endif**         4. 插件实现中用到的.json配置文件必须和插件实现的源文件在同一目录** @author lixingye* @date   2021-09-13*/#ifndef IPLUGININTERFACE_H
#define IPLUGININTERFACE_H#include "ipluginroute.h"
#include "qt_plugin_def.h"#include <QObject>
#include <QTranslator>namespace x_qtplugin
{class BASE_PLUGIN_API iPluginInterface
{
private:QString             m_id;QString             m_name;QString             m_description;iPluginInterface   *m_pParent;iPluginRoute       *m_pRoute;QTranslator        *m_pTranslator;public:X_CLASS_INFO()iPluginInterface();/*** @brief       设置插件唯一标识* @param [in]  id      - 插件唯一标识*/virtual void        setUniId(const QString &id);/*** @brief       获取插件唯一标识** @return      插件唯一标识符*/virtual QString     uniId();/*** @brief       设置插件名称* @note        默认值是类名，如果调用此函数重新设置，则为新名字* @param [in]  name    - 插件名*/virtual void        setName(const QString &name);/*** @brief       获取插件名* @note        以类名作为插件名** @return      插件名*/virtual QString     name();/*** @brief       设置插件描述信息* @param [in]  descrip     - 插件描述信息*/virtual void        setDescription(const QString &descrip);/*** @brief       获取插件描述信息** @return      插件描述信息*/virtual QString     description();/*** @brief       设置父插件* @param [in]  pParent     - 父插件*/virtual void        setParent(iPluginInterface *pParent);/*** @brief       加载翻译文件* @param[in]   翻译文件所在目录** @return*      - -1    - 翻译文件加载失败*      -  0    - 翻译文件加载成功*/virtual int         translate(const QString &dir);/*** @brief       插件将自身的信号sg_iPluginInterface_signal连接到目标对象的槽函数* @note        由于QT的connect需要QObject以及声明Q_OBJECT宏，所以此函数留给具体插件实现** @param[in]   receiver    - 中转对象/路由对象指针* @param[in]   pRecSlot    - 中转对象/路由对象的槽函数* @param[in]   ifConnect   - 建立连接/解除连接标志，true为建立连接，false为解除连接** @return*      - false - 建立连接失败*      - true  - 建立连接成功** @note        receiver指示的标对象一般为路由器，作中转信号作用，用于实现插件间的通信*              receiver通常是直接归属Qt继承体系的类，如继承QObject*/virtual bool        customConnect(QObject *receiver, const char *pRecSlot, bool ifConnect = true)   = 0;/*** @brief       启用路由功能* @note        customConnect 的简易版，交由具体插件实现* @param [in]  pRoute  - 路由器*/virtual void        enableRoute(iPluginRoute *pRoute)                                               = 0;/*** @brief       获取插件** @return*      - NULL  - 插件获取失败*      - !NULL - 插件获取成功*/virtual QWidget *   centerWidget()                                                                  = 0;/*** @brief       插件信号/消息* @param[in]   msg - 统一的消息结构，详情参考 @ret ipluginroute.h中的PluginMsg类** @note        define a signal in interface*              以纯虚函数形式声明一个信号，在实现类中需要使用Qt的signals:进行修饰*/virtual void        sg_iPluginInterface_signal(PluginMsg msg)                                       = 0;/* define a slot in interface, will be called by router directly *//*** @brief       插件槽函数* @param[in]   msg - 统一的消息结构，详情参考 @ret ipluginroute.h中的PluginMsg类** @note        define a slot in interface, will be called by router directly*              此槽函数不需要使用Qt的connect()函数与信号链接，也不能直接被connect()函数链接，*              否则会提示"...slot not found/not defined"*              而是直接由路由器调用。*/virtual void        sl_iPluginInterface_slot(PluginMsg msg)                                         = 0;protected:virtual ~iPluginInterface() {}
};}/* 如果加上命名空间，以下两句代码不能在命名空间内部，且类名需要写为"namespace::iPluginInterface" */
#define IPLUGININTERFACE_iid "com.Plugin.iPluginInterface"
Q_DECLARE_INTERFACE(x_qtplugin::iPluginInterface, IPLUGININTERFACE_iid)#endif // IPLUGININTERFACE_H

2. 插件管理器

我的插件管理器比较简陋，只有三个功能：加载、卸载和获取插件实例。插件管理器内部会使用QMap<QString, QPluginLoader*>建立插件名到插件的映射(其实这里为了适应同一插件多实例的场景，应该建立uniId->插件实例的映射，只是我目前的项目没用到，偷了个懒)，而插件管理器自身继承自QStringList，保存已加载的各个插件名，比较方便查看已经加载了哪些插件。

如果没有插件间数据交互的需要，实现插件管理器之后就可以使用这个插件框架了。

/*** @file   pluginsmanager.h* @brief* @note   目前实现的插件间通信是需要一个直接继承QObject或者是间接继承QObject的类作为中转的，插件间不能直接通信*         兼容静态插件加载和动态插件加载** @ref    https://blog.csdn.net/yizhou2010/article/details/79961554*         https://www.cnblogs.com/newstart/p/3457072.html?spm=a2c6h.12873639.0.0.ef5335d1Yrgn2Y*         https://blog.csdn.net/kenfan1647/article/details/107493294*         https://www.tqwba.com/x_d/jishu/218926.html  // 这篇讲的很透彻**         // custom interface*         https://www.cnblogs.com/cheungxiongwei/p/11796839.html** @author lixingye* @date   2021-09-13*/#ifndef PLUGINSMANAGER_H
#define PLUGINSMANAGER_H#include "qt_plugin_def.h"#include <QObject>
#include <QPluginLoader>
#include <QMap>#ifdef Q_OS_WIN#ifdef QT_DEBUG#define PLUGIN_LIB_NAME(name) (name + "d.dll")#else#define PLUGIN_LIB_NAME(name) (name + ".dll")#endif
#else#ifdef QT_DEBUG#define PLUGIN_LIB_NAME(name) ("lib" + name + "d.so")#else#define PLUGIN_LIB_NAME(name) ("lib" + name + ".so")#endif
#endifnamespace x_qtplugin
{class iPluginRoute;class BASE_PLUGIN_API PluginsManager : public QObject, public QStringList
{Q_OBJECT
private:QMap<QString, QPluginLoader *> m_plugins;           /**< here is better to save QPluginLoader or QObject(concrect plugin) ? */// QMap<QString, QObject *>       m_plugins;iPluginRoute                  *m_pRoute;            /**< 为了接口更好用，引入与路由的双向依赖 */public:PluginsManager(iPluginRoute *pRoute, QObject *parent = 0);virtual ~PluginsManager();/*** @brief       从插件目录中加载指定插件* @param[in]   pluginDir   - 插件目录* @param[in]   pluginName  - 指定插件名, 带.so后缀以及lib前缀** @note        目前对某一插件，仅能加载一个实例*              且传入的plugiName参数统一转换为小写之后，必须和插件.json配置文件中的"Keys"一致*              .json配置文件可用于判断插件合法性** @attention   该实现尚未完善处理动态加载debug还是release区分** @return *      - false - 加载失败*      - trur  - 加载成功*/virtual bool load(const QString &pluginDir, const QString &pluginName);/*** @brief       从插件目录中加载所有插件* @note        一般来说目录中最好至存放插件，否则推荐调用带插件名的load接口，可以指定插件，确保插件合法性* @param[in]   pluginDir   - 插件目录** @return*      - false - 加载失败*      - true  - 加载成功*/virtual bool load(const QString &pluginsDir);/*** @brief       从插件管理器中卸载指定插件* @param[in]   pluginName  - 指定插件名** @return *      - false - 卸载失败*      - true  - 卸载成功*/virtual bool unload(const QString &pluginName);/*** @brief       卸载插件管理器中的所有插件*/virtual void unload();/*** @brief       根据插件名从插件管理器中获取已加载插件的一个实例* @param[in]   pluginName - 指定插件名** @return*      - NULL  - 获取插件实例失败*      - !NULL - 获取插件实例成功** @note        每一个插件仅能获取一个实例，目前不支持同一插件多实例获取*/virtual QObject * getPlugin(const QString &pluginName);
};}#endif // PLUGINSMANAGER_H

3. 插件间路由

因为之前尝试过Qt插件间不能直接进行数据交换，使用全局变量是可以的，但是总感觉使用全局变量的路子不太对，所以后面查了一下插件间可以通过插件管理器作路由来转发数据/消息，这种方法比较麻烦，不如全局变量来得快，也算是多积累一种方法吧。

由于我的插件接口没有继承QObject，因为不想连一个接口内部都带着Qt的QObject，感觉这样接口有点“胖”。所以不能直接使用Qt的信号与槽，只能另辟蹊径。消息通信嘛，需要一个协议，也就是相对统一的消息结构，然后直到消息的来源去向，基本上就可以实现了，消息接收方自行根据来源和数据解析消息，然后进行相应操作即可。

/*** @file   ipluginroute.h* @brief  插件框架的插件消息路由接口定义以及统一消息类定义* @note** @author lixingye* @date   2021-09-13*/#ifndef IPLUGINROUTE_H
#define IPLUGINROUTE_H#include "qt_plugin_def.h"#include <QString>
#include <QMap>
#include <QVariant>namespace x_qtplugin
{class BASE_PLUGIN_API PluginMsg
{
private:QString m_srcPlugin;                    /**< 消息来源，发送消息的插件名 */  QString m_dstPlugin;                    /**< 消息去向，接收消息的插件名 */QMap<QString, QVariant> m_parameters;   /**< key-val pair: <name, val> */QObject                *m_pObject;      /**< 可以是发送消息插件的一些部件指针，如QWidget *等，由接收消息插件处理消息后直接使用，也可以是一些大型数据不能通过作为信号参数发送的 */public:inline QString & srcPlugin() { return m_srcPlugin; }inline QString & dstPlugin() { return m_dstPlugin; }inline QMap<QString, QVariant> & paramters() { return m_parameters; }inline QObject *& object() { return m_pObject; }
};class PluginsManager;/*** @brief   插件消息路由类* @note    接口实现与插件管理器形成双向依赖*/
class BASE_PLUGIN_API iPluginRoute
{
public:static iPluginRoute * newRoute();static void           delRoute(iPluginRoute *pRoute);/*** @brief       为路由设置插件管理器，路由依靠插件管理器查找目标插件* @param [in]  pManager    - 插件管理器对象指针，值为NULL时复位插件管理器设置，路由无效*/virtual void setPluginManager(PluginsManager *pManager) = 0;/*** @brief       根据消息中的来源和去向实现消息转发* @note        实际上是一个槽函数，供插件连接*/virtual void route(PluginMsg msg)                       = 0;protected:virtual ~iPluginRoute() {}
};}// #define IPLUGINROUTE_IID "com.Plugin.PluginRoute"
// Q_DECLARE_INTERFACE(iPluginRoute, IPLUGINROUTE_IID)#endif // IPLUGINROUTE_H

4. 完整代码

/*** @file   qt_plugin_def.h* @brief  qt插件管理框架使用到的公共定义* @note** @author lixingye* @date   2021-10-27*/#ifndef QT_PLUGIN_DEF_H
#define QT_PLUGIN_DEF_H#include <typeinfo>
#include <cxxabi.h>#if defined(BASE_PLUGIN_STATICLIB)#define BASE_PLUGIN_API
#elif defined(WIN32) || defined(_WIN32)#if defined(BASE_PLUGIN_EXPORTS)#define BASE_PLUGIN_API __declspec(dllexport)#else#define BASE_PLUGIN_API __declspec(dllimport)#endif
#else#define BASE_PLUGIN_API __attribute__((visibility("default")))
#endifnamespace x_qtplugin
{/*** @note    获取类名的宏*          此宏需要在public可见性之后声明**          使用方式：*              public:*                  X_CLASS_INFO()  // 这里不用加分号，部分ide会报错或者警告*/
#define X_CLASS_INFO_GCC() \int status = -1;                                                                            \char *demangledName = abi::__cxa_demangle(typeid(*this).name(), NULL, NULL, &status);       \if (status == 0)                                                                            \{                                                                                           \resName = demangledName;                                                                \::free(demangledName);                                                                  \}#define X_CLASS_INFO_MSVC() \resName     = typeid(*this).name();                                                         \int index   = resName.find(' ');                                                            \if (index != resName.nops)                                                                  \{                                                                                           \resName.assign(resName, index + 1, resName.length());                                   \}#if defined(__clang__) || defined(__GNUC__) || defined(__GNUG)
#define X_CLASS_INFO()                                                                          \virtual std::string classname()                                                             \{                                                                                           \std::string resName = "";                                                               \X_CLASS_INFO_GCC();                                                                     \return resName;                                                                         \}
#else
#define X_CLASS_INFO()                                                                          \virtual std::string classname()                                                             \{                                                                                           \std::string resName = "";                                                               \X_CLASS_INFO_MSVC();                                                                    \return resName;                                                                         \}
#endif}#endif // QT_PLUGIN_DEF_H

// iplugininterface.cpp 头文件在本文上边
#include "iplugininterface.h"
#include <QApplication>namespace x_qtplugin
{iPluginInterface::iPluginInterface(): m_id(""), m_description(""),m_pParent(NULL), m_pRoute(NULL),m_pTranslator(NULL)
{m_name = QString::fromStdString(classname());
}void iPluginInterface::setUniId(const QString &id)
{m_id = id;
}QString iPluginInterface::uniId()
{return m_id;
}void iPluginInterface::setName(const QString &name)
{m_name = name;
}QString iPluginInterface::name()
{return m_name;
}void iPluginInterface::setDescription(const QString &descrip)
{m_description = descrip;
}QString iPluginInterface::description()
{return m_description;
}void iPluginInterface::setParent(iPluginInterface *pParent)
{m_pParent = pParent;
}int iPluginInterface::translate(const QString &dir)
{if (m_pTranslator == NULL){m_pTranslator = new QTranslator();}if (dir.compare("") == 0){return -1;}if (!m_pTranslator->load(dir)){return -1;}return (qApp->installTranslator(m_pTranslator) ? 0 : -1);
}}

/*** @file   pluginsmanager.cpp  头文件在本文上边* @brief* @note** @author lixingye* @date   2021-09-11*/#include "pluginsmanager.h"
#include "ipluginroute.h"
#include "iplugininterface.h"#include <QDir>
#include <QDebug>
#include <QJsonArray>namespace x_qtplugin
{PluginsManager::PluginsManager(iPluginRoute *pRoute, QObject *parent): m_pRoute(pRoute)
{Q_UNUSED(parent);clear();m_pRoute->setPluginManager(this);
}PluginsManager::~PluginsManager()
{unload();
}bool PluginsManager::load(const QString &pluginDir, const QString &pluginName)
{
#ifdef BUILD_QT_STATICQVector<QStaticPlugin> plugins  = QPluginLoader::staticPlugins();QString _pluginName             = "";QObject * pRes                  = nullptr;iUpgUiPlugin * plugin           = nullptr;for (int i = 0; i < plugins.size(); ++i){QJsonObject meta = plugins[i].metaData().value("MetaData").toObject();QString name     = meta.value("Keys").toArray().at(0).toString();if ((name != "") && pluginName.contains(name, Qt::CaseInsensitive)){plugin = qobject_cast<iUpgUiPlugin *>(plugins[i].instance());_pluginName = name;break;}}if (plugin == nullptr){qDebug() << "static load plugin failed: " << _pluginName;return false;}
#elseQDir plugins(pluginDir);if (!plugins.exists()){return false;}QString _pluginName = pluginName;if (!QLibrary::isLibrary(_pluginName)){_pluginName = PLUGIN_LIB_NAME(pluginName);}QPluginLoader *pLoader = new QPluginLoader(plugins.absoluteFilePath(_pluginName));QObject       *pPlugin = pLoader->instance();QJsonObject    meta    = pLoader->metaData().value("MetaData").toObject();QString        key     = meta.value("Keys").toArray().at(0).toString();if ((key.compare("") == 0) || !_pluginName.contains(key, Qt::CaseInsensitive)){qDebug() << "load plugin failed: " << _pluginName << ", err: please add 'Keys' value into " + _pluginName + ".json";return false;}if (!pLoader->load() || !pPlugin){qDebug() << "load plugin failed: " << _pluginName << ", err: " << pLoader->errorString();return false;}/* make sure there is only one plugin instance in process */this->unload(_pluginName);m_plugins.insert(_pluginName, pLoader);auto plugin = qobject_cast<iPluginInterface *>(pLoader->instance());#endifthis->append(_pluginName);/* 去重复 */this->toSet().toList();if (m_pRoute != NULL){// plugin->enableRoute(m_pRoute);plugin->customConnect(dynamic_cast<QObject *>(m_pRoute), SLOT(route(PluginMsg)));}qDebug() << "load plugin successfully: " << _pluginName;return true;
}bool PluginsManager::load(const QString &pluginsDir)
{QDir plugins(pluginsDir);if (!plugins.exists()){return false;}foreach (const QString &pluginName, plugins.entryList(QDir::Files)){load(pluginsDir, pluginName);}return true;
}bool PluginsManager::unload(const QString &pluginName)
{
#ifdef BUILD_QT_STATIC#elseQString _pluginName = pluginName;if (!QLibrary::isLibrary(_pluginName)){_pluginName = PLUGIN_LIB_NAME(pluginName);}QMap<QString, QPluginLoader *>::iterator iter = m_plugins.find(_pluginName);if (iter == m_plugins.end()){// qDebug() << "unload plugin failed: " << _pluginName << ", err: not found the plugin.";return false;}QPluginLoader *pLoader = iter.value();if (!pLoader->unload()){qDebug() << "unload plugin failed: " << _pluginName << ", err: " << pLoader->errorString();return false;}m_plugins.erase(iter);delete pLoader;pLoader = nullptr;int index = -1;while ((index = this->indexOf(_pluginName)) >= 0){this->removeAt(index);index = -1;}#endifreturn true;
}void PluginsManager::unload()
{foreach (const QString &pluginName, m_plugins.keys()){this->unload(pluginName);}this->clear();
}QObject * PluginsManager::getPlugin(const QString &pluginName)
{ 
#ifdef BUILD_QT_STATICQVector<QStaticPlugin> plugins = QPluginLoader::staticPlugins();QObject * pRes = nullptr;for (int i = 0; i < plugins.size(); ++i){QJsonObject meta = plugins[i].metaData().value("MetaData").toObject();QString name     = "";name             = meta.value("Keys").toArray().at(0).toString();if (pluginName == name){pRes = plugins[i].instance();break;}}#elseQString _pluginName = pluginName;if (!QLibrary::isLibrary(_pluginName)){_pluginName = PLUGIN_LIB_NAME(pluginName);}QMap<QString, QPluginLoader *>::iterator iter = m_plugins.find(_pluginName);if (iter == m_plugins.end()){qDebug() << "plugin not exist: " << _pluginName;return nullptr;}if (!iter.value()->isLoaded()){return nullptr;}QObject *pRes = iter.value()->instance();if (pRes == nullptr){qDebug() << "get plugin failed, err: " << iter.value()->errorString();}#endifreturn pRes;
}}

// ipluginroute.cpp 头文件在本文上边
#include "ipluginroute.h"
#include "pluginroute.h"namespace x_qtplugin
{iPluginRoute * iPluginRoute::newRoute()
{return (new PluginRoute());
#if 0static PluginRoute router(pPluginsManager);return &router;
#endif
}void iPluginRoute::delRoute(iPluginRoute *pRoute)
{if (pRoute){delete (PluginRoute *)pRoute;}
}}

/*** @file   pluginroute.h* @brief  插件路由器实现* @note** @author lixingye* @date   2021-10-27*/#ifndef PLUGINROUTE_H
#define PLUGINROUTE_H#include <QObject>
#include "ipluginroute.h"
#include "pluginsmanager.h"namespace x_qtplugin
{class PluginRoute : public QObject, public iPluginRoute
{Q_OBJECT// Q_INTERFACES(iPluginRoute)private:PluginsManager * m_pPluginsManager;public:PluginRoute();virtual ~PluginRoute();protected:virtual void setPluginManager(PluginsManager *pManager) override;public slots:virtual void route(PluginMsg msg)        override;
};}#endif // PLUGINROUTE_H

#include "pluginroute.h"
#include "iplugininterface.h"
#include <QDebug>namespace x_qtplugin
{PluginRoute::PluginRoute(): m_pPluginsManager(NULL)
{}PluginRoute::~PluginRoute()
{}void PluginRoute::setPluginManager(PluginsManager *pManager)
{m_pPluginsManager = pManager;
}void PluginRoute::route(PluginMsg msg)
{qDebug() << "plugin route received: " << msg.srcPlugin();if (!m_pPluginsManager){qDebug() << "route failed, err: plugins manager is null";return;}QObject * pObj = m_pPluginsManager->getPlugin(msg.dstPlugin());if (pObj){iPluginInterface *pPLugin = qobject_cast<iPluginInterface *>(pObj);pPLugin->sl_iPluginInterface_slot(msg);}
}}

QMake工程

我的Qt版本是5.9.4，我在centos7和windows都已经编译通过了使用时，需要注意根据自身情况修改工程目标生成目录，如tmp_api.path、tmp_lib.path以及target.path。

QT                             += core gui widgetsTEMPLATE                        = lib# 一般linux下qmake生成的目标库会有4个，原因大概是利用软链接达到更换lib*.so版本更便捷，只需要修改lib*.so的指向
# 如果不想生成4个.so.*文件，可以使用CONFIG += plugin
CONFIG                         += pluginCONFIG(debug, debug|release) {
BUILD_POSTFIX                   = "d"
BUILD_TYPE                      = "debug"       # 这里获取构件类型是因为windows下编译产生的临时目录比linux多了一级，在编译时拷贝操作会用到
}
else {
BUILD_POSTFIX                   = ""
BUILD_TYPE                      = "release"
}# TARGET在Debug下自动会带'd'后缀，但是使用了自定义的TARGET名后不会自动加'd'
TARGET                          = plugin_manager$${BUILD_POSTFIX} # 注意，这里不等价 target.files += plugin_managerd# 为了跨平台，会使用qmake条件判断，qmake中关于平台相关的判断变量有win32/unix/macx
win32 {DEFINES                    += BASE_PLUGIN_EXPORTS
}INCLUDEPATH                    +=                           \api                       \src                       \HEADERS                        +=                           \api/pluginsmanager.h      \api/ipluginroute.h        \src/pluginroute.h         \api/iplugininterface.h    \api/qt_plugin_def.hSOURCES                        +=                           \src/pluginsmanager.cpp    \src/pluginroute.cpp       \src/ipluginroute.cpp      \src/iplugininterface.cpp# 编译时拷贝接口api文件
tmp_api.files                  += $${PWD}/api/*.h
tmp_api.path                    = $${PWD}/../../compile_api# 编译时拷贝生成库
unix {tmp_lib.files              += $${OUT_PWD}/lib$${TARGET}.so
}win32 {tmp_lib.files              += $${OUT_PWD}/$${BUILD_TYPE}/$${TARGET}.dll
}tmp_lib.path                    = $${PWD}/../../compile_libunix {copy_api                    = $${QMAKE_COPY_FILE} $${tmp_api.files} $${tmp_api.path}copy_libs                   = $${QMAKE_COPY_FILE} $${tmp_lib.files} $${tmp_lib.path}QMAKE_POST_LINK            += $$copy_libs; $$copy_api
}win32 {# 由于windows命令行大多数命令都不支持路径中使用'/'，需要将路径转换为'\\'，replace()内置函数可以通过"qtcreator->帮助->索引"进行搜索tmp_api.files               = $$replace(tmp_api.files, /, \\)tmp_api.path                = $$replace(tmp_api.path, /, \\)tmp_lib.files               = $$replace(tmp_lib.files, /, \\)tmp_lib.path                = $$replace(tmp_lib.path, /, \\)# windows下如果目标目录不存在可能会出问题，所以还可以先判断目录是否存在，若不存在则创建，其实linux下也可以多加这一步mkdir_inc                   = (if not exist $${tmp_api.path} $${QMAKE_MKDIR} $${tmp_api.path})mkdir_lib                   = (if not exist $${tmp_lib.path} $${QMAKE_MKDIR} $${tmp_lib.path})copy_api                    = $${QMAKE_COPY_FILE} $${tmp_api.files} $${tmp_api.path}copy_libs                   = $${QMAKE_COPY_FILE} $${tmp_lib.files} $${tmp_lib.path}QMAKE_POST_LINK            += $$copy_libs && $$copy_api
}# target应该是qmake内置变量，当TARGET模板是库时，使用target.path指定安装路径
# https://doc.qt.io/archives/qt-4.8/qmake-variable-reference.html#target
# https://doc.qt.io/archives/qt-4.8/qmake-variable-reference.html#destdir
# 官网中两个变量TARGET和DESTDIR分别是设置target.files和target.path的，但是TARGET不等价与target.files
target.path                     = $${PWD}/../../lib # 等价于 DESTDIR         = $${PWD}/../../lib# 一般库是需要提供接口的，所以api也许要安装到指定目录，也可以直接在编译时就把api拷贝到最终目录
apis.files                     += $${PWD}/api/*
apis.path                       = $${PWD}/../../api/plugin_managerINSTALLS                       += target apis

偷得浮生半日闲，又摘桃花换酒钱！现在的我已经是废废的了，做啥都抬不起劲，连游戏都不想打了。。。睡了！