Rust中EventHandler模式实现失败问题及替代方案咨询

问题原因与修复方案 #

你遇到的错误核心是类型不兼容：Rc<dyn Observer> 和 Rc<State> 是不同的类型，无法直接强制转换；另外原代码还存在一个隐藏问题：Rc 是共享不可变容器，而 Observer trait 的 on_keypress 需要 &mut self，这会导致后续调用时无法获取可变引用。

步骤1：修复类型与可变性问题

我们需要用 RefCell 实现内部可变性，同时保留具体类型的引用：

1. 修改 EventHandler，让它持有带内部可变性的 trait 对象：

use std::rc::Rc;
use std::cell::RefCell;
use crate::global::cursor::CursorAction;
use crate::global::state::State;

pub trait Observer {
    fn on_keypress(&mut self, cursor_action: &CursorAction, old_state: &State);
}

#[derive(Default)]
pub struct EventHandler {
    // 用 RefCell 实现内部可变性
    listeners: Vec<Rc<RefCell<dyn Observer>>>
}

impl EventHandler {
    pub fn register(&mut self, observer: Rc<RefCell<dyn Observer>>) {
        self.listeners.push(observer);
    }

    pub fn notify(&mut self, cursor_action: &CursorAction, old_state: &State) {
        for listener in &mut self.listeners {
            // 通过 borrow_mut 获取可变引用
            listener.borrow_mut().on_keypress(cursor_action, old_state);
        }
    }
}

2. 调整 src/lib.rs 中的代码，保留 State 的具体类型引用，并适配 RefCell：

use std::error::Error;
use std::rc::Rc;
use std::cell::RefCell;
use crate::event_handler::{EventHandler, Observer};
use crate::global::state::State;

mod terminal;
mod global;
mod domain;
mod event_handler;

pub fn start() -> Result<(), Box<dyn Error>> {
    let mut event_handler = EventHandler::default();
    // 用 Rc<RefCell<State>> 包裹状态，同时支持共享和内部可变
    let state = Rc::new(RefCell::new(State::default()));
    // 注册时自动转换为 trait 对象
    event_handler.register(Rc::clone(&state));
    // 传递 Rc<RefCell<State>> 给 init
    init(&state);

    let mut terminal = terminal::setup_terminal()?;
    // 根据 terminal::run 的签名调整参数，比如传递 &state
    terminal::run(&mut terminal, &state, event_handler)?;
    terminal::restore_terminal(&mut terminal)?;
    Ok(())
}

fn init(state: &Rc<RefCell<State>>) {
    let raw_files = domain::retrieve_files();
    // 通过 borrow_mut 获取可变引用修改状态
    state.borrow_mut().set_files(raw_files);
}

3. 确保 State 正确实现 Observer trait：

impl Observer for State {
    fn on_keypress(&mut self, cursor_action: &CursorAction, old_state: &State) {
        // 你的按键事件处理逻辑
    }
}

替代方案：用通道实现发布订阅（更符合 Rust 风格） #

Rust 的所有权模型不太适合传统的 Observer 模式（容易出现可变引用冲突），更 idiomatic 的方式是用**通道（Channel）**实现广播：

1. 定义事件类型：

#[derive(Clone)]
pub struct KeypressEvent {
    pub cursor_action: CursorAction,
    pub old_state: State,
}

2. 实现广播器：

use std::sync::mpsc::{Sender, Receiver, channel};

pub struct EventBroadcaster {
    senders: Vec<Sender<KeypressEvent>>,
}

impl EventBroadcaster {
    pub fn new() -> Self {
        Self { senders: Vec::new() }
    }

    // 订阅事件，返回接收器
    pub fn subscribe(&mut self) -> Receiver<KeypressEvent> {
        let (sender, receiver) = channel();
        self.senders.push(sender);
        receiver
    }

    // 广播事件给所有订阅者
    pub fn broadcast(&self, event: KeypressEvent) {
        for sender in &self.senders {
            // 忽略发送失败（比如订阅者已销毁）
            let _ = sender.send(event.clone());
        }
    }
}

3. 在应用中使用：

pub fn start() -> Result<(), Box<dyn Error>> {
    let mut broadcaster = EventBroadcaster::new();
    let state = Rc::new(RefCell::new(State::default()));
    
    // 让 State 订阅事件
    let receiver = broadcaster.subscribe();
    let state_clone = Rc::clone(&state);
    // 在后台线程监听事件（TUI 场景也可以整合到主事件循环）
    std::thread::spawn(move || {
        let mut state = state_clone.borrow_mut();
        for event in receiver {
            state.on_keypress(&event.cursor_action, &event.old_state);
        }
    });

    init(&state);

    // 当捕获到按键事件时，广播
    // broadcaster.broadcast(KeypressEvent {
    //     cursor_action: some_action,
    //     old_state: current_state.clone(),
    // });

    let mut terminal = terminal::setup_terminal()?;
    terminal::run(&mut terminal, &state, broadcaster)?;
    terminal::restore_terminal(&mut terminal)?;
    Ok(())
}

这种方式利用 Rust 的通道机制，天然避免了可变引用冲突，也更符合 Rust 的并发与所有权设计理念。

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