【24种设计模式】观察者模式（Observer Pattern）

观察者模式：实现对象间的一对多依赖关系

观察者模式（Observer Pattern）是一种行为设计模式，它允许对象（称为观察者）在发生某些事件或状态变化时自动接收其他对象（称为主题或可观察者）的通知。这种模式实现了一种一对多的对象依赖关系，当一个对象的状态改变时，所有依赖它的对象都会得到通知并自动更新。

主要角色

观察者模式包含以下主要角色：

1. 主题（Subject）: 可观察的对象，它发送通知给观察者。主题可以是接口或抽象类，定义了添加、删除和通知观察者的方法。
2. 具体主题（ConcreteSubject）: 实现了主题接口，维护观察者列表，发送通知给观察者。
3. 观察者（Observer）: 接收主题的通知，并进行相应的处理。观察者可以是接口或抽象类，定义了接收通知的方法。
4. 具体观察者（ConcreteObserver）: 实现了观察者接口，接收主题的通知并进行具体的业务处理。

使用场景

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

1. 当一个对象的改变需要同时改变其他对象，且它们之间存在一种一对多的依赖关系时。
2. 当一个抽象模型有两个方面，其中一个方面依赖于另一个方面，将这两者封装在独立的对象中以使它们可以各自独立地改变和复用时。
3. 当一个对象必须通知其他对象，而不知道这些对象是谁时。

示例代码

下面是一个简单的示例代码，演示了如何使用观察者模式实现一个天气预报系统。

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

// 主题接口
interface Subject {
    void registerObserver(Observer observer);
    void removeObserver(Observer observer);
    void notifyObservers();
}

// 具体主题类
class Weather implements Subject {
    private List<Observer> observers;
    private String weatherData;

    public Weather() {
        this.observers = new ArrayList<>();
    }

    @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(weatherData);
        }
    }

    public void setWeatherData(String weatherData) {
        this.weatherData = weatherData;
        notifyObservers();
    }
}

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

// 具体观察者类
class User implements Observer {
    private String name;

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

    @Override
    public void update(String weatherData) {
        System.out.println(name + " 收到天气更新：" + weatherData);
    }
}

public class Main {
    public static void main(String[] args) {
        Weather weather = new Weather();

        // 创建观察者对象
        Observer user1 = new User("User 1");
        Observer user2 = new User("User 2");
        Observer user3 = new User("User 3");

        // 注册观察者
        weather.registerObserver(user1);
        weather.registerObserver(user2);
        weather.registerObserver(user3);

        // 设置天气数据，触发通知
        weather.setWeatherData("晴天");

        // 移除观察者
        weather.removeObserver(user2);

        // 再次设置天气数据，触发通知
        weather.setWeatherData("下雨");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85

在上述示例中，我们定义了一个 Weather 类作为具体主题，实现了 Subject 接口。它维护了一个观察者列表，并提供了注册、移除和通知观察者的方法。

我们还定义了一个 User 类作为具体观察者，实现了 Observer 接口。每个用户对象都可以收到天气更新的通知。

在 Main 类中，我们创建了一个 Weather 对象作为主题，并创建了三个 User 对象作为观察者。首先注册了观察者，然后设置天气数据并触发通知。用户将收到相应的天气更新。

然后，我们移除了一个观察者，并再次设置天气数据。这次只有两个用户收到了天气更新。

执行以上代码，会输出以下结果：

User 1 收到天气更新：晴天
User 2 收到天气更新：晴天
User 3 收到天气更新：晴天
User 1 收到天气更新：下雨
User 3 收到天气更新：下雨
1
2
3
4
5

以上代码演示了观察者模式的基本用法和效果。

观察者模式优点

观察者模式有以下优点：

松耦合：主题和观察者之间的依赖关系是松耦合的，它们可以独立变化，互不影响。
可扩展性：可以动态地添加或删除观察者，从而实现主题的灵活性和可扩展性。
分离关注点：将观察者与主题分离开来，使它们各自关注自己的职责。
便于维护：由于观察者和主题之间的依赖关系被封装在抽象的接口中，易于维护和扩展。

观察者模式缺点

观察者模式也存在以下缺点：

开销较大：如果观察者特别多、通知频繁，则可能导致性能问题。
顺序问题：观察者之间的顺序是不确定的，可能会导致观察者处理事件的顺序混乱。
异常处理：如果观察者的处理逻辑出现异常，有可能导致其他观察者无法收到通知，或者通知被终止。

观察者模式与其他设计模式的关联

观察者模式与其他设计模式通常也会有关联。以下是一些常见的关联方式：

发布-订阅模式：发布-订阅模式是观察者模式的一种扩展，它将观察者分组，通过消息队列、事件总线等机制实现观察者与主题之间的松耦合通信。
状态模式：状态模式和观察者模式都与对象的状态变化有关。在状态模式中，状态的改变会导致行为的改变，而在观察者模式中，状态的改变会导致通知给观察者。
模板方法模式：模板方法模式定义了一种算法骨架，其中某些步骤可以由子类进行实现。观察者模式中，通知观察者的算法骨架是固定的，但具体的通知操作可以由不同的观察者进行实现。

总结起来，观察者模式通过定义主题和观察者之间的接口，实现了一种松耦合的对象间通信方式。它使得主题和观察者可以独立变化，达到了对象之间的解耦。观察者模式在很多场景下都能发挥作用，如事件驱动系统、GUI 界面组件、消息队列等。

希望通过这篇博客，你对观察者模式有了更深入的理解。如有任何问题，请随时提问！