阅读本文大概需要 6.6分钟

一般情况下在没有头文件支持情况下，想要引入某个动态库，最好的办法就是使用「动态加载」的方法，在Qt中一般使用QLibyary来操作

  1.  QLibrary(const QString& fileName, QObject *parent = nullptr);
  2.  QFunctionPointer resolve(const char *symbol);
  3.  bool load();
  4.  bool unload();
  5.  bool isLoaded() const;

官方说明

下面我们来看下详细的使用过程

我们创建一个「子工程」，用来编写我们的测试方法，该工程需要导出为动态库，完整的示例如下所示

  1. ├─App
  2. │      App.pro
  3. │      main.cpp
  4. │
  5. └─Libs
  6.         Libs.pro
  7.         SDKCore.cpp
  8.         SDKCore.h
  9.         SDKCoreImpl.cpp
  10.         SDKCoreImpl.h
  11.         SDKCore_global.h
  12.         SDKStruct.h

我们创建一个函数，并且导出

SDKCore.h

  1. extern "C" SDK_EXPORT int runFunction(const char * funName, const DS_Request &request, DS_Request& response);

SDKCore.cpp

  1. int runFunction(const char *funName, const DS_Request &request, DS_Request &response)
  2. {
  3.     Internal::SDKCoreImpl m_pCoreImpl;
  4.     int nRet = -1;
  5.     QMetaObject::invokeMethod(&m_pCoreImpl, funName,
  6.                               Qt::DirectConnection,
  7.                               Q_RETURN_ARG(int, nRet),
  8.                               Q_ARG(DS_Request, request),
  9.                               Q_ARG(DS_Request&,response));
  10.     return nRet;
  11. }

这里为了访问方便，具体的函数都放在了SDKCoreImpl中实现，调用采用了反射，调用的时候直接传方法字符串即可

上面中入参和出参数据格式是自定义的，为了统一而自定义，具体如下所示

  1. struct DS_Request{
  2.     QString m_strData;
  3.     QByteArray m_baStream;
  4. };

这样就兼容所有的格式了，不管是传 字符串还是数据流都使用统一的格式

这里写一个简单的加法运算

  1. int SDKCoreImpl::addNum(const DS_Request &request, DS_Request &response)
  2. {
  3.     QVariantMap map = QJsonDocument::fromJson(request.m_strData.toLatin1()).toVariant().toMap();
  4.     int nValue1 = map.value("nValue1").toInt();
  5.     int nValue2 = map.value("nValue2").toInt();
  6.     int nResult = nValue1 + nValue2;
  7.     QVariantMap mapResult;
  8.     mapResult.insert("result", nResult);
  9.     QJsonDocument doc = QJsonDocument::fromVariant(mapResult);
  10.     response.m_strData = QString(doc.toJson());
  11.     return SDKCODE_SUCCEED;
  12. }

加载动态库就变的很简单了，只需要几行代码即可获取到对应的函数符号

  1.  QLibrary library(strSDKName);
  2.  bool bLoad = library.load();

只要动态库路径合法就会加载成功，一般加载失败可能就是路径后者导出符号有问题，遇到这些问题可以排查下

使用前先定义一个函数指针

  1. typedef int (* pRunFunctionFun)(const char *, const DS_Request &, DS_Request&);

调用addNum函数

  1. pRunFunctionFun pFun = (pRunFunctionFun) library.resolve("runFunction");
  2. if ( pFun)
  3. {
  4.     int nRet = pFun("addNum", request, response);
  5.     qDebug() << "add Resut:" << nRet << response.m_strData;
  6. }

这样一个完整的调用流程就跑通了

但是，如果你认为完了，那就错了，仔细看下就会发现上述代码有冗余，难道每调用不同的函数，都要重复上述过程么？肯定不会呀，程序员不会自己干重复的事情，要重复只能让机器去做

下面优化下，把重复的代码单独封装下，定义成宏

通过上述代码，我们可以看出来，首先这个方法可以封装成模板，每一次调用都是一样的

  1. library.resolve("")

封装成模板调用

  1. template <typename T>
  2. T getFunction(QLibrary *lib, const char *symbol)
  3. {
  4.     T f = (T)lib->resolve(func);
  5.     if (f == nullptr)
  6.     {
  7.         return nullptr;
  8.     }
  9.     return f;
  10. }

然后接着优化，获取函数符号流程封装成宏

  1. #define GET_SDK_FUNC(type, func, symbol)  GET_FUNC(sdk, type, func, symbol);
  2. #define GET_FUNC(sdk, type, func, symbol) \
  3.     type func = getFunction<type>(&sdk, symbol); \
  4.     if (func == nullptr) \
  5. { \
  6.     qDebug()<<"fun is null: "<< symbol; \
  7.     return 0; \
  8. }

优化完成后，我们看下调用过程会如何更简单

  1. QLibrary library(strSDKName);
  2. bool bLoad = library.load();
  3. GET_FUNC(library, pRunFunctionFun, runFun, "runFunction");
  4. int nRet = runFun("addNum", request, response);

完整代码已经上传到GitHub，感兴趣的可以自行去下载

demo 源码下载

在平时工作中，很多大型工程都是动态库调用，这样做的好处就是方便他人直接调用使用现有功能和业务，减少重复复杂的工作，提高我们的工作效率

上述代码中有没有发现一条迷惑之处，就是动态库的路径和名称没有看到呀，是怎么加载的？

这个其实用到了之前介绍的一种技术,qmake语法糖

阅读过源码你就会发现，我在pri文件中编写了字符串宏定义，这样在代码中就可以直接调用对应的字符串了，如果那一天要修改，那么只修改pri文件即可，其它都不需要动

  1. DEFINES += LIB_DIR_PATH=\"\\\"$$LIB_DIR_PATH\\\"\"
  2. DEFINES += FILE_DLL_EXT=\"\\\"$$FILE_DLL_EXT\\\"\"
  3. DEFINES += LIB_NAME=\"\\\"$$LIB_NAME\\\"\"

版权声明：本文为kevinlq原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/kevinlq/p/14294936.html