罗罗编程学习记录
本页内容 展开查看

01.3.2.9 观察者模式

所属:全栈开发面试题库 / 01 计算机基础与通用工程 / 01.3 设计模式与架构基础 / 01.3.2 常用设计模式多语言详解

覆盖范围

  • 主题(Subject)与观察者(Observer)角色与通知方向
  • 推模型与拉模型的取舍
  • 同步通知链、重入问题与异常隔离
  • 取消订阅与内存泄漏(强引用、匿名函数、channel 关闭)
  • C# event 与弱事件、TypeScript EventEmitter/EventTarget
  • Go 用 channel 做扇出与 WaitGroup 收口
  • Rust 借用检查下的观察者:Rc<RefCell<..>> 或改用消息通道
  • Python weakref 观察者与框架落地(Spring 事件、Vue 响应式、Node EventEmitter、tokio broadcast)
  • 观察者与 Pub/Sub、观察者与责任链的区别
  • 通知顺序、幂等与可靠投递

面试题索引

编号 题目 难度 状态 备注
01.3.2.9-001 观察者模式的主题与观察者角色怎么分?通知方向是什么? 基础 已完成 角色
01.3.2.9-002 推模型与拉模型怎么选? 基础 已完成 数据传递
01.3.2.9-003 同步通知链里的重入问题怎么解决? 进阶 已完成 遍历中增删
01.3.2.9-004 单个观察者抛异常如何隔离,不影响其他观察者? 进阶 已完成 异常隔离
01.3.2.9-005 取消订阅与内存泄漏有哪些典型坑? 进阶 已完成 生命周期
01.3.2.9-006 C# 的 event 与弱事件怎么用? 进阶 已完成 委托与泄漏
01.3.2.9-007 TypeScript 的 EventEmitter 与 EventTarget 怎么选? 进阶 已完成 Node/DOM
01.3.2.9-008 Go 用 channel 做扇出与 WaitGroup 收口怎么写? 进阶 已完成 CSP
01.3.2.9-009 Rust 借用检查下怎么实现观察者? 高级 已完成 所有权约束
01.3.2.9-010 Python 观察者为什么常用 weakref? 进阶 已完成 弱引用
01.3.2.9-011 Spring、Vue、Node、tokio 的事件机制怎么对应观察者? 进阶 已完成 框架落地
01.3.2.9-012 观察者与 Pub/Sub 的本质区别? 基础 已完成 进程内 vs 跨进程
01.3.2.9-013 观察者与责任链的区别?通知顺序与幂等怎么定? 高级 已完成 易混淆

01.3.2.9-001 观察者模式的主题与观察者角色怎么分?通知方向是什么?

一句话结论

主题(Subject)维护一份观察者列表,负责 subscribe/unsubscribe 与 notify;观察者(Observer)实现一个回调接口(如 onEvent(e)),只接收事件、不反过来持有主题。通知方向是主题 → 观察者单向,观察者不应反向修改主题。

概念解释

  • 主题:被观察对象,状态变化时主动广播。
  • 观察者:订阅方,实现回调接口,不关心谁发的事件。
  • 事件对象:承载数据,通常不可变。
  • 解耦目标:发布者不认识具体订阅者,新增订阅者不改主题。

原理流程

  1. 主题暴露 subscribe(observer) 与 unsubscribe(observer)。
  2. 内部维护观察者集合。
  3. 状态变化时遍历集合,调用每个观察者的回调。
  4. 观察者只处理事件,不直接改主题(避免双向依赖与重入)。

代码或图示

public interface Observer<E> {
    void onEvent(E event);
}

public class Subject<E> {
    private final List<Observer<E>> observers = new CopyOnWriteArrayList<>();

    public void subscribe(Observer<E> o) { observers.add(o); }
    public void unsubscribe(Observer<E> o) { observers.remove(o); }

    public void notify(E event) {
        for (Observer<E> o : observers) o.onEvent(event);
    }
}
Subject ──notify(e)──> ObserverA.onEvent(e)
       ─────────────> ObserverB.onEvent(e)
观察者不持有 Subject 引用(或只持有弱引用)

常见误区

  • 观察者反向调用主题修改状态:形成循环依赖与重入,见 003 题。
  • 主题把事件对象传给观察者后又修改它:后发观察者读到被污染的数据。
  • 观察者列表用普通 ArrayList:并发遍历与增删会出 ConcurrentModificationException。

追问

  • 主题应该知道观察者的业务身份吗?答:不需要,只认识回调接口;业务身份由事件数据或事件类型表达。
  • 观察者可以订阅多个主题吗?答:可以,它实现多个接口或在回调里区分事件来源。

01.3.2.9-002 推模型与拉模型怎么选?

一句话结论

推模型把事件数据打包进通知,观察者直接用;拉模型只通知「状态变了」,观察者自己回头读主题。推模型耦合低、观察者不需要持有主题引用;拉模型耦合高但数据按需获取,适合事件数据大或观察者只关心部分字段。

概念解释

  • 推模型:notify(event),事件对象携带全部数据。
  • 拉模型:notify(subject),观察者调用 subject.getState() 取数据。
  • 现代实践:事件对象不可变,推模型为主;拉模型主要出现在 GUI 与老的 Java EventListener。

原理流程

  1. 事件数据小、字段固定:推模型,定义不可变事件。
  2. 事件数据大、观察者只关心子集:拉模型或按需传递 view。
  3. 观察者不应反向修改主题:拉模型下也要保证读的是快照。

代码或图示

// 推模型:事件自带数据
public class OrderCreatedEvent {
    private final Long orderId;
    private final BigDecimal amount;
    // 构造后不可变
}
// 拉模型:观察者回头读主题
public interface Observer {
    void onEvent(Subject s);   // 拉
}

常见误区

  • 推模型事件对象是可变的:主题复用同一个事件对象,后发观察者读到前次的脏数据。
  • 拉模型让观察者直接改主题字段:破坏封装,且引入重入。
  • 事件里塞了所有字段:观察者不需要的字段也会被构造与传输,事件应只带当前通知需要的数据。

追问

  • 推模型怎么保证不可变?答:字段 final、getter 只暴露只读视图、集合用 List.of() 或防御式拷贝。
  • 拉模型有什么好处?答:避免一次性构造大事件;但代价是观察者必须持有主题引用,耦合更紧。

01.3.2.9-003 同步通知链里的重入问题怎么解决?

一句话结论

重入问题来自两种场景:通知过程中观察者又调用 subscribe/unsubscribe,或观察者回调里又触发主题的 notify;解决办法是「先快照再通知」,并在通知期间冻结订阅列表或把重入事件入队延后处理。

概念解释

  • 遍历中增删:ConcurrentModificationException 或漏通知。
  • 重入通知:观察者 A 的回调里修改了主题状态,触发第二次 notify,通知顺序错乱。
  • 快照:通知前复制一份观察者列表,遍历快照,增删作用于原列表。

原理流程

  1. notify 开始时复制快照。
  2. 遍历快照回调,增删只改原列表,不影响本次通知。
  3. 重入 notify 直接执行(允许),但要避免无限递归,必要时用「通知中标记 + 事件队列」合并。
  4. 事件对象不可变,避免重入时被改。

代码或图示

public void notify(E event) {
    List<Observer<E>> snapshot = new ArrayList<>(observers);  // 快照
    for (Observer<E> o : snapshot) {
        try {
            o.onEvent(event);
        } catch (Exception ex) {
            log.error("observer fail", ex);   // 见 004 题
        }
    }
}
错误:遍历 observers 时,回调里 unsubscribe → 遍历报错或漏人
正确:快照后遍历原列表的拷贝;增删影响下一次通知

常见误区

  • 用 CopyOnWriteArrayList 就以为万事大吉:它能容忍遍历中增删,但本次通知仍可能漏掉刚加入的观察者,语义要明确。
  • 观察者回调里又 notify:顺序不可控,复杂业务应改成异步事件队列。
  • 通知过程中改事件对象:重入时第二次通知读到脏数据。

追问

  • 怎么避免无限递归?答:限制嵌套深度,或在通知中把事件入队、主线程串行消费。
  • 快照后刚订阅的观察者收不到本次事件怎么办?答:这是预期行为,订阅语义以「下一次通知」为准;若需要立即收到,主题要提供 immediate 参数。

01.3.2.9-004 单个观察者抛异常如何隔离,不影响其他观察者?

一句话结论

通知循环里对每个观察者独立 try/catch,捕获后记录日志并继续下一个;不能让一个订阅者的异常中断整批通知,更不能让异常冒泡回发布者。需要失败重试时,把失败交给异步重试队列,而不是在通知链里同步重试。

概念解释

  • 隔离边界:每个观察者是一个独立 try/catch。
  • 异常处理:记录上下文(事件类型、观察者标识),不吞掉堆栈。
  • 重试策略:同步重试会拖慢通知链,应异步或走 MQ。

原理流程

  1. 遍历快照。
  2. 对每个观察者独立 try/catch。
  3. catch 里记录日志,不 rethrow。
  4. 失败的观察者如果需要重试,发送到重试队列。

代码或图示

public void notify(E event) {
    for (Observer<E> o : new ArrayList<>(observers)) {
        try {
            o.onEvent(event);
        } catch (Exception ex) {
            log.error("observer fail: type={}, event={}",
                    o.getClass().getSimpleName(), event, ex);
            // 不 rethrow,继续下一个
        }
    }
}

常见误区

  • 在 catch 里 throw 回去:一个观察者失败,整批通知中断。
  • catch 里不记录上下文:线上排查时不知道是哪个观察者挂的。
  • 同步重试:一个慢观察者拖垮整个通知链,其他观察者也跟着延迟。

追问

  • 观察者失败要不要补偿?答:业务上需要强一致的后续动作,应该用本地事件表 + 事务消息,而不是内存观察者。
  • 怎么知道哪个观察者失败最多?答:给每个观察者加指标(调用次数、失败次数、耗时),监控告警。

01.3.2.9-005 取消订阅与内存泄漏有哪些典型坑?

一句话结论

内存泄漏来自「长生命周期主题持有短生命周期观察者的强引用」:Java 用普通 List<Observer>、TS 用匿名函数订阅后无法移除、Go 把 channel 关闭后还在发送;解决办法是订阅与反订阅配对、用弱引用、用命名函数而不是匿名函数。

概念解释

  • Java:主题是单例,观察者是请求级或页面级,强引用会让观察者无法 GC。
  • TypeScript:emitter.on('x', () => {...}) 传的是匿名函数,off 时传的是另一个函数引用,移除失败。
  • Go:向已关闭的 channel 发送会 panic,订阅者退出后要先关闭接收侧或通知主题停止发送。

原理流程

  1. 观察者注册时返回 Disposable/unsubscribe 句柄。
  2. 观察者销毁时必须调用反订阅。
  3. 主题无法感知观察者生命周期时,用弱引用(WeakReference、weakref)。
  4. Go 场景:订阅者退出时先关闭自己的 channel,主题用 select + default 非阻塞发送或用 context 取消。

代码或图示

// 错误:匿名函数无法移除
emitter.on('order', () => console.log('a'));
emitter.off('order', () => console.log('a'));  // 引用不同,移除失败

// 正确:命名函数
const handler = () => console.log('a');
emitter.on('order', handler);
emitter.off('order', handler);
// 弱引用观察者:主题持有弱引用,观察者可被 GC
List<WeakReference<Observer<E>>> refs = new CopyOnWriteArrayList<>();

常见误区

  • 订阅后忘记反订阅:尤其在前端组件卸载、Android onDestroy、Vue 组件卸载时。
  • 用匿名函数订阅:永远移除不掉。
  • 主题持有观察者强引用,观察者又持有主题:形成循环引用,GC 也回收不掉。

追问

  • Java 怎么自动清理已 GC 的弱引用?答:通知时遍历 WeakReference.get(),null 就从列表里移除。
  • 前端怎么避免订阅泄漏?答:在 useEffect/onUnmounted 里返回清理函数,或用框架提供的生命周期订阅 API。

01.3.2.9-006 C# 的 event 与弱事件怎么用?

一句话结论

C# 的 event 是基于委托的多播,订阅用 +=,取消用 -=;当发布者长生命周期、订阅者短生命周期时,委托的强引用会让订阅者无法 GC,这时用弱事件模式(WeakEventManager 或自实现弱委托)。

概念解释

  • event:封装 delegate,外部只能 +=/-=,不能直接赋值。
  • 多播委托:event 内部是 Delegate.Combine 的链。
  • 弱事件:用 WeakReference 持有订阅者,发布者不阻止订阅者 GC。

原理流程

  1. 发布者声明 public event EventHandler<OrderEvent> OrderCreated;。
  2. 订阅者 pub.OrderCreated += OnOrder;。
  3. 取消时 pub.OrderCreated -= OnOrder;。
  4. 跨长生命周期对象时,改用 WeakEventManager。

代码或图示

public class OrderPublisher
{
    public event EventHandler<OrderEvent>? OrderCreated;

    public void Raise(OrderEvent e)
    {
        // 复制到局部变量避免竞态
        var handler = OrderCreated;
        handler?.Invoke(this, e);
    }
}

// 订阅者
publisher.OrderCreated += OnOrder;
// 取消
publisher.OrderCreated -= OnOrder;

private void OnOrder(object? sender, OrderEvent e) { /* ... */ }

常见误区

  • 在 Raise 里直接 OrderCreated?.Invoke:多线程下 OrderCreated 可能在判空后被置空,应先复制到局部变量。
  • 订阅匿名方法却想取消:和 TS 一样,-= 传另一个 lambda 移除不掉。
  • 跨长生命周期对象用强事件:WPF/团队中常用 WeakEventManager 解决,否则订阅者无法释放。

追问

  • event 和普通 delegate 字段的区别?答:event 限制外部只能 +=/-=,不能赋值或直接调用,封装性更好。
  • 弱事件怎么实现?答:发布者内部存 WeakReference<Subscriber>,触发时遍历,已 GC 的清掉。

01.3.2.9-007 TypeScript 的 EventEmitter 与 EventTarget 怎么选?

一句话结论

Node.js 生态用 EventEmitter(events 模块),浏览器 DOM 用 EventTarget(addEventListener/removeEventListener);前者 API 简单、支持任意事件名与参数,后者是浏览器标准、支持 AbortSignal 自动取消订阅。新代码优先用 EventTarget + AbortSignal。

概念解释

  • EventEmitter:Node 内置,on/off/emit,支持任意参数。
  • EventTarget:DOM 标准,浏览器与现代 Node 都实现,addEventListener 支持 { signal }。
  • AbortSignal:可以在 AbortController.abort() 时自动取消所有监听,避免手动 off。

原理流程

  1. Node 服务端事件总线:EventEmitter。
  2. 浏览器事件、组件通信:EventTarget 或框架事件系统。
  3. 长生命周期监听:用 AbortSignal 统一取消。

代码或图示

// EventEmitter(Node)
import { EventEmitter } from "node:events";
const bus = new EventEmitter();

bus.on("order", (orderId: number) => console.log("order", orderId));
bus.emit("order", 123);
// EventTarget + AbortSignal(浏览器/现代 Node)
const target = new EventTarget();
const controller = new AbortController();

target.addEventListener(
  "order",
  (e) => console.log((e as CustomEvent).detail),
  { signal: controller.signal },
);

target.dispatchEvent(new CustomEvent("order", { detail: 123 }));
controller.abort();  // 自动取消监听

常见误区

  • EventEmitter 事件名拼错:运行时静默失败,应定义事件名常量或类型。
  • 用 EventTarget 却传多个参数:CustomEvent.detail 只能放一个对象,多个参数要包成对象。
  • 不取消订阅:组件卸载时监听还在,内存泄漏。

追问

  • EventEmitter 最大监听数警告?答:默认 10 个,超过会打印 MaxListenersExceededWarning,可以 emitter.setMaxListeners(n) 调整。
  • EventTarget 能传任意参数吗?答:不能,必须用 CustomEvent + detail,类型也更严格。

01.3.2.9-008 Go 用 channel 做扇出与 WaitGroup 收口怎么写?

一句话结论

Go 没有「观察者列表回调」的惯用形态,更自然的做法是:每个订阅者一个接收 channel,发布者向所有 channel 非阻塞发送(扇出),用 sync.WaitGroup 等待所有订阅者处理完成,或用 context.Context 取消。

概念解释

  • 扇出(fan-out):一份事件分发给多个接收 channel。
  • WaitGroup:发布者等待所有订阅者处理完,用于同步语义。
  • context:订阅者退出时取消,避免 goroutine 泄漏。
  • 非阻塞发送:用 select { case ch <- e: default: },订阅者慢时不阻塞发布者。

原理流程

  1. 主题维护 map[subID]chan Event。
  2. subscribe 返回新 channel。
  3. notify 遍历 channel,非阻塞发送。
  4. 需要同步等待时,每个订阅者 wg.Done(),发布者 wg.Wait()。

代码或图示

type Bus struct {
    mu     sync.RWMutex
    subs   map[int]chan Event
    nextID int
}

func (b *Bus) Subscribe() (int, <-chan Event) {
    b.mu.Lock()
    defer b.mu.Unlock()
    ch := make(chan Event, 8)
    id := b.nextID
    b.nextID++
    b.subs[id] = ch
    return id, ch
}

func (b *Bus) Unsubscribe(id int) {
    b.mu.Lock()
    defer b.mu.Unlock()
    if ch, ok := b.subs[id]; ok {
        close(ch)
        delete(b.subs, id)
    }
}

func (b *Bus) Notify(e Event) {
    b.mu.RLock()
    defer b.mu.RUnlock()
    for _, ch := range b.subs {
        select {
        case ch <- e:
        default: // 订阅者慢,丢弃或走另一条路
        }
    }
}

常见误区

  • 向已关闭的 channel 发送:panic。Unsubscribe 关闭后,Notify 不能再向它发;要么先从 map 移除再关闭,要么用 sync.Map + 恢复。
  • 订阅者忘记退出:goroutine 泄漏,必须用 context 取消。
  • 用无缓冲 channel:发布者会阻塞在慢订阅者上,应加缓冲或非阻塞发送。

追问

  • 怎么同步等待所有订阅者?答:发布者构造 WaitGroup,每个订阅者处理完 wg.Done();但 Go 更倾向异步,同步等待意味着事件变成请求-响应。
  • 怎么广播给多个 channel 不阻塞?答:缓冲 channel + select/default,或每个订阅者一个 goroutine 从独立 channel 读。

01.3.2.9-009 Rust 借用检查下怎么实现观察者?

一句话结论

Rust 借用检查让「主题持有观察者可变引用」变得非常别扭:常见做法是 Rc<RefCell<..>> 包装主题与观察者,但要小心 RefCell 的运行时借用 panic;更地道的做法是改用消息通道(mpsc、tokio::sync::broadcast),把观察者变成消费端,从根上绕开共享可变状态。

概念解释

  • Rc<RefCell<Subject>>:单线程共享可变,但 borrow_mut() 与 borrow() 不能重入。
  • mpsc:多生产者单消费者,订阅者退出即断开。
  • tokio::sync::broadcast:异步广播 channel,多个接收者各自收到副本。

原理流程

  1. 单线程 GUI 场景:用 Rc<RefCell<..>>,通知时小心重入。
  2. 异步服务:用 tokio::sync::broadcast::channel(n),发布者 send,订阅者 subscribe().recv().await。
  3. 跨线程:用 Arc<Mutex<..>> 或 channel,不要硬用 Rc。

代码或图示

// 异步惯用:tokio broadcast
use tokio::sync::broadcast;

#[derive(Clone, Debug)]
struct Event {
    order_id: u64,
}

#[tokio::main]
async fn main() {
    let (tx, mut rx1) = broadcast::channel::<Event>(16);
    let mut rx2 = tx.subscribe();

    tokio::spawn(async move {
        while let Ok(e) = rx1.recv().await {
            println!("sub1: {:?}", e);
        }
    });

    tokio::spawn(async move {
        while let Ok(e) = rx2.recv().await {
            println!("sub2: {:?}", e);
        }
    });

    tx.send(Event { order_id: 1 }).unwrap();
}

常见误区

  • 用 Rc<RefCell<Subject>> 又在通知回调里 borrow_mut:同一线程重入时 RefCell 会 panic。
  • 用 mpsc 想广播:mpsc 是单消费者,一条消息只能被一个接收者拿到;广播用 broadcast。
  • 忘记 broadcast 滞后:接收者慢于发送者会丢消息,Lagged 错误要处理。

追问

  • broadcast 怎么做到不丢消息?答:设置足够大的缓冲,接收者快消费;不能保证时用 mpsc + 每个订阅者独立 channel 或持久化队列。
  • Rust 为什么不推荐回调式观察者?答:共享可变状态在所有权模型下要么运行时借用检查(RefCell),要么用锁,都比消息通道别扭。

01.3.2.9-010 Python 观察者为什么常用 weakref?

一句话结论

Python 的主题通常用 list 或 dict 持有观察者强引用,观察者销毁时若忘记反订阅就会泄漏;用 weakref.WeakKeyDictionary 或 WeakMethod 持有观察者,主题就不会阻止观察者被 GC,GC 时自动清理。

概念解释

  • WeakMethod:持有绑定方法的弱引用,对象销毁后方法自动失效。
  • WeakKeyDictionary:以对象为键,键被 GC 后条目自动移除。
  • 适用:主题长生命周期、观察者短生命周期(如 GUI、ORM、事件总线)。

原理流程

  1. 主题内部用 WeakSet 或 WeakKeyDictionary。
  2. subscribe 存弱引用。
  3. notify 遍历弱引用,ref() 取到 None 就清理。
  4. 观察者销毁时无需手动反订阅。

代码或图示

import weakref

class Subject:
    def __init__(self) -> None:
        self._observers: weakref.WeakSet = weakref.WeakSet()

    def subscribe(self, obs) -> None:
        self._observers.add(obs)

    def notify(self, event) -> None:
        for obs in list(self._observers):  # 遍历时可能被 GC,先快照
            obs.on_event(event)

常见误区

  • 用弱引用持有临时对象:刚 subscribe 的对象如果没有其他强引用,下一行就被 GC,等于没订阅。
  • 在 notify 里遍历 WeakSet 不快照:遍历中 GC 触发修改,可能抛异常或漏通知。
  • 对函数对象用 WeakMethod:普通函数不是绑定方法,要用 ref(func) 或改成类。

追问

  • weakref 的代价?答:取引用要 ref() 一次,且不能弱引用所有对象(如 list、dict 原生实例不能直接 weakref),需要子类化。
  • Django 信号是强引用还是弱引用?答:Django 信号默认强引用,断开连接必须显式调用,版本行为以官方文档为准。

01.3.2.9-011 Spring、Vue、Node、tokio 的事件机制怎么对应观察者?

一句话结论

Spring 的 ApplicationEventPublisher + @EventListener 是进程内同步观察者(可 @Async 转异步);Vue 的响应式系统是数据变化时自动通知依赖组件(更细粒度的观察者);Node 的 EventEmitter 是标准实现;tokio 的 broadcast 是异步 channel 广播。它们本质都是观察者,只是底层机制不同。

概念解释

  • Spring:发布者 publishEvent(e),监听者 @EventListener 注解方法,默认同步。
  • Vue:ref/reactive 数据变化时通知依赖该数据的 effect/computed。
  • Node:EventEmitter,见 007 题。
  • tokio:broadcast,见 009 题。

原理流程

  1. 进程内业务事件:Spring 事件、EventEmitter。
  2. UI 状态变化:Vue 响应式。
  3. 异步并发:tokio broadcast。
  4. 需要跨进程:改用 MQ,不是观察者。

代码或图示

// Spring
@Component
public class OrderService {
    private final ApplicationEventPublisher publisher;
    public OrderService(ApplicationEventPublisher p) { this.publisher = p; }

    public void create(Order o) {
        // 保存订单
        publisher.publishEvent(new OrderCreatedEvent(o.getId()));
    }
}

@Component
public class OrderListener {
    @EventListener
    public void on(OrderCreatedEvent e) {
        // 发短信、加积分
    }
}
// Vue 响应式:数据变化自动通知
import { ref, watchEffect } from "vue";
const count = ref(0);
watchEffect(() => console.log(count.value));  // 依赖 count,变化时自动跑
count.value = 1;  // 触发 watchEffect

常见误区

  • Spring 事件默认同步:发布者线程会跑完所有监听者才返回,慢监听会拖垮主流程。
  • 把 Spring 事件当可靠消息:进程重启即丢,需要可靠用事务消息或 MQ。
  • Vue 响应式里做副作用:会重复触发,应该用 watch 明确依赖。

追问

  • Spring 事件怎么异步?答:监听方法加 @Async,且启动类加 @EnableAsync;异常处理要配置 AsyncUncaughtExceptionHandler。
  • Vue 响应式和观察者区别?答:响应式依赖追踪是自动的,不需要手动订阅;观察者需要显式 subscribe。

01.3.2.9-012 观察者与 Pub/Sub 的本质区别?

一句话结论

观察者是进程内、主题直接持有观察者引用、通常同步调用;Pub/Sub 是跨进程、通过 broker/消息中间件路由、通常异步。观察者是 Pub/Sub 的进程内简化形态,二者在「发布者不认识订阅者」这一点上一致,但通信范围与可靠性不同。

概念解释

  • 观察者:同进程、直接引用、同步、不持久化。
  • Pub/Sub:broker 中转、跨进程、异步、可持久化。
  • 演进路径:进程内事件 → 本地事件表 + 事务消息 → MQ。

原理流程

  1. 同事务内后续动作:观察者 / Spring 事件。
  2. 跨服务、需要持久化、需要重试:MQ。
  3. 观察者不能保证不丢事件:进程重启即丢,需要可靠时升级。

代码或图示

观察者:Subject ──直接调用──> ObserverA / ObserverB(同进程)
Pub/Sub:Publisher ──> Broker(topic) ──> SubscriberA / SubscriberB(跨进程)

常见误区

  • 把观察者当可靠消息:内存事件不持久化,进程崩溃即丢。
  • 跨服务还用观察者伪装:直接 RPC 调用不是 Pub/Sub,应该用 MQ 并处理消费语义。
  • 观察者里做重业务事务:会和主流程耦合,应该发 MQ 异步处理。

追问

  • 本地事件表和观察者怎么选?答:本地事件表是「事务内落库 + 异步投递」,可靠;观察者是内存广播,不可靠。需要可靠就用事件表。
  • MQ 消费幂等怎么做?答:业务唯一键去重、状态机防重入、消费记录落库。

01.3.2.9-013 观察者与责任链的区别?通知顺序与幂等怎么定?

一句话结论

观察者是「一事件广播给所有订阅者」,每个订阅者独立处理,彼此不传递结果;责任链是「请求沿链路传递,每个节点决定处理或放行,只有一个或少数节点最终处理」。通知顺序应在文档中明确(注册顺序或显式排序),订阅者必须幂等,因为重试或重复投递可能多次触发。

概念解释

  • 观察者:一对多,所有订阅者都跑,互不感知。
  • 责任链:一对一,请求在节点间流转,节点可中断或放行。
  • 顺序:观察者按注册顺序或 @Order 排序;责任链按显式编排顺序。
  • 幂等:订阅者重复收到同一事件不应产生副作用。

原理流程

  1. 看是否所有订阅者都要处理:是 → 观察者。
  2. 看请求是否在节点间传递:是 → 责任链。
  3. 通知顺序用注册顺序或显式排序字段。
  4. 事件带唯一 ID,订阅者用 ID 去重。

代码或图示

观察者:OrderCreated ──> 发短信 / 加积分 / 推报表(三个订阅者都跑)
责任链:Request ──> AuthFilter ──> LogFilter ──> Controller(依次传递,可中断)

常见误区

  • 在观察者里让某个订阅者「决定」事件是否继续:这是责任链语义,观察者应无差别广播。
  • 不定义通知顺序:多个订阅者之间有依赖时,顺序不确定会导致偶发 bug。
  • 订阅者不幂等:重试或重复投递会产生重复发短信、重复加积分。

追问

  • 怎么给观察者排序?答:Spring 用 @Order(n),EventEmitter 按注册顺序;自定义总线维护有序集合。
  • 幂等怎么做?答:事件带 eventId,订阅者记录已处理 ID(Redis SET、数据库唯一约束),重复 ID 直接跳过。

跨语言差异对照

语言 惯用实现 差异要点
Java List<Observer> + 同步遍历;Spring ApplicationEventPublisher 强引用易泄漏,可用 WeakReference;默认同步
Go channel 扇出 + WaitGroup/context CSP 模型,没有回调式列表;订阅者退出要显式取消
Python 函数/对象列表 + weakref WeakSet/WeakMethod 自动清理;Django 信号是强引用
PHP 事件类 + 监听器数组;Laravel Event facade FPM 下请求结束即销毁,泄漏风险低;跨请求不可靠
C#/.NET event 多播委托;WeakEventManager event 是语言级封装;长生命周期对象需弱事件
TypeScript EventEmitter(Node)/ EventTarget + AbortSignal(浏览器) 匿名函数订阅无法移除;AbortSignal 自动取消
Rust tokio::sync::broadcast 或 Rc<RefCell<..>> 借用检查让回调式别扭,消息通道是首选

跨语言差异

  • Java/Spring 是回调式 + 同步的典型,需要自己处理异常隔离与快照。
  • Go 与 Rust 因为并发与所有权模型,更倾向 channel 广播,而不是回调列表。
  • C# 的 event 是语言级多播委托,封装性最好,但弱事件要额外机制。
  • Python 用 weakref 自动清理,是 GC 友好语言的独特便利。
  • TypeScript 在浏览器里有 EventTarget 标准与 AbortSignal,订阅取消是一等公民。
  • PHP 受请求生命周期影响,观察者是请求级的,跨请求要靠 MQ。
  • 所有语言都要面对:异常隔离、快照遍历、取消订阅、幂等,只是机制不同。

待整理清单

  • [ ] 补充 Spring @TransactionalEventListener 与事务绑定事件的时机
  • [ ] 补充 tokio broadcast 与 mpsc 在不同并发模型下的选型基准
  • [ ] 补充 Vue 响应式与 RxJS 在前端事件流中的差异
  • [ ] 补充 Android LiveData/Flow、iOS NotificationCenter 的观察者语义