插件系统设计与实现指南（二）

插件和应用程序的关系是什么？插件和进程的关系是什么？如何设计一个插件应用？

我们首先从概念上理解插件和应用程序的关系，以及插件和进程的关系，然后深入探讨如何设计一个插件应用，包括其工作机制和原理，并举例说明。

一、插件和应用程序的关系

插件（Plugin）是一种遵循一定规范的应用程序接口编写出来的程序，它不能独立运行，必须依附于主应用程序（宿主程序）。插件是为了扩展主程序的功能而存在的。主程序通过预定义的接口与插件通信，调用插件提供的功能。

关系：

• 主从关系：应用程序是主体，插件是扩展。应用程序负责加载和管理插件，插件在应用程序的框架内运行。

• 接口约定：应用程序定义接口，插件实现接口。这种关系类似于面向对象中的接口与实现类。

• 动态扩展：应用程序的功能可以通过插件动态扩展，而不需要修改应用程序本身的代码。

二、插件和进程的关系

插件和进程的关系取决于插件系统的设计。主要有两种方式：

1. 在相同进程内运行（In-Process）：插件作为动态库（如DLL、SO）被加载到主程序的进程空间中。这种方式调用效率高，但插件的不稳定可能导致主程序崩溃。

2. 在独立进程内运行（Out-of-Process）：插件运行在独立的进程中，与主程序通过进程间通信（IPC）进行交互。这种方式稳定性好，插件崩溃不会影响主程序，但通信开销较大。

现代插件系统有时会混合使用两种方式，根据插件的需求决定。

三、如何设计一个插件应用

设计一个插件应用需要考虑以下几个方面：

1. 插件接口设计：定义插件必须实现的接口，以及主程序提供给插件的接口。

2. 插件发现与加载：主程序如何发现插件（如扫描特定目录，读取配置文件），以及如何加载插件（动态库加载、类加载等）。

3. 插件生命周期管理：插件的安装、激活、禁用、卸载等。

4. 插件间通信：插件之间如何通信，以及插件与主程序如何通信。

5. 安全性：插件可能具有恶意代码，需要沙箱机制限制插件的权限。

6. 性能：插件加载和运行时的性能影响。

四、插件的工作机制和原理

插件的工作机制通常包括以下步骤：

1. 定义接口：主程序定义一组接口，插件需要实现这些接口。

2. 插件实现：插件开发者实现这些接口，并将插件打包成特定格式（如动态库、JAR包、Python模块等）。

3. 插件发现：主程序在启动时或运行时扫描插件目录，读取插件元数据（如插件名称、版本、入口类等）。

4. 插件加载：主程序使用相应的加载机制（如操作系统的动态库加载、Java的类加载器、Python的import）加载插件。

5. 插件注册：加载插件后，主程序调用插件的初始化函数，插件向主程序注册自己（如注册菜单、命令、事件处理函数等）。

6. 插件调用：主程序在适当的时机（如用户点击菜单、事件触发）调用插件提供的功能。

7. 插件卸载：主程序在关闭时或动态卸载插件时，调用插件的清理函数，然后卸载插件。

五、核心是什么？

插件系统的核心是接口（契约）。主程序和插件都遵循同一套接口，这样主程序可以调用任何符合接口的插件，而插件也可以被任何符合接口的主程序使用。接口是两者通信的桥梁。

此外，插件系统的核心还包括动态加载和生命周期管理。

六、实例

接下来，我将用UML图和不同语言的示例来说明。

6.1 UML类图

一个简单的插件系统可能包含以下角色：

• IPlugin：插件接口，所有插件必须实现。

• PluginManager：插件管理器，负责加载、管理插件。

• HostApplication：主程序，使用插件管理器来加载插件，并通过接口调用插件。

@startuml
interface IPlugin {
  +initialize(): void
  +execute(): void
  +cleanup(): void
}

class ConcretePlugin {
  +initialize(): void
  +execute(): void
  +cleanup(): void
}

class PluginManager {
  -plugins: List<IPlugin>
  +loadPlugin(path: String): void
  +unloadPlugin(plugin: IPlugin): void
  +getPlugins(): List<IPlugin>
}

class HostApplication {
  -pluginManager: PluginManager
  +run(): void
}

HostApplication --> PluginManager
PluginManager --> IPlugin
ConcretePlugin ..|> IPlugin
@enduml

6.2 C/C++ 示例

在C/C++中，插件通常以动态库的形式存在。主程序通过动态加载库（如dlopen）来加载插件，并通过函数指针调用插件中的函数。

接口定义（plugin_interface.h）

#ifndef PLUGIN_INTERFACE_H
#define PLUGIN_INTERFACE_H

#ifdef __cplusplus
extern "C" {
#endif

typedef struct {
    const char* name;
    void (*initialize)();
    void (*execute)();
    void (*cleanup)();
} Plugin;

// 每个插件必须实现这个函数，返回一个Plugin结构体实例
typedef Plugin* (*GetPluginFunc)();

#ifdef __cplusplus
}
#endif

#endif // PLUGIN_INTERFACE_H

插件实现（my_plugin.c）

#include <stdio.h>
#include "plugin_interface.h"

static void initialize() {
    printf("MyPlugin initialized.\n");
}

static void execute() {
    printf("MyPlugin executing.\n");
}

static void cleanup() {
    printf("MyPlugin cleaned up.\n");
}

static Plugin plugin = {
    .name = "MyPlugin",
    .initialize = initialize,
    .execute = execute,
    .cleanup = cleanup
};

Plugin* get_plugin() {
    return &plugin;
}

主程序（main.c）

#include <stdio.h>
#include <dlfcn.h>
#include "plugin_interface.h"

int main() {
    void* handle = dlopen("./my_plugin.so", RTLD_LAZY);
    if (!handle) {
        fprintf(stderr, "Cannot load plugin: %s\n", dlerror());
        return 1;
    }

    GetPluginFunc get_plugin = (GetPluginFunc)dlsym(handle, "get_plugin");
    if (!get_plugin) {
        fprintf(stderr, "Cannot find symbol: %s\n", dlerror());
        dlclose(handle);
        return 1;
    }

    Plugin* plugin = get_plugin();
    plugin->initialize();
    plugin->execute();
    plugin->cleanup();

    dlclose(handle);
    return 0;
}

编译插件：

gcc -shared -fPIC -o my_plugin.so my_plugin.c

编译主程序：

gcc -o main main.c -ldl

6.3 Java 示例

在Java中，插件通常以JAR包的形式存在，通过类加载器加载，并使用接口来定义契约。

接口定义（Plugin.java）

public interface Plugin {
    void initialize();
    void execute();
    void cleanup();
}

插件实现（MyPlugin.java）

public class MyPlugin implements Plugin {
    @Override
    public void initialize() {
        System.out.println("MyPlugin initialized.");
    }

    @Override
    public void execute() {
        System.out.println("MyPlugin executing.");
    }

    @Override
    public void cleanup() {
        System.out.println("MyPlugin cleaned up.");
    }
}

插件管理器（PluginManager.java）

import java.io.File;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.ArrayList;
import java.util.List;
import java.util.ServiceLoader;

public class PluginManager {
    private List<Plugin> plugins = new ArrayList<>();

    public void loadPlugins(String pluginDir) throws Exception {
        File dir = new File(pluginDir);
        if (!dir.exists()) return;

        for (File jar : dir.listFiles((d, name) -> name.endsWith(".jar"))) {
            URLClassLoader classLoader = new URLClassLoader(
                new URL[]{jar.toURI().toURL()},
                getClass().getClassLoader()
            );
            // 使用ServiceLoader机制，要求插件JAR的META-INF/services下有配置文件
            ServiceLoader<Plugin> serviceLoader = ServiceLoader.load(Plugin.class, classLoader);
            for (Plugin plugin : serviceLoader) {
                plugins.add(plugin);
            }
        }
    }

    public List<Plugin> getPlugins() {
        return plugins;
    }
}

主程序（Main.java）

public class Main {
    public static void main(String[] args) throws Exception {
        PluginManager pluginManager = new PluginManager();
        pluginManager.loadPlugins("./plugins");

        for (Plugin plugin : pluginManager.getPlugins()) {
            plugin.initialize();
            plugin.execute();
            plugin.cleanup();
        }
    }
}

6.4 Python 示例

Python中，插件可以通过模块动态加载实现。

接口定义（plugin_interface.py）

import abc

class Plugin(abc.ABC):
    @abc.abstractmethod
    def initialize(self):
        pass

    @abc.abstractmethod
    def execute(self):
        pass

    @abc.abstractmethod
    def cleanup(self):
        pass

插件实现（my_plugin.py）

from plugin_interface import Plugin

class MyPlugin(Plugin):
    def initialize(self):
        print("MyPlugin initialized.")

    def execute(self):
        print("MyPlugin executing.")

    def cleanup(self):
        print("MyPlugin cleaned up.")

插件管理器（plugin_manager.py）

import importlib
import os
import sys

class PluginManager:
    def __init__(self):
        self.plugins = []

    def load_plugins(self, plugin_dir):
        sys.path.insert(0, plugin_dir)
        for filename in os.listdir(plugin_dir):
            if filename.endswith('.py') and not filename.startswith('_'):
                module_name = filename[:-3]
                module = importlib.import_module(module_name)
                for attr_name in dir(module):
                    attr = getattr(module, attr_name)
                    if isinstance(attr, type) and issubclass(attr, Plugin) and attr is not Plugin:
                        plugin_instance = attr()
                        self.plugins.append(plugin_instance)

    def get_plugins(self):
        return self.plugins

主程序（main.py）

from plugin_manager import PluginManager

if __name__ == "__main__":
    plugin_manager = PluginManager()
    plugin_manager.load_plugins("./plugins")

    for plugin in plugin_manager.get_plugins():
        plugin.initialize()
        plugin.execute()
        plugin.cleanup()

6.5 JavaScript (Node.js) 示例

在Node.js中，插件可以通过require动态加载。

接口定义（Plugin.js）

class Plugin {
    initialize() {
        throw new Error('Method not implemented');
    }

    execute() {
        throw new Error('Method not implemented');
    }

    cleanup() {
        throw new Error('Method not implemented');
    }
}

module.exports = Plugin;

插件实现（MyPlugin.js）

const Plugin = require('./Plugin');

class MyPlugin extends Plugin {
    initialize() {
        console.log('MyPlugin initialized.');
    }

    execute() {
        console.log('MyPlugin executing.');
    }

    cleanup() {
        console.log('MyPlugin cleaned up.');
    }
}

module.exports = MyPlugin;

插件管理器（PluginManager.js）

const fs = require('fs');
const path = require('path');

class PluginManager {
    constructor() {
        this.plugins = [];
    }

    loadPlugins(pluginDir) {
        const files = fs.readdirSync(pluginDir);
        files.forEach(file => {
            if (file.endsWith('.js') && !file.startsWith('_')) {
                const pluginPath = path.join(pluginDir, file);
                const PluginClass = require(pluginPath);
                const pluginInstance = new PluginClass();
                this.plugins.push(pluginInstance);
            }
        });
    }

    getPlugins() {
        return this.plugins;
    }
}

module.exports = PluginManager;

主程序（main.js）

const PluginManager = require('./PluginManager');

const pluginManager = new PluginManager();
pluginManager.loadPlugins('./plugins');

const plugins = pluginManager.getPlugins();
plugins.forEach(plugin => {
    plugin.initialize();
    plugin.execute();
    plugin.cleanup();
});

七、概述总结

插件系统的设计核心在于定义清晰的接口，并实现动态加载。不同语言实现插件系统的方式各有特点，但原理相似。在设计时，还需要考虑插件的生命周期、依赖管理、版本兼容性、安全性等问题。以上示例为简单演示，实际系统中可能需要更复杂的设计。

插件系统深度解析：从理论到多语言实现

一、插件与应用程序的关系

1.1 本质关系：扩展与宿主

关键特征：

• 寄生性：插件不能独立运行，必须依附于宿主应用
• 扩展性：插件为主程序添加新功能或修改现有功能
• 模块化：插件是功能模块，便于独立开发、测试和部署
• 松耦合：理想情况下插件与主程序、插件之间相互独立

1.2 关系类型

关系类型	描述	示例
功能扩展	添加新功能	IDE的代码格式化插件
界面定制	修改UI/UX	浏览器主题插件
协议支持	支持新格式	图片编辑器支持PSD格式
服务增强	增强核心服务	数据库管理工具的连接池优化

二、插件与进程的关系

2.1 进程模型对比

// 进程关系示意图代码表示
/*
 * 插件进程模型：
 * 
 * 模型1: 同进程（In-Process）
 * ┌─────────────────────┐
 * │   主进程            │
 * │  ┌──────┐ ┌──────┐ │
 * │  │插件A │ │插件B │ │
 * │  └──────┘ └──────┘ │
 * └─────────────────────┘
 * 优点：高性能，直接调用
 * 缺点：安全性差，稳定性风险
 * 
 * 模型2: 独立进程（Out-of-Process）
 * ┌─────────┐   IPC   ┌─────────┐
 * │主进程   │←──────→│插件进程 │
 * └─────────┘         └─────────┘
 * 优点：安全隔离，稳定性好
 * 缺点：通信开销大
 * 
 * 模型3: 混合模型
 * ┌─────────────────┐   IPC   ┌─────────┐
 * │主进程           │←──────→│插件进程A│
 * │  ┌──────┐       │         └─────────┘
 * │  │插件B │       │   IPC   ┌─────────┐
 * │  └──────┘       │←──────→│插件进程C│
 * └─────────────────┘         └─────────┘
 */

2.2 进程通信机制

// C++ 跨进程插件通信示例
class PluginIPC {
public:
    // 共享内存通信
    class SharedMemoryChannel {
    private:
        int shm_fd;
        void* shm_ptr;
        size_t shm_size;
        
    public:
        SharedMemoryChannel(const std::string& name, size_t size) {
            // 创建或打开共享内存
            shm_fd = shm_open(name.c_str(), O_CREAT | O_RDWR, 0666);
            ftruncate(shm_fd, size);
            shm_ptr = mmap(NULL, size, PROT_READ | PROT_WRITE, 
                          MAP_SHARED, shm_fd, 0);
            shm_size = size;
        }
        
        template<typename T>
        bool write(const T& data) {
            if (sizeof(T) > shm_size) return false;
            std::memcpy(shm_ptr, &data, sizeof(T));
            return true;
        }
        
        template<typename T>
        T read() {
            T data;
            std::memcpy(&data, shm_ptr, sizeof(T));
            return data;
        }
    };
    
    // 消息队列通信
    class MessageQueueChannel {
    private:
        mqd_t mq;
        
    public:
        MessageQueueChannel(const std::string& name) {
            struct mq_attr attr = {
                .mq_flags = 0,
                .mq_maxmsg = 10,
                .mq_msgsize = 1024,
                .mq_curmsgs = 0
            };
            
            mq = mq_open(name.c_str(), O_CREAT | O_RDWR, 0666, &attr);
        }
        
        bool send(const std::string& message, int priority = 0) {
            return mq_send(mq, message.c_str(), message.size(), priority) == 0;
        }
        
        std::string receive() {
            char buffer[1024];
            ssize_t bytes = mq_receive(mq, buffer, sizeof(buffer), NULL);
            if (bytes >= 0) {
                return std::string(buffer, bytes);
            }
            return "";
        }
    };
};

三、插件系统设计：核心原理与机制

3.1 UML架构设计

@startuml
' 插件系统UML类图

package "核心框架" {
  interface IPlugin {
    +getName(): string
    +getVersion(): string
    +initialize(): void
    +activate(): void
    +deactivate(): void
    +destroy(): void
  }
  
  class PluginManager {
    -plugins: Map<String, IPlugin>
    -eventBus: EventBus
    -serviceRegistry: ServiceRegistry
    +loadPlugin(path: string): IPlugin
    +unloadPlugin(name: string): void
    +getPlugin(name: string): IPlugin
    +emitEvent(event: PluginEvent): void
  }
  
  class PluginContext {
    -pluginId: string
    -config: PluginConfig
    -services: ServiceContainer
    +getService<T>(name: string): T
    +setService(name: string, service: any): void
    +getConfig(): PluginConfig
  }
  
  class EventBus {
    -subscribers: Map<String, List<EventHandler>>
    +subscribe(event: string, handler: EventHandler): void
    +unsubscribe(event: string, handler: EventHandler): void
    +publish(event: string, data: any): void
  }
}

package "插件实现" {
  class ConcretePlugin {
    -context: PluginContext
    +getName(): string
    +getVersion(): string
    +initialize(): void
    +activate(): void
    +deactivate(): void
    +destroy(): void
    -handleEvent(event: PluginEvent): void
  }
  
  class PluginFactory {
    +createPlugin(manifest: PluginManifest): IPlugin
  }
}

PluginManager --> IPlugin : 管理
PluginManager --> EventBus : 使用
PluginManager --> PluginContext : 创建
ConcretePlugin ..|> IPlugin : 实现
PluginFactory --> ConcretePlugin : 创建
PluginContext --> ConcretePlugin : 注入

@enduml

3.2 序列图：插件生命周期

@startuml
' 插件加载序列图
participant "主程序" as Host
participant "插件管理器" as Manager
participant "插件加载器" as Loader
participant "插件实例" as Plugin
participant "服务注册器" as Registry

Host -> Manager: loadPlugin("plugin.dll")
Manager -> Loader: loadLibrary("plugin.dll")
Loader -> Loader: 验证签名
Loader -> Loader: 检查依赖
Loader -> Plugin: createInstance()
Plugin -> Plugin: initialize()
Plugin -> Registry: registerServices()
Registry -> Registry: 注册到服务容器
Plugin -> Manager: 返回插件实例
Manager -> Host: 插件加载完成

Host -> Manager: activatePlugin("plugin")
Manager -> Plugin: activate()
Plugin -> Plugin: 订阅事件
Plugin -> Plugin: 注册命令
Plugin -> Host: 激活完成

Host -> Manager: emitEvent("data.ready")
Manager -> Plugin: onEvent("data.ready")
Plugin -> Plugin: handleEvent()
Plugin -> Host: 处理完成

Host -> Manager: unloadPlugin("plugin")
Manager -> Plugin: deactivate()
Plugin -> Plugin: 清理资源
Plugin -> Registry: unregisterServices()
Manager -> Loader: unloadLibrary()
Loader -> Loader: 释放资源
Manager -> Host: 插件卸载完成
@enduml

四、多语言实现实例

4.1 C语言实现（系统级插件）

// plugin_interface.h - 插件接口定义
#ifndef PLUGIN_INTERFACE_H
#define PLUGIN_INTERFACE_H

#ifdef __cplusplus
extern "C" {
#endif

// 插件API版本
#define PLUGIN_API_VERSION 1

// 插件信息结构
typedef struct {
    const char* name;
    const char* version;
    const char* author;
    const char* description;
    int api_version;
} PluginInfo;

// 插件操作函数指针类型
typedef void* (*PluginCreateFunc)(void);
typedef int (*PluginInitFunc)(void* instance, void* context);
typedef int (*PluginExecuteFunc)(void* instance, const char* command, void* data);
typedef void (*PluginDestroyFunc)(void* instance);

// 插件接口结构
typedef struct {
    PluginInfo info;
    PluginCreateFunc create;
    PluginInitFunc initialize;
    PluginExecuteFunc execute;
    PluginDestroyFunc destroy;
} PluginInterface;

// 插件导出函数声明
typedef PluginInterface* (*GetPluginInterfaceFunc)(void);

// 插件管理器
typedef struct {
    void* handle;
    PluginInterface* interface;
    void* instance;
    int initialized;
} PluginHandle;

// 插件管理器函数
PluginHandle* plugin_load(const char* path);
int plugin_initialize(PluginHandle* handle, void* context);
int plugin_execute(PluginHandle* handle, const char* command, void* data);
void plugin_unload(PluginHandle* handle);

#ifdef __cplusplus
}
#endif

#endif // PLUGIN_INTERFACE_H

// plugin_manager.c - 插件管理器实现
#include "plugin_interface.h"
#include <dlfcn.h>
#include <stdlib.h>
#include <string.h>

PluginHandle* plugin_load(const char* path) {
    // 打开动态库
    void* handle = dlopen(path, RTLD_LAZY);
    if (!handle) {
        fprintf(stderr, "Failed to load plugin: %s\n", dlerror());
        return NULL;
    }
    
    // 获取插件接口函数
    GetPluginInterfaceFunc get_interface = 
        (GetPluginInterfaceFunc)dlsym(handle, "get_plugin_interface");
    if (!get_interface) {
        fprintf(stderr, "Invalid plugin: no interface\n");
        dlclose(handle);
        return NULL;
    }
    
    // 获取插件接口
    PluginInterface* interface = get_interface();
    if (!interface || interface->info.api_version != PLUGIN_API_VERSION) {
        fprintf(stderr, "API version mismatch\n");
        dlclose(handle);
        return NULL;
    }
    
    // 创建插件句柄
    PluginHandle* plugin_handle = malloc(sizeof(PluginHandle));
    plugin_handle->handle = handle;
    plugin_handle->interface = interface;
    plugin_handle->instance = NULL;
    plugin_handle->initialized = 0;
    
    printf("Loaded plugin: %s v%s\n", 
           interface->info.name, 
           interface->info.version);
    
    return plugin_handle;
}

int plugin_initialize(PluginHandle* handle, void* context) {
    if (!handle || !handle->interface) return -1;
    
    // 创建插件实例
    handle->instance = handle->interface->create();
    if (!handle->instance) return -1;
    
    // 初始化插件
    int result = handle->interface->initialize(handle->instance, context);
    if (result == 0) {
        handle->initialized = 1;
    }
    
    return result;
}

int plugin_execute(PluginHandle* handle, const char* command, void* data) {
    if (!handle || !handle->initialized) return -1;
    return handle->interface->execute(handle->instance, command, data);
}

void plugin_unload(PluginHandle* handle) {
    if (!handle) return;
    
    if (handle->instance && handle->interface->destroy) {
        handle->interface->destroy(handle->instance);
    }
    
    if (handle->handle) {
        dlclose(handle->handle);
    }
    
    free(handle);
}

// example_plugin.c - 示例插件实现
#include "plugin_interface.h"
#include <stdio.h>

// 插件实例数据
typedef struct {
    int counter;
    void* user_data;
} ExamplePlugin;

// 插件实现函数
static void* example_create(void) {
    ExamplePlugin* plugin = malloc(sizeof(ExamplePlugin));
    if (plugin) {
        plugin->counter = 0;
        plugin->user_data = NULL;
    }
    return plugin;
}

static int example_init(void* instance, void* context) {
    ExamplePlugin* plugin = (ExamplePlugin*)instance;
    plugin->user_data = context;
    printf("ExamplePlugin initialized\n");
    return 0;
}

static int example_execute(void* instance, const char* command, void* data) {
    ExamplePlugin* plugin = (ExamplePlugin*)instance;
    
    if (strcmp(command, "increment") == 0) {
        plugin->counter++;
        printf("Counter: %d\n", plugin->counter);
        return plugin->counter;
    } else if (strcmp(command, "greet") == 0) {
        const char* name = (const char*)data;
        printf("Hello, %s!\n", name ? name : "World");
        return 0;
    }
    
    return -1;
}

static void example_destroy(void* instance) {
    ExamplePlugin* plugin = (ExamplePlugin*)instance;
    printf("ExamplePlugin destroyed (final count: %d)\n", plugin->counter);
    free(plugin);
}

// 插件接口实例
static PluginInterface example_interface = {
    .info = {
        .name = "ExamplePlugin",
        .version = "1.0.0",
        .author = "Plugin Developer",
        .description = "An example C plugin",
        .api_version = PLUGIN_API_VERSION
    },
    .create = example_create,
    .initialize = example_init,
    .execute = example_execute,
    .destroy = example_destroy
};

// 导出函数
PluginInterface* get_plugin_interface(void) {
    return &example_interface;
}

4.2 C++实现（面向对象插件系统）

// plugin_system.hpp
#pragma once
#include <memory>
#include <string>
#include <unordered_map>
#include <vector>
#include <functional>

namespace PluginSystem {

// 前置声明
class IPlugin;
class PluginContext;
class PluginEvent;

// 插件接口
class IPlugin {
public:
    virtual ~IPlugin() = default;
    
    virtual std::string getName() const = 0;
    virtual std::string getVersion() const = 0;
    virtual std::vector<std::string> getDependencies() const = 0;
    
    virtual void initialize(std::shared_ptr<PluginContext> context) = 0;
    virtual void activate() = 0;
    virtual void deactivate() = 0;
    virtual void shutdown() = 0;
    
    virtual bool handleEvent(const PluginEvent& event) = 0;
    
    // 插件元数据
    struct Metadata {
        std::string id;
        std::string name;
        std::string version;
        std::string description;
        std::vector<std::string> dependencies;
        std::unordered_map<std::string, std::string> configuration;
    };
};

// 插件上下文
class PluginContext {
public:
    PluginContext(std::string pluginId) : pluginId_(std::move(pluginId)) {}
    
    template<typename T>
    std::shared_ptr<T> getService(const std::string& name) {
        auto it = services_.find(name);
        if (it != services_.end()) {
            return std::dynamic_pointer_cast<T>(it->second);
        }
        return nullptr;
    }
    
    template<typename T>
    void registerService(const std::string& name, std::shared_ptr<T> service) {
        services_[name] = service;
    }
    
    void unregisterService(const std::string& name) {
        services_.erase(name);
    }
    
    void setConfiguration(const std::unordered_map<std::string, std::string>& config) {
        config_ = config;
    }
    
    std::string getConfigValue(const std::string& key, 
                               const std::string& defaultValue = "") const {
        auto it = config_.find(key);
        return it != config_.end() ? it->second : defaultValue;
    }
    
private:
    std::string pluginId_;
    std::unordered_map<std::string, std::shared_ptr<void>> services_;
    std::unordered_map<std::string, std::string> config_;
};

// 插件管理器
class PluginManager {
public:
    PluginManager();
    ~PluginManager();
    
    // 插件生命周期管理
    bool loadPlugin(const std::string& path);
    bool unloadPlugin(const std::string& pluginId);
    bool activatePlugin(const std::string& pluginId);
    bool deactivatePlugin(const std::string& pluginId);
    
    // 插件发现
    void discoverPlugins(const std::string& directory);
    
    // 服务管理
    template<typename T>
    std::shared_ptr<T> getService(const std::string& name) {
        std::lock_guard<std::mutex> lock(mutex_);
        auto it = globalServices_.find(name);
        if (it != globalServices_.end()) {
            return std::dynamic_pointer_cast<T>(it->second);
        }
        return nullptr;
    }
    
    template<typename T>
    void registerService(const std::string& name, std::shared_ptr<T> service) {
        std::lock_guard<std::mutex> lock(mutex_);
        globalServices_[name] = service;
        
        // 通知所有插件
        for (auto& [pluginId, plugin] : plugins_) {
            auto context = pluginContexts_[pluginId];
            context->registerService(name, service);
        }
    }
    
    // 事件系统
    using EventHandler = std::function<void(const PluginEvent&)>;
    void subscribe(const std::string& eventType, EventHandler handler);
    void publish(const PluginEvent& event);
    
private:
    std::unordered_map<std::string, std::shared_ptr<IPlugin>> plugins_;
    std::unordered_map<std::string, std::shared_ptr<PluginContext>> pluginContexts_;
    std::unordered_map<std::string, std::shared_ptr<void>> globalServices_;
    std::unordered_map<std::string, std::vector<EventHandler>> eventHandlers_;
    std::mutex mutex_;
    
    void* loadLibrary(const std::string& path);
    void unloadLibrary(void* handle);
    std::shared_ptr<IPlugin> createPluginInstance(void* handle);
    
    // 依赖解析
    bool resolveDependencies(const IPlugin::Metadata& metadata);
    std::vector<std::string> getLoadOrder() const;
};

// 插件工厂
template<typename PluginType>
class PluginFactory {
public:
    static std::shared_ptr<IPlugin> createInstance() {
        return std::make_shared<PluginType>();
    }
};

// 宏定义简化插件创建
#define DECLARE_PLUGIN(PluginClass) \
extern "C" { \
    __attribute__((visibility("default"))) \
    PluginSystem::IPlugin* create_plugin() { \
        return new PluginClass(); \
    } \
    __attribute__((visibility("default"))) \
    void destroy_plugin(PluginSystem::IPlugin* plugin) { \
        delete plugin; \
    } \
}

} // namespace PluginSystem

// example_plugin.cpp - C++插件示例
#include "plugin_system.hpp"
#include <iostream>

class CalculatorPlugin : public PluginSystem::IPlugin {
public:
    std::string getName() const override {
        return "CalculatorPlugin";
    }
    
    std::string getVersion() const override {
        return "1.0.0";
    }
    
    std::vector<std::string> getDependencies() const override {
        return {"MathService"}; // 依赖其他服务
    }
    
    void initialize(std::shared_ptr<PluginSystem::PluginContext> context) override {
        context_ = context;
        std::cout << "CalculatorPlugin initialized" << std::endl;
        
        // 从配置读取设置
        std::string precision = context_->getConfigValue("precision", "high");
        std::cout << "Calculation precision: " << precision << std::endl;
    }
    
    void activate() override {
        std::cout << "CalculatorPlugin activated" << std::endl;
        
        // 注册服务
        context_->registerService("Calculator", 
            std::shared_ptr<CalculatorService>(new CalculatorService()));
    }
    
    void deactivate() override {
        std::cout << "CalculatorPlugin deactivated" << std::endl;
        context_->unregisterService("Calculator");
    }
    
    void shutdown() override {
        std::cout << "CalculatorPlugin shutdown" << std::endl;
    }
    
    bool handleEvent(const PluginSystem::PluginEvent& event) override {
        // 处理事件
        return false;
    }
    
private:
    std::shared_ptr<PluginSystem::PluginContext> context_;
    
    class CalculatorService {
    public:
        double add(double a, double b) { return a + b; }
        double subtract(double a, double b) { return a - b; }
        double multiply(double a, double b) { return a * b; }
        double divide(double a, double b) { return b != 0 ? a / b : 0; }
    };
};

// 导出插件
DECLARE_PLUGIN(CalculatorPlugin)

4.3 Java实现（企业级插件系统）

// Plugin.java - 插件接口
package com.example.pluginsystem;

import java.util.Map;
import java.util.List;

public interface Plugin {
    // 插件信息
    String getId();
    String getName();
    String getVersion();
    String getDescription();
    
    // 生命周期
    void initialize(PluginContext context);
    void start();
    void stop();
    void destroy();
    
    // 能力声明
    List<Class<?>> getProvidedServices();
    List<Class<?>> getRequiredServices();
    
    // 配置
    void configure(Map<String, Object> configuration);
    
    // 状态
    PluginState getState();
    
    enum PluginState {
        INSTALLED, RESOLVED, STARTING, ACTIVE, STOPPING, UNINSTALLED
    }
}

// PluginContext.java - 插件上下文
package com.example.pluginsystem;

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

public class PluginContext {
    private final String pluginId;
    private final Map<String, Object> properties;
    private final ServiceRegistry serviceRegistry;
    private final EventBus eventBus;
    
    public PluginContext(String pluginId, ServiceRegistry registry, EventBus eventBus) {
        this.pluginId = pluginId;
        this.serviceRegistry = registry;
        this.eventBus = eventBus;
        this.properties = new ConcurrentHashMap<>();
    }
    
    public <T> T getService(Class<T> serviceClass) {
        return serviceRegistry.getService(serviceClass);
    }
    
    public <T> T getService(Class<T> serviceClass, String filter) {
        return serviceRegistry.getService(serviceClass, filter);
    }
    
    public <T> void registerService(Class<T> serviceClass, T service) {
        serviceRegistry.registerService(pluginId, serviceClass, service);
    }
    
    public <T> void registerService(Class<T> serviceClass, T service, 
                                    Map<String, String> properties) {
        serviceRegistry.registerService(pluginId, serviceClass, service, properties);
    }
    
    public void unregisterService(Class<?> serviceClass) {
        serviceRegistry.unregisterService(pluginId, serviceClass);
    }
    
    public void publishEvent(Object event) {
        eventBus.publish(pluginId, event);
    }
    
    public void subscribe(String eventType, EventHandler handler) {
        eventBus.subscribe(pluginId, eventType, handler);
    }
    
    public void unsubscribe(String eventType, EventHandler handler) {
        eventBus.unsubscribe(pluginId, eventType, handler);
    }
    
    public Object getProperty(String key) {
        return properties.get(key);
    }
    
    public void setProperty(String key, Object value) {
        properties.put(key, value);
    }
}

// OSGi风格的插件管理器
package com.example.pluginsystem;

import java.io.File;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.*;
import java.util.jar.JarFile;
import java.util.jar.Manifest;

public class PluginManager {
    private final Map<String, PluginBundle> bundles = new ConcurrentHashMap<>();
    private final ServiceRegistry serviceRegistry = new ServiceRegistry();
    private final EventBus eventBus = new EventBus();
    private final DependencyResolver dependencyResolver = new DependencyResolver();
    
    public PluginBundle installPlugin(File jarFile) throws PluginException {
        try (JarFile jar = new JarFile(jarFile)) {
            Manifest manifest = jar.getManifest();
            
            // 解析插件清单
            PluginManifest pluginManifest = parseManifest(manifest);
            String bundleId = pluginManifest.getBundleId();
            
            // 创建类加载器
            URLClassLoader classLoader = new URLClassLoader(
                new URL[]{jarFile.toURI().toURL()},
                getClass().getClassLoader()
            );
            
            // 加载插件类
            Class<?> pluginClass = classLoader.loadClass(pluginManifest.getPluginClass());
            Plugin plugin = (Plugin) pluginClass.newInstance();
            
            // 创建插件包
            PluginBundle bundle = new PluginBundle(
                bundleId, plugin, classLoader, pluginManifest
            );
            
            bundles.put(bundleId, bundle);
            return bundle;
        } catch (Exception e) {
            throw new PluginException("Failed to install plugin", e);
        }
    }
    
    public void startPlugin(String bundleId) throws PluginException {
        PluginBundle bundle = bundles.get(bundleId);
        if (bundle == null) {
            throw new PluginException("Bundle not found: " + bundleId);
        }
        
        // 解析依赖
        List<String> dependencies = bundle.getManifest().getDependencies();
        for (String dep : dependencies) {
            PluginBundle depBundle = bundles.get(dep);
            if (depBundle == null || depBundle.getState() != PluginState.ACTIVE) {
                throw new PluginException("Unsatisfied dependency: " + dep);
            }
        }
        
        // 创建上下文
        PluginContext context = new PluginContext(
            bundleId, serviceRegistry, eventBus
        );
        
        // 配置插件
        Plugin plugin = bundle.getPlugin();
        plugin.configure(bundle.getManifest().getConfiguration());
        
        // 初始化插件
        plugin.initialize(context);
        
        // 启动插件
        plugin.start();
        bundle.setState(PluginState.ACTIVE);
        
        System.out.println("Plugin started: " + bundleId);
    }
    
    public void stopPlugin(String bundleId) throws PluginException {
        PluginBundle bundle = bundles.get(bundleId);
        if (bundle == null || bundle.getState() != PluginState.ACTIVE) {
            throw new PluginException("Plugin not active: " + bundleId);
        }
        
        // 检查是否有其他插件依赖此插件
        for (PluginBundle other : bundles.values()) {
            if (other.getState() == PluginState.ACTIVE && 
                other.getManifest().getDependencies().contains(bundleId)) {
                throw new PluginException("Cannot stop plugin: " + 
                    other.getId() + " depends on it");
            }
        }
        
        // 停止插件
        Plugin plugin = bundle.getPlugin();
        plugin.stop();
        bundle.setState(PluginState.RESOLVED);
        
        System.out.println("Plugin stopped: " + bundleId);
    }
    
    public void uninstallPlugin(String bundleId) throws PluginException {
        PluginBundle bundle = bundles.get(bundleId);
        if (bundle == null) {
            throw new PluginException("Bundle not found: " + bundleId);
        }
        
        if (bundle.getState() == PluginState.ACTIVE) {
            stopPlugin(bundleId);
        }
        
        // 销毁插件
        bundle.getPlugin().destroy();
        
        // 关闭类加载器
        try {
            bundle.getClassLoader().close();
        } catch (Exception e) {
            // 忽略关闭错误
        }
        
        bundles.remove(bundleId);
        System.out.println("Plugin uninstalled: " + bundleId);
    }
    
    // 内部类：插件包
    private static class PluginBundle {
        private final String id;
        private final Plugin plugin;
        private final ClassLoader classLoader;
        private final PluginManifest manifest;
        private PluginState state = PluginState.INSTALLED;
        
        public PluginBundle(String id, Plugin plugin, 
                           ClassLoader classLoader, PluginManifest manifest) {
            this.id = id;
            this.plugin = plugin;
            this.classLoader = classLoader;
            this.manifest = manifest;
        }
        
        // getters and setters...
    }
}

4.4 Python实现（动态插件系统）

# plugin_base.py - Python插件基类
import abc
import importlib
import inspect
import json
import os
import sys
from pathlib import Path
from typing import Dict, List, Any, Optional, Type, TypeVar, Callable
from dataclasses import dataclass, field
from enum import Enum

T = TypeVar('T')

class PluginState(Enum):
    """插件状态"""
    UNLOADED = "unloaded"
    LOADED = "loaded"
    INITIALIZED = "initialized"
    ACTIVE = "active"
    ERROR = "error"

@dataclass
class PluginMetadata:
    """插件元数据"""
    id: str
    name: str
    version: str
    description: str = ""
    author: str = ""
    dependencies: List[str] = field(default_factory=list)
    entry_point: str = "Plugin"  # 插件类名
    config_schema: Dict[str, Any] = field(default_factory=dict)

class PluginContext:
    """插件上下文"""
    def __init__(self, plugin_id: str, plugin_manager: 'PluginManager'):
        self.plugin_id = plugin_id
        self.plugin_manager = plugin_manager
        self.config: Dict[str, Any] = {}
        self.services: Dict[str, Any] = {}
        
    def get_service(self, service_name: str) -> Any:
        """获取服务"""
        return self.plugin_manager.get_service(service_name)
    
    def register_service(self, service_name: str, service: Any):
        """注册服务"""
        self.plugin_manager.register_service(
            f"{self.plugin_id}.{service_name}", 
            service
        )
        self.services[service_name] = service
    
    def publish_event(self, event_type: str, data: Any = None):
        """发布事件"""
        self.plugin_manager.publish_event(
            event_type, 
            {"source": self.plugin_id, "data": data}
        )
    
    def subscribe_event(self, event_type: str, handler: Callable):
        """订阅事件"""
        self.plugin_manager.subscribe_event(event_type, handler)
    
    def unsubscribe_event(self, event_type: str, handler: Callable):
        """取消订阅事件"""
        self.plugin_manager.unsubscribe_event(event_type, handler)

class BasePlugin(abc.ABC):
    """插件基类"""
    
    def __init__(self):
        self.context: Optional[PluginContext] = None
        self.state = PluginState.UNLOADED
        self.metadata: Optional[PluginMetadata] = None
    
    @abc.abstractmethod
    def initialize(self, context: PluginContext) -> None:
        """初始化插件"""
        pass
    
    @abc.abstractmethod
    def activate(self) -> None:
        """激活插件"""
        pass
    
    @abc.abstractmethod
    def deactivate(self) -> None:
        """停用插件"""
        pass
    
    def handle_event(self, event_type: str, event_data: Any) -> None:
        """处理事件（可选）"""
        pass
    
    def get_dependencies(self) -> List[str]:
        """获取依赖列表"""
        if self.metadata:
            return self.metadata.dependencies
        return []
    
    def configure(self, config: Dict[str, Any]) -> None:
        """配置插件"""
        if self.context:
            self.context.config.update(config)

class PluginManager:
    """插件管理器"""
    
    def __init__(self, plugin_dirs: List[str] = None):
        self.plugin_dirs = plugin_dirs or ["./plugins"]
        self.plugins: Dict[str, BasePlugin] = {}
        self.contexts: Dict[str, PluginContext] = {}
        self.services: Dict[str, Any] = {}
        self.event_handlers: Dict[str, List[Callable]] = {}
        
        # 自动发现插件
        self._discover_plugins()
    
    def _discover_plugins(self) -> None:
        """发现插件"""
        for plugin_dir in self.plugin_dirs:
            if not os.path.exists(plugin_dir):
                continue
                
            for item in Path(plugin_dir).iterdir():
                if item.is_dir():
                    self._load_plugin_from_dir(item)
                elif item.suffix == '.py':
                    self._load_plugin_from_file(item)
    
    def _load_plugin_from_dir(self, plugin_dir: Path) -> None:
        """从目录加载插件"""
        manifest_file = plugin_dir / "manifest.json"
        if not manifest_file.exists():
            return
        
        try:
            with open(manifest_file, 'r', encoding='utf-8') as f:
                manifest_data = json.load(f)
            
            metadata = PluginMetadata(**manifest_data)
            
            # 添加插件目录到Python路径
            if str(plugin_dir) not in sys.path:
                sys.path.insert(0, str(plugin_dir))
            
            # 动态导入插件模块
            module_name = metadata.id.replace('-', '_')
            module = importlib.import_module(module_name)
            
            # 获取插件类
            plugin_class = getattr(module, metadata.entry_point)
            
            # 创建插件实例
            plugin: BasePlugin = plugin_class()
            plugin.metadata = metadata
            
            # 创建上下文
            context = PluginContext(metadata.id, self)
            plugin.context = context
            
            # 存储插件
            self.plugins[metadata.id] = plugin
            self.contexts[metadata.id] = context
            
            plugin.state = PluginState.LOADED
            print(f"Plugin loaded: {metadata.name} v{metadata.version}")
            
        except Exception as e:
            print(f"Failed to load plugin from {plugin_dir}: {e}")
    
    def initialize_plugin(self, plugin_id: str) -> bool:
        """初始化插件"""
        if plugin_id not in self.plugins:
            return False
        
        plugin = self.plugins[plugin_id]
        
        # 检查依赖
        for dep_id in plugin.get_dependencies():
            if dep_id not in self.plugins:
                print(f"Missing dependency: {dep_id}")
                return False
            if self.plugins[dep_id].state.value < PluginState.INITIALIZED.value:
                print(f"Dependency not initialized: {dep_id}")
                return False
        
        try:
            plugin.initialize(self.contexts[plugin_id])
            plugin.state = PluginState.INITIALIZED
            return True
        except Exception as e:
            print(f"Failed to initialize plugin {plugin_id}: {e}")
            plugin.state = PluginState.ERROR
            return False
    
    def activate_plugin(self, plugin_id: str) -> bool:
        """激活插件"""
        if (plugin_id not in self.plugins or 
            self.plugins[plugin_id].state != PluginState.INITIALIZED):
            return False
        
        try:
            plugin = self.plugins[plugin_id]
            plugin.activate()
            plugin.state = PluginState.ACTIVE
            
            # 自动订阅事件
            if hasattr(plugin, 'handle_event'):
                self.subscribe_event('*', plugin.handle_event)
            
            return True
        except Exception as e:
            print(f"Failed to activate plugin {plugin_id}: {e}")
            plugin.state = PluginState.ERROR
            return False
    
    def deactivate_plugin(self, plugin_id: str) -> bool:
        """停用插件"""
        if plugin_id not in self.plugins:
            return False
        
        plugin = self.plugins[plugin_id]
        if plugin.state != PluginState.ACTIVE:
            return False
        
        try:
            plugin.deactivate()
            plugin.state = PluginState.INITIALIZED
            
            # 取消事件订阅
            if hasattr(plugin, 'handle_event'):
                self.unsubscribe_event('*', plugin.handle_event)
            
            return True
        except Exception as e:
            print(f"Failed to deactivate plugin {plugin_id}: {e}")
            return False
    
    def get_service(self, service_name: str) -> Any:
        """获取服务"""
        return self.services.get(service_name)
    
    def register_service(self, service_name: str, service: Any) -> None:
        """注册服务"""
        self.services[service_name] = service
    
    def publish_event(self, event_type: str, event_data: Any) -> None:
        """发布事件"""
        handlers = self.event_handlers.get(event_type, [])
        for handler in handlers:
            try:
                handler(event_type, event_data)
            except Exception as e:
                print(f"Error in event handler for {event_type}: {e}")
        
        # 全局处理器
        all_handlers = self.event_handlers.get('*', [])
        for handler in all_handlers:
            try:
                handler(event_type, event_data)
            except Exception as e:
                print(f"Error in global event handler: {e}")
    
    def subscribe_event(self, event_type: str, handler: Callable) -> None:
        """订阅事件"""
        if event_type not in self.event_handlers:
            self.event_handlers[event_type] = []
        self.event_handlers[event_type].append(handler)
    
    def unsubscribe_event(self, event_type: str, handler: Callable) -> None:
        """取消订阅事件"""
        if event_type in self.event_handlers:
            self.event_handlers[event_type].remove(handler)

# calculator_plugin.py - Python插件示例
import os
from typing import Dict, Any
from plugin_base import BasePlugin, PluginContext

class CalculatorPlugin(BasePlugin):
    """计算器插件"""
    
    def initialize(self, context: PluginContext) -> None:
        """初始化插件"""
        self.context = context
        print(f"CalculatorPlugin initialized with config: {context.config}")
        
        # 注册计算服务
        self.context.register_service("calculator", {
            "add": self.add,
            "subtract": self.subtract,
            "multiply": self.multiply,
            "divide": self.divide
        })
        
        # 订阅事件
        self.context.subscribe_event("calculation.request", self.handle_calculation)
    
    def activate(self) -> None:
        """激活插件"""
        print("CalculatorPlugin activated")
        
        # 发布激活事件
        self.context.publish_event("plugin.activated", {
            "plugin": "calculator",
            "version": "1.0.0"
        })
    
    def deactivate(self) -> None:
        """停用插件"""
        print("CalculatorPlugin deactivated")
        self.context.unsubscribe_event("calculation.request", self.handle_calculation)
    
    def handle_event(self, event_type: str, event_data: Any) -> None:
        """处理事件"""
        if event_type == "system.shutdown":
            print("CalculatorPlugin received shutdown event")
            self.deactivate()
    
    def handle_calculation(self, event_type: str, event_data: Any) -> None:
        """处理计算请求"""
        operation = event_data.get("operation")
        a = event_data.get("a", 0)
        b = event_data.get("b", 0)
        
        result = None
        if operation == "add":
            result = self.add(a, b)
        elif operation == "subtract":
            result = self.subtract(a, b)
        elif operation == "multiply":
            result = self.multiply(a, b)
        elif operation == "divide":
            result = self.divide(a, b)
        
        # 发布结果事件
        self.context.publish_event("calculation.result", {
            "operation": operation,
            "a": a,
            "b": b,
            "result": result
        })
    
    # 计算函数
    def add(self, a: float, b: float) -> float:
        return a + b
    
    def subtract(self, a: float, b: float) -> float:
        return a - b
    
    def multiply(self, a: float, b: float) -> float:
        return a * b
    
    def divide(self, a: float, b: float) -> float:
        if b == 0:
            raise ValueError("Division by zero")
        return a / b

# 插件类名必须与manifest中的entry_point一致
Plugin = CalculatorPlugin

{
  "id": "com.example.calculator",
  "name": "Calculator Plugin",
  "version": "1.0.0",
  "description": "A simple calculator plugin",
  "author": "Plugin Developer",
  "entry_point": "Plugin",
  "dependencies": [],
  "config_schema": {
    "precision": {
      "type": "string",
      "default": "high",
      "enum": ["low", "medium", "high"]
    }
  }
}

4.5 JavaScript/TypeScript实现（Web插件系统）

// plugin.types.ts - TypeScript类型定义
export interface IPlugin {
  // 插件标识
  readonly id: string;
  readonly name: string;
  readonly version: string;
  readonly description?: string;
  
  // 生命周期
  initialize(context: IPluginContext): Promise<void>;
  activate(): Promise<void>;
  deactivate(): Promise<void>;
  destroy(): Promise<void>;
  
  // 能力
  getCapabilities(): PluginCapability[];
  
  // 事件处理
  onEvent?(event: PluginEvent): void;
}

export interface IPluginContext {
  // 插件标识
  readonly pluginId: string;
  
  // 服务访问
  getService<T>(serviceId: string): T | null;
  getService<T>(serviceId: string, defaultValue: T): T;
  
  // 服务注册
  registerService<T>(serviceId: string, service: T): void;
  unregisterService(serviceId: string): void;
  
  // 配置访问
  getConfig<T = any>(key: string): T | undefined;
  getConfig<T = any>(key: string, defaultValue: T): T;
  setConfig(key: string, value: any): void;
  
  // 事件系统
  emitEvent(event: PluginEvent): void;
  subscribe(eventType: string, handler: EventHandler): void;
  unsubscribe(eventType: string, handler: EventHandler): void;
  
  // 资源管理
  loadResource<T>(path: string): Promise<T>;
  registerResource(path: string, resource: any): void;
}

export interface PluginManifest {
  id: string;
  name: string;
  version: string;
  description?: string;
  author?: string;
  license?: string;
  
  // 入口点
  main: string;
  
  // 依赖
  dependencies?: Record<string, string>;
  peerDependencies?: Record<string, string>;
  
  // 贡献点
  contributes?: {
    commands?: Array<{
      id: string;
      title: string;
      icon?: string;
    }>;
    views?: Record<string, any>;
    themes?: Array<any>;
    languages?: Array<any>;
  };
  
  // 激活事件
  activationEvents?: string[];
}

// plugin-manager.ts - 插件管理器
import { IPlugin, IPluginContext, PluginManifest } from './plugin.types';

export class PluginManager {
  private plugins: Map<string, IPlugin> = new Map();
  private contexts: Map<string, IPluginContext> = new Map();
  private services: Map<string, any> = new Map();
  private eventHandlers: Map<string, Set<Function>> = new Map();
  
  // Web Workers用于隔离插件
  private pluginWorkers: Map<string, Worker> = new Map();
  
  constructor(private options: PluginManagerOptions = {}) {}
  
  // 异步加载插件
  async loadPlugin(url: string): Promise<IPlugin> {
    try {
      // 加载插件清单
      const manifest = await this.fetchManifest(url);
      
      // 验证插件
      this.validatePlugin(manifest);
      
      // 检查依赖
      await this.checkDependencies(manifest);
      
      // 创建插件上下文
      const context = this.createPluginContext(manifest.id);
      
      // 加载插件代码
      const pluginCode = await this.loadPluginCode(manifest.main);
      
      // 创建插件实例
      let plugin: IPlugin;
      
      if (this.options.sandboxed) {
        // 在Web Worker中运行插件
        plugin = await this.createSandboxedPlugin(manifest, pluginCode, context);
      } else {
        // 在主线程中运行插件
        plugin = this.createInProcessPlugin(manifest, pluginCode, context);
      }
      
      // 存储插件
      this.plugins.set(manifest.id, plugin);
      this.contexts.set(manifest.id, context);
      
      console.log(`Plugin loaded: ${manifest.name} v${manifest.version}`);
      
      return plugin;
    } catch (error) {
      console.error(`Failed to load plugin from ${url}:`, error);
      throw error;
    }
  }
  
  // 创建沙箱插件
  private async createSandboxedPlugin(
    manifest: PluginManifest,
    code: string,
    context: IPluginContext
  ): Promise<IPlugin> {
    return new Promise((resolve, reject) => {
      // 创建Web Worker
      const worker = new Worker(
        URL.createObjectURL(new Blob([this.getWorkerTemplate(code)], { type: 'application/javascript' }))
      );
      
      this.pluginWorkers.set(manifest.id, worker);
      
      // 设置通信
      const messageHandler = (event: MessageEvent) => {
        const { type, payload } = event.data;
        
        switch (type) {
          case 'PLUGIN_READY':
            resolve(this.createWorkerProxy(manifest.id, worker));
            break;
            
          case 'SERVICE_REQUEST':
            const service = this.services.get(payload.serviceId);
            worker.postMessage({
              type: 'SERVICE_RESPONSE',
              payload: { 
                requestId: payload.requestId,
                result: service 
              }
            });
            break;
            
          case 'EVENT_EMIT':
            this.emitEvent(payload.event);
            break;
        }
      };
      
      worker.addEventListener('message', messageHandler);
      worker.addEventListener('error', reject);
      
      // 初始化Worker
      worker.postMessage({
        type: 'INIT',
        payload: { manifest, context }
      });
    });
  }
  
  // Worker代理
  private createWorkerProxy(pluginId: string, worker: Worker): IPlugin {
    return {
      id: pluginId,
      name: '',
      version: '',
      async initialize(context) {
        return new Promise((resolve) => {
          const handler = (event: MessageEvent) => {
            if (event.data.type === 'INITIALIZED') {
              worker.removeEventListener('message', handler);
              resolve();
            }
          };
          worker.addEventListener('message', handler);
          worker.postMessage({ type: 'INITIALIZE', payload: { context } });
        });
      },
      async activate() {
        worker.postMessage({ type: 'ACTIVATE' });
      },
      async deactivate() {
        worker.postMessage({ type: 'DEACTIVATE' });
      },
      async destroy() {
        worker.postMessage({ type: 'DESTROY' });
        worker.terminate();
      },
      getCapabilities() {
        return [];
      }
    };
  }
  
  // Worker模板
  private getWorkerTemplate(pluginCode: string): string {
    return `
      // Worker环境
      let pluginInstance = null;
      let pluginContext = null;
      
      // 消息处理
      self.addEventListener('message', async (event) => {
        const { type, payload } = event.data;
        
        switch (type) {
          case 'INIT':
            pluginContext = payload.context;
            await initializePlugin(payload.manifest);
            break;
            
          case 'INITIALIZE':
            await pluginInstance.initialize(payload.context);
            self.postMessage({ type: 'INITIALIZED' });
            break;
            
          case 'ACTIVATE':
            await pluginInstance.activate();
            break;
            
          case 'DEACTIVATE':
            await pluginInstance.deactivate();
            break;
            
          case 'DESTROY':
            await pluginInstance.destroy();
            break;
        }
      });
      
      // 初始化插件
      async function initializePlugin(manifest) {
        // 动态执行插件代码
        const module = {};
        Function('module', 'exports', 'require', \`${pluginCode}\`)(
          module, module.exports, createRequire(manifest)
        );
        
        pluginInstance = module.exports;
        
        // 发送就绪消息
        self.postMessage({ type: 'PLUGIN_READY' });
      }
      
      // 创建require函数
      function createRequire(manifest) {
        return function require(serviceId) {
          return new Promise((resolve) => {
            const requestId = Math.random().toString(36);
            
            const handler = (event) => {
              if (event.data.type === 'SERVICE_RESPONSE' && 
                  event.data.payload.requestId === requestId) {
                self.removeEventListener('message', handler);
                resolve(event.data.payload.result);
              }
            };
            
            self.addEventListener('message', handler);
            self.postMessage({
              type: 'SERVICE_REQUEST',
              payload: { serviceId, requestId }
            });
          });
        };
      }
      
      // 事件发射
      function emitEvent(event) {
        self.postMessage({
          type: 'EVENT_EMIT',
          payload: { event }
        });
      }
    `;
  }
}

// 浏览器插件示例
// calculator-plugin.ts
import { IPlugin, IPluginContext } from './plugin.types';

export default class CalculatorPlugin implements IPlugin {
  readonly id = 'com.example.calculator';
  readonly name = 'Calculator Plugin';
  readonly version = '1.0.0';
  readonly description = 'A calculator plugin for web applications';
  
  private context: IPluginContext | null = null;
  private calculationHistory: Array<{expression: string, result: number}> = [];
  
  async initialize(context: IPluginContext): Promise<void> {
    this.context = context;
    console.log('CalculatorPlugin initialized');
    
    // 从配置加载设置
    const precision = context.getConfig('precision', 'high');
    
    // 注册计算服务
    context.registerService('calculator', {
      add: (a: number, b: number) => this.add(a, b),
      subtract: (a: number, b: number) => this.subtract(a, b),
      multiply: (a: number, b: number) => this.multiply(a, b),
      divide: (a: number, b: number) => this.divide(a, b),
      getHistory: () => this.calculationHistory
    });
    
    // 订阅事件
    context.subscribe('calculation.request', this.handleCalculation.bind(this));
  }
  
  async activate(): Promise<void> {
    console.log('CalculatorPlugin activated');
    
    // 在UI中注册计算器组件
    this.registerUIComponent();
  }
  
  async deactivate(): Promise<void> {
    console.log('CalculatorPlugin deactivated');
    this.context?.unsubscribe('calculation.request', this.handleCalculation.bind(this));
  }
  
  async destroy(): Promise<void> {
    console.log('CalculatorPlugin destroyed');
    this.calculationHistory = [];
  }
  
  getCapabilities(): string[] {
    return ['calculation', 'history'];
  }
  
  private handleCalculation(event: any): void {
    const { operation, a, b } = event;
    let result: number;
    
    switch (operation) {
      case 'add':
        result = this.add(a, b);
        break;
      case 'subtract':
        result = this.subtract(a, b);
        break;
      case 'multiply':
        result = this.multiply(a, b);
        break;
      case 'divide':
        result = this.divide(a, b);
        break;
      default:
        throw new Error(`Unknown operation: ${operation}`);
    }
    
    // 记录历史
    this.calculationHistory.push({
      expression: `${a} ${operation} ${b}`,
      result
    });
    
    // 发出结果事件
    this.context?.emitEvent({
      type: 'calculation.result',
      data: { operation, a, b, result }
    });
  }
  
  private registerUIComponent(): void {
    // 动态创建UI元素
    const calculatorEl = document.createElement('div');
    calculatorEl.className = 'calculator-plugin';
    calculatorEl.innerHTML = `
      <style>
        .calculator-plugin {
          position: fixed;
          bottom: 20px;
          right: 20px;
          width: 300px;
          background: white;
          border: 1px solid #ccc;
          border-radius: 8px;
          box-shadow: 0 2px 10px rgba(0,0,0,0.1);
          padding: 15px;
          z-index: 1000;
        }
        .calculator-inputs {
          display: grid;
          grid-template-columns: 1fr 1fr;
          gap: 10px;
          margin-bottom: 10px;
        }
        .calculator-result {
          font-weight: bold;
          text-align: center;
          margin: 10px 0;
        }
      </style>
      <div class="calculator-inputs">
        <input type="number" id="calc-a" placeholder="Number A" />
        <input type="number" id="calc-b" placeholder="Number B" />
      </div>
      <div>
        <button data-op="add">+</button>
        <button data-op="subtract">-</button>
        <button data-op="multiply">×</button>
        <button data-op="divide">÷</button>
      </div>
      <div class="calculator-result" id="calc-result"></div>
    `;
    
    // 添加事件监听
    calculatorEl.querySelectorAll('button').forEach(button => {
      button.addEventListener('click', (e) => {
        const op = (e.target as HTMLElement).dataset.op;
        const a = parseFloat((document.getElementById('calc-a') as HTMLInputElement).value);
        const b = parseFloat((document.getElementById('calc-b') as HTMLInputElement).value);
        
        this.context?.emitEvent({
          type: 'calculation.request',
          data: { operation: op, a, b }
        });
      });
    });
    
    // 监听结果事件
    this.context?.subscribe('calculation.result', (event: any) => {
      const resultEl = document.getElementById('calc-result');
      if (resultEl) {
        resultEl.textContent = `Result: ${event.data.result}`;
      }
    });
    
    document.body.appendChild(calculatorEl);
  }
  
  // 计算方法
  private add(a: number, b: number): number {
    return a + b;
  }
  
  private subtract(a: number, b: number): number {
    return a - b;
  }
  
  private multiply(a: number, b: number): number {
    return a * b;
  }
  
  private divide(a: number, b: number): number {
    if (b === 0) throw new Error('Division by zero');
    return a / b;
  }
}

五、插件系统核心总结

5.1 核心原则

1. 接口契约：定义清晰的接口规范，确保插件与宿主的一致性
2. 生命周期管理：完整的生命周期（加载、初始化、激活、停用、卸载）
3. 依赖管理：解析和管理插件之间的依赖关系
4. 隔离机制：通过进程、线程或沙箱实现插件间的隔离
5. 事件系统：支持插件间、插件与宿主间的松耦合通信
6. 服务发现：插件可以注册和发现服务

5.2 设计模式应用

设计模式	在插件系统中的应用
工厂模式	创建插件实例
观察者模式	事件系统实现
策略模式	插件算法的动态替换
桥接模式	分离插件接口与实现
依赖注入	插件服务的自动装配

5.3 安全考量

# 安全沙箱示例
class PluginSandbox:
    """插件安全沙箱"""
    
    def __init__(self, plugin_id):
        self.plugin_id = plugin_id
        self.allowed_actions = set()
        self.denied_actions = set()
        
        # 默认安全策略
        self.set_default_policy()
    
    def set_default_policy(self):
        """设置默认安全策略"""
        # 允许的操作
        self.allowed_actions.update([
            'read_config',
            'emit_event',
            'register_service'
        ])
        
        # 禁止的操作
        self.denied_actions.update([
            'file_system_write',
            'network_access',
            'process_spawn'
        ])
    
    def check_permission(self, action, resource=None):
        """检查权限"""
        if action in self.denied_actions:
            raise SecurityError(f"Action {action} denied for plugin {self.plugin_id}")
        
        if action not in self.allowed_actions:
            raise SecurityError(f"Action {action} not allowed for plugin {self.plugin_id}")
        
        return True
    
    def execute_safely(self, func, *args, **kwargs):
        """安全执行函数"""
        try:
            # 设置执行上下文
            context = {
                'plugin_id': self.plugin_id,
                'sandbox': self
            }
            
            # 执行函数
            return func(*args, **kwargs, context=context)
            
        except Exception as e:
            # 记录错误但不影响宿主
            print(f"Plugin {self.plugin_id} error: {e}")
            return None

六、现代插件架构趋势

6.1 微服务化插件

• 独立部署：每个插件作为独立微服务
• API网关：统一的管理接口
• 服务网格：插件间的智能通信

6.2 WebAssembly插件

• 跨语言支持：多种语言编译为Wasm
• 安全沙箱：内存安全的执行环境
• 高性能：接近原生性能

6.3 边缘计算插件

• 分布式部署：插件运行在边缘节点
• 低延迟：靠近数据源处理
• 离线能力：不依赖中心服务器

通过以上多语言实现和详细解析，我们可以看到插件系统的核心在于标准化接口、动态加载、安全隔离和灵活扩展。不同语言有不同的实现重点，但核心原理相通。设计良好的插件系统可以极大地提高软件的灵活性、可维护性和可扩展性。