观察者模式：从博客订阅到消息队列的解耦实践

观察者模式：从博客订阅到消息队列的解耦实践

一、模式核心：用事件驱动实现对象间松耦合

在新闻 APP 中，当热点事件发生时需要实时通知所有订阅用户；在电商系统中，库存变化需触发价格监控模块重新计算。这类场景的核心矛盾是：对象间存在依赖关系，但不能硬编码耦合。** 观察者模式（Observer Pattern）** 通过定义「发布 - 订阅」模型，让对象间的通知关系完全解耦，核心解决：

• 数据变更通知：当主题（Subject）状态变化时，自动通知所有关联的观察者（Observer）
• 模块解耦：观察者与主题无需互相知道具体实现，仅通过抽象接口交互

核心思想与 UML 类图

二、核心实现：构建通用事件通知框架

1. 定义主题接口（Subject）

import java.util.ArrayList;
import java.util.List;public abstract class Subject {private List<Observer> observers = new ArrayList<>();// 注册观察者public void attach(Observer observer) {observers.add(observer);}// 注销观察者public void detach(Observer observer) {observers.remove(observer);}// 通知所有观察者protected void notifyObservers(Object data) {observers.forEach(observer -> observer.update(data));}// 抽象方法：主题状态变化时调用public abstract void updateState(Object newState);
}

2. 实现具体主题（ConcreteSubject）

public class StockSubject extends Subject {private double stockPrice; // 主题状态：股票价格public double getStockPrice() {return stockPrice;}@Overridepublic void updateState(Object newState) {this.stockPrice = (double) newState;notifyObservers(stockPrice); // 状态变化时触发通知}
}

3. 定义观察者接口（Observer）

public interface Observer {// 接收主题通知的更新方法void update(Object data);
}

4. 实现具体观察者（ConcreteObserver）

public class InvestorObserver implements Observer {private String investorName;public InvestorObserver(String name) {this.investorName = name;}@Overridepublic void update(Object data) {double price = (double) data;System.out.println("投资者 " + investorName + " 收到通知：股票价格更新为 " + price);// 执行具体业务逻辑（如触发交易策略）}
}

5. 客户端调用示例

public class ClientDemo {public static void main(String[] args) {// 创建主题与观察者StockSubject stock = new StockSubject();Observer investorA = new InvestorObserver("张三");Observer investorB = new InvestorObserver("李四");// 注册观察者stock.attach(investorA);stock.attach(investorB);// 主题状态变化，触发通知stock.updateState(15.5); // 输出：两位投资者收到价格更新通知stock.detach(investorB); // 注销观察者Bstock.updateState(16.2); // 仅投资者A收到通知}
}

三、进阶：实现异步事件驱动与精准通知

1. 支持泛型的强类型通知

// 定义带泛型的观察者接口
public interface GenericObserver<T> {void update(T data);
}// 主题支持特定类型的事件数据
public class GenericSubject<T> {private List<GenericObserver<T>> observers = new ArrayList<>();public void notifyObservers(T data) {observers.forEach(observer -> observer.update(data));}
}// 使用示例：股票价格变化事件（Double类型）
GenericSubject<Double> stock = new GenericSubject<>();
stock.attach((Double price) -> System.out.println("精准通知：价格" + price));

2. 异步通知机制（解耦通知与业务处理）

public class AsyncSubject<T> extends GenericSubject<T> {private ExecutorService executor = Executors.newFixedThreadPool(5);@Overridepublic void notifyObservers(T data) {// 使用线程池异步执行观察者逻辑executor.submit(() -> super.notifyObservers(data));}
}// 优势：避免主题阻塞，提升系统吞吐量
// 注意：需处理异步带来的线程安全与数据一致性问题

3. 带事件类型的精准通知（基于 Guava EventBus）

// 定义具体事件类型
public class PriceUpdateEvent {private double newPrice;public PriceUpdateEvent(double price) {this.newPrice = price;}// getters...
}// 使用Guava EventBus实现
EventBus eventBus = new EventBus();
eventBus.register(new Object() {@Subscribepublic void onPriceUpdate(PriceUpdateEvent event) {// 仅接收PriceUpdateEvent类型的事件System.out.println("处理价格更新事件：" + event.getNewPrice());}
});
eventBus.post(new PriceUpdateEvent(18.7)); // 精准触发对应观察者

四、框架与源码中的观察者模式实践

1. Spring ApplicationEvent（同步通知）

• 核心类：ApplicationEvent（事件）、ApplicationListener（观察者）、ApplicationEventPublisher（主题）

• 使用示例：

  // 定义自定义事件
  public class OrderPaidEvent extends ApplicationEvent {private String orderId;public OrderPaidEvent(Object source, String orderId) {super(source);this.orderId = orderId;}
  }// 注册观察者
  @Component
  public class OrderListener implements ApplicationListener<OrderPaidEvent> {@Overridepublic void onApplicationEvent(OrderPaidEvent event) {// 处理订单支付后的业务（如更新库存、发送短信）}
  }// 发布事件
  applicationEventPublisher.publishEvent(new OrderPaidEvent(this, "1001"));
  

2. Android Listener 机制（异步回调）

• 典型场景：按钮点击事件、网络请求回调

• 实现原理：

  // 主题（Button）注册观察者（OnClickListener）
  button.setOnClickListener(new View.OnClickListener() {@Overridepublic void onClick(View v) {// 观察者逻辑}
  });
  

3. Kafka 消息队列（分布式观察者）

• 主题：Kafka 的 Topic（如 “stock-price-topic”）
• 观察者：Kafka 消费者组（Consumer Group）
• 优势：支持百万级观察者的分布式通知，实现系统间的松耦合

// Kafka消费者示例（观察者）
KafkaConsumer<String, Double> consumer = new KafkaConsumer<>(props);
consumer.subscribe(Collections.singletonList("stock-price-topic"));
while (true) {ConsumerRecords<String, Double> records = consumer.poll(Duration.ofMillis(100));for (ConsumerRecord<String, Double> record : records) {handlePriceUpdate(record.value()); // 处理通知}
}

五、避坑指南：正确使用观察者模式的 4 个要点

1. 避免内存泄漏（及时注销观察者）

• ❌ 错误实践：观察者注册后未调用detach()，导致主题持有观察者强引用

• ✅ 最佳实践：在观察者销毁时（如 Activity 销毁），主动从主题中注销

  @Override
  protected void onDestroy() {super.onDestroy();subject.detach(this); // 注销当前观察者
  }
  

2. 控制通知粒度（避免过度频繁通知）

• 当主题状态变化频繁时（如实时数据流），增加防抖机制或批量通知

  // 防抖示例：1秒内多次变化合并为一次通知
  public void updateState(Object newState) {if (lastUpdateTime + 1000 > System.currentTimeMillis()) {return; // 忽略短时间内的重复通知}lastUpdateTime = System.currentTimeMillis();super.updateState(newState);
  }
  

3. 处理循环依赖（观察者反向修改主题）

• 当观察者更新时可能再次触发主题状态变化，需增加

  事件防火墙

  public void update(Object data) {if (isProcessingEvent) return; // 避免循环触发isProcessingEvent = true;// 业务逻辑isProcessingEvent = false;
  }
  

4. 反模式：滥用观察者导致复杂度上升

• 当观察者链过深（如 A→B→C→D）时，改用责任链模式或事件总线重构
• 避免为简单的双向通信使用观察者（直接调用接口更高效）

六、总结：何时该用观察者模式？

适用场景	核心特征	典型案例
实时数据通知	一个对象状态变化需触发多个对象的响应	股票行情推送、邮件订阅系统
模块解耦需求	对象间存在依赖但不想硬编码关联	微服务事件驱动架构、GUI 事件处理
异步事件处理	需要将通知与业务逻辑分离	消息队列、日志异步写入

观察者模式通过「主题抽象 + 事件驱动」的设计，将对象间的依赖关系从「直接调用」转化为「事件订阅」，这是实现松耦合系统的核心模式之一。下一篇我们将深入探讨状态模式，解析有限状态机在电商订单系统中的设计与实现，敬请期待！

扩展思考：观察者模式 vs 发布 - 订阅模式

两者核心思想相似，但存在关键区别：

模式	中介者	通知方式	应用场景
观察者模式	主题直接关联观察者	主题主动通知观察者	本地模块间通信
发布 - 订阅模式	事件总线作为中介	发布者与订阅者无直接关联	分布式系统、微服务间通信

理解这些差异，有助于在不同架构场景中选择最合适的设计方案。