如何实现一个动态模块加载框架（C++）

背景：

实际项目中，我们往往将一个系统分解成一个个功能模块，这些功能模块以动态库加载的方式由主程序加载使用。

• 需求1： 主程序定义好功能类的接口，每个功能模块继承这些功能类（基类），然后实现其中的接口函数。
• 需求2：主程序以动态库的方式加载这些功能模块，实例化功能模块对象，调用对应的接口函数。
• 需求3：主程序以模块名称的方式加载各功能模块，能够从名称创建一个功能模块对象。

方案：

image.png

• 主程序需要定义功能基类。
• 需要在主程序中定义一个全局的模块注册表，每个模块在动态加载时自动的将模块注册到该表中。
• 需要提供一种方便快捷的模块注册机制。

实现示例代码：

总体的代码结构如下：

.
├── main
├── main.cpp
├── ModuleA
│   ├── build.sh
│   ├── libma.so
│   ├── ModuleA.cpp
│   └── ModuleA.h
├── ModuleB
│   ├── build.sh
│   ├── libmb.so
│   ├── ModuleB.cpp
│   └── ModuleB.h
├── Module.cpp
└── Module.h

• 模块基类定义+注册宏（Module.h）

#pragma once
#include <map>
#include <functional>
#include <memory>
class Module {
public:
    Module() {}
    virtual ~Module() {}
    virtual void Process() = 0;
};
#define REGISTER_MODULE(MODULE_NAME)   \
    extern std::map<std::string, std::function<Module*()>> allModules_; \
    static int fuse_ = ([]()->int { \
                allModules_[#MODULE_NAME] = []()->Module* { \
                    return new MODULE_NAME(); \
                }; \
                return 0;\
            })()
extern std::shared_ptr<Module> GetModule(const std::string& moduleName);

说明：
（1）定义了一个模块接口类，并定义了纯虚函数，每个功能模块需要实现这个纯虚函数。
（2）提供了一个模块注册宏，每个模块可以引用该宏进行注册。
（3）在注册宏中引用了一个全局map表，这个表即是模块注册表，它的key是模块名称，value是一个创建功能模块实例的函数对象（std::function）。
（4）定义了一个static int变量（fuse_），这个变量唯一的目的是在加载动态库时触发注册的过程，在这里将注册的过程实现为一个Lambda函数，在此Lambda函数往全局map表中注册一个KV对。
（5）全局map需要在主程序的代码中定义，此时，核心问题是如何将主程序中定义的全局变量在动态模块中得以使用，这里使用了gcc编译器的"-Wl, --export-dynamic"链接选项，后面会提到。
（6）提供一个从动态模块名称获取动态模块实例的接口函数。

• 全局表的定义以及接口函数实现（Module.cpp）:

#include "Module.h"
std::map<std::string, std::function<Module*()>> allModules_;

std::shared_ptr<Module> GetModule(const std::string& moduleName)
{
    if (allModules_.find(moduleName) == allModules_.end()) {
        return nullptr;
    }

    return std::shared_ptr<Module>(allModules_[moduleName]());
}

可以看到全局map是在这里给出定义的。

• 模块A的实现：
  • ModuleA.h

#pragma once
#include "../Module.h"
class ModuleA : public Module {
public:
    virtual void Process() override;
};

• ModuleA.cpp

#include <iostream>
#include "ModuleA.h"

void ModuleA::Process()
{
    std::cout << ">>Entering ModuleA::Process" << std::endl;
}

REGISTER_MODULE(ModuleA);

可以看到在实现文件的最后调用了注册宏完成注册。

• 模块B的实现：
  • ModuleB.h

#pragma once
#include "../Module.h"
class ModuleB : public Module {
public:
    virtual void Process() override;
};

• ModuleB.cpp

#include <iostream>
#include "ModuleB.h"

void ModuleB::Process()
{
    std::cout << ">>Entering ModuleB::Process" << std::endl;
}

REGISTER_MODULE(ModuleB);

• 分别编译模块A和模块B，使其变成两个动态库：

# g++ -std=c++11 -fPIC -shared -o libma.so ModuleA.cpp
# g++ -std=c++11 -fPIC -shared -o libmb.so ModuleB.cpp

• 主程序代码：

#include <dlfcn.h>
#include "Module.h"
int main()
{
    void* ha = dlopen("./ModuleA/libma.so", RTLD_LAZY);
    void* hb = dlopen("./ModuleB/libmb.so", RTLD_LAZY);

    std::shared_ptr<Module> ma = GetModule("ModuleA");
    std::shared_ptr<Module> mb = GetModule("ModuleB");

    ma->Process();
    mb->Process();

    return 0;
}

• 测试运行
  链接时需要加上“-Wl, --export-dynamic”选项，这是关键：

g++ -std=c++11 -O2 -Wl,--export-dynamic -o main main.cpp Module.cpp -ldl

运行程序：

# ./main
>>Entering ModuleA::Process
>>Entering ModuleB::Process