Rust中实现MVC：如何让Model引用Controller并通知变更

原代码的核心问题 #

你的代码存在两个关键问题：

1. 自引用初始化错误：在main中创建Controller时，尝试用&controller作为Model的引用，但此时controller还未完成初始化，Rust的安全规则禁止这种未初始化变量的引用。
2. 循环引用与生命周期矛盾：Controller拥有Model的所有权，同时Model持有Controller的引用，这种循环依赖无法通过Rust的静态生命周期检查——编译器无法确定两者的生命周期边界。

解决方案1：使用Rc<RefCell<T>>实现双向引用 #

通过引用计数（Rc）和内部可变性（RefCell），可以打破单一所有权限制，实现Model对Controller的可共享、可访问引用。

修改后的代码：

use std::rc::Rc;
use std::cell::RefCell;

struct Controller {
    model: Option<Model>,
}

impl Controller {
    pub fn on_model_change(&self) {
        println!("Model has changed");
        // 这里添加变更后的处理逻辑
    }
}

struct Model {
    controller: Rc<RefCell<Controller>>,
    foo: i32,
}

impl Model {
    // 通知Controller模型变更
    pub fn notify_controller_change(&self) {
        self.controller.borrow().on_model_change();
    }

    // 示例：修改模型值并触发通知
    pub fn set_foo(&mut self, new_val: i32) {
        self.foo = new_val;
        self.notify_controller_change();
    }
}

fn main() {
    // 先创建Controller的Rc<RefCell>实例
    let controller_rc = Rc::new(RefCell::new(Controller { model: None }));
    
    // 创建Model，持有Controller的引用
    let model = Model {
        controller: controller_rc.clone(),
        foo: 0,
    };
    
    // 将Model赋值给Controller
    controller_rc.borrow_mut().model = Some(model);

    // 测试：修改Model值，触发通知
    if let Some(ref mut model) = controller_rc.borrow_mut().model {
        model.set_foo(10);
    }
}

原理说明 #

• Rc：允许多个所有者共享同一个Controller实例，解决了单一所有权的限制。
• RefCell：提供内部可变性，允许在持有不可变引用的情况下修改Controller的内部数据（比如赋值model），同时在运行时检查借用规则，避免数据竞争。

解决方案2：使用消息传递模式（更符合Rust设计理念） #

避免直接引用，改用消息传递实现Model到Controller的通知。这种方式完全遵循Rust的所有权模型，没有循环引用问题，还天然支持多线程场景。

修改后的代码：

use std::sync::mpsc;

// 定义Model发送给Controller的消息类型
enum ModelMessage {
    DataChanged,
}

struct Controller {
    rx: mpsc::Receiver<ModelMessage>,
}

impl Controller {
    pub fn new(rx: mpsc::Receiver<ModelMessage>) -> Self {
        Controller { rx }
    }

    // 启动Controller的消息监听逻辑
    pub fn start_listening(self) {
        while let Ok(msg) = self.rx.recv() {
            match msg {
                ModelMessage::DataChanged => {
                    println!("Model has changed");
                    // 处理模型变更的逻辑
                }
            }
        }
    }
}

struct Model {
    tx: mpsc::Sender<ModelMessage>,
    foo: i32,
}

impl Model {
    // 修改模型值并发送变更通知
    pub fn set_foo(&mut self, new_val: i32) {
        self.foo = new_val;
        // 发送消息，忽略发送失败（比如Controller已退出）
        let _ = self.tx.send(ModelMessage::DataChanged);
    }
}

fn main() {
    // 创建消息通道：发送端给Model，接收端给Controller
    let (tx, rx) = mpsc::channel();
    
    let mut model = Model { tx, foo: 0 };
    let controller = Controller::new(rx);

    // 启动Controller线程监听消息
    std::thread::spawn(move || {
        controller.start_listening();
    });

    // 测试修改Model
    model.set_foo(10);
}

原理说明 #

• mpsc::channel创建一个单向消息通道，Model持有发送端（tx），Controller持有接收端（rx）。
• 当Model发生变更时，发送消息到通道，Controller通过接收消息来处理变更逻辑，完全避免了双向引用的问题。

方案选择建议 #

• 若你的MVC是单线程场景且逻辑简单，Rc<RefCell<T>>方案足够直观。
• 若涉及多线程，或希望代码更符合Rust的所有权与并发设计理念，优先选择消息传递方案。

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