C++中插件使用举例

╰半夏微凉° 2023-05-28 09:59 10阅读 0赞

插件并不是在构建时链接的，而是在运行时发现并加载的。因此，用户可以利用你定义好的插件API来编写自己的插件。这样他们就能以指定方式扩展API的功能。**插件库是一个动态库，它可以独立于核心****API****编译，在运行时根据需要显示加载。不过插件也可以使用静态库，比如在嵌入式系统中，所有插件都是在编译时静态链接到应用程序中的**。

你总是可以引入自己的插件文件扩展名。例如，Adobe Illustrator使用的插件扩展名是.aip，而Microsoft Excel插件的扩展名是.xll。

很多商业化软件包都允许使用C/C++插件扩展其核心功能。在API中采样插件模型有以下优点：

(1).更为通用：使你的API可以用于解决更大范围内的问题，而不需要为所有问题提供解决方案。

(2).更新量小：以插件形式存在的功能很容易独立于应用程序而更新，只需引入新版本的插件即可。相比发布整个应用程序的新版本，这种方式的更新量要小得多。

一般而言，如果要创建插件系统，有两个主要特性是必须要设计的：

(1).插件API：要创建插件，用户必须编译并链接插件API。插件API是你提供给用户的用于创建插件的接口。

(2).插件管理器：这是核心API代码中的一个对象(一般设计为单例)，负责管理所有插件的生命周期，即插件的加载、注册和卸载等各个阶段。该对象也叫做插件注册表。

当为API设计插件时，一些设计决策会影响插件系统的精确架构：

(1).C还是C++：C++规范并没有明确地定义ABI。因此，不同的编译器，甚至同一编译器的不同版本，生成的代码可能无法做到二进制兼容。这就暗示我们，对插件系统而言，如果客户在开发插件时使用了一个ABI不同的编译器，那么这样的插件可能无法加载。相反，纯C代码的ABI有明确的含义，可以跨平台和跨编译器工作。

(2).版本控制：需要确定某插件构建时使用的API版本是否与你的API版本兼容。

(3).内部元数据还是外部元数据：元数据，比如可读的名字和版本信息，既可以在插件代码内部定义，也可以通过一种简单的外部文件格式指定。使用外部元数据的优点是，并不需要加载所有插件，就能了解所有可用对象的集合。

(4).插件管理器是通用的还是专用的：插件管理器的一种实现方法是，使它的层次非常低，实现通用性，也就是说，它只是简单地加载插件并访问其中的符号。然而，这样做意味着插件管理器不了解API中是否存在具体类型。其结果是对象可能必须以void\*指针的形式返回，在使用之前再转化为具体的类型。或者，插件管理器可以以最低限度前向声明插件中任何对象的类型，这种方案的类型安全性更好，但也正因如此，它无法独立于你的API而实现。

(5).安全性：你必须决定你对用户插件的信任程度。插件是可以运行在进程之中的任意编译过的代码。因此，插件有可能做任何事情，包括访问它不应该访问的数据，以及删除最终用户硬盘上的文件，甚至让整个应用程序奔溃。如果你需要防护这种恶意插件，可以考虑创建一种基于套接字的方案，使插件运行在独立的进程中，通过IPC通道与核心API通信。

(6).静态库还是动态库：插件也可以定义为静态库，这意味着插件必须编译到应用程序中。对消费型应用程序而言，更常见的方案是采用动态库，因为用户可以编写自己的插件，并且在运行时扩展应用程序。编写静态插件还有一个约束，你必须确保任意两个插件中没有定义相同的符号，也就是说，每个插件中初始化函数的命名必须是唯一的。

因为跨平台和跨编译器的ABI问题，支持C++插件有些困难，有些方法可以在插件中更安全地使用C++：

(1).使用抽象基类：实现抽象基类的虚方法可以使插件与ABI问题隔离，因为虚方法调用通常是用类的虚函数表中的索引来表示的。

(2).自由函数使用C链接：为了避免C++ ABI问题，插件API中的所有全局函数都要使用C链接方式，也就是说，它们应该使用extern “C”声明。同理，为了最大化可移植性，插件传递给核心API的回调函数也应该使用C链接方式。

(3).避免使用STL和异常：STL类(如std::string和std::vector)的不同实现可能不是ABI兼容的。因此，核心API与插件API之间的函数调用应该尽量避免使用这些容器。同样，因为不同编译器之间异常的ABI往往也是不稳定的，所以在你的插件API中也应该避免。

(4).不要混用内存分配器：插件链接的内存分配器可能与你的API不同。要么所有的对象由插件分配并回收，要么将控制传给核心API，由核心API负责所有对象的创建与销毁。但核心API绝对不要释放插件分配的对象，反之亦然。

插件API：插件API是你提供给用户的用于创建插件的接口。当核心API加载一个插件时，为了让插件正常工作，它需要知道应该调用哪个函数或者要访问哪个符号。这意味着插件中应该明确定义具名的入口点，用户在创建插件时必须提供。这一点可以以不同的方式实现。

插件管理器：需要处理以下任务：

(1).加载所有插件的元数据：这些元数据既可以保存在单独的文件中(比如xml文件)，也可以嵌入到插件内部。如果是后一种情况，为了收集所有插件的元数据，插件管理器需要加载所有可用的插件。你可以以元数据的形式向用户提供可用插件列表，以供他们选择。

(2).将动态库加载到内存中，提供对库中符号的访问能力，并在必要时卸载库。在Unix(也包括Mac OSX)平台上，这会涉及dlopen、dlclose、dlsym等函数，而在Windows平台上，涉及的是LoadLibrary、FreeLibrary及GetProcAddress等函数。

(3).当插件加载时，调用其初始化例程；而当插件卸载时，调用其清理例程。

因为插件管理器为系统中的所有插件提供了单一访问点，所以它往往以单例模式实现。从设计角度看，我们可以将插件管理器看做一组插件实例的集合，其中每个插件实例表示一个插件，并提供了加载和卸载该插件的功能。

插件版本控制：既可以让插件使用与核心API相同的版本号，也可以为其引入专门的插件API版本号。我建议采用后者，因为插件API实际上是从核心API分离出来的接口，两者可能以不同的频率修改。除此之外，用户可以选择指定该插件支持的API的最小版本号和最大版本号。更普遍的做法是指定最小版本号。最小/最大版本号也可以通过外部元文件格式指定。

注：以上内容摘自《C++ API设计》

以下是测试代码：组织结构如下图所示：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlbmdiaW5nY2h1bg_size_16_color_FFFFFF_t_70][]

src目录下存放所有的API和核心库code，common.hpp中的接口可认为是核心API，plugin.hpp中为插件API，编译此目录可生成动态库address。

plugin目录下存放插件API的实现，编译此目录可生成一个名字为plugin\_area.fbc的插件。

tests目录为调用核心API和插件API的code，用来验证生成动态库address和插件plugin\_area.fbc的正确性。

可通过配置文件如json或xml来指定需要加载的插件，在code中解析此配置文件，这样替换插件时可无需重新编译，直接修改配置文件即可。

通过脚本build.sh和CMakeLists.txt来编译测试代码，执行build.sh 0生成plugin\_area.fbc插件，执行build.sh 1生成address动态库和执行文件Plugin\_Test。插件和动态库/执行文件的生成是独立的，它们在编译生成时无任何依赖关系。

各个文件内容如下：

plugin/plugin\_area.cpp:

#include <string.h>
    #include <iostream>
    #include <string>
    #include <stdexcept>
    #include "plugin.hpp"
    
    class Area : public Base {
    public:
    	Area() = default;
    	~Area() = default;
    
    	const char* version() override { return "1.0.0"; }
    	const char* name() override { return "plugin_area"; }
    	int get_area(const fbc_rect_t& rect) override { return ((rect.right - rect.left) * (rect.bottom - rect.top) + 10); }
    };
    
    #ifdef __cplusplus
    extern "C" {
    #endif
    
    FBC_API Base* get_plugin_instance(const char* name)
    {
    	Area* area = new Area();
    	if (strcmp(area->name(), name) != 0) {
    		fprintf(stderr, "plugin name mismatch: %s, %s\n", area->name(), name);
    		delete area;
    		throw std::runtime_error("plugin name mismatch");
    		return nullptr;
    	}
    
    	return area;
    }
    
    FBC_API std::string get_plugin_name_version(Base* handle)
    {
    	if (!handle) {
    		fprintf(stdout, "handle cann't equal nullptr\n");
    		throw std::runtime_error("handle cann't equal nullptr");
    		return "";
    	}
    
    	Area* area = dynamic_cast<Area*>(handle);
    	std::string str(area->name());
    	str += ".fbc.";
    	str += area->version();
    	return str;
    }
    
    FBC_API void release_plugin_instance(Base* handle)
    {
    	delete dynamic_cast<Area*>(handle);
    }
    
    #ifdef __cplusplus
    }
    #endif

src/common.hpp:

#ifndef FBC_PLUGIN_TEST_COMMON_HPP_
    #define FBC_PLUGIN_TEST_COMMON_HPP_
    
    #ifdef _MSC_VER
        #ifdef DLL_EXPORTS
            #define FBC_API __declspec(dllexport)
        #else
            #define FBC_API
        #endif // _MSC_VER
    #else
        #ifdef DLL_EXPORTS
            #define FBC_API __attribute__((visibility("default")))
        #else
            #define FBC_API
        #endif
    #endif
    
    typedef struct fbc_rect_t {
        int left, top;
        int right, bottom;
    } fbc_rect_t;
    
    FBC_API char* get_csdn_blog_address();
    FBC_API char* get_github_address();
    
    #endif // FBC_PLUGIN_TEST_COMMON_HPP_

src/common.cpp:

#include "common.hpp"
    
    FBC_API char* get_csdn_blog_address()
    {
    	return "https://blog.csdn.net/fengbingchun";
    }
    
    FBC_API char* get_github_address()
    {
    	return "https://github.com//fengbingchun";
    }

src/plugin.hpp:

#ifndef FBC_PLUGIN_TEST_PLUGIN_HPP_
    #define FBC_PLUGIN_TEST_PLUGIN_HPP_
    
    #include "common.hpp"
    
    class Base {
    public:
    	virtual const char* version() = 0;
    	virtual const char* name() = 0;
    	virtual int get_area(const fbc_rect_t& rect) = 0;
    
    	virtual ~Base() = default;
    };
    
    #ifdef __cplusplus
    extern "C" {
    #endif
    
    FBC_API Base* get_plugin_instance(const char* name);
    FBC_API std::string get_plugin_name_version(Base* handle);
    FBC_API void release_plugin_instance(Base* handle);
    
    #ifdef __cplusplus
    }
    #endif 
    
    #endif // FBC_PLUGIN_TEST_PLUGIN_HPP_

test/test.cpp:

#include <iostream>
    #include <string>
    #include <stdexcept>
    #ifdef _MSC_VER
    #include <windows.h>
    #else
    #include <dlfcn.h>
    #endif
    #include "common.hpp"
    #include "plugin.hpp"
    
    int main()
    {
        // test general dynamic library
    	fprintf(stdout, "csdn blog address: %s\n", get_csdn_blog_address());
    	fprintf(stdout, "github address: %s\n", get_github_address());
    
        // test plugin
    	const std::string plugin_name {"plugin_area"}, plugin_suffix {"fbc"};
    	fbc_rect_t rect = {1, 2, 31, 52};
    
    #ifdef _MSC_VER
        HINSTANCE handle = LoadLibrary((plugin_name+"."+plugin_suffix).c_str());
        if (!handle) {
            fprintf(stderr, "fail to load plugin: %s, %d\n", plugin_name.c_str(), GetLastError());
    		return -1;
        }
    
    	typedef Base* (*LPGETINSTANCE)(const char* name);
    	LPGETINSTANCE lpGetInstance = (LPGETINSTANCE)GetProcAddress(handle, "get_plugin_instance");
    	if (!lpGetInstance) {
    		fprintf(stderr, "fail to GetProcAddress: get_plugin_instance, %d\n", GetLastError());
    		return -1;
    	}
    
    	Base* instance = nullptr;
    	try {
    		instance = (*lpGetInstance)(plugin_name.c_str());
    		fprintf(stdout, "plugin name: %s, version: %s\n", instance->name(), instance->version());
    	} catch (const std::exception& e) {
    		fprintf(stderr, "exception: %s\ntest fail\n", e.what());
    		return -1;
    	}
    
    	fprintf(stdout, "area: %d\n", instance->get_area(rect));
    
    	typedef std::string (*LPVERSIONNAME)(Base* base);
    	LPVERSIONNAME lpVersionName = (LPVERSIONNAME)GetProcAddress(handle, "get_plugin_name_version");
    	if (!lpVersionName) {
    		fprintf(stderr, "fail to GetProcAddress: get_plugin_name_version, %d\n", GetLastError());
    		return -1;
    	}
    
    	try {
    		fprintf(stdout, "plugin name version: %s\n", (*lpVersionName)(instance).c_str());
    	} catch (const std::exception& e) {
    		fprintf(stderr, "exception: %s\ntest fail\n", e.what());
    		return -1;
    	}
    
    	typedef void (*LPRELEASEINSTANCE)(Base* base);
    	LPRELEASEINSTANCE lpReleaseInstance = (LPRELEASEINSTANCE)GetProcAddress(handle, "release_plugin_instance");
    	if (!lpReleaseInstance) {
    		fprintf(stderr, "fail to GetProcAddress: release_plugin_instance, %d\n", GetLastError());
    		return -1;
    	}
    	fprintf(stdout, "destroy Base\n");
    	(*lpReleaseInstance)(instance);
    
    	FreeLibrary(handle);
    #else
    	void* handle = dlopen((plugin_name+"."+plugin_suffix).c_str(), RTLD_LAZY);
    	if (!handle) {
    		fprintf(stderr, "fail to load plugin: %s\n", plugin_name.c_str());
    		return -1;
    	}
    
    	typedef Base* (*pGetInstance)(const char* name);
    	pGetInstance pInstance = (pGetInstance)dlsym(handle, "get_plugin_instance");
    	if (!pInstance) {
    		fprintf(stderr, "fail to dlsym: get_plugin_instance\n");
    		return -1;
    	}
    
    	Base* instance = nullptr;
    	try {
    		instance = (*pInstance)(plugin_name.c_str());
    		fprintf(stdout, "plugin name: %s, version: %s\n", instance->name(), instance->version());
    	} catch (const std::exception& e) {
    		fprintf(stderr, "exception: %s\ntest fail\n", e.what());
    		return -1;
    	}
    
    	fprintf(stdout, "area: %d\n", instance->get_area(rect));
    
    	typedef std::string (*pVersionName)(Base* base);
    	pVersionName pvername = (pVersionName)dlsym(handle, "get_plugin_name_version");
    	if (!pvername) {
    		fprintf(stderr, "fail to dlsym: get_plugin_name_version\n");
    		return -1;
    	}
    
    	try {
    		fprintf(stdout, "plugin name version: %s\n", (*pvername)(instance).c_str());
    	} catch (const std::exception& e) {
    		fprintf(stderr, "exception: %s\ntest fail\n", e.what());
    		return -1;
    	}
    
    	typedef void (*pReleaseInstance)(Base* base);
    	pReleaseInstance prelins = (pReleaseInstance)dlsym(handle, "release_plugin_instance");
    	if (!prelins) {
    		fprintf(stderr, "fail to dlsym: release_plugin_instance\n");
    		return -1;
    	}
    	fprintf(stdout, "destroy Base\n");
    	(*prelins)(instance);
    
    	dlclose(handle);
    #endif
    
    	fprintf(stdout, "test finish\n");
    	return 0;
    }

build.sh:

#! /bin/bash
    
    usage() {
        echo "usage: $0 param"
        echo "if build plugin, then execute: $0 0"
        echo "if build src and test, then execute: $0 1"
        exit -1
    }
    
    if [ $# != 1 ]; then
        usage
    fi
    
    real_path=$(realpath $0)
    echo "real_path: ${real_path}"
    dir_name=`dirname "${real_path}"`
    echo "dir_name: ${dir_name}"
    
    build_dir=${dir_name}/build
    mkdir -p ${build_dir}
    cd ${build_dir}
    if [ "$(ls -A ${build_dir})" ]; then
    	echo "directory is not empty: ${build_dir}"
    else
    	echo "directory is empty: ${build_dir}"
    fi
    
    platform=`uname`
    echo "##### current platform: ${platform}"
    
    if [ ${platform} == "Linux" ]; then
        if [ $1 == 0 ]; then
            echo "########## build plugin ##########"
            cmake -DBUILD_PLUGIN=ON ..
        elif [ $1 == 1 ]; then
            echo "########## build src and test ##########"
            cmake -DBUILD_PLUGIN=OFF ..
        else
            usage
        fi
    
        make
    else
        if [ $1 == 0 ]; then
            echo "########## build plugin ##########"
            cmake -G"Visual Studio 15 2017" -A x64 -DBUILD_PLUGIN=ON ..
        elif [ $1 == 1 ]; then
            echo "########## build src and test ##########"
            cmake -G"Visual Studio 15 2017" -A x64 -DBUILD_PLUGIN=OFF ..
        else
            usage
        fi
    
        cmake --build . --target ALL_BUILD --config Release
    fi
    
    cd -

CMakeLists.txt:

PROJECT(Plugin_Test)
    CMAKE_MINIMUM_REQUIRED(VERSION 3.9)
    
    SET(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -std=gnu++0x")
    SET(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -std=gnu++0x")
    SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -O2 -std=gnu++0x")
    SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=gnu++0x -Wall -O2")
    
    SET(PATH_TEST_DIR ${CMAKE_CURRENT_SOURCE_DIR}/./../../../demo/Plugin_Test/demo1/test)
    SET(PATH_SRC_DIR ${CMAKE_CURRENT_SOURCE_DIR}/./../../../demo/Plugin_Test/demo1/src)
    SET(PATH_PLUGIN_DIR ${CMAKE_CURRENT_SOURCE_DIR}/./../../../demo/Plugin_Test/demo1/plugin)
    
    INCLUDE_DIRECTORIES(${PATH_SRC_DIR})
    
    FILE(GLOB_RECURSE PLUGIN_CPP_LIST ${PATH_PLUGIN_DIR}/*.cpp)
    FILE(GLOB_RECURSE SRC_CPP_LIST ${PATH_SRC_DIR}/*.cpp)
    FILE(GLOB_RECURSE TEST_CPP_LIST ${PATH_TEST_DIR}/*.cpp)
    
    ADD_DEFINITIONS(-DDLL_EXPORTS)
    
    IF(BUILD_PLUGIN)
    	MESSAGE(STATUS "########## BUILD PLUGIN ##########")
        ADD_LIBRARY(plugin_area SHARED ${PLUGIN_CPP_LIST})
        SET_TARGET_PROPERTIES(plugin_area PROPERTIES PREFIX "" SUFFIX ".fbc")
    ELSE()
    	MESSAGE(STATUS "########## BUILD SRC AND TEST ##########")
        #SET(CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS ON) # can generate address.lib in windows
        ADD_LIBRARY(address SHARED ${SRC_CPP_LIST})  
    
        ADD_EXECUTABLE(Plugin_Test ${TEST_CPP_LIST})
        IF(WIN32)
            TARGET_LINK_LIBRARIES(Plugin_Test address)
        ELSE()
            TARGET_LINK_LIBRARIES(Plugin_Test address dl)
        ENDIF()
    ENDIF()

此测试代码可同时在Windows和Linux下执行。

在Windows下执行结果如下：

![20200325212318231.png][]

在Linux下执行结果如下：

![20200325212344349.png][]

**GitHub**：[https://github.com/fengbingchun/Messy\_Test][https_github.com_fengbingchun_Messy_Test]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlbmdiaW5nY2h1bg_size_16_color_FFFFFF_t_70]: /images/20230528/5db8260149324b7db3575f0e789cb854.png
[20200325212318231.png]: /images/20230528/a8514d73bbb444d4bc95e5121c001c08.png
[20200325212344349.png]: /images/20230528/93ed756b4dce43308ffcc12d93486373.png
[https_github.com_fengbingchun_Messy_Test]: https://github.com/fengbingchun/Messy_Test