devbox
小舞很执着
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

插件化开发探索与实践_插件开发

作者：小舞很执着 | 2024-07-21 13:50:45

赞

踩

插件开发

一、背景

顾名思义，插件化开发就是将某个功能代码封装为一个插件模块，通过插件中心的配置来下载、激活、禁用、或者卸载，主程序无需再次重启即可获取新的功能，从而实现快速集成。当然，实现这样的效果，必须遵守一些插件接口的标准，不能与已有的功能冲突。目前能支持插件化开发的成熟框架很多，但本文仅从思路的实现角度，从0到1实现简单的插件化开发框架。

二、实现思路

思路：定义插件接口 -> 实现插件接口 -> 通过反射机制加载插件 -> 调用插件方法。

开发语言：支持反射机制的所有高级语言均可实现插件式开发，或有 FFI 调用 Native 函数的编程语言。

三、Java 通过反射机制实现插件化开发

1、创建插件接口

定义插件接口：一个执行方法

  1.  
  2. package service;
  3.  
  4. /**
  5.  * 通用插件接口
  6.  *
  7.  * @author yushanma
  8.  * @since 2023/3/5 16:36
  9.  */
  10. public interface IPluginService {
  11.     /**
  12.      * 执行插件
  13.      */
  14.     public void run();
  15. }

2、实现插件接口

  1.  
  2. package impl;
  3. import service.IPluginService;
  4.  
  5. /**
  6.  * 打印插件
  7.  *
  8.  * @author yushanma
  9.  * @since 2023/3/5 16:37
  10.  */
  11. public class MyPrinterPlugin implements IPluginService {
  12.  
  13.     @Override
  14.     public void run() {
  15.         System.out.println("执行插件方法...");
  16.     }
  17. }

3、插件中心

管理与加载插件。

Step 1、插件实体类封装

  1.  
  2. package entity;
  3.  
  4. import lombok.Data;
  5.  
  6. /**
  7.  * 插件实体类
  8.  *
  9.  * @author yushanma
  10.  * @since 2023/3/5 16:44
  11.  */
  12. @Data
  13. public class PluginEntity {
  14.     /**
  15.      * 插件名
  16.      */
  17.     private String pluginName;
  18.  
  19.     /**
  20.      * 插件路径
  21.      */
  22.     private String jarPath;
  23.  
  24.     /**
  25.      * 字节码名字
  26.      */
  27.     private String className;
  28. }

需要获取插件名、插件实现的Jar包路径、字节码路径

Step 2、通过反射机制实现插件实例化

  1.  
  2. package loader;
  3.  
  4. import entity.PluginEntity;
  5. import exception.PluginException;
  6. import lombok.Data;
  7. import lombok.NoArgsConstructor;
  8. import service.IPluginService;
  9.  
  10. import java.io.File;
  11. import java.net.URL;
  12. import java.net.URLClassLoader;
  13. import java.util.HashMap;
  14. import java.util.List;
  15. import java.util.Map;
  16.  
  17. /**
  18.  * 插件管理器
  19.  *
  20.  * @author yushanma
  21.  * @since 2023/3/5 16:44
  22.  */
  23. @Data
  24. @NoArgsConstructor
  25. public class PluginManager {
  26.     private Map<String, Class<?>> clazzMap = new HashMap<>();
  27.  
  28.     public PluginManager(List<PluginEntity> plugins) throws PluginException {
  29.         initPlugins(plugins);
  30.     }
  31.  
  32.     public void initPlugin(PluginEntity plugin) throws PluginException {
  33.         try {
  34.             //URL url = new URL("file:" + plugin.getJarPath());
  35.             URL url = new File(plugin.getJarPath()).toURI().toURL();
  36.             URLClassLoader classLoader = new URLClassLoader(new URL[]{url});
  37.             Class<?> clazz = classLoader.loadClass(plugin.getClassName());
  38.             clazzMap.put(plugin.getClassName(), clazz);
  39.         } catch (Exception e) {
  40.             throw new PluginException("plugin " + plugin.getPluginName() + " init error: >>> " + e.getMessage());
  41.         }
  42.     }
  43.  
  44.     public void initPlugins(List<PluginEntity> plugins) throws PluginException {
  45.         for (PluginEntity plugin : plugins) {
  46.             initPlugin(plugin);
  47.         }
  48.     }
  49.  
  50.     public IPluginService getInstance(String className) throws PluginException {
  51.         Class<?> clazz = clazzMap.get(className);
  52.         Object instance = null;
  53.         try {
  54.             instance = clazz.newInstance();
  55.         } catch (Exception e) {
  56.             throw new PluginException("plugin " + className + " instantiate error," + e.getMessage());
  57.         }
  58.         return (IPluginService) instance;
  59.     }
  60. }

Step 3、通过 XML 文件来配置管理插件

  1.  
  2.         <dependency>
  3.             <groupId>org.dom4j</groupId>
  4.             <artifactId>dom4j</artifactId>
  5.             <version>2.1.1</version>
  6.         </dependency>
  1.  
  2. package conf;
  3.  
  4. import entity.PluginEntity;
  5. import exception.PluginException;
  6. import org.dom4j.Document;
  7. import org.dom4j.Element;
  8. import org.dom4j.io.SAXReader;
  9.  
  10. import java.io.File;
  11. import java.util.ArrayList;
  12. import java.util.List;
  13.  
  14. /**
  15.  * 解析 XML 插件配置
  16.  *
  17.  * @author yushanma
  18.  * @since 2023/3/5 16:44
  19.  */
  20. public class PluginXmlParser {
  21.  
  22.     public static List<PluginEntity> getPluginList() throws PluginException {
  23.  
  24.         List<PluginEntity> list = new ArrayList<>();
  25.  
  26.         SAXReader saxReader = new SAXReader();
  27.         Document document = null;
  28.         try {
  29.             document = saxReader.read(new File("src/main/resources/plugin.xml"));
  30.         } catch (Exception e) {
  31.             throw new PluginException("read plugin.xml error," + e.getMessage());
  32.         }
  33.         Element root = document.getRootElement();
  34.         List<?> plugins = root.elements("plugin");
  35.         for (Object pluginObj : plugins) {
  36.             Element pluginEle = (Element) pluginObj;
  37.             PluginEntity plugin = new PluginEntity();
  38.             plugin.setPluginName(pluginEle.elementText("name"));
  39.             plugin.setJarPath(pluginEle.elementText("jar"));
  40.             plugin.setClassName(pluginEle.elementText("class"));
  41.             list.add(plugin);
  42.         }
  43.         return list;
  44.     }
  45.  
  46. }
  1. <!-- plugin.xml -->
  2. <?xml version="1.0" encoding="UTF-8"?>
  3. <plugins>
  4.     <plugin>
  5.         <name>测试插件</name>
  6.         <jar>plugins/PrinterPlugin-1.0-SNAPSHOT.jar</jar>
  7.         <class>impl.MyPrinterPlugin</class>
  8.     </plugin>
  9.     <plugin>
  10.         <name>测试插件</name>
  11.         <jar>plugins/PrinterPlugin-1.0-SNAPSHOT.jar</jar>
  12.         <class>impl.MyPrinterPlugin</class>
  13.     </plugin>
  14. </plugins>

Step 4、解析 XML 文件并加载插件

  1.  
  2. package loader;
  3.  
  4. import conf.PluginXmlParser;
  5. import entity.PluginEntity;
  6. import exception.PluginException;
  7. import service.IPluginService;
  8.  
  9. import java.util.List;
  10.  
  11. /**
  12.  * 插件加载器
  13.  *
  14.  * @author yushanma
  15.  * @since 2023/3/5 16:44
  16.  */
  17. public class PluginLoader {
  18.  
  19.     public void run() throws PluginException {
  20.         // 从配置文件加载插件
  21.         List<PluginEntity> pluginList = PluginXmlParser.getPluginList();
  22.         PluginManager pluginManager = new PluginManager(pluginList);
  23.  
  24.         for (PluginEntity plugin : pluginList) {
  25.             IPluginService pluginService = pluginManager.getInstance(plugin.getClassName());
  26.             System.out.println("开始执行[" + plugin.getPluginName() + "]插件...");
  27.             // 调用插件
  28.             pluginService.run();
  29.             System.out.println("[" + plugin.getPluginName() + "]插件执行完成");
  30.         }
  31.  
  32.         // 动态加载插件
  33. //        PluginEntity plugin = new PluginEntity();
  34. //        plugin.setPluginName("");
  35. //        plugin.setJarPath("");
  36. //        plugin.setClassName("");
  37. //        pluginManager.initPlugin(plugin);
  38. //        IPluginService pluginService = pluginManager.getInstance("");
  39. //        pluginService.run();
  40.     }
  41. }

4、测试效果

  1.  
  2. import exception.PluginException;
  3. import loader.PluginLoader;
  4.  
  5. /**
  6.  * desc
  7.  *
  8.  * @author yushanma
  9.  * @since 2023/3/5 16:44
  10.  */
  11. public class DemoMain {
  12.     public static void main(String[] args) throws PluginException {
  13.         PluginLoader loader = new PluginLoader();
  14.         loader.run();
  15.     }
  16. }

四、Rust 通过 libloader 库实现插件化开发

通过 libloader 库可以调用动态链接库函数，需要 FFI 支持。

Step 1、创建 lib

  1.  
  2. cargo new --lib mydll
  1. // 有参数没有返回值
  2. #[no_mangle]
  3. pub fn println(str: &str) {
  4.     println!("{}", str);
  5. }
  6.  
  7. // 有参数有返回值
  8. #[no_mangle]
  9. pub fn add(a: usize, b: usize) -> usize {
  10.     a + b
  11. }
  12.  
  13. // 没有参数没有返回值
  14. #[no_mangle]
  15. pub fn print_hello() {
  16.     println!("Hello");
  17. }
  18.  
  19. // 字符串类型
  20. #[no_mangle]
  21. pub fn return_str(s1: &str) -> &str{
  22.     s1
  23. }

Step 2、toml 配置编译类型

  1. [package]
  2. name = "mydll"
  3. version = "0.1.0"
  4. edition = "2021"
  5.  
  6. # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
  7.  
  8. [dependencies]
  9.  
  10.  
  11. # rlib：Rust库，这是cargo new默认的种类，只能被Rust调用；
  12. # dylib：Rust规范的动态链接库，windows上编译成.dll，linux上编译成.so，也只能被Rust调用；
  13. # cdylib：满足C语言规范的动态链接库，windows上编译成.dll，linux上编译成.so，可以被其他语言调用
  14. # staticlib：静态库，windows上编译成.lib，linux上编译成.a，可以被其他语言调用
  15.  
  16. [lib]
  17. crate-type = ["cdylib"]

Step 3、编译为 dll

cargo build

可以看到，所有的函数都被正常导出，具体原理请参考：So you want to live-reload Rust

Step 4、动态加载 dll

  1. use cstr::cstr;
  2. use libloader::*;
  3. use std::{ffi::CStr,os::raw::c_char};
  4.  
  5. fn main() {
  6.     get_libfn!("dll/mydll.dll", "println", println, (), s: &str);
  7.     println("你好");
  8.  
  9.     get_libfn!("dll/mydll.dll", "add", add, usize, a: usize, b: usize);
  10.     println!(" 1 + 2 = {}", add(1, 2));
  11.  
  12.     get_libfn!("dll/mydll.dll", "print_hello", print_hello, bool);
  13.     print_hello();
  14.  
  15.     get_libfn!("dll/mydll.dll","return_str", return_str,*const c_char, s: *const c_char);
  16.     let str = unsafe { CStr::from_ptr(return_str(cstr!("你好 ").as_ptr())) };
  17.     print!("out {}", str.to_str().unwrap());
  18. }

五、C# 通过反射机制实现插件化开发

Step 1、定义插件接口

  1.  
  2. namespace PluginInterface
  3. {
  4.  
  5.     public interface IPlugin
  6.     {
  7.         // 获取插件名字
  8.         public string GetName();
  9.  
  10.         // 获取插件所提供的功能列表
  11.         public string[] GetFunction();
  12.  
  13.         // 执行插件某个功能
  14.         public bool Execute(string fn);
  15.     }
  16.  
  17. }

Step 2、实现插件接口

  1.  
  2. using PluginInterface;
  3. using System;
  4. using System.Linq;
  5.  
  6. namespace MyPlugin
  7. {
  8.  
  9.     public class PrinterPlugin : IPlugin
  10.     {
  11.         private static readonly string PLUGIN_NAME = "PrinterPlugin";
  12.  
  13.         // 获取插件名字
  14.         public string GetName()
  15.         {
  16.             return PLUGIN_NAME;
  17.         }
  18.  
  19.         // 获取插件所提供的功能列表
  20.         public string[] GetFunction()
  21.         {
  22.             return PrinterFunc.FuncDics.Keys.ToArray();
  23.         }
  24.  
  25.         // 执行插件某个功能
  26.         public bool Execute(string fn)
  27.         {
  28.             return PrinterFunc.Run(fn);
  29.         }
  30.  
  31.         // 传参功能
  32.         public static object PrintLabel(string sn)
  33.         {
  34.             Console.WriteLine($"打印标签{sn}...DONE");
  35.             return true;
  36.         }
  37.     }
  38. }
  1.  
  2. using System;
  3. using System.Collections.Generic;
  4.  
  5. namespace MyPlugin
  6. {
  7.     // 封装打印机支持的功能
  8.     internal class PrinterFunc
  9.     {
  10.         // 功能字典
  11.         public static Dictionary<string, Func<bool>> FuncDics = new Dictionary<string, Func<bool>>
  12.         {
  13.             {"PrintPhoto",PrintPhoto },
  14.             {"PrintDoc",PrintDoc }
  15.         };
  16.         // 执行某个功能
  17.         public static bool Run(string name)
  18.         {
  19.             if (!FuncDics.ContainsKey(name))
  20.             {
  21.                 return false;
  22.             }
  23.  
  24.             return (bool)FuncDics[name].Invoke();
  25.         }
  26.         // 打印照片
  27.         public static bool PrintPhoto()
  28.         {
  29.             Console.WriteLine("打印照片...DONE");
  30.             return true;
  31.         }
  32.         // 打印文档
  33.         public static bool PrintDoc()
  34.         {
  35.             Console.WriteLine("打印文档...DONE");
  36.             return true;
  37.         }
  38.     }
  39.  
  40. }

Step 3、通过反射实例化插件

  1.  
  2. using PluginInterface;
  3. using System;
  4. using System.Collections.Generic;
  5. using System.IO;
  6. using System.Reflection;
  7.  
  8. namespace CLI.Loader
  9. {
  10.     public class PluginLoader
  11.     {
  12.         // 初始化时加载插件
  13.         public PluginLoader()
  14.         {
  15.             LoadPlugin();
  16.         }
  17.  
  18.         public Dictionary<string, IPlugin> ListName = new Dictionary<string, IPlugin>();
  19.  
  20.         // 加载所有插件
  21.         public void LoadPlugin()
  22.         {
  23.             try
  24.             {
  25.                 // 清除所有插件缓存
  26.                 ListName.Clear();
  27.                 // 插件文件夹
  28.                 string fileName = "D:\\AwsomeWorkSpace\\CLI\\Plugins\\net5.0\\";
  29.                 // 获取所有插件文件
  30.                 DirectoryInfo info = new DirectoryInfo(fileName);
  31.                 FileInfo[] files = info.GetFiles();
  32.                 foreach (FileInfo file in files)
  33.                 {
  34.                     if (!file.FullName.EndsWith(".dll"))
  35.                     {
  36.                         continue;
  37.                     }
  38.                     // 通过反射机制创建插件实例
  39.                     Assembly assembly = Assembly.LoadFile(file.FullName);
  40.                     Type[] types = assembly.GetTypes();
  41.                     foreach (Type type in types)
  42.                     {
  43.                         // 如果某些类实现了预定义的插件接口，则认为该类适配与主程序(是主程序的插件)
  44.  
  45.                         if (type.GetInterface("IPlugin") != null)
  46.                         {
  47.                             // 创建该类实例
  48.                             IPlugin plugin = assembly.CreateInstance(type.FullName) as IPlugin;
  49.                             if (plugin == null)
  50.                             {
  51.                                 throw new Exception("插件错误");
  52.                             }
  53.                             ListName.Add(plugin.GetName(), plugin);
  54.                             // 调用插件的某个传参方法
  55.                             MethodInfo printLabel = type.GetMethod("PrintLabel");
  56.                             object res = printLabel.Invoke(plugin, parameters: new object[] { "HQ31122222222222" });
  57.                             Console.WriteLine(res?.ToString());
  58.                             // 调用插件内部的 Execute 方法
  59.                             MethodInfo execute = type.GetMethod("Execute");
  60.                             res = execute.Invoke(plugin, parameters: new object[] { "PrintPhoto" });
  61.                             Console.WriteLine(res?.ToString());
  62.                             res = execute.Invoke(plugin, parameters: new object[] { "PrintDoc" });
  63.                             Console.WriteLine(res?.ToString());
  64.                         }
  65.                     }
  66.                 }
  67.             }
  68.             catch (Exception e)
  69.             {
  70.                 Console.WriteLine(e.Message);
  71.             }
  72.         }
  73.  
  74.         // 插件启动
  75.         public void Start()
  76.         {
  77.             Console.WriteLine("==== 插件中心 ====");
  78.             Console.WriteLine("1--加载插件列表");
  79.             Console.WriteLine("2--重新刷新插件");
  80.             int switchVal = int.Parse(Console.ReadLine());
  81.             switch (switchVal)
  82.             {
  83.                 case 1:
  84.                     GetPluginList();
  85.                     break;
  86.                 case 2:
  87.                     LoadPlugin();
  88.                     break; ;
  89.             }
  90.  
  91.         }
  92.  
  93.         // 加载插件列表
  94.         public void GetPluginList()
  95.         {
  96.             Console.WriteLine("--------插件列表--------");
  97.             foreach (var VARIABLE in ListName.Keys)
  98.             {
  99.                 Console.WriteLine($"----{VARIABLE}");
  100.             }
  101.             Console.WriteLine("--------请输入插件名--------");
  102.             GetPluginFunc(Console.ReadLine());
  103.         }
  104.  
  105.         // 加载插件功能
  106.         public void GetPluginFunc(string pluginName)
  107.         {
  108.             if (!ListName.ContainsKey(pluginName))
  109.             {
  110.                 return;
  111.             }
  112.             IPlugin plugin = ListName[pluginName];
  113.             string[] funcList = plugin.GetFunction();
  114.             for (int i = 0; i < funcList.Length; i++)
  115.             {
  116.                 Console.WriteLine(funcList[i]);
  117.                 plugin.Execute(funcList[i]);
  118.             }
  119.         }
  120.  
  121.  
  122.     }
  123. }

ok，可以看到，插件化开发的实现并不复杂，但是其中用到的反射机制会消耗部分性能，并且 dll 也会存在一些逆向工程或者反向注入等信安问题，需要谨慎使用。当然，框架的完善更是任重道远的过程。

六、.NET 6/7 导出非托管函数能力

环境：Visual Studio 2022 / .NET7

参考：https://github.com/dotnet/runtime/tree/main/src/coreclr/nativeaot/docs

Step 1、创建类库项目

  1.  
  2. dotnet new classlib -o mydll -f net6.0

Step 2、配置 AOT Native

  1. <Project Sdk="Microsoft.NET.Sdk">
  2.  
  3.   <PropertyGroup>
  4.     <TargetFramework>net7.0</TargetFramework>
  5.     <ImplicitUsings>enable</ImplicitUsings>
  6.     <Nullable>enable</Nullable>
  7.     <PublishAot>true</PublishAot>
  8.   </PropertyGroup>
  9.  
  10. </Project>

Step 3、导出非托管函数

  1.  
  2. using System.Runtime.InteropServices;
  3. using Seagull.BarTender.Print;
  4.  
  5. namespace ClassLibrary1
  6. {
  7.     public class Class1
  8.     {
  9.         // 无参数有返回值
  10.         [UnmanagedCallersOnly(EntryPoint = "IsOk")]
  11.         public static bool IsOk()
  12.         {
  13.             return true;
  14.         }
  15.         // 有参数无返回值
  16.         [UnmanagedCallersOnly(EntryPoint = "MyPrinter")]
  17.         public static void MyPrinter(IntPtr pString)
  18.         {
  19.  
  20.             try
  21.             {
  22.                 if (pString != IntPtr.Zero)
  23.                 {
  24.                     string str = new(Marshal.PtrToStringAnsi(pString));
  25.                     Console.WriteLine(str);
  26.                 }
  27.             }
  28.             catch (Exception e)
  29.             {
  30.                 Console.WriteLine(">>> Exception " + e.Message);
  31.             }
  32.         }
  33.         // 有参数有返回值
  34.         [UnmanagedCallersOnly(EntryPoint = "MyConcat")]
  35.         public static IntPtr MyConcat(IntPtr pString1, IntPtr pString2)
  36.         {
  37.             string concat = "";
  38.  
  39.             try
  40.             {
  41.                 if (pString1 != IntPtr.Zero && pString2 != IntPtr.Zero)
  42.                 {
  43.                     string str1 = new(Marshal.PtrToStringAnsi(pString1));
  44.                     string str2 = new(Marshal.PtrToStringAnsi(pString2));
  45.                     concat = string.Concat(str1, str2);
  46.                 }
  47.             }
  48.             catch (Exception e)
  49.             {
  50.                 concat = e.Message;
  51.             }
  52.             return Marshal.StringToHGlobalAnsi(concat);
  53.         }
  54.         // 无参数无返回值
  55.         [UnmanagedCallersOnly(EntryPoint = "PrintHello")]
  56.         public static void PrintHello()
  57.         {
  58.             Console.WriteLine(">>> Hello");
  59.         }
  60.     }
  61. }

Step 4、查看导出结果

  1.  
  2. dotnet publish /p:NativeLib=Shared /p:SelfContained=true -r win-x64 -c release

可以看到 native 、publish 文件夹，里面的 dll 文件

函数正常导出，最后一个是默认导出的函数。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/小舞很执着/article/detail/861064
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号