Rust插件库cust_core的使用指南

cust_core是一个为Rust设计的插件系统核心库，提供了高效且可扩展的插件架构实现。它允许开发者轻松地将插件功能集成到他们的应用程序中，支持动态加载和卸载插件。

主要特性

• 轻量级插件系统核心
• 高性能的插件加载和管理
• 支持动态插件加载
• 类型安全的插件接口
• 可扩展的插件生命周期管理

基本使用方法

1. 添加依赖

首先，在Cargo.toml中添加cust_core依赖：

[dependencies]
cust_core = "0.1.0"  # 请使用最新版本

2. 定义插件接口

use cust_core::{Plugin, PluginManager};

// 定义插件trait
pub trait MyPlugin: Plugin {
    fn do_something(&self, input: &str) -> String;
}

3. 实现插件

use cust_core::Plugin;

struct MySamplePlugin;

impl Plugin for MySamplePlugin {
    fn name(&self) -> &str {
        "sample_plugin"
    }
    
    fn version(&self) -> &str {
        "1.0.0"
    }
}

impl MyPlugin for MySamplePlugin {
    fn do_something(&self, input: &str) -> String {
        format!("Plugin processed: {}", input)
    }
}

4. 注册和使用插件

use cust_core::PluginManager;

fn main() {
    // 创建插件管理器
    let mut manager = PluginManager::new();
    
    // 注册插件
    manager.register_plugin(Box::new(MySamplePlugin));
    
    // 获取插件并调用
    if let Some(plugin) = manager.get_plugin::<dyn MyPlugin>("sample_plugin") {
        let result = plugin.do_something("Hello");
        println!("{}", result);  // 输出: "Plugin processed: Hello"
    }
}

动态加载插件

cust_core支持从动态库加载插件：

use cust_core::{DynamicPluginLoader, PluginManager};

fn main() {
    let mut manager = PluginManager::new();
    let loader = DynamicPluginLoader::new();
    
    // 从动态库加载插件
    if let Ok(plugin) = loader.load::<dyn MyPlugin>("path/to/plugin.so") {
        manager.register_plugin(plugin);
    }
    
    // 使用插件...
}

高级功能

插件生命周期管理

use cust_core::{Plugin, PluginManager};

struct LifecyclePlugin;

impl Plugin for LifecyclePlugin {
    fn name(&self) -> &str {
        "lifecycle_plugin"
    }
    
    fn on_load(&self) {
        println!("Plugin loaded!");
    }
    
    fn on_unload(&self) {
        println!("Plugin unloaded!");
    }
}

fn main() {
    let mut manager = PluginManager::new();
    manager.register_plugin(Box::new(LifecyclePlugin));
    
    // 卸载插件
    manager.unload_plugin("lifecycle_plugin");
    // 控制台会输出 "Plugin unloaded!"
}

插件依赖管理

use cust_core::{Plugin, PluginManager, PluginDependency};

struct DependentPlugin;

impl Plugin for DependentPlugin {
    fn name(&self) &str {
        "dependent_plugin"
    }
    
    fn dependencies(&self) -> Vec<PluginDependency> {
        vec![
            PluginDependency::new("some_other_plugin", "1.0.0")
        ]
    }
}

fn main() {
    let mut manager = PluginManager::new();
    
    // 注册依赖插件...
    
    // 注册依赖其他插件的插件
    if manager.check_dependencies(&DependentPlugin).is_ok() {
        manager.register_plugin(Box::new(DependentPlugin));
    }
}

性能提示

cust_core经过优化，但在高性能场景下，可以考虑：

1. 使用get_plugin_with避免多次查找
2. 对频繁调用的插件方法考虑使用#[inline]
3. 批量处理插件操作减少锁竞争

if let Some(plugin) = manager.get_plugin_with::<dyn MyPlugin, _>(|p| p.name() == "sample_plugin") {
    // 高效调用
}

完整示例Demo

下面是一个完整的使用cust_core的插件系统示例：

// Cargo.toml
// [dependencies]
// cust_core = "0.1.0"

use cust_core::{Plugin, PluginManager, DynamicPluginLoader, PluginDependency};

// 1. 定义插件接口
pub trait TextProcessor: Plugin {
    fn process_text(&self, input: &str) -> String;
}

// 2. 实现基本插件
struct UpperCasePlugin;

impl Plugin for UpperCasePlugin {
    fn name(&self) -> &str {
        "uppercase_plugin"
    }
    
    fn version(&self) -> &str {
        "1.0.0"
    }
}

impl TextProcessor for UpperCasePlugin {
    fn process_text(&self, input: &str) -> String {
        input.to_uppercase()
    }
}

// 3. 实现带生命周期的插件
struct LoggerPlugin;

impl Plugin for LoggerPlugin {
    fn name(&self) -> &str {
        "logger_plugin"
    }
    
    fn on_load(&self) {
        println!("Logger plugin loaded");
    }
    
    fn on_unload(&self) {
        println!("Logger plugin unloaded");
    }
}

// 4. 实现带依赖的插件
struct CompositePlugin;

impl Plugin for CompositePlugin {
    fn name(&self) -> &str {
        "composite_plugin"
    }
    
    fn dependencies(&self) -> Vec<PluginDependency> {
        vec![
            PluginDependency::new("uppercase_plugin", "1.0.0")
        ]
    }
}

impl TextProcessor for CompositePlugin {
    fn process_text(&self, input: &str) -> String {
        format!("[Composite] {}", input)
    }
}

fn main() {
    // 初始化插件管理器
    let mut manager = PluginManager::new();
    
    // 注册基本插件
    manager.register_plugin(Box::new(UpperCasePlugin));
    
    // 使用基本插件
    if let Some(plugin) = manager.get_plugin::<dyn TextProcessor>("uppercase_plugin") {
        println!("{}", plugin.process_text("hello")); // 输出: "HELLO"
    }
    
    // 注册生命周期插件
    manager.register_plugin(Box::new(LoggerPlugin));
    
    // 注册带依赖的插件
    if manager.check_dependencies(&CompositePlugin).is_ok() {
        manager.register_plugin(Box::new(CompositePlugin));
        
        if let Some(plugin) = manager.get_plugin::<dyn TextProcessor>("composite_plugin") {
            println!("{}", plugin.process_text("test")); // 输出: "[Composite] test"
        }
    }
    
    // 动态加载插件示例
    let loader = DynamicPluginLoader::new();
    if let Ok(plugin) = loader.load::<dyn TextProcessor>("path/to/text_plugin.so") {
        manager.register_plugin(plugin);
    }
    
    // 卸载插件
    manager.unload_plugin("logger_plugin"); // 会触发on_unload回调
}

cust_core为Rust应用程序提供了强大而灵活的插件系统基础，适用于需要模块化架构的各种场景。