【架构实战】插件化架构设计与SPI机制

┌─────────────────────────────────────────────────────────────────┐│                      插件化架构                                   │├─────────────────────────────────────────────────────────────────┤│                                                                  ││  ┌──────────────────────────────────────────────────────────┐  ││  │                      主程序（核心）                        │  ││  │  ┌──────────────────────────────────────────────────┐  │  ││  │  │              插件管理器（PluginManager）            │  │  ││  │  │  - 插件加载/卸载                                    │  │  ││  │  │  - 生命周期管理                                      │  │  ││  │  │  - 依赖管理                                          │  │  ││  │  └──────────────────────────────────────────────────┘  │  ││  │  ┌──────────────────────────────────────────────────┐  │  ││  │  │              插件接口（Plugin SPI）                 │  │  ││  │  │  - 定义插件标准                                    │  │  ││  │  │  - 提供服务发现机制                                │  │  ││  │  └──────────────────────────────────────────────────┘  │  ││  └──────────────────────────────────────────────────────────┘  ││                              │                                   ││          ┌───────────────────┼───────────────────┐              ││          │                   │                   │              ││          ▼                   ▼                   ▼              ││  ┌──────────────┐   ┌──────────────┐   ┌──────────────┐      ││  │   插件A      │   │   插件B      │   │   插件C      │      ││  │ (认证插件)   │   │ (日志插件)   │   │ (存储插件)   │      ││  └──────────────┘   └──────────────┘   └──────────────┘      ││                                                                  │└─────────────────────────────────────────────────────────────────┘

// SPI接口定义public interface DataSourcePlugin {    String getName();    void connect();    void disconnect();    Result executeQuery(String sql);}// SPI实现public class MySQLPlugin implements DataSourcePlugin {    @Override    public String getName() {        return "MySQL";    }    @Override    public void connect() {        // MySQL连接逻辑    }    @Override    public void disconnect() {        // MySQL断开连接    }    @Override    public Result executeQuery(String sql) {        // 执行查询        return null;    }}// 在META-INF/services/目录下创建文件// 文件名：com.example.plugin.DataSourcePlugin// 内容：com.example.plugin.impl.MySQLPlugin// 加载SPIpublic class SPILoader {    public static <T> List<T> load(Class<T> spiClass) {        ServiceLoader<T> loader = ServiceLoader.load(spiClass);        List<T> plugins = new ArrayList<>();        for (T plugin : loader) {            plugins.add(plugin);        }        return plugins;    }    public static void main(String[] args) {        List<DataSourcePlugin> plugins = SPILoader.load(DataSourcePlugin.class);        for (DataSourcePlugin plugin : plugins) {            System.out.println("加载插件: " + plugin.getName());            plugin.connect();        }    }}

# resources/META-INF/spring.factoriesorg.springframework.boot.autoconfigure.EnableAutoConfiguration=\com.example.plugin.auth.JwtAuthPlugin,\com.example.plugin.cache.RedisCachePlugin,\com.example.plugin.export.ExcelExportPlugin

// Dubbo SPI接口@SPIpublic interface Protocol {    @Adaptive    <T> Exporter<T> export(Invoker<T> invoker) throws RpcException;    @Adaptive    <T> Invoker<T> refer(Class<T> type, URL url) throws RpcException;    void destroy();}// 使用@Adaptive进行自适应扩展@Adaptivepublic class AdaptiveProtocol implements Protocol {    @Override    public <T> Exporter<T> export(Invoker<T> invoker) throws RpcException {        URL url = invoker.getUrl();        String protocol = url.getProtocol();        // 根据URL中的协议加载对应实现        return ExtensionLoader.getExtensionLoader(Protocol.class)            .getExtension(protocol).export(invoker);    }}// 配置扩展// Dubbo-Protocol: dubbo, rmi, hessian, http, webservice, thrift, memcached, redis

// 插件基础接口public interface Plugin {    // 插件标识    String getId();    // 插件名称    String getName();    // 插件版本    String getVersion();    // 插件描述    String getDescription();    // 插件类型    PluginType getType();    // 初始化    default void init(PluginContext context) {}    // 启动    default void start() {}    // 停止    default void stop() {}    // 卸载    default void destroy() {}}// 插件类型枚举public enum PluginType {    AUTH,           // 认证    CACHE,          // 缓存    STORAGE,        // 存储    EXPORT,         // 导出    IMPORT,         // 导入    NOTIFICATION,   // 通知    VALIDATION,     // 校验    TRANSFORM       // 数据转换}// 插件上下文public class PluginContext {    private Map<String, Object> config;    private ApplicationContext springContext;    private PluginManager pluginManager;    // 获取依赖的插件    public <T extends Plugin> T getDependency(Class<T> pluginClass) {        return pluginManager.getPlugin(pluginClass);    }}

@Componentpublic class PluginManager {    private final Map<String, Plugin> plugins = new ConcurrentHashMap<>();    private final Map<String, PluginMetadata> pluginMetadata = new ConcurrentHashMap<>();    @Autowired    private ApplicationContext applicationContext;    // 扫描并加载插件    public void scanAndLoadPlugins(String scanPackage) {        Reflections reflections = new Reflections(scanPackage);        Set<Class<? extends Plugin>> pluginClasses =             reflections.getSubTypesOf(Plugin.class);        for (Class<? extends Plugin> pluginClass : pluginClasses) {            loadPlugin(pluginClass);        }    }    // 加载单个插件    public void loadPlugin(Class<? extends Plugin> pluginClass) {        try {            PluginMetadata annotation = pluginClass.getAnnotation(PluginMetadata.class);            if (annotation == null) {                throw new IllegalStateException("插件类必须标注@PluginMetadata");            }            Plugin plugin = pluginClass.getDeclaredConstructor().newInstance();            // 初始化插件            PluginContext context = createPluginContext(plugin);            plugin.init(context);            // 启动插件            plugin.start();            // 注册插件            plugins.put(annotation.id(), plugin);            pluginMetadata.put(annotation.id(), annotation);            System.out.println("插件加载成功: " + annotation.name());        } catch (Exception e) {            throw new PluginLoadException("插件加载失败: " + pluginClass.getName(), e);        }    }    // 卸载插件    public void unloadPlugin(String pluginId) {        Plugin plugin = plugins.remove(pluginId);        if (plugin != null) {            plugin.stop();            plugin.destroy();            System.out.println("插件卸载成功: " + pluginId);        }    }    // 获取插件    @SuppressWarnings("unchecked")    public <T extends Plugin> T getPlugin(Class<T> pluginClass) {        for (Plugin plugin : plugins.values()) {            if (pluginClass.isInstance(plugin)) {                return (T) plugin;            }        }        return null;    }    // 获取指定类型的插件    public List<Plugin> getPluginsByType(PluginType type) {        return plugins.values().stream()            .filter(p -> p.getType() == type)            .collect(Collectors.toList());    }}

// 插件元数据注解@Retention(RetentionPolicy.RUNTIME)@Target(ElementType.TYPE)public @interface PluginMetadata {    String id();              // 插件唯一标识    String name();            // 插件名称    String version();          // 插件版本    String description();     // 插件描述    PluginType type();        // 插件类型    String[] dependencies() default {};  // 依赖的插件    String author() default "";         // 作者}// 插件实现示例@PluginMetadata(    id = "auth-jwt",    name = "JWT认证插件",    version = "1.0.0",    description = "提供JWT Token认证功能",    type = PluginType.AUTH,    dependencies = {},    author = "example")public class JwtAuthPlugin implements Plugin {    @Override    public String getId() {        return "auth-jwt";    }    @Override    public String getName() {        return "JWT认证插件";    }    @Override    public PluginType getType() {        return PluginType.AUTH;    }    @Override    public void start() {        System.out.println("JWT认证插件启动");    }    // 实现认证逻辑    public boolean authenticate(String token) {        // JWT认证实现        return true;    }}

public class IsolatedClassLoader extends URLClassLoader {    private final Map<String, Class<?>> classes = new ConcurrentHashMap<>();    public IsolatedClassLoader(URL[] urls, ClassLoader parent) {        super(urls, null); // 不委托给父加载器    }    @Override    protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {        // 首先检查已加载的类        Class<?> clazz = classes.get(name);        if (clazz == null) {            // 委派给同级类加载器            clazz = findClass(name);        }        if (resolve) {            resolveClass(clazz);        }        return clazz;    }    @Override    protected Class<?> findClass(String name) throws ClassNotFoundException {        // 从插件jar中加载类        String path = name.replace('.', '/') + ".class";        try (InputStream is = getResourceAsStream(path)) {            if (is == null) {                throw new ClassNotFoundException(name);            }            byte[] bytes = IOUtils.toByteArray(is);            return defineClass(name, bytes, 0, bytes.length);        } catch (IOException e) {            throw new ClassNotFoundException(name, e);        }    }}

@Componentpublic class HotReloadWatcher {    private final Map<String, PluginClassLoader> classLoaders = new ConcurrentHashMap<>();    @Autowired    private PluginManager pluginManager;    // 监听插件目录变化    @PostConstruct    public void watch() {        WatchService watchService = createWatchService();        new Thread(() -> {            try {                while (true) {                    WatchKey key = watchService.take();                    for (WatchEvent<?> event : key.pollEvents()) {                        if (event.kind() == ENTRY_MODIFY) {                            handlePluginChange((Path) event.context());                        }                    }                    key.reset();                }            } catch (Exception e) {                e.printStackTrace();            }        }).start();    }    private void handlePluginChange(Path path) {        if (path.toString().endsWith(".jar")) {            String pluginId = extractPluginId(path);            // 卸载旧插件            pluginManager.unloadPlugin(pluginId);            // 加载新插件            try {                pluginManager.loadPlugin(loadPluginClass(pluginId));            } catch (Exception e) {                System.err.println("热加载失败: " + e.getMessage());            }        }    }}

@Servicepublic class PluginDependencyManager {    // 检查依赖    public boolean checkDependencies(PluginMetadata metadata) {        String[] deps = metadata.dependencies();        for (String dep : deps) {            if (!isPluginLoaded(dep)) {                System.err.println("缺少依赖插件: " + dep);                return false;            }        }        return true;    }    // 拓扑排序加载顺序    public List<String> resolveLoadOrder(List<PluginMetadata> plugins) {        Map<String, Set<String>> graph = new HashMap<>();        // 构建依赖图        for (PluginMetadata plugin : plugins) {            graph.put(plugin.id(), new HashSet<>(Arrays.asList(plugin.dependencies())));        }        // 拓扑排序        return topologicalSort(graph);    }    private List<String> topologicalSort(Map<String, Set<String>> graph) {        List<String> result = new ArrayList<>();        Set<String> visited = new HashSet<>();        Set<String> visiting = new HashSet<>();        for (String node : graph.keySet()) {            visit(node, graph, visited, visiting, result);        }        return result;    }    private void visit(String node, Map<String, Set<String>> graph,                      Set<String> visited, Set<String> visiting, List<String> result) {        if (visited.contains(node)) return;        if (visiting.contains(node)) {            throw new IllegalStateException("循环依赖: " + node);        }        visiting.add(node);        for (String dep : graph.getOrDefault(node, Collections.emptySet())) {            visit(dep, graph, visited, visiting, result);        }        visiting.remove(node);        visited.add(node);        result.add(node);    }}

// OSGi Bundle Activatorpublic class MyBundleActivator implements BundleActivator {    @Override    public void start(BundleContext context) {        // 注册服务        Dictionary<String, String> props = new Hashtable<>();        props.put("name", "MyService");        context.registerService(MyService.class.getName(), new MyServiceImpl(), props);    }    @Override    public void stop(BundleContext context) {        // 清理资源    }}// OSGi Service Reference@ServiceReferenceprivate MyService myService;

// PF4J插件定义public class MyPlugin extends Plugin {    public MyPlugin(PluginWrapper wrapper) {        super(wrapper);    }    @Override    public void start() {        System.out.println("插件启动");    }    @Override    public void stop() {        System.out.println("插件停止");    }}// PF4J插件加载器PluginManager pluginManager = new DefaultPluginManager();pluginManager.loadPlugins();pluginManager.startPlugins();

// 清晰的接口定义public interface ReportPlugin {    // 插件标识    String getId();    String getName();    // 支持的类型    List<String> supportedTypes();    // 生成报告    Report generate(ReportRequest request);    // 预览    String preview(ReportRequest request);    // 导出格式    ExportFormat[] supportedFormats();    // 生命周期    default void init(PluginContext context) {}    default void destroy() {}}

# 插件配置plugins:  auth-jwt:    enabled: true    secret: {REDIS_HOST}    port: 6379

// 插件安全沙箱public class PluginSandbox {    // 限制插件权限    public static PermissionCollection getPermissions(ProtectionDomain domain) {        Policy policy = Policy.getPolicy();        PermissionCollection perms = policy.getPermissions(domain);        // 只允许特定权限        perms.add(new RuntimePermission("accessClassInPackage.xxx"));        perms.add(new SocketPermission("localhost:8080", "connect"));        return perms;    }    // 限制插件访问的文件    public static void checkFileAccess(String path) {        if (!path.startsWith(ALLOWED_PLUGIN_DIR)) {            throw new SecurityException("禁止访问: " + path);        }    }}