Java设计模式【观察者模式】-行为型

1. 介绍

1.1 什么是观察者模式？

观察者模式（Observer Pattern）是一种行为型设计模式，定义了一种一对多的依赖关系，使得一个对象状态的改变可以自动通知并更新依赖于它的多个对象。观察者模式的关键在于，将对象之间的耦合度降低，使得一个对象的变化不会直接影响其他对象，但可以通过通知机制间接影响它们。

观察者模式通常由两个主要角色组成：

• 主体（Subject）：也称为被观察者，它维护一组观察者并负责通知它们状态的变化。
• 观察者（Observer）：注册到主体上，当主体的状态发生变化时，观察者会被通知。

1.2 优缺点

优点：

• 松耦合：观察者和主体之间的依赖性较低，主体不需要知道观察者的具体实现，反之亦然。
• 动态更新：观察者可以在运行时注册或取消订阅，实现动态响应。
• 符合开闭原则：通过添加新的观察者类，可以在不修改现有代码的情况下扩展系统功能。

缺点：

• 性能问题：如果观察者数量很多，通知所有观察者可能会导致性能问题，尤其是同步通知的情况下。
• 通知顺序难以控制：在某些情况下，可能需要确保观察者的通知顺序，这在观察者模式中不易实现。
• 可能导致循环依赖：如果观察者和主体之间有双向依赖关系，可能会引发循环依赖问题。

---

2. 应用场景

观察者模式适用于以下场景：

• 一个对象的改变需要同时改变其他对象，而且对象数量未知或动态变化。
• 事件驱动的系统，如 GUI 事件处理系统、实时数据更新、订阅-发布系统等。
• 需要提供通知机制，当某些数据或状态发生变化时，其他相关对象能够自动响应。

示例场景：

• 新闻订阅系统：当有新新闻发布时，所有订阅者（观察者）都会收到通知。
• 股票市场监控：当股票价格变化时，所有注册的投资者（观察者）都会收到通知。
• GUI 事件处理：按钮点击、文本框输入等事件可以通知所有注册的监听器（观察者）。

---

3. Java实现示例

以下是一个使用观察者模式的简单示例，模拟新闻发布系统：

import java.util.ArrayList;
import java.util.List;

// 观察者接口
interface Observer {
    void update(String message);
}

// 具体观察者类：订阅者
class Subscriber implements Observer {
    private String name;

    public Subscriber(String name) {
        this.name = name;
    }

    @Override
    public void update(String message) {
        System.out.println(name + " received update: " + message);
    }
}

// 主题接口：被观察者
interface Subject {
    void registerObserver(Observer observer);
    void removeObserver(Observer observer);
    void notifyObservers();
}

// 具体主题类：新闻发布系统
class NewsPublisher implements Subject {
    private List<Observer> observers = new ArrayList<>();
    private String news;

    public void setNews(String news) {
        this.news = news;
        notifyObservers(); // 新闻发布后通知所有观察者
    }

    @Override
    public void registerObserver(Observer observer) {
        observers.add(observer);
    }

    @Override
    public void removeObserver(Observer observer) {
        observers.remove(observer);
    }

    @Override
    public void notifyObservers() {
        for (Observer observer : observers) {
            observer.update(news);
        }
    }
}

// 客户端代码
public class ObserverPatternExample {
    public static void main(String[] args) {
        NewsPublisher newsPublisher = new NewsPublisher();

        // 创建订阅者
        Observer subscriber1 = new Subscriber("Subscriber 1");
        Observer subscriber2 = new Subscriber("Subscriber 2");

        // 订阅新闻
        newsPublisher.registerObserver(subscriber1);
        newsPublisher.registerObserver(subscriber2);

        // 发布新闻
        newsPublisher.setNews("Breaking News: Observer Pattern in Java!");
    }
}

---

4. Spring中的使用场景

在 Spring 框架中，观察者模式被广泛应用，尤其是在事件驱动的编程模型中。

• Spring 事件机制：Spring 提供了一个内置的事件机制，使用观察者模式实现。ApplicationEventPublisher 是事件发布者，它负责发布事件，而 ApplicationListener 是事件监听器，它负责监听并响应事件。每当事件发布者发布一个事件时，所有注册的监听器都会被通知。

Spring 事件机制示例：

import org.springframework.context.ApplicationEvent;
import org.springframework.context.ApplicationListener;
import org.springframework.context.event.ContextRefreshedEvent;
import org.springframework.stereotype.Component;

// 自定义事件
class CustomEvent extends ApplicationEvent {
    public CustomEvent(Object source) {
        super(source);
    }

    @Override
    public String toString() {
        return "Custom Event Occurred!";
    }
}

// 自定义事件监听器
@Component
class CustomEventListener implements ApplicationListener<CustomEvent> {
    @Override
    public void onApplicationEvent(CustomEvent event) {
        System.out.println(event.toString());
    }
}

// 在 Spring 上下文刷新时发布事件
@Component
class EventPublisher {
    private final ApplicationEventPublisher publisher;

    public EventPublisher(ApplicationEventPublisher publisher) {
        this.publisher = publisher;
    }

    @EventListener
    public void handleContextRefresh(ContextRefreshedEvent event) {
        publisher.publishEvent(new CustomEvent(this));
    }
}

在这个示例中，当 Spring 上下文刷新时，EventPublisher 发布 CustomEvent，并由 CustomEventListener 监听和处理这个事件。这就是 Spring 中观察者模式的一个实际应用。

---

5. 总结

观察者模式是一种强大的行为型设计模式，特别适用于事件驱动的系统和需要动态通知机制的场景。在 Java 中，观察者模式的实现相对简单，但它提供了灵活性和扩展性，使系统在动态场景中能够轻松应对变化。

Spring 框架通过内置的事件机制广泛使用了观察者模式，尤其是在事件处理、应用程序生命周期管理等方面。通过观察者模式，可以实现低耦合的代码结构，使系统更易于维护和扩展。

观察者模式的主要缺点在于潜在的性能问题和复杂性，尤其是当观察者数量较多时。在实际使用中，应该根据具体的业务需求和系统规模来决定是否采用观察者模式。