大白话讲解Java观察者模式-CSDN博客

本文链接：https://blog.csdn.net/qq_36955155/article/details/140199677

滴答滴：设计模式我是边学边记录，有问题的欢迎大家指出。学习的过程中会借助AI工具，我想说的是我们要把AI工具当作一个学识渊博的学者，同时要敢于质疑它，不能盲目的觉得对方说的一定是正确的，因为有时它的回答不见得是正确的，我们要带着自己的思考去使用AI工具，不断的和它对话和探讨，最终得出我们想要的答案。

一.什么是观察者模式

观察者模式是23种设计模式之一，是一种行为型设计模式，言而言之就是创建好对象之后，用来定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。

比如：

手机中的天气预报，当天气预报站（被观察者或者主题）预报的天气发生改变时，就会通知我们手机（观察者）中的天气发生变化。每当被观察者的状态发生变化时，它都会通知多有注册的观察者，然后这些观察者会根据自己的需要来响应这个变化，这就是观察者模式。

你有一个微信群，你是群主（主题对象/被观察者）。每当你在群里发了一条消息（状态变化），群里的所有成员（观察者对象）都会收到通知，并可能根据这条消息做出反应，比如回复你或者只是阅读。

二.观察者模式实现方式

观察者模式主要由四部分组成：抽象主题（被观察者），具体主题，抽象观察者，具体观察者。

1.Java标准库

Java在Java.util包中提供了Observable类和Observer接口，允许我们以接近标准的方式来实现观察者模式，不过，需要注意的是，从java9开始，Observable类和Observer接口已被标记为过时，因为它在设计上存在一些限制，比如它不支持泛型，且通知机制较为简单。但此处为了展示，我还是以举例

import java.util.Observable;
import java.util.Observer;

// 实现Observer接口
class MyObserver implements Observer {
private String name;

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

@Override
public void update(Observable o, Object arg) {
// arg参数通常用于传递状态变化的具体信息
if (arg instanceof String) {
System.out.println(name + " received message: " + arg);
}
}
}

// 继承Observable类具体被观察者
class MyObservable extends Observable {
// 假设这个方法会触发状态变化，并通知所有观察者
public void notifyObserversMessage(String message) {
setChanged(); // 标记Observable对象已更改
notifyObservers(message); // 通知所有观察者
}
}

// 使用示例
public class ObserverPatternDemo {
public static void main(String[] args) {
MyObservable observable = new MyObservable();

MyObserver observer1 = new MyObserver("Alice");
MyObserver observer2 = new MyObserver("Bob");

// 注册观察者
observable.addObserver(observer1);
observable.addObserver(observer2);

// 触发状态变化并通知观察者
observable.notifyObserversMessage("Hello, Observers!");

// 如果你想移除一个观察者
// observable.deleteObserver(observer1);
// observable.notifyObserversMessage("This message will not be sent to Alice.");

// 注意：Observable类没有直接提供deleteObserver方法，
// 所以这里的注释代码只是为了说明目的。实际删除观察者需要通过观察者列表进行管理，
// 或者你可以通过继承Observable并重写其内部机制来实现。
}
}

// 注意：由于Observable类没有提供deleteObserver方法，
// 如果你需要删除观察者，你可能需要维护一个自己的观察者列表，
// 并在notifyObservers时只通知这个列表中的观察者。

2.手动实现

这是最直接且灵活的方式，不涉及任何java标准库中的特定类

定义观察者接口

public interface Observer {
void update(String message);
}

实现观察者

public class ConcreteObserver implements Observer {
private String name;

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

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

定义被观察者类（主题）

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

public class Subject {
private List<Observer> observers = new ArrayList<>();
private String state;

public void addObserver(Observer observer) {
observers.add(observer);
}

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

public void notifyObservers(String message) {
for (Observer observer : observers) {
observer.update(message);
}
}

public void setState(String state) {
this.state = state;
notifyObservers("State changed to: " + state);
}

// 可以添加getState()等方法
}

使用示例

public class ObserverPatternDemo {
public static void main(String[] args) {
Subject subject = new Subject();
Observer observer1 = new ConcreteObserver("Observer 1");
Observer observer2 = new ConcreteObserver("Observer 2");

subject.addObserver(observer1);
subject.addObserver(observer2);

subject.setState("New State");

subject.removeObserver(observer1);
subject.setState("Another New State");
}
}

3.Spring的事件发布/订阅模式

Spring框架提供了强大的事件发布/订阅功能，允许你在应用程序的不同部分之间以松耦合的方式进行通信。Spring的事件模型是基于ApplicationEvent和ApplicationListener接口的，你可以通过实现这些接口来创建自定义的事件和监听器。

在Spring中，你可以使用ApplicationEventPublisher接口（或者ApplicationContext）来发布事件。这个接口允许你发布任何继承自ApplicationEvent的事件。同时，任何实现了ApplicationListener接口的bean都会自动被注册为事件监听器，并在相应的事件被发布时得到通知。

定义事件: MyApplicationEvent继承 ApplicationEvent 抽象类。

发布事件：applicationContext.publishEvent(myApplicationEvent)发布。

监听事件：使用@EventListener注解或者实现了ApplicationListener接口的类会被注册为监听器，监听到myApplicationEvent被发布之后可以执行自定义的逻辑。

示例如下：

// 自定义事件

import org.springframework.context.ApplicationEvent;

public class CustomEvent extends ApplicationEvent {
private String message;

public CustomEvent(Object source, String message) {
super(source);
this.message = message;
}

public String getMessage() {
return message;
}
}

// 事件监听器

import org.springframework.context.ApplicationListener;

public class CustomEventListener implements ApplicationListener<CustomEvent> {
@Override
public void onApplicationEvent(CustomEvent event) {
System.out.println("Received custom event: " + event.getMessage());
}
}

// 发布事件这通常在你的Spring应用程序的某个部分进行，比如一个服务或控制器中，你需要注入

// ApplicationEventPublisher或者ApplicationContext来发布事件

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.stereotype.Service;

@Service
public class EventPublisherService {

@Autowired
private ApplicationEventPublisher publisher;

public void publishCustomEvent(String message) {
CustomEvent event = new CustomEvent(this, message);
publisher.publishEvent(event);
}
}

4.Java的事件监听机制

尚未使用到，等用到时再补充

5.响应式编程库

尚未使用到，等用到时再补充

...

三.观察者模式的优缺点

1.优点

降低耦合度：将对象之间的耦合度从静态的继承或者依赖关系转变为动态的一对多的依赖关系，使得对象之间的耦合度更低，从而更容易扩展和维护。这种解耦特性使得主题和观察者可以独立变化，互不干扰。

增加灵活性和可扩展性：通过观察者模式，可以动态地添加和删除观察者对象，这使得程序具有更大的灵活性和可扩展性。当需要增加新的观察者或主题时，只需实现相应的接口或继承相应的类即可，而无需修改原有代码。

实现开闭原则：观察者模式通过将程序的可变部分（即观察者）抽象出来，使得程序在扩展新功能时不需要修改原有的代码，从而符合开闭原则（对扩展开放，对修改关闭）。

支持广播通信：观察者模式可以实现一对多的通信机制，从而方便地进行广播通信。当主题对象的状态发生变化时，可以一次性通知所有的观察者对象，提高了通信效率。

提高代码的可重用性：观察者模式中的主题和观察者接口都是可重用的，它们可以被不同的类实现以适用于不同的场景。这种可重用性使得观察者模式在多个项目中都能得到广泛的应用。

2.缺点

开发复杂度和调式难度增加：由于程序中包括一个被观察者和多个观察者，因此开发、调试和维护这些内容可能会变得更加复杂。特别是在大型项目中，需要仔细管理观察者和被观察者之间的关系，以避免出现错误或遗漏。

执行效率问题：在Java中，消息的通知一般是顺序执行的。如果某个观察者对象的更新操作耗时较长或者出现卡顿，那么可能会影响整体的执行效率。为了解决这个问题，可以采用异步实现方式，但这又会增加实现的复杂度和成本。

观察者之间的交互复杂性：如果多个观察者之间需要互相通信，那么它们之间的交互可能会变得复杂且难以维护。这种情况下，可能需要考虑使用其他设计模式或机制来简化观察者之间的交互。

性能问题：当观察者数量过多时，每次主题状态变化都需要通知所有观察者进行更新，这可能会导致性能问题。特别是在高并发场景下，需要仔细考虑如何优化观察者模式的实现以提高性能。

四.观察者模式使用场景

1.数据更新通知

图形用户界面(GUI)应用程序：当界面中的一个元素（如按钮）被操作时，可能需要更新其他元素（如文本框）的内容。观察者模式允许定义一个接口，该接口包含更新方法，当数据模型发生变化时，自动调用这些方法。

实时数据分析系统：在这些系统中，数据源的数据可能频繁变化，观察者模式可以用来监听数据源的变化，并实时更新视图或执行其他操作。

2.事件处理

游戏开发：在游戏中，玩家可能触发一系列的事件，如移动、攻击、受伤等。观察者模式可以用来注册和通知这些事件的监听器，从而在不同的游戏组件之间传递事件信息。

事件驱动的编程：在事件驱动的系统中，观察者模式是实现事件处理机制的核心。事件源对象在事件发生时通知事件处理程序（观察者），以执行相应的操作。

3.异步处理

处理大量请求的系统：在需要异步处理大量请求的系统中，观察者模式可以帮助将请求发送者和处理者解耦。发送者只需将请求发送给中心服务，而不需要关心处理者的实现细节。

4.缓存和数据流处理

需要缓存或处理大量数据的系统：观察者模式可以帮助实现数据的实时更新和处理。当数据源发生变化时，观察者可以自动获取最新的数据并进行处理。

5.分布式系统

节点之间的通信和同步：在分布式系统中，观察者模式可以帮助实现节点之间的通信和同步。一个节点可以发布事件，其他节点可以作为观察者监听这些事件，并在事件发生时做出响应。

6.发布-订阅系统

消息队列系统：观察者模式是发布-订阅模式的核心。生产者将消息发送到队列，而消费者作为观察者订阅队列以接收和处理消息。比如kafka。