Rust对象注册表：规避借用问题的替代实现方案咨询

一、修正现有引用式注册表的问题 #

你当前代码的核心问题是错误地将register函数的self借用生命周期绑定到了Registry的'a生命周期，导致第一次调用后Registry被长期借用，无法再次调用。只需调整生命周期标注，就能让register返回()且支持多次调用：

trait Doable {
    fn do_it(&mut self);
}

struct Registry<'a> {
    components: Vec<&'a dyn Doable>, // 无需额外Box，直接存 trait 对象引用
}

impl<'a> Registry<'a> {
    // self 的借用生命周期不绑定到 'a，使用 Rust 默认的匿名生命周期即可
    fn register(&mut self, d: &'a impl Doable) {
        self.components.push(d);
    }

    // 可选：添加遍历调用的方法，体现注册表的实际用途
    fn run_all(&mut self) {
        for comp in self.components.iter_mut() {
            comp.do_it();
        }
    }
}

struct Foo {
    name: String,
    value: u32,
}
impl Foo {
    fn set_value(&mut self, v: u32) {
        self.value = v
    }
}
impl Doable for Foo {
    fn do_it(&mut self) {
        println!("The value of {} is {}", self.name, self.value);
    }
}

struct Bar {
    nm: String,
    id: u32,
}
impl Bar {
    fn set_id(&mut self, v: u32) {
        self.id = v
    }
}
impl Doable for Bar {
    fn do_it(&mut self) {
        println!("The id of {} is {}", self.nm, self.id);
    }
}

fn main() {
    let mut r = Registry { components: Vec::new() };
    let mut foo = Foo { name: "foo".to_string(), value: 0 };
    let mut bar = Bar { nm: "bar".to_string(), id: 0 };
    let mut baz = Foo { name: "baz".to_string(), value: 0 };

    // 直接多次调用 register，无需链式赋值
    r.register(&foo);
    r.register(&bar);
    r.register(&baz);

    foo.set_value(41);
    bar.set_id(5);
    baz.set_value(11);

    // 调用注册表的批量执行方法
    r.run_all();
}

关键调整说明： #

• 移除Box<&'a dyn Doable>的冗余包装，直接存储&'a dyn Doable trait对象引用即可；
• register函数的self参数使用默认的匿名生命周期（即&mut self等价于&'_ mut self），而不是&'a mut self，这样每次调用register后，可变借用会立即释放，不会阻塞后续调用。

二、所有权式注册表（更推荐的方案） #

如果希望注册表完全管理对象的生命周期（无需外部保持对象存活），可以将对象的所有权转移给注册表，这样代码无需生命周期参数，更加简洁安全：

trait Doable {
    fn do_it(&mut self);
}

// 无需生命周期参数，注册表拥有对象所有权
struct Registry {
    components: Vec<Box<dyn Doable>>,
}

impl Registry {
    fn new() -> Self {
        Registry { components: Vec::new() }
    }

    // 接收实现 Doable 的对象的所有权
    fn register(&mut self, d: impl Doable + 'static) {
        self.components.push(Box::new(d));
    }

    fn run_all(&mut self) {
        for comp in self.components.iter_mut() {
            comp.do_it();
        }
    }
}

// Foo、Bar 实现保持不变...

fn main() {
    let mut r = Registry::new();

    // 直接将对象所有权转移给注册表
    r.register(Foo { name: "foo".to_string(), value: 0 });
    r.register(Bar { nm: "bar".to_string(), id: 0 });
    r.register(Foo { name: "baz".to_string(), value: 0 });

    // 如果需要修改对象，可以给 Doable 添加对应方法，或者使用 downcast（需 trait 继承 Any）
    r.run_all();
}

优势： #

• 无需处理复杂的生命周期标注，代码更易维护；
• 注册表完全掌控对象的生命周期，避免外部对象提前销毁导致的悬垂引用问题；
• 符合Rust的所有权模型，逻辑更清晰。

三、链式调用的优雅写法（如果仍需要） #

如果你确实喜欢链式调用的风格，也可以让register返回&mut Self，但无需绑定生命周期到'a，写法更自然：

impl<'a> Registry<'a> {
    fn register(&mut self, d: &'a impl Doable) -> &mut Self {
        self.components.push(d);
        self
    }
}

// 使用时可以链式调用：
r.register(&foo).register(&bar).register(&baz);

这种写法不会导致长期借用问题，因为self的借用生命周期是匿名的，每次链式调用都是复用临时的可变引用，调用完成后借用自动释放。

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