Java观察者模式详解：一对多的依赖关系
一、什么是观察者模式？
观察者模式是一种行为型设计模式，它定义了一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都会得到通知并自动更新。
简单来说，观察者模式就像订阅号：你关注了一个微信公众号，当公众号发布新文章时，所有关注者都会收到通知。
二、生活中的观察者模式
想象这样的场景：
- 天气预报系统：气象站（主题）收集天气数据，多个显示设备（观察者）如手机APP、电视、广播等都需要获取并显示最新天气
- 股票市场：股票价格（主题）变动时，交易员、分析师、自动交易系统（观察者）都需要收到通知
- 拍卖会：拍卖师（主题）宣布最新出价，所有竞拍者（观察者）都会关注价格变化
这些都是观察者模式的生活例子！
三、观察者模式基础实现
1. 创建主题接口
// 定义主题接口
public interface Subject {
// 注册观察者
void registerObserver(Observer observer);
// 移除观察者
void removeObserver(Observer observer);
// 通知所有观察者
void notifyObservers();
}
2. 创建观察者接口
// 定义观察者接口
public interface Observer {
// 更新方法，当主题状态改变时调用
void update(float temperature, float humidity, float pressure);
}
3. 创建具体主题实现类
// 具体主题：天气数据
public class WeatherData implements Subject {
private List<Observer> observers; // 观察者列表
private float temperature; // 温度
private float humidity; // 湿度
private float pressure; // 气压
public WeatherData() {
this.observers = new ArrayList<>();
}
@Override
public void registerObserver(Observer observer) {
if (!observers.contains(observer)) {
observers.add(observer);
}
}
@Override
public void removeObserver(Observer observer) {
observers.remove(observer);
}
@Override
public void notifyObservers() {
// 通知所有观察者
for (Observer observer : observers) {
observer.update(temperature, humidity, pressure);
}
}
// 天气数据发生变化时调用
public void measurementsChanged() {
notifyObservers();
}
// 设置新的天气数据
public void setMeasurements(float temperature, float humidity, float pressure) {
this.temperature = temperature;
this.humidity = humidity;
this.pressure = pressure;
measurementsChanged(); // 数据变化，通知观察者
}
}
4. 创建具体观察者实现类
// 具体观察者：当前天气展示板
public class CurrentConditionsDisplay implements Observer {
private float temperature;
private float humidity;
private Subject weatherData;
// 构造时注册为观察者
public CurrentConditionsDisplay(Subject weatherData) {
this.weatherData = weatherData;
weatherData.registerObserver(this);
}
@Override
public void update(float temperature, float humidity, float pressure) {
this.temperature = temperature;
this.humidity = humidity;
display(); // 收到更新后，显示最新信息
}
public void display() {
System.out.println("当前天气情况：温度 " + temperature + "°C，湿度 " + humidity + "%");
}
}
// 具体观察者：天气统计展示板
public class StatisticsDisplay implements Observer {
private float maxTemp = 0.0f;
private float minTemp = 200.0f;
private float tempSum = 0.0f;
private int numReadings = 0;
private Subject weatherData;
public StatisticsDisplay(Subject weatherData) {
this.weatherData = weatherData;
weatherData.registerObserver(this);
}
@Override
public void update(float temperature, float humidity, float pressure) {
tempSum += temperature;
numReadings++;
if (temperature > maxTemp) {
maxTemp = temperature;
}
if (temperature < minTemp) {
minTemp = temperature;
}
display();
}
public void display() {
System.out.println("统计信息：平均气温 " + (tempSum / numReadings) +
"°C，最高气温 " + maxTemp + "°C，最低气温 " + minTemp + "°C");
}
}
5. 客户端使用
public class WeatherStation {
public static void main(String[] args) {
// 创建天气数据主题
WeatherData weatherData = new WeatherData();
// 创建各种显示板（观察者）
CurrentConditionsDisplay currentDisplay = new CurrentConditionsDisplay(weatherData);
StatisticsDisplay statisticsDisplay = new StatisticsDisplay(weatherData);
// 天气数据更新
System.out.println("第一次天气更新：");
weatherData.setMeasurements(25, 65, 1013.2f);
System.out.println("\n第二次天气更新：");
weatherData.setMeasurements(27, 70, 1012.1f);
// 移除一个观察者
weatherData.removeObserver(currentDisplay);
System.out.println("\n第三次天气更新（移除当前天气显示）：");
weatherData.setMeasurements(26, 75, 1010.5f);
}
}
运行结果:
第一次天气更新：
当前天气情况：温度 25.0°C，湿度 65.0%
统计信息：平均气温 25.0°C，最高气温 25.0°C，最低气温 25.0°C
第二次天气更新：
当前天气情况：温度 27.0°C，湿度 70.0%
统计信息：平均气温 26.0°C，最高气温 27.0°C，最低气温 25.0°C
第三次天气更新（移除当前天气显示）：
统计信息：平均气温 26.0°C，最高气温 27.0°C，最低气温 25.0°C
四、Java内置的观察者模式
Java提供了内置的观察者模式支持，通过java.util.Observable类和java.util.Observer接口：
1. 使用Java内置API实现
import java.util.Observable;
import java.util.Observer;
// 具体主题：使用Java内置Observable类
public class WeatherDataBuiltIn extends Observable {
private float temperature;
private float humidity;
private float pressure;
public void setMeasurements(float temperature, float humidity, float pressure) {
this.temperature = temperature;
this.humidity = humidity;
this.pressure = pressure;
setChanged(); // 标记状态已改变
notifyObservers(); // 通知观察者
}
// 获取数据的方法
public float getTemperature() {
return temperature;
}
public float getHumidity() {
return humidity;
}
public float getPressure() {
return pressure;
}
}
// 具体观察者：使用Java内置Observer接口
public class CurrentDisplayBuiltIn implements Observer {
private float temperature;
private float humidity;
private Observable observable;
public CurrentDisplayBuiltIn(Observable observable) {
this.observable = observable;
observable.addObserver(this);
}
@Override
public void update(Observable obs, Object arg) {
if (obs instanceof WeatherDataBuiltIn) {
WeatherDataBuiltIn weatherData = (WeatherDataBuiltIn) obs;
this.temperature = weatherData.getTemperature();
this.humidity = weatherData.getHumidity();
display();
}
}
public void display() {
System.out.println("当前天气情况：温度 " + temperature + "°C，湿度 " + humidity + "%");
}
}
注意：从Java 9开始，Observable和Observer已被标记为过时，推荐使用Flow API或其他替代方案。
五、观察者模式进阶用法
1. 使用事件参数
更好的方式是通过事件对象传递数据：
// 天气改变事件类
public class WeatherChangedEvent {
private float temperature;
private float humidity;
private float pressure;
public WeatherChangedEvent(float temperature, float humidity, float pressure) {
this.temperature = temperature;
this.humidity = humidity;
this.pressure = pressure;
}
// getter方法
public float getTemperature() { return temperature; }
public float getHumidity() { return humidity; }
public float getPressure() { return pressure; }
}
// 修改主题接口和观察者接口
public interface WeatherSubject {
void registerObserver(WeatherObserver observer);
void removeObserver(WeatherObserver observer);
void notifyObservers(WeatherChangedEvent event);
}
public interface WeatherObserver {
void update(WeatherChangedEvent event);
}
2. 使用泛型实现更灵活的观察者模式
// 泛型主题接口
public interface GenericSubject<T> {
void registerObserver(GenericObserver<T> observer);
void removeObserver(GenericObserver<T> observer);
void notifyObservers(T event);
}
// 泛型观察者接口
public interface GenericObserver<T> {
void update(T event);
}
// 使用示例
public class WeatherStation implements GenericSubject<WeatherChangedEvent> {
private List<GenericObserver<WeatherChangedEvent>> observers = new ArrayList<>();
@Override
public void registerObserver(GenericObserver<WeatherChangedEvent> observer) {
observers.add(observer);
}
@Override
public void removeObserver(GenericObserver<WeatherChangedEvent> observer) {
observers.remove(observer);
}
@Override
public void notifyObservers(WeatherChangedEvent event) {
for (GenericObserver<WeatherChangedEvent> observer : observers) {
observer.update(event);
}
}
public void weatherChanged(float temperature, float humidity, float pressure) {
WeatherChangedEvent event = new WeatherChangedEvent(temperature, humidity, pressure);
notifyObservers(event);
}
}
3. 使用Lambda表达式简化
Java 8引入的Lambda表达式可以大大简化观察者模式的实现：
public class ModernWeatherStation {
private List<Consumer<WeatherChangedEvent>> observers = new ArrayList<>();
// 注册观察者
public void addObserver(Consumer<WeatherChangedEvent> observer) {
observers.add(observer);
}
// 移除观察者
public void removeObserver(Consumer<WeatherChangedEvent> observer) {
observers.remove(observer);
}
// 通知观察者
public void notifyObservers(WeatherChangedEvent event) {
observers.forEach(observer -> observer.accept(event));
}
// 客户端调用示例
public static void main(String[] args) {
ModernWeatherStation station = new ModernWeatherStation();
// 使用Lambda表达式添加观察者
station.addObserver(event ->
System.out.println("当前天气：温度 " + event.getTemperature() + "°C")
);
station.addObserver(event ->
System.out.println("湿度通知：当前湿度 " + event.getHumidity() + "%")
);
// 触发通知
station.notifyObservers(new WeatherChangedEvent(26, 70, 1012.5f));
}
}
六、观察者模式高级应用
1. 异步观察者模式
在实际应用中，可能需要异步通知观察者，特别是观察者处理可能耗时较长时：
// 异步通知观察者
public void notifyObserversAsync(WeatherChangedEvent event) {
for (GenericObserver<WeatherChangedEvent> observer : observers) {
CompletableFuture.runAsync(() -> {
observer.update(event);
});
}
}
2. 线程安全的观察者模式
当多线程环境下使用观察者模式时，需要确保线程安全：
public class ThreadSafeWeatherStation implements GenericSubject<WeatherChangedEvent> {
// 使用线程安全的集合
private final List<GenericObserver<WeatherChangedEvent>> observers =
Collections.synchronizedList(new ArrayList<>());
@Override
public synchronized void registerObserver(GenericObserver<WeatherChangedEvent> observer) {
observers.add(observer);
}
@Override
public synchronized void removeObserver(GenericObserver<WeatherChangedEvent> observer) {
observers.remove(observer);
}
@Override
public void notifyObservers(WeatherChangedEvent event) {
// 创建观察者列表的副本，避免并发修改异常
List<GenericObserver<WeatherChangedEvent>> observersCopy;
synchronized(this) {
observersCopy = new ArrayList<>(observers);
}
for (GenericObserver<WeatherChangedEvent> observer : observersCopy) {
observer.update(event);
}
}
}
3. 带优先级的观察者模式
某些情况下，我们希望观察者按特定顺序收到通知：
public class PriorityObserver<T> implements Comparable<PriorityObserver<T>> {
private GenericObserver<T> observer;
private int priority;
public PriorityObserver(GenericObserver<T> observer, int priority) {
this.observer = observer;
this.priority = priority;
}
public void update(T event) {
observer.update(event);
}
@Override
public int compareTo(PriorityObserver<T> other) {
// 优先级高的排在前面
return other.priority - this.priority;
}
}
public class PriorityWeatherStation<T> {
private PriorityQueue<PriorityObserver<T>> observers =
new PriorityQueue<>();
public void registerObserver(GenericObserver<T> observer, int priority) {
observers.add(new PriorityObserver<>(observer, priority));
}
public void notifyObservers(T event) {
// 创建副本以保持原始优先级队列不变
PriorityQueue<PriorityObserver<T>> queue = new PriorityQueue<>(observers);
while (!queue.isEmpty()) {
queue.poll().update(event);
}
}
}
七、观察者模式的优缺点
优点：
1. 松耦合：主题和观察者之间的依赖关系弱化，它们可以独立变化
2. 支持广播通信：主题无需指定接收者，所有注册的观察者都会收到通知
3. 符合开闭原则：无需修改主题就能添加新的观察者
4. 建立了一套触发机制：当某个对象的状态发生改变时，所有依赖于它的对象都会得到通知
缺点：
1. 可能引起性能问题：如果观察者太多，或者观察者处理耗时，会影响系统性能
2. 可能导致循环依赖：如果观察者和主题之间存在循环依赖，可能导致系统死循环
3. 通知顺序不确定：无法保证观察者收到通知的顺序
4. 事件处理不当容易出错：如果观察者在处理通知时出现错误，可能影响其他观察者或整个系统
八、观察者模式的实际应用场景
1. GUI系统：按钮点击、窗口关闭等事件监听
2. 消息队列系统：如RabbitMQ, Kafka等基于发布/订阅模式的消息中间件
3. 网络编程：如Netty的ChannelHandler机制
4. Spring框架：事件监听机制如ApplicationListener
5. Android开发：广播接收器、EventBus等
6. 数据库触发器：数据变化时触发相应操作
7. ReactiveX编程：如RxJava中的Observable/Observer模式
九、总结
观察者模式是一种强大而灵活的设计模式，它定义了对象间一对多的依赖关系。它在需要将变化通知给多个对象的场景中非常有用，尤其适合于事件驱动型的系统设计。
从简单实现到高级应用，观察者模式提供了一种松耦合的对象交互方式，让系统更加灵活、可扩展。在Java中，我们可以使用自定义实现、内置API或函数式编程等多种方式来实现观察者模式。
在实际应用中，需要根据具体场景考虑线程安全性、性能优化等因素，选择合适的实现方式。随着响应式编程的流行，观察者模式的思想也在不断演进，如今的RxJava、Project Reactor等库都是基于观察者模式的思想发展而来的。
记住：观察者模式的核心是"发布-订阅"关系，主题发布状态变化，观察者获得通知并做出响应，这种设计让系统更加灵活，组件间更加松耦合！
关注公众号回复：Java设计模式
获取设计模式源码+学习资料；
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
