如何在Rust中实现类似Python inspect模块的动态类执行功能？

1. 核心接口定义（替代Python的BaseTransform） #

Rust是静态类型语言，用trait定义所有Transform必须遵循的统一接口，确保类型一致性：

use serde_json::Value; // 对应Python的dict，也可自定义结构体+serde反序列化

pub trait Transform {
    // 返回唯一标识ID，对应Python类的id字段
    fn id(&self) -> &'static str;
    // 执行转换逻辑，输入字典类型数据，返回可序列化结果（带错误处理）
    fn run(&self, data: &Value) -> Result<Value, Box<dyn std::error::Error>>;
}

// 若Transform无状态，可改用静态方法优化性能：
// pub trait Transform {
//     fn id() -> &'static str;
//     fn run(data: &Value) -> Result<Value, Box<dyn std::error::Error>>;
// }

2. 单个Transform实现（替代Python的Class1Transform等） #

每个转换逻辑对应一个结构体，实现上述trait：

// 示例：src/transforms/sub1/class1.rs
use super::Transform;
use serde_json::Value;

pub struct Class1Transform;

impl Transform for Class1Transform {
    fn id(&self) -> &'static str {
        "class_1"
    }

    fn run(&self, data: &Value) -> Result<Value, Box<dyn std::error::Error>> {
        // 业务逻辑示例：读取data字段并处理
        let input = data.get("input")?.as_str().ok_or("input字段缺失")?;
        Ok(Value::String(format!("processed_{}", input)))
    }
}

3. 全局注册表实现（替代Python的inspect反射） #

Rust无内置动态反射，需手动维护注册表映射ID与Transform实例/构造函数。针对100+类的场景，推荐用过程宏自动注册减少重复劳动。

3.1 手动注册方案（适合少量类） #

用静态HashMap存储注册表，程序启动时初始化：

use std::collections::HashMap;
use std::sync::OnceLock;

type TransformBox = Box<dyn Transform>;
type TransformFactory = fn() -> TransformBox;

// 全局静态注册表，线程安全
static TRANSFORM_REGISTRY: OnceLock<HashMap<&'static str, TransformFactory>> = OnceLock::new();

// 初始化注册表
fn init_registry() {
    let mut registry = HashMap::new();
    registry.insert("class_1", || Box::new(Class1Transform));
    registry.insert("class_2", || Box::new(Class2Transform));
    // ... 注册其他所有Transform
    TRANSFORM_REGISTRY.set(registry).unwrap();
}

// 根据ID获取Transform实例
pub fn get_transform(id: &str) -> Option<TransformBox> {
    let registry = TRANSFORM_REGISTRY.get_or_init(init_registry);
    registry.get(id).map(|factory| factory())
}

3.2 自动注册方案（适合100+类） #

自定义过程宏#[transform(id = "xxx")]，编译时自动完成注册：

步骤1：创建proc-macro crate

# transform-macro/Cargo.toml
[package]
name = "transform-macro"
version = "0.1.0"
edition = "2021"
proc-macro = true

[dependencies]
syn = { version = "2.0", features = ["full"] }
quote = "1.0"
proc-macro2 = "1.0"
ctor = "0.1"

步骤2：实现宏

// transform-macro/src/lib.rs
use proc_macro::TokenStream;
use quote::quote;
use syn::{parse_macro_input, DeriveInput};

#[proc_macro_attribute]
pub fn transform(args: TokenStream, input: TokenStream) -> TokenStream {
    let args = parse_macro_input!(args as syn::LitStr);
    let id = args.value();
    let input = parse_macro_input!(input as DeriveInput);
    let struct_name = &input.ident;

    // 生成自动注册代码
    let expanded = quote! {
        #input

        impl Transform for #struct_name {
            fn id(&self) -> &'static str {
                #id
            }
        }

        // 程序启动时自动执行注册
        #[ctor::ctor]
        fn register_#struct_name() {
            let registry = TRANSFORM_REGISTRY.get_or_init(|| HashMap::new());
            registry.insert(#id, || Box::new(#struct_name));
        }
    };

    TokenStream::from(expanded)
}

步骤3：业务代码中使用宏

use transform_macro::transform;
use serde_json::Value;

#[transform(id = "class_1")]
pub struct Class1Transform;

// 仅需实现run方法，id由宏自动生成
impl Transform for Class1Transform {
    fn run(&self, data: &Value) -> Result<Value, Box<dyn std::error::Error>> {
        // 业务逻辑
        Ok(Value::Null)
    }
}

4. 执行逻辑（替代Python的main.py） #

读取命令行参数或JSON配置，匹配ID并执行：

use serde_json::Value;
use std::env;
use std::fs;

// 模拟从数据库获取字典数据
fn get_data() -> Value {
    serde_json::json!({"input": "test_data"})
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let args: Vec<String> = env::args().collect();
    if args.len() < 2 {
        eprintln!("用法: {} <transform_id|json配置路径>", args[0]);
        std::process::exit(1);
    }

    let target = &args[1];
    if target.ends_with(".json") {
        // 按JSON配置顺序执行多个Transform
        let config: Vec<String> = serde_json::from_str(&fs::read_to_string(target)?)?;
        let mut current_data = get_data();
        for id in config {
            match get_transform(&id) {
                Some(transform) => {
                    current_data = transform.run(&current_data)?;
                    println!("{} 执行成功", id);
                }
                None => {
                    eprintln!("未找到Transform: {}", id);
                    std::process::exit(1);
                }
            }
        }
        println!("最终结果: {}", current_data);
    } else {
        // 执行单个Transform
        match get_transform(target) {
            Some(transform) => {
                let result = transform.run(&get_data())?;
                println!("结果: {}", result);
            }
            None => {
                eprintln!("未找到Transform: {}", target);
                std::process::exit(1);
            }
        }
    }

    Ok(())
}

5. 项目结构（适配10个子包） #

按业务拆分10个子包，结构如下：

src/
   main.rs
   transforms/
      mod.rs
      sub1/
         mod.rs
         class1.rs
         class2.rs
      sub2/
         mod.rs
         class3.rs
         ...
      ... 共10个子包
   transform_macro/ （自动注册宏所在crate）
      src/
         lib.rs

在transforms/mod.rs中导出所有子包：

pub mod sub1;
pub mod sub2;
// ... 其他子包

关键依赖配置 #

主项目Cargo.toml需添加以下依赖：

[dependencies]
serde = { version = "1.0", features = ["derive"] }
serde_json = "1.0"
ctor = "0.1"
transform-macro = { path = "./transform-macro" }

内容的提问来源于stack exchange，提问作者yuser099881232