在软件系统中，对象间的依赖关系如同复杂的神经网络。当某个对象状态变化时，如何高效通知依赖方而不引入耦合？观察者模式给出了优雅的解决方案，而Spring事件机制将其价值发挥到极致。
一、问题引入
想象电商系统中的订单创建场景：
graph LR
A[订单服务] --> B[库存服务]
A --> C[物流服务]
A --> D[营销服务]
A --> E[审计日志]
当订单创建时，需要通知多个服务协同工作。传统硬编码调用方式：
java
public void createOrder() {
// 核心业务逻辑
inventoryService.reduceStock(); // 库存服务
logisticsService.schedule(); // 物流服务
marketingService.grantPoints(); // 营销服务
auditLogService.log(); // 审计日志
}这种实现存在三大痛点：
- 紧耦合：订单服务需感知所有下游服务
- 难扩展：新增通知方需修改订单代码
- 难维护：调用链越长，异常处理越复杂
观察者模式正是为解决这类问题而生！
二、观察者模式详解
1. 模式定义
观察者模式（Observer Pattern） 定义对象间的一对多依赖关系，当一个对象（主题）状态改变时，所有依赖它的对象（观察者）都会自动收到通知并更新。
2. 模式结构
classDiagram
class Subject {
+attach(Observer)
+detach(Observer)
+notify()
}
class Observer {
+update()
}
class ConcreteSubject {
-state: Object
+getState()
+setState()
}
class ConcreteObserver {
+update()
}
Subject <|-- ConcreteSubject
Observer <|-- ConcreteObserver
Subject "1" --> "0..*" Observer
3. 代码实现
java
// 主题接口
interface Subject {
void attach(Observer o);
void detach(Observer o);
void notifyObservers();
}
// 具体主题
class OrderService implements Subject {
private List<Observer> observers = new ArrayList<>();
private String orderStatus;
public void createOrder(String id) {
// 创建订单业务...
this.orderStatus = "CREATED";
notifyObservers(); // 状态变化通知
}
@Override
public void notifyObservers() {
observers.forEach(o -> o.update(orderStatus));
}
}
// 观察者接口
interface Observer {
void update(String status);
}
// 具体观察者
class InventoryObserver implements Observer {
@Override
public void update(String status) {
if ("CREATED".equals(status)) {
reduceStock();
}
}
}4. 工作流程
sequenceDiagram
participant Subject as 订单服务
participant ObserverA as 库存服务
participant ObserverB as 日志服务
Subject->>ObserverA: 注册观察者
Subject->>ObserverB: 注册观察者
Subject->>Subject: 订单创建(setState)
Subject->>ObserverA: 通知更新
Subject->>ObserverB: 通知更新
三、Spring中的事件机制
Spring框架通过ApplicationEvent体系将观察者模式标准化，成为企业级开发的基石。
1. 核心组件
| 组件 | 作用 | 对应观察者模式角色 |
|---|---|---|
ApplicationEvent |
事件基类 | ConcreteSubject |
ApplicationEventPublisher |
事件发布器 | Subject |
ApplicationListener |
事件监听接口 | Observer |
@EventListener |
注解式监听器 | ConcreteObserver |
2. 审计日志实战案例
java
// 1. 定义审计事件
public class AuditEvent extends ApplicationEvent {
private String entity;
private String action;
public AuditEvent(Object source, String entity, String action) {
super(source);
this.entity = entity;
this.action = action;
}
// Getters...
}
// 2. 业务代码发布事件
@Service
public class OrderService {
@Autowired
private ApplicationEventPublisher eventPublisher;
@Transactional
public Order createOrder(OrderDTO dto) {
Order order = repository.save(convert(dto));
// 发布审计事件（解耦关键！）
eventPublisher.publishEvent(
new AuditEvent(this, "Order", "CREATE")
);
return order;
}
}
// 3. 监听器处理审计日志
@Component
public class AuditLogListener {
@Async // 异步处理
@TransactionalEventListener(phase = AFTER_COMMIT)
public void handleAuditEvent(AuditEvent event) {
auditLogRepository.save(
new AuditLog(event.getEntity(),
event.getAction(),
LocalDateTime.now())
);
}
}3. 架构优势分析
| 优势 | 说明 |
|---|---|
| 业务解耦 | 订单服务不感知日志实现 |
| 事务安全 | @TransactionalEventListener 确保日志在事务提交后记录 |
| 异步性能 | @Async 避免日志写入阻塞主线程 |
| 动态扩展 | 新增日志维度只需添加监听器 |
| 统一处理 | 可在监听器中统一处理异常和重试 |
4. 高级特性
条件过滤监听
java
@EventListener(condition = "#event.action == 'DELETE'")
public void handleDelete(AuditEvent event) {
// 仅处理删除操作
}异步线程池配置
yaml
spring:
task:
execution:
pool:
audit-pool:
core-size: 5
max-size: 10
queue-capacity: 200事务绑定
java
@TransactionalEventListener(
phase = TransactionPhase.AFTER_COMPLETION,
fallbackExecution = true // 无事务时仍执行
)四、模式对比与选型
| 场景 | 解决方案 | 特点 |
|---|---|---|
| 简单通知 | 观察者模式 | 轻量级，直接调用 |
| 跨系统通知 | 发布-订阅 | 完全解耦，支持异步 |
| Spring生态 | 事件机制 | 开箱即用，整合事务/异步 |
Spring事件本质 ：是观察者模式和发布-订阅的融合体，通过
ApplicationContext作为中介解耦发布者和监听者。
五、观察者模式的适用场景
- 事件驱动架构：用户注册后发送邮件/短信
- 状态变化通知：订单状态变更触发物流更新
- 配置中心：配置修改实时同步到服务节点
- UI交互：按钮点击触发多个组件更新
- 监控告警：服务器指标超阈值触发告警
反模式警示
java
// 错误示例：在主题中直接调用复杂逻辑
public void notifyObservers() {
observers.forEach(o -> {
o.update();
// 包含数据库操作、远程调用等耗时逻辑
});
}正确做法：在观察者内部异步处理耗时操作，保持通知流程轻量化。
六、总结：模式思想的永恒价值
观察者模式的精髓在于解耦 和扩展，其价值体现在三个维度：
-
架构维度
- 通过事件驱动划分清晰的服务边界
- 支持微服务间的最终一致性
-
工程维度
- 符合开闭原则（新增观察者无需修改主题）
- 提升代码可测试性（主题可单独测试）
-
思想维度
- 体现好莱坞原则（"别调用我们，我们会通知你"）
- 为响应式编程奠定基础（如RxJava）
Spring事件的启示 ：
优秀的框架设计不是创造新模式，而是将经典模式以更优雅的方式落地。当你在Spring中发布一个事件时，不仅是完成功能，更是践行"高内聚，低耦合"的架构哲学。