本文已收录至Github，推荐阅读 👉 Java随想录

微信公众号：Java随想录

观察者模式（Observer Pattern）是一种常见的行为型设计模式，用于在对象之间建立一种一对多的依赖关系。当一个对象的状态发生变化时，所有依赖它的对象都将得到通知并自动更新。

使用场景

观察者模式在许多应用中都有广泛的应用，特别是当存在对象之间的一对多关系，并且需要实时通知和更新时，观察者模式非常适用。下面列举几个典型的使用场景：

• 消息发布/订阅系统：观察者模式可以用于构建消息发布/订阅系统，其中消息发布者充当主题（被观察者），而订阅者则充当观察者。当发布者发布新消息时，所有订阅者都会收到通知并执行相应操作。
• 用户界面组件：在图形用户界面 (GUI) 开发中，观察者模式常被用于处理用户界面组件之间的交互。当一个组件的状态发生变化时，其他依赖该组件的组件将自动更新以反映新的状态。
• 股票市场监控：在金融领域，观察者模式可用于实现股票市场监控系统。各个投资者可以作为观察者订阅感兴趣的股票，在股票价格变动时即时收到通知。
• 事件驱动系统：观察者模式也常用于事件驱动系统中，如图形用户界面框架、游戏引擎等。当特定事件发生时，触发相应的回调函数并通知所有注册的观察者。

以上仅是观察者模式的一些典型使用场景，实际上，只要存在对象之间的依赖关系，并且需要实现解耦和灵活性，观察者模式都可以考虑作为一种设计方案。

实现方式

观察者模式包含以下几个核心角色：

• 主题（Subject）：也称为被观察者或可观察者，它是具有状态的对象，并维护着一个观察者列表。主题提供了添加、删除和通知观察者的方法。
• 观察者（Observer）：观察者是接收主题通知的对象。观察者需要实现一个更新方法，当收到主题的通知时，调用该方法进行更新操作。
• 具体主题（Concrete Subject）：具体主题是主题的具体实现类。它维护着观察者列表，并在状态发生改变时通知观察者。
• 具体观察者（Concrete Observer）：具体观察者是观察者的具体实现类。它实现了更新方法，定义了在收到主题通知时需要执行的具体操作。

下面是观察者模式的经典实现方式：

1. 定义观察者接口：创建一个名为 Observer 的接口，包含一个用于接收通知的方法，例如 update()。

public interface Observer {void update();
}

2. 定义主题接口：创建一个名为 Subject 的接口，包含用于管理观察者的方法，如 registerObserver()、removeObserver() 和 notifyObservers()。

public interface Subject {void registerObserver(Observer observer);void removeObserver(Observer observer);void notifyObservers();
}

3. 实现具体主题：创建一个具体类实现 Subject 接口，实现注册、移除和通知观察者的方法。在状态变化时调用 notifyObservers() 方法通知所有观察者。

import java.util.ArrayList;
import java.util.List;public class ConcreteSubject implements Subject {private final List<Observer> observers = new ArrayList<>();private int state;public void setState(int state) {this.state = state;notifyObservers();}@Overridepublic void registerObserver(Observer observer) {observers.add(observer);}@Overridepublic void removeObserver(Observer observer) {observers.remove(observer);}@Overridepublic void notifyObservers() {for (Observer observer : observers) {observer.update();}}
}

4. 实现具体观察者：创建一个具体类实现 Observer 接口，实现接收通知并进行相应处理的方法。

public class ConcreteObserver implements Observer {private String name;private Subject subject;public ConcreteObserver(String name, Subject subject) {this.name = name;this.subject = subject;}@Overridepublic void update() {System.out.println(name+" received notification");}
}

5. 使用观察者模式：在实际代码中，我们可以创建具体的主题和观察者对象，并进行注册和触发状态变化。

public class Main {public static void main(String[] args) {ConcreteSubject subject = new ConcreteSubject();ConcreteObserver observer1 = new ConcreteObserver("Observer 1", subject);ConcreteObserver observer2 = new ConcreteObserver("Observer 2", subject);subject.registerObserver(observer1);subject.registerObserver(observer2);subject.setState(10);// Output:// Observer 1 received notification// Observer 2 received notificationsubject.removeObserver(observer1);subject.setState(20);// Output:// Observer 2 received notification}
}

Java对观察者模式的支持

观察者模式在Java语言中的地位非常重要。在JDK的 java.util 包中，提供 Observable 类以及 Observer 接口，它们构成了Java语言对观察者模式的支持。

使用 Observable 类以及 Observer 接口，优化之后的代码为：

// 具体观察者
public class ConcreteObserver implements Observer {private String name;public ConcreteObserver(String name) {// 设置每一个观察者的名字this.name = name;}/*** 当变化之后，就会自动触发该方法*/@Overridepublic void update(Observable o, Object arg) {if (arg instanceof Integer) {System.out.println(this.name + " 观察到 state 更改为：" + arg);}}
}

// 被观察者，继承 Observable 表示可以被观察
public class ConcreteSubject extends Observable {private int state;public ConcreteSubject(int state) {this.setState(state);}public int getState() {return state;}public void setState(int state) {// 设置变化点super.setChanged();// 状态变化，通知观察者super.notifyObservers(state);this.state = state;}@Overridepublic String toString() {return "state：" + this.state;}
}

public class TestObserve {public static void main(String[] args) {// 创建被观察者ConcreteSubject subject = new ConcreteSubject(0);// 创建观察者ConcreteObserver ConcreteObserverA = new ConcreteObserver("观察者 A");ConcreteObserver ConcreteObserverB = new ConcreteObserver("观察者 B");ConcreteObserver ConcreteObserverC = new ConcreteObserver("观察者 C");// 添加可观察对象subject.addObserver(ConcreteObserverA);subject.addObserver(ConcreteObserverB);subject.addObserver(ConcreteObserverC);System.out.println(subject);// Output:// state：0subject.setState(1);// Output:// 观察者 C 观察到 state 更改为：1// 观察者 B 观察到 state 更改为：1// 观察者 A 观察到 state 更改为：1System.out.println(subject);// Output:// state：1}
}

Guava对观察者模式的支持

Guava 中使用 Event Bus 来实现对观察者模式的支持。

com.google.common.eventbus.EventBus 提供了以下主要方法：

• register(Object listener)：将一个对象注册为事件的监听器。
• unregister(Object listener)：从事件总线中注销一个监听器。
• post(Object event)：发布一个事件到事件总线，以便通知所有注册的监听器。
• getSubscribers(Class<?> eventClass)：返回订阅指定事件类型的所有监听器的集合。

这些方法提供了事件的注册、注销、发布和获取监听器等功能，使得开发者可以方便地使用 EventBus 进行事件驱动编程。

@Getter
@AllArgsConstructor
public class MyEvent {private String message;
}

@Slf4j
public class EventSubscriber {@Subscribepublic void handleEvent(MyEvent event) {String message = event.getMessage();// Handle the event logiclog.info("Received event: " + message);}
}

@Test
public void test() {EventBus eventBus = new EventBus();EventSubscriber subscriber = new EventSubscriber();eventBus.register(subscriber);// Publish an eventeventBus.post(new MyEvent("Hello, World!"));// Output:// Received event: Hello, World!   }

Spring对观察者模式的支持

Spring 中可以使用 Spring Event 来实现观察者模式。

在Spring Event中，有一些核心的概念和组件，包括ApplicationEvent、ApplicationListener、ApplicationContext和ApplicationEventMulticaster。

• ApplicationEvent（应用事件）：
  • ApplicationEvent是Spring Event框架中的基础类，它是所有事件类的父类。
  • 通过继承ApplicationEvent，并定义自己的事件类，可以创建特定类型的事件对象。
  • 事件对象通常包含与事件相关的信息，例如状态变化、操作完成等。
• ApplicationListener（应用监听器）：
  • ApplicationListener是Spring Event框架中的接口，用于监听并处理特定类型的事件。
  • 通过实现ApplicationListener接口，并指定感兴趣的事件类型，可以创建具体的监听器。
  • 监听器可以定义在任何Spring Bean中，当所监听的事件被发布时，监听器会自动接收到该事件，并执行相应的处理逻辑。
• ApplicationContext（应用上下文）：
  • ApplicationContext是Spring框架的核心容器，它负责管理Bean的生命周期和依赖关系。
  • 在Spring Event中，ApplicationContext是事件的发布者和订阅者的容器。
  • 通过获取ApplicationContext实例，可以获取ApplicationEventPublisher来发布事件，也可以注册ApplicationListener来监听事件。
• ApplicationEventMulticaster（事件广播器）：
  • ApplicationEventMulticaster是Spring Event框架中的组件，用于将事件广播给各个监听器。
  • 它负责管理事件和监听器之间的关系，并将事件传递给对应的监听器进行处理。
  • Spring框架提供了几种实现ApplicationEventMulticaster的类，如SimpleApplicationEventMulticaster和AsyncApplicationEventMulticaster，用于支持不同的事件分发策略。

通过使用这些关键概念和组件，可以在 Spring 应用程序中实现事件驱动的编程模型。事件发布者（ApplicationEventPublisher）可以发布特定类型的事件，而订阅者（ApplicationListener）可以监听和处理已发布的事件。ApplicationContext作为容器，负责管理事件和监听器，并使用ApplicationEventMulticaster来实现事件的广播和分发。

下面是使用 Spring Event 实现观察者模式的例子：

/*** <p>* 基础事件发布类* </p>**/public abstract class BaseEvent<T> extends ApplicationEvent {/*** 该类型事件携带的信息*/private T eventData;/**** @param source 最初触发该事件的对象* @param eventData 该类型事件携带的信息*/public BaseEvent(Object source, T eventData) {super(source);this.eventData = eventData;}public T getEventData() {return eventData;}
}

这里定义了一个基础事件发布抽象类，所有的事件发布类都可以继承此类。

@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public  class User {private Integer userId;private String userName;
}

public class UserEvent  extends BaseEvent<User>{private static final long serialVersionUID = 8145130999696021526L;public UserEvent(Object source, User user) {super(source,user);}}

@Slf4j
@Service
public class UserListener {/** @Async加了就是异步监听,没加就是同步（启动类要开启@EnableAsync注解）* 可以使用@Order定义监听者顺序，默认是按代码书写顺序* 如果返回类型不为void,则会被当成一个新的事件,再次发布* @EventListener注解在EventListenerMethodProcessor类被扫描* 可以使用SpEL表达式来设置监听器生效的条件* 监听器可以看做普通方法,如果监听器抛出异常,在publishEvent里处理即可*///@Async@Order(1)@EventListener(condition = "#userEvent.getEventData().getUserName().equals('小明')")public String lister1(UserEvent userEvent){User user =userEvent.getEventData();log.info(user.toString());return "小米";}@Async@Order(2)@EventListenerpublic void lister3(UserEvent userEvent){log.info("监听者2");}@Async@Order(3)@EventListenerpublic void lister2(String name){log.info("我叫："+name);}}

@Slf4j
@SpringBootTest
@RunWith(SpringRunner.class)
public class ObserveTest {@Resourceprivate ApplicationEventPublisher applicationEventPublisher;@Testpublic void test() {applicationEventPublisher.publishEvent(new UserEvent(this, new User(1, "小明")));// Output:// User(userId=1, userName=小明)// 我叫：小米// 监听者2}}

IDEA 中可以直接跳转到对应的监听器。

相比于 Guava Event Bus，Spring Event 在实现观察者模式时具有以下优点：

• 集成性：Spring Event 是 Spring 框架的一部分，可以与其他 Spring 组件（如 Spring Boot、Spring MVC 等）无缝集成。这使得在一个应用程序中使用 Spring Event 变得更加方便和统一。
• 注解驱动：Spring Event 支持使用注解来声明事件监听器和发布事件。通过使用 @EventListener 注解，开发人员可以轻松定义事件监听器方法，并且不需要显式注册和注销监听器。

优缺点

观察者模式有以下几个优点：

• 解耦性：观察者模式能够将主题和观察者之间的耦合度降到最低。主题与观察者之间都是松散耦合的关系，它们之间可以独立地进行扩展和修改，而不会相互影响。
• 灵活性：通过使用观察者模式，可以动态地添加、删除和通知观察者，使系统更加灵活。无需修改主题或观察者的代码，就可以实现新的观察者加入和旧观察者离开的功能。
• 一对多关系：观察者模式支持一对多的依赖关系，一个主题可以有多个观察者。这样可以方便地实现消息的传递和广播，当主题状态更新时，所有观察者都能得到通知。

虽然观察者模式具有许多优点，但也存在一些缺点：

• 可能引起性能问题：如果观察者较多或通知过于频繁，可能会导致性能问题。每个观察者都需要接收通知并执行相应操作，当观察者较多时，可能会增加处理时间和系统负载。
• 可能引起循环依赖：由于观察者之间可以相互注册，如果设计不当，可能会导致循环依赖的问题。这样会导致触发通知的死循环，造成系统崩溃或异常。
• 顺序不确定性：在观察者模式中，观察者的执行顺序是不确定的。如果观察者之间有依赖关系，可能会产生意外的结果。

综上所述，观察者模式在许多场景下都非常有用，但在使用时需要注意性能问题、循环依赖和执行顺序等方面的考虑。