详解设计模式：观察者模式

观察者模式（Observer Pattern）也被称为发布-订阅（Publish/Subscribe）模式、模型-视图（Model/View）模式，是在 GoF 23 种设计模式中定义了的行为型模式。

观察者模式 定义了一对多的关系，让多个观察者对象同时监听某一个主体对象，这个主体对象发生变化时就会通知所有的观察者对象，使得他们能够自己更新自己。

～

本片文章内容包括：关于观察者模式、观察者模式 Demo（伪代码）

---

---

一、关于观察者模式

1、关于观察者模式

观察者模式（Observer Pattern）也被称为发布-订阅（Publish/Subscribe）模式、模型-视图（Model/View）模式，是在 GoF 23 种设计模式中定义了的行为型模式。

观察者模式 定义了一对多的关系，让多个观察者对象同时监听某一个主体对象，这个主体对象发生变化时就会通知所有的观察者对象，使得他们能够自己更新自己。

观察者模式的特点：

1. 被观察者不知道具体的观察者是谁，只知道自己被观察了，并且在合适的时机进行广播，让感兴趣的观察者知道发生了什么事情；

2. 观察者依赖于被观察者，被观察者不依赖于观察者，是单向关系，耦合程度不高。没有被观察者，观察者无法工作；没有观察者，被观察者该干啥干啥，因为被观察者本来就不清楚谁观察他，发广播是被观察的个人行为；

3. 通常被观察者出现行为上的变化，需要观察者做出反馈。显然一般情况下观察者并不知道被观察者啥时候会有变化，因此该反馈是一种被动反馈，实现的是一种回调机制。

2、关于观察者模式构成

策略模式主要由 4 种角色构成：

• 目标（Subject）：目标又称为主题，它是指被观察的对象。在目标中定义了一个观察者集合，一个观察目标可以接受任意数量的观察者来观察，它提供了一系列方法来增加和删除观察者对象，同时它定义了通知方法 notify()。目标类可以是接口，也可以是抽象类或具体类。
• 具体目标（ConcreteSubject）：具体目标是目标类的子类，它通常包含有经常发生改变的数据，当它的状态发生改变时它向各个观察者发出通知；同时它还实现了在目标类中定义的抽象业务逻辑方法。如果无须扩展目标类，具体目标类可以省略。
• 观察者（Observer）：观察者将对观察目标的改变做出反映，观察者一般定义为接口，该接口声明了更新数据的方法 update()，因此又称为抽象观察者。
• 具体观察者（ConcreteObserver）：在具体观察者中维护一个指向具体目标对象的引用，它存储具体观察者的有关状态，这些状态需要和具体目标的状态保持一致；它实现了在抽象观察者 Observer 中定义的 update() 方法。通常在实现时可以调用具体目标类的 attach() 方法将自己添加到目标类的集合中或者通过 detach() 方法将自己从目标类的集合中删除。

3、关于观察者模式XML

4、观察者模式解决的问题

• 定义对象之间的一对多依赖关系而不使对象紧密耦合。
• 确保当一个对象改变状态时，自动更新开放数量的从属对象。
• 一个对象应该可以通知开放式数量的其他对象

5、观察者模式的优点和缺点

# 观察者模式的优点

• 观察者与被观察者抽象耦合，容易扩展；
• 建立了一套触发机制。

# 观察者模式的缺点：

• 循环依赖会导致系统崩溃；
• 观察者太多会浪费时间。

---

二、观察者模式 Demo（伪代码）

1、伪代码 Demo 实现

# Subject 目标

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

public abstract class Subject {
    /**
     * 定义一个观察者集合用于存储所有观察者对象
     */
    protected List<Observer> observers = new ArrayList<Observer>();

    /**
     * 注册方法，用于向观察者集合中增加一个观察者
     * @param observer Observer
     */
    public void attachObserver(Observer observer) {
        observers.add(observer);
    }

    /**
     * 注销方法，用于在观察者集合中删除一个观察者
     * @param observer Observer
     */
    public void detachObserver(Observer observer) {
        observers.remove(observer);
    }

    /**
     * 声明抽象通知方法
     */
    public abstract void notifyObserver();
}

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

# ConcreteSubject 具体目标

public class ConcreteSubject extends Subject {

    /**
     * 实现通知方法
     */
    @Override
    public void notifyObserver() {
        //遍历观察者集合，调用每一个观察者的响应方法
        for(Observer obs:observers) {
            obs.update();
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

# Observer 观察者

public interface Observer {

    /**
     * 声明响应方法
     */
    public void update();
}

1
2
3
4
5
6
7
8

# ConcreteObserver 具体观察者

public class ConcreteObserverA implements Observer {
    /**
     * 实现响应方法
     */
    @Override
    public void update() {
        //具体响应代码
        System.out.println("ConcreteObserverA 相应");
    }
}
public class ConcreteObserverB implements Observer {
    /**
     * 实现响应方法
     */
    @Override
    public void update() {
        //具体响应代码
        System.out.println("ConcreteObserverB 相应");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

2、Demo 测试

public class Client {

    public static void main(String[] args) {

        Subject subject = new ConcreteSubject();

        subject.attachObserver(new ConcreteObserverA());
        subject.attachObserver(new ConcreteObserverB());

        subject.notifyObserver();
        
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14