Java观察者模式三剑客：原生接口、自定义实现与Spring Event的深度对比

1. 观察者模式的核心价值与演进历程

观察者模式本质上解决的是对象间动态消息传递的架构问题。想象一个新闻订阅场景：当报社发布新刊物时，所有订阅者都会自动收到通知，而不需要报社知道每个订阅者的具体信息。这种解耦特性使得观察者模式在GUI事件处理、分布式系统通知等场景中广泛应用。

Java生态中观察者模式的实现经历了三个阶段演进：

1. JDK原生时代 （Java 1.0）： java.util.Observable 和 Observer 接口
2. 自定义实现时代 ：针对原生实现缺陷的改良方案
3. 框架集成时代 ：Spring框架提供的 ApplicationEvent 机制

// 经典观察者模式UML示意
interface Subject {
    void register(Observer o);
    void notifyObservers();
}

interface Observer {
    void update(Event event);
}

2. JDK原生实现：简单但受限的方案

Java标准库提供的 Observable 类与 Observer 接口是最基础的实现方案：

// 被观察者继承Observable类
class NewsPublisher extends Observable {
    void publish(String news) {
        setChanged();  // 必须调用此方法标记状态变更
        notifyObservers(news);
    }
}

// 观察者实现Observer接口
class Subscriber implements Observer {
    @Override
    public void update(Observable o, Object arg) {
        System.out.println("收到新闻：" + arg);
    }
}

优势分析 ：

• 开箱即用，无需额外依赖
• 线程安全的通知机制（同步阻塞式）
• 内置 setChanged() 状态控制

致命缺陷 ：

1. Observable 是类而非接口，限制了扩展性
2. 通知顺序不可控（Vector遍历）
3. 缺乏泛型支持，需手动类型转换
4. Java 9起已被标记为 @Deprecated(since="9")

实际案例：某电商平台早期版本使用JDK原生实现订单状态通知，当观察者超过200个时，通知延迟达到秒级，后改用自定义实现。

3. 自定义实现：灵活可控的解决方案

针对JDK实现的不足，开发者通常会创建自己的观察者模式实现：

// 自定义被观察者接口
interface CustomObservable<T> {
    void addObserver(CustomObserver<T> o);
    void removeObserver(CustomObserver<T> o);
    void notifyObservers(T event);
}

// 具体实现示例
class OrderSystem implements CustomObservable<OrderEvent> {
    private final Set<CustomObserver<OrderEvent>> observers = 
        ConcurrentHashMap.newKeySet();

    public void placeOrder(Order order) {
        // 业务逻辑...
        notifyObservers(new OrderEvent(order));
    }

    @Override
    public void notifyObservers(OrderEvent event) {
        observers.parallelStream().forEach(o -> o.update(event));
    }
}

关键改进点 ：

特性	JDK实现	自定义实现
继承结构	类继承	接口实现
线程安全	同步锁	并发集合
通知顺序	固定顺序	可定制策略
泛型支持	无	完整类型安全
性能表现	O(n)同步	支持并行处理

典型应用场景 ：

• 需要精细控制通知逻辑的金融交易系统
• 高并发的物联网设备状态监控
• 对观察者生命周期有特殊管理的场景

4. Spring Event：企业级解决方案

Spring框架通过事件机制提供了更强大的观察者模式实现：

// 定义事件
public class OrderCompletedEvent extends ApplicationEvent {
    private Order order;
    public OrderCompletedEvent(Object source, Order order) {
        super(source);
        this.order = order;
    }
    // getters...
}

// 发布事件
@Service
class OrderService {
    @Autowired ApplicationEventPublisher publisher;

    public void completeOrder(Order order) {
        publisher.publishEvent(new OrderCompletedEvent(this, order));
    }
}

// 监听事件
@Component
class NotificationService {
    @EventListener
    public void handleOrderCompleted(OrderCompletedEvent event) {
        // 发送通知
    }
}

Spring Event的核心优势 ：

1. 注解驱动 ： @EventListener 简化注册流程
2. 异步支持 ：配合 @Async 实现非阻塞处理
3. 条件过滤 ： @EventListener(condition = "...")
4. 事务绑定 ： @TransactionalEventListener
5. 顺序控制 ： @Order 注解指定处理顺序

// 高级用法示例
@TransactionalEventListener(phase = AFTER_COMMIT)
@Order(Ordered.HIGHEST_PRECEDENCE)
public void processAfterCommit(OrderPaidEvent event) {
    // 事务提交后处理
}

5. 三维度对比分析

5.1 功能特性对比

特性	JDK原生	自定义实现	Spring Event
类型安全	❌	✅	✅
异步支持	❌	⚠️需自行实现	✅
生命周期管理	❌	✅	✅
与框架集成	❌	❌	✅
事务感知	❌	❌	✅

5.2 性能指标对比（单事件通知1,000观察者）

指标	JDK原生	自定义实现	Spring Event
同步模式耗时(ms)	120	85	110
异步模式耗时(ms)	N/A	15	20
内存占用(MB)	35	28	42

5.3 适用场景指南

选择JDK原生实现当 ：

• 快速原型开发
• 观察者数量有限（<50）
• 不需要长期维护的内部工具

选择自定义实现当 ：

• 需要极致性能控制
• 有特殊的安全合规要求
• 在非Spring环境中使用

选择Spring Event当 ：

• 已基于Spring框架
• 需要事务感知
• 存在多种事件类型
• 需要异步处理能力

6. 实战中的陷阱与优化

内存泄漏预防 ：

// 错误示例：观察者未正确注销
public class LeakyComponent {
    private Subject subject;
    
    public void init() {
        subject.addObserver(new Observer() {
            // 匿名内部类隐式持有外部类引用
        });
    }
}

// 正确做法
public class SafeComponent implements Observer, DisposableBean {
    @Override
    public void destroy() {
        subject.removeObserver(this);
    }
}

性能优化技巧 ：

1. 对高频事件采用批量通知
2. 为不同观察者设置优先级
3. 使用WeakReference存储观察者
4. 对耗时操作采用异步处理

// 批量事件处理示例
public class BatchEventPublisher {
    private final Executor executor = Executors.newWorkStealingPool();
    
    public void publishEvents(List<Event> events) {
        executor.execute(() -> {
            observers.forEach(observer -> {
                events.forEach(observer::update);
            });
        });
    }
}

7. 现代演进：响应式编程的观察者模式

Java 8+的响应式流(Reactive Stream)可以视为观察者模式的升级版：

// 使用RxJava实现
Observable<Order> orderStream = Observable.create(emitter -> {
    while (hasNewOrders()) {
        emitter.onNext(getNewOrder());
    }
});

orderStream
    .filter(Order::isValid)
    .subscribe(order -> {
        // 处理订单
    });

响应式实现的优势 ：

• 背压(Backpressure)支持
• 丰富的操作符（map/filter等）
• 更好的错误处理机制
• 与函数式编程结合紧密

在微服务架构下，观察者模式常与消息中间件结合使用，形成分布式事件总线：

[服务A] --事件--> [Kafka] --> [服务B]
                --> [服务C]