如何在Rust中实现Checker依赖数据的自动识别与高效获取？

代码定义 #

Checker Trait定义 #

use std::{error::Error, fmt::Debug};
use super::CheckResult;

/// A Checker is a component that is responsible for checking a
/// particular aspect of the node under investigation, be that metrics,
/// system information, API checks, load tests, etc.
#[async_trait::async_trait]
pub trait Checker: Debug + Sync + Send {
    type Input: Debug;

    /// This function is expected to take input, whatever that may be,
    /// and return a vec of check results.
    async fn check(&self, input: &Self::Input) -> anyhow::Result<Vec<CheckResult>>;
}

Checker实现示例 #

pub struct ApiData {
    some_response: String,
}

pub struct MetricsData {
    number_of_events: u64,
}

pub struct ApiChecker;

impl Checker for ApiChecker { 
    type Input = ApiData;

    // implement check function
}
 
pub struct MetricsChecker;

impl Checker for MetricsChecker { 
    type Input = MetricsData;

    // implement check function
}  

服务结构体 #

pub struct MyServer {
    checkers: Vec<Box<dyn Checker>>,
}

核心需求 #

希望根据MyServer中持有的Checker集合自动确定需要获取的数据：

• 仅包含ApiChecker时，只需获取ApiData
• 同时包含ApiChecker和MetricsChecker时，需获取ApiData和MetricsData
• 若存在Input为(ApiData, MetricsData)的Checker，仍只需各获取一次数据

现有方案的问题 #

曾考虑为Checker trait添加required_data方法：

fn required_data(&self) -> HashSet<DataId>;

但该方案存在两个核心问题：

1. 依赖声明重复：Input关联类型与required_data方法都描述依赖，容易因不一致引入bug
2. 信任风险：调用代码必须依赖Checker实现方准确声明依赖，否则会触发panic

期望直接通过Input关联类型表达依赖需求，无需额外声明。已知Rust nightly版有Provider和Demand特性，但需使用稳定版Rust，因此提出以下问题：

1. 在稳定Rust中，如何在运行时检查函数参数（包括结构体、元组等复杂输入）的类型？
2. 是否存在更优的代码设计方案，可避免反射需求，同时解决上述问题？

解决方案 #

问题1：稳定Rust中的运行时类型检查 #

稳定Rust没有原生反射机制，但可以通过**类型标识（std::any::TypeId）**结合自定义trait实现Input类型的依赖解析：

1. 定义trait DataDependency，提取Input包含的所有基础数据类型的TypeId：

use std::any::TypeId;
use std::collections::HashSet;

pub trait DataDependency {
    fn required_types() -> HashSet<TypeId>;
}

// 为基础数据类型实现
impl DataDependency for ApiData {
    fn required_types() -> HashSet<TypeId> {
        HashSet::from([TypeId::of::<ApiData>()])
    }
}

impl DataDependency for MetricsData {
    fn required_types() -> HashSet<TypeId> {
        HashSet::from([TypeId::of::<MetricsData>()])
    }
}

// 为二元组实现（可扩展更多元数）
impl<A: DataDependency, B: DataDependency> DataDependency for (A, B) {
    fn required_types() -> HashSet<TypeId> {
        let mut set = A::required_types();
        set.extend(B::required_types());
        set
    }
}

2. 修改Checker trait，要求Input实现DataDependency：

#[async_trait::async_trait]
pub trait Checker: Debug + Sync + Send {
    type Input: Debug + DataDependency;

    async fn check(&self, input: &Self::Input) -> anyhow::Result<Vec<CheckResult>>;

    // 默认方法，获取当前Checker需要的所有数据类型
    fn required_data_types(&self) -> HashSet<TypeId> {
        <Self::Input as DataDependency>::required_types()
    }
}

3. 在MyServer中汇总所有Checker的依赖：

impl MyServer {
    pub fn collect_required_data(&self) -> HashSet<TypeId> {
        let mut required = HashSet::new();
        for checker in &self.checkers {
            required.extend(checker.required_data_types());
        }
        required
    }
}

该方式通过编译期实现的trait解析依赖，避免运行时反射开销，同时保证依赖与Input类型绑定，不会出现不一致。

问题2：更优的无反射设计方案 #

采用**数据上下文（Data Context）**模式，将所有数据存入统一上下文结构体，Checker从上下文中提取所需数据，同时利用编译期检查保证依赖正确性：

1. 定义全局数据上下文：

pub struct DataContext {
    api_data: Option<ApiData>,
    metrics_data: Option<MetricsData>,
    // 可扩展更多数据类型
}

impl DataContext {
    // 获取数据时返回错误而非panic，避免运行时崩溃
    pub fn get_api_data(&self) -> anyhow::Result<&ApiData> {
        self.api_data.as_ref().ok_or_else(|| anyhow::anyhow!("ApiData not available"))
    }

    pub fn get_metrics_data(&self) -> anyhow::Result<&MetricsData> {
        self.metrics_data.as_ref().ok_or_else(|| anyhow::anyhow!("MetricsData not available"))
    }
}

2. 修改Checker trait，统一使用DataContext作为输入，并添加编译期依赖声明：

#[async_trait::async_trait]
pub trait Checker: Debug + Sync + Send {
    // 移除Input关联类型，统一使用DataContext
    async fn check(&self, ctx: &DataContext) -> anyhow::Result<Vec<CheckResult>>;

    // 声明当前Checker需要的数据类型（编译期检查）
    fn requires_api_data(&self) -> bool { false }
    fn requires_metrics_data(&self) -> bool { false }
}

// ApiChecker实现
impl Checker for ApiChecker {
    async fn check(&self, ctx: &DataContext) -> anyhow::Result<Vec<CheckResult>> {
        let api_data = ctx.get_api_data()?;
        // 执行检查逻辑
        Ok(Vec::new())
    }

    fn requires_api_data(&self) -> bool { true }
}

// MetricsChecker实现
impl Checker for MetricsChecker {
    async fn check(&self, ctx: &DataContext) -> anyhow::Result<Vec<CheckResult>> {
        let metrics_data = ctx.get_metrics_data()?;
        // 执行检查逻辑
        Ok(Vec::new())
    }

    fn requires_metrics_data(&self) -> bool { true }
}

// 多数据依赖的Checker示例
pub struct CombinedChecker;

impl Checker for CombinedChecker {
    async fn check(&self, ctx: &DataContext) -> anyhow::Result<Vec<CheckResult>> {
        let api_data = ctx.get_api_data()?;
        let metrics_data = ctx.get_metrics_data()?;
        // 执行检查逻辑
        Ok(Vec::new())
    }

    fn requires_api_data(&self) -> bool { true }
    fn requires_metrics_data(&self) -> bool { true }
}

3. 在MyServer中根据Checker声明收集并构建数据上下文：

impl MyServer {
    pub async fn run_checks(&self) -> anyhow::Result<Vec<CheckResult>> {
        // 收集需要的数据类型
        let mut needs_api = false;
        let mut needs_metrics = false;
        for checker in &self.checkers {
            needs_api = needs_api || checker.requires_api_data();
            needs_metrics = needs_metrics || checker.requires_metrics_data();
        }

        // 构建数据上下文
        let mut ctx = DataContext {
            api_data: None,
            metrics_data: None,
        };
        if needs_api {
            ctx.api_data = Some(self.fetch_api_data().await?);
        }
        if needs_metrics {
            ctx.metrics_data = Some(self.fetch_metrics_data().await?);
        }

        // 执行所有检查
        let mut results = Vec::new();
        for checker in &self.checkers {
            results.extend(checker.check(&ctx).await?);
        }
        Ok(results)
    }

    // 模拟数据获取方法
    async fn fetch_api_data(&self) -> anyhow::Result<ApiData> {
        Ok(ApiData { some_response: "ok".to_string() })
    }

    async fn fetch_metrics_data(&self) -> anyhow::Result<MetricsData> {
        Ok(MetricsData { number_of_events: 100 })
    }
}

该方案优势：

• 编译期安全：Checker必须明确声明依赖，获取数据时返回错误而非panic，避免运行时崩溃
• 无反射开销：所有依赖检查在编译期完成，运行时仅需简单布尔判断
• 扩展性强：新增数据类型时，只需扩展DataContext字段和Checker的requires_*方法

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