Rust插件库Cactus的使用：高效、灵活的插件系统扩展，提升Rust应用模块化开发能力

Cactus库提供了一个不可变的仙人掌栈（也称为意大利面条栈或父指针树）。仙人掌栈是一个（可能为空的）节点，带有一个（可能为空的）指向父节点的指针。任何给定节点都有一个返回根节点的唯一路径。与其可变地更新栈，不如创建和获取对不可变节点的访问（当节点变得不可达时，其内存会自动回收）。

基本使用示例

use cactus::Cactus;
let c = Cactus::new();
assert!(c.is_empty());
let c2 = c.child(1);
assert_eq!(c2.len(), 1);
assert_eq!(*c2.val().unwrap(), 1);
let c3 = c2.parent().unwrap();
assert!(c3.is_empty());

创建多个子栈示例

use cactus::Cactus;
let c = Cactus::new().child(1);
let c2 = c.child(2);
let c3 = c.child(3);
assert!(c2 != c3);
assert_eq!(c2.vals().cloned().collect::<Vec<_>>(), [2, 1]);
assert_eq!(c3.vals().cloned().collect::<Vec<_>>(), [3, 1]);

完整示例代码

下面是一个更完整的示例，展示了如何使用Cactus库来构建一个简单的插件系统：

use cactus::Cactus;

// 定义插件特征
trait Plugin {
    fn name(&self) -> &str;
    fn execute(&self);
}

// 实现一个具体插件
struct GreetPlugin;
impl Plugin for GreetPlugin {
    fn name(&self) -> &str {
        "greet"
    }
    
    fn execute(&self) {
        println!("Hello from GreetPlugin!");
    }
}

// 实现另一个插件
struct LogPlugin;
impl Plugin for LogPlugin {
    fn name(&self) &str {
        "log"
    }
    
    fn execute(&self) {
        println!("Logging from LogPlugin");
    }
}

fn main() {
    // 创建空的插件栈
    let plugin_stack = Cactus::new();
    
    // 添加插件
    let with_greet = plugin_stack.child(GreetPlugin);
    let with_log = with_greet.child(LogPlugin);
    
    // 遍历并执行所有插件
    for plugin in with_log.vals() {
        plugin.execute();
    }
    
    // 输出:
    // Logging from LogPlugin
    // Hello from GreetPlugin!
}

更复杂的插件系统示例

use cactus::Cactus;
use std::any::{Any, TypeId};

// 定义插件管理器和特征
struct PluginManager {
    plugins: Cactus<Box<dyn Any>>,
}

impl PluginManager {
    fn new() -> Self {
        Self {
            plugins: Cactus::new(),
        }
    }
    
    fn add_plugin<T: 'static>(&self, plugin: T) -> Self {
        Self {
            plugins: self.plugins.child(Box::new(plugin)),
        }
    }
    
    fn get_plugin<T: 'static>(&self) -> Option<&T> {
        for plugin in self.plugins.vals() {
            if plugin.is::<T>() {
                return plugin.downcast_ref::<T>();
            }
        }
        None
    }
}

// 定义几个插件类型
struct DatabasePlugin {
    connection: String,
}

struct AuthPlugin {
    token: String,
}

fn main() {
    let manager = PluginManager::new()
        .add_plugin(DatabasePlugin {
            connection: "localhost".to_string(),
        })
        .add_plugin(AuthPlugin {
            token: "secret".to_string(),
        });
    
    // 获取并使用插件
    if let Some(db) = manager.get_plugin::<DatabasePlugin>() {
        println!("Database connection: {}", db.connection);
    }
    
    if let Some(auth) = manager.get_plugin::<AuthPlugin>() {
        println!("Auth token: {}", auth.token);
    }
}

这些示例展示了如何使用Cactus库来构建灵活、可扩展的插件系统，使Rust应用具有更好的模块化开发能力。通过不可变的数据结构和父子关系，可以安全地管理插件生命周期和依赖关系。

完整示例Demo

基于上述内容，下面是一个更完整的Cactus插件系统实现示例，展示了如何在实际项目中使用：

use cactus::Cactus;
use std::any::{Any, TypeId};

// 定义插件特征
trait Plugin: Any {
    fn name(&self) -> &str;
    fn init(&self);
    fn execute(&self, context: &mut PluginContext);
}

// 插件上下文
struct PluginContext {
    data: String,
}

// 具体插件实现 - 日志插件
struct LoggerPlugin {
    log_level: String,
}

impl Plugin for LoggerPlugin {
    fn name(&self) -> &str {
        "logger"
    }

    fn init(&self) {
        println!("Initializing LoggerPlugin with level: {}", self.log_level);
    }

    fn execute(&self, context: &mut PluginContext) {
        println!("[{}] Processing: {}", self.log_level, context.data);
        context.data = context.data.to_uppercase();
    }
}

// 具体插件实现 - 验证插件
struct ValidationPlugin;

impl Plugin for ValidationPlugin {
    fn name(&self) -> &str {
        "validator"
    }

    fn init(&self) {
        println!("Initializing ValidationPlugin");
    }

    fn execute(&self, context: &mut PluginContext) {
        if context.data.is_empty() {
            println!("Validation error: empty input");
        }
    }
}

// 插件管理器
struct PluginSystem {
    plugins: Cactus<Box<dyn Plugin>>,
}

impl PluginSystem {
    fn new() -> Self {
        Self {
            plugins: Cactus::new(),
        }
    }

    fn add_plugin<P: Plugin + 'static>(mut self, plugin: P) -> Self {
        println!("Adding plugin: {}", plugin.name());
        plugin.init();
        Self {
            plugins: self.plugins.child(Box::new(plugin)),
        }
    }

    fn execute_all(&self, mut context: PluginContext) -> PluginContext {
        for plugin in self.plugins.vals() {
            plugin.execute(&mut context);
        }
        context
    }
}

fn main() {
    // 创建插件系统并添加插件
    let system = PluginSystem::new()
        .add_plugin(LoggerPlugin {
            log_level: "INFO".to_string(),
        })
        .add_plugin(ValidationPlugin);

    // 创建执行上下文
    let mut context = PluginContext {
        data: "hello world".to_string(),
    };

    // 执行所有插件
    context = system.execute_all(context);
    println!("Final result: {}", context.data);

    // 输出:
    // Adding plugin: logger
    // Initializing LoggerPlugin with level: INFO
    // Adding plugin: validator
    // Initializing ValidationPlugin
    // [INFO] Processing: hello world
    // Final result: HELLO WORLD
}