Rust中用enum实现多参数Hook机制

在 Rust 中，如果想为 enum 实现一个带多参数的 Hook 机制，可以结合模式匹配和枚举来处理。这种方式可以扩展到支持不同类型的输入参数和逻辑处理。

以下是一个实现 enum 和 Hook 的多参数机制的完整示例：

1. 定义枚举和 Hook 类型

use std::sync::{Arc, Mutex};

// 定义一个多参数枚举
enum HookInput {
    Add(i32, i32),
    Multiply(i32, i32),
    Concat(String, String),
}

// 定义一个多返回值枚举
enum HookOutput {
    Sum(i32),
    Product(i32),
    Combined(String),
    None,
}

// 定义 Hook 类型
type HookFn = Arc<dyn Fn(HookInput) -> HookOutput + Send + Sync>;

// Hook 管理器
struct HookManager {
    hooks: Mutex<Vec<HookFn>>,
}

impl HookManager {
    fn new() -> Self {
        Self {
            hooks: Mutex::new(Vec::new()),
        }
    }

    // 添加 Hook 函数
    fn add_hook<F>(&self, hook: F)
    where
        F: Fn(HookInput) -> HookOutput + Send + Sync + 'static,
    {
        self.hooks.lock().unwrap().push(Arc::new(hook));
    }

    // 执行所有 Hook
    fn execute_hooks(&self, input: HookInput) -> Vec<HookOutput> {
        let hooks = self.hooks.lock().unwrap();
        hooks.iter().map(|hook| hook(input.clone())).collect()
    }
}

// 实现 Clone 对 HookInput 的支持
impl Clone for HookInput {
    fn clone(&self) -> Self {
        match self {
            HookInput::Add(a, b) => HookInput::Add(*a, *b),
            HookInput::Multiply(a, b) => HookInput::Multiply(*a, *b),
            HookInput::Concat(a, b) => HookInput::Concat(a.clone(), b.clone()),
        }
    }
}

2. 使用 Hook 管理器

fn main() {
    let manager = HookManager::new();

    // 添加第一个 Hook：处理 Add
    manager.add_hook(|input| match input {
        HookInput::Add(a, b) => {
            println!("Adding: {} + {}", a, b);
            HookOutput::Sum(a + b)
        }
        _ => HookOutput::None,
    });

    // 添加第二个 Hook：处理 Multiply
    manager.add_hook(|input| match input {
        HookInput::Multiply(a, b) => {
            println!("Multiplying: {} * {}", a, b);
            HookOutput::Product(a * b)
        }
        _ => HookOutput::None,
    });

    // 添加第三个 Hook：处理 Concat
    manager.add_hook(|input| match input {
        HookInput::Concat(a, b) => {
            println!("Concatenating: {} + {}", a, b);
            HookOutput::Combined(format!("{}{}", a, b))
        }
        _ => HookOutput::None,
    });

    // 执行 Hook：Add
    let add_results = manager.execute_hooks(HookInput::Add(3, 4));
    println!("Results for Add: {:?}", add_results);

    // 执行 Hook：Multiply
    let multiply_results = manager.execute_hooks(HookInput::Multiply(5, 6));
    println!("Results for Multiply: {:?}", multiply_results);

    // 执行 Hook：Concat
    let concat_results = manager.execute_hooks(HookInput::Concat(
        "Hello".to_string(),
        "World".to_string(),
    ));
    println!("Results for Concat: {:?}", concat_results);
}

示例运行结果

Adding: 3 + 4
Results for Add: [Sum(7), None, None]

Multiplying: 5 * 6
Results for Multiply: [None, Product(30), None]

Concatenating: Hello + World
Results for Concat: [None, None, Combined("HelloWorld")]

代码解析

1. 多参数处理：
   • HookInput 使用枚举定义了不同的输入类型（如 Add(i32, i32)、Multiply(i32, i32)、Concat(String, String)）。
   • 每个变体表示不同的逻辑分支，可扩展为更多的操作类型。
2. 多返回值处理：
   • HookOutput 使用枚举定义了不同的输出类型（如 Sum(i32)、Product(i32)、Combined(String)）。
   • 每个变体对应不同的返回值逻辑。
3. Hook 管理器：
   • HookManager 使用 Vec 存储所有注册的 Hook 函数。
   • execute_hooks 遍历所有 Hook，并根据输入调用相应逻辑，收集返回值。
4. 扩展性：
   • 可以轻松添加新的 HookInput 和 HookOutput 枚举变体，扩展新的逻辑。
   • 新的 Hook 函数只需要匹配新添加的变体即可。

优化方向

1. 并行执行：
   如果多个 Hooks 可以并行执行，可以引入并行迭代工具，如 rayon。

use rayon::prelude::*;
hooks.par_iter().map(|hook| hook(input.clone())).collect()

2. 动态分派：
   如果需要动态注册更多类型的操作，可以将输入参数定义为 Box，并结合 downcast 使用。
3. 返回值过滤：
   可以在 execute_hooks 中过滤掉 HookOutput::None 的结果，以简化结果处理。

总结

• 核心思路：
利用 enum 表达多种输入和输出类型，配合模式匹配实现多参数和多逻辑分支的 Hook 机制。
• 扩展性强：
通过新增枚举变体，可以轻松支持更多的输入和返回值类型。
• 适用场景：
• 插件系统
• 事件驱动架构
• 动态业务逻辑处理