设计模式精讲：什么是观察者模式？它观察的是什么？

发表于 分类于 阅读次数： 本文字数： 3.2k 阅读时长 ≈ 3 分钟

你好，我是猿java。

观察者模式是比较常见的一种模式，那么，什么是观察者模式？它是如何工作的？这篇文章我们将深入探讨观察者模式的定义、结构、优缺点、适用场景以及代码实现等方面。

1. 观察者模式是什么？

观察者设计模式（Observer Pattern）是一种行为型设计模式，它定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。当主题对象的状态发生变化时，所有依赖于它的观察者对象都会得到通知并自动更新。这种模式常用于事件处理系统。

2. 观察者模式的组成部分

观察者模式主要由以下几个部分组成：

  • 主题（Subject）：它是一个接口或者抽象类，定义了注册、注销和通知观察者的方法。
  • 具体主题（Concrete Subject）：具体主题类实现了主题接口，维护一个观察者列表，当自身状态改变时，通知所有观察者。
  • 观察者（Observer）：它是一个接口或者抽象类，定义了更新自身的方法。
  • 具体观察者（Concrete Observer）：具体观察者类实现了观察者接口，以便在接收到通知时自身状态能与主题同步。

img

3. 工作流程

从整体上看，观察者模式的工作流程包含如下步骤：

  • 注册观察者：观察者通过调用主题的注册方法（如 attach()）将自己注册到主题中。
  • 状态改变：主题的状态或数据发生变化（例如，属性值改变）。
  • 通知观察者：主题执行通知方法（如 notify()），遍历所有注册的观察者。调用每个观察者的更新方法（如 update()），并传递必要的数据。
  • 观察者更新：观察者接收到通知后，根据主题的当前状态进行相应的处理（如更新自己的状态或执行操作）。

为了更好地理解观察者模式的工作原理，下面我们通过一个简单的Java示例，演示如何实现观察者模式。

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
import java.util.ArrayList;
import java.util.List;

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

// 具体观察者
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);
    }
}

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

// 具体主题
class ConcreteSubject implements Subject {
    private List<Observer> observers = new ArrayList<>();
    private String message;

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

    public void setMessage(String message) {
        this.message = message;
        notifyObservers();
    }
}

// 测试类
public class ObserverPatternDemo {
    public static void main(String[] args) {
        ConcreteSubject subject = new ConcreteSubject();

        Observer observer1 = new ConcreteObserver("Observer 1");
        Observer observer2 = new ConcreteObserver("Observer 2");

        subject.registerObserver(observer1);
        subject.registerObserver(observer2);

        subject.setMessage("Hello, Observers!");
        subject.setMessage("Another message");

        subject.removeObserver(observer1);
        subject.setMessage("Observer 1 should not receive this");
    }
}

代码详细解析

1. 主题接口与具体主题：

  • Subject接口定义了注册、移除和通知观察者的方法。
  • ConcreteSubject实现了Subject接口，并维护一个观察者列表。当其状态改变时，通过调用notifyObservers()方法通知所有观察者。

2. 观察者接口与具体观察者：

  • Observer接口定义了update方法，当主题状态改变时，主题会调用此方法。
  • ConcreteObserver实现了Observer接口，并在update方法中定义了当收到通知时的具体行为。

3. 通知机制：

  • 当ConcreteSubject的状态通过setMessage方法改变时，它会调用notifyObservers()方法，向所有的观察者发送更新通知。
  • 观察者通过实现update方法来处理这些通知。

4. 优缺点

4.1 优点

  • 松耦合：观察者模式实现了对象之间的松耦合，观察者和主题之间并不需要明确的依赖关系，只通过接口来交互。这使得系统更具扩展性。
  • 动态交互：可以在运行时添加或移除观察者，灵活性强。这对于需要动态调整的程序非常有用。
  • 多种订阅方式：不同的观察者可以对同一主题订阅不同的条件，以应对复杂的业务逻辑。

4.2 缺点

  • 通知机制开销：在主题状态改变时，需要通知所有观察者，这可能导致性能问题，尤其是在观察者数量较多时。
  • 观察者管理复杂：观察者的管理可能会变得复杂，特别是在大量观察者需要注销的情况下，需要确保所有观察者的状态一致性。
  • 隐式依赖：虽然观察者模式松耦合，但是观察者和主题之间仍然存在隐式依赖关系，可能导致在系统分析和维护时的复杂性增加。

5. 总结

这篇文章，我们分析了观察者模式以及实现的示例代码，它是一种常用的设计模式，适用于需要对一个对象的状态变化做出响应的场景。通过使用观察者模式，可以实现对象之间的松耦合，提高系统的灵活性和可维护性。

6. 学习交流

如果你觉得文章有帮助，请帮忙转发给更多的好友，或关注公众号：猿java，持续输出硬核文章。

drawing