如何自动将所有Handler模块添加到Rust的数组/向量中？

我的Rust项目结构如下：

|- src
|  |- main.rs
|  |- handler.rs
|  |- modules
|  |  |- handler1.rs
|  |  |- handler2.rs
|  |  |  ...

对应的伪代码如下：

// handler.rs
trait Handler {
    fn handle(message: str) -> bool;
}

// handler1.rs
struct Handler1;
impl Handler for Handler1 {
    fn handle(message: str) -> bool {
        //...
    }
}

// handler2.rs
struct Handler2;
impl Handler for Handler2 {
    fn handle(message: str) -> bool {
        //...
    }
}

// main.rs
const handlers: Vec<Handler> = vec![Box::new(Handler1 {}), Box::new(Handler2 {})];

fn handleMessage(myMessage: str) {
    for handler in handlers.iter() {
        if (handler.handle(myMessage)) {
            break;
        };
    }
}

先纠正伪代码里的基础错误：Rust中不能直接用str作为函数参数，需改为&str；trait对象必须用dyn标记，因此handlers的正确类型是Vec<Box<dyn Handler>>；另外const无法用vec!构造动态集合，需改用静态初始化或运行时构建。

我希望能根据项目结构自动创建上述handlers集合，目前想到两种思路：

1. 在每个模块中使用注册宏
   示例如下：

// handler2.rs
struct Handler2;
impl Handler for Handler2 {
    fn handle(message: &str) -> bool {
        //...
    }
}
registerHandler!{Handler2}

2. 编译时扫描所有实现Handler trait的模块（或带有特定标记的实现）

我对这两种实现方式都不太了解，这类问题有没有标准解决方案？

解决方案说明 #

思路1：自定义注册宏

通过宏结合全局静态变量实现手动注册，步骤如下：

1. 在handler.rs中定义全局存储容器和注册宏：

// handler.rs
use std::sync::Mutex;
use lazy_static::lazy_static;

pub trait Handler {
    fn handle(&self, message: &str) -> bool;
}

// 全局静态容器存储注册的Handler实例
lazy_static! {
    pub static ref HANDLERS: Mutex<Vec<Box<dyn Handler>>> = Mutex::new(Vec::new());
}

#[macro_export]
macro_rules! register_handler {
    ($handler:ty) => {
        lazy_static::lazy_static! {
            static ref _REGISTRATION: () = {
                // 要求Handler实现Default trait，用于自动创建实例
                $crate::handler::HANDLERS.lock().unwrap().push(Box::new(<$handler>::default()));
            };
        }
        // 强制触发静态变量初始化，确保注册逻辑执行
        #[used]
        static _FORCE_REGISTRATION: &'static () = &_REGISTRATION;
    };
}

2. 在每个Handler模块中实现Default并调用宏：

// handler1.rs
use crate::handler::{Handler, register_handler};

struct Handler1;

impl Default for Handler1 {
    fn default() -> Self {
        Self
    }
}

impl Handler for Handler1 {
    fn handle(&self, message: &str) -> bool {
        // 业务逻辑
        true
    }
}

register_handler!(Handler1);

3. 在main.rs中使用注册的Handler：

// main.rs
use handler::{Handler, HANDLERS};

fn handle_message(my_message: &str) {
    let handlers = HANDLERS.lock().unwrap();
    for handler in handlers.iter() {
        if handler.handle(my_message) {
            break;
        }
    }
}

fn main() {
    handle_message("test message");
}

需要在Cargo.toml中添加依赖：

[dependencies]
lazy_static = "1.4.0"

思路2：编译时自动扫描（标准方案）

使用Rust生态中的inventory crate，可在编译时自动收集标记的trait实现，无需手动调用注册宏：

1. 添加依赖：

[dependencies]
inventory = "0.3.0"

2. 修改handler.rs，给trait添加#[collect]标记：

// handler.rs
use inventory::collect;

#[collect]
pub trait Handler: Send + Sync + 'static {
    fn handle(&self, message: &str) -> bool;
}

3. 在每个Handler实现上添加#[inventory::submit]标记：

// handler2.rs
use crate::handler::Handler;

#[inventory::submit]
struct Handler2;

impl Handler for Handler2 {
    fn handle(&self, message: &str) -> bool {
        // 业务逻辑
        false
    }
}

4. 在main.rs中遍历收集到的Handler：

// main.rs
use handler::Handler;
use inventory::iter;

fn handle_message(my_message: &str) {
    for handler in iter::<dyn Handler> {
        if handler.handle(my_message) {
            break;
        }
    }
}

fn main() {
    handle_message("test message");
}

这种方式在编译期完成收集，无需运行时锁，性能更优，是这类自动注册问题的标准解决方案之一。

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