设计模式：观察者模式

观察者

设计模式：观察者模式

本文是设计模式系列中的第三篇，上一篇是 单例模式。

观察者模式是使用频率最高的设计模式之一。是对象之间的一种一对多的依赖关系，使得当一个对象「被观察者」发生改变，其相关依赖对象「观察者」皆收到通知，并自动更新。

比如，我们注册某个网站的时，默认订阅了它的促销活动邮件及账户安全邮件。当促销活动发生时，所有用户都会收到与促销相关的邮件，当公司信息发生泄漏，需要用户更改密码时，向所有用户发送更改密码的邮件提示。

在这个例子中，观察者就是每一个注册网站的用户，被观察者就是网站中具体的业务（可能是促销信息、也可能是账户安全信息）。当被观察者产生事件时，观察者收到事件。

通常来说，被观察者可能有多个观察者，比如，小王和小蒋比较喜欢购物，就没有取消订阅促销信息邮件通知，小李因为平时不怎么用在线购物，所以他主动取消了促销信息的订阅。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// 注册用户
Person jiang = new Person("小蒋");
Person wang = new Person("小王");
Person li = new Person("小李");

// 系统功能
SaleProduct saleProduct = new SaleProduct();
SafeAccount safeAccount = new SafeAccount();

// 默认情况下，订阅系统邮件
saleProduct.registerObserver(jiang);
saleProduct.registerObserver(wang);
saleProduct.registerObserver(li);

safeAccount.registerObserver(jiang);
safeAccount.registerObserver(wang);
safeAccount.registerObserver(li);

// 小李、小王主动取消订阅相关产品邮件
saleProduct.unRegisterObserver(li);

所以，被观察者「公司产品」内部需要维护一个集合，用于添加及删除订阅的观察者「用户」，以及当事件「促销及安全信息」产生时，通知所有订阅当前被观察者的观察者。

由于公司可能有多个产品，所以我们把被观察者定义为接口，名为 Obserable，而每一个用户都具有订阅的能力，都是一个观察者，我们也定义一个接口，名为 Observer。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public interface Observable {
    // 注册观察者
    void registerObserver(Observer  observer);

    // 解绑观察者
    void unRegisterObserver(Observer observer);

    // 产生事件
    void changeObserver();
}

public interface Observer {
    //接受被观察者发出的事件
    void onChange(Object object);
}

之后定义公司产品「促销及安全」和个人账户。

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
public class SaleProduct implements Observable {
    List<Observer> useSaleNameList = new ArrayList<>();

    @Override
    public void registerObserver(Observer observer) {
        useSaleNameList.add(observer);
    }

    @Override
    public void unRegisterObserver(Observer observer) {
        observer.onChange("----- 您已经取消订阅促销信息 -----");
        useSaleNameList.remove(observer);
    }

    @Override
    public void changeObserver() {
        for (Observer observer : useSaleNameList) {
            observer.onChange("大型售卖活动开始了");
        }
    }
}

public class SafeAccount implements Observable {
    List<Observer> observers = new ArrayList<>();

    @Override
    public void registerObserver(Observer observer) {
        observers.add(observer);
    }

    @Override
    public void unRegisterObserver(Observer observer) {
        observer.onChange("----- 您已经取消订阅安全信息 -----");
        observers.remove(observer);
    }

    @Override
    public void changeObserver() {
        for (Observer observer : observers) {
            observer.onChange("当前账户安全受到威胁");
        }
    }
}

public class Person implements Observer {

    private static final String TAG = "Person";
    private String name;

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

    @Override
    public void onChange(Object object) {
        Log.d(TAG, name + " 收到了邮件，内容是：" + object.toString());
    }
}

观察者模式并不难，思路清晰就可以写出。不过需要注意的是，观察者「用户」需订阅被观察者「产品」的动态，在用代码写出来的是：产品.regisisterObserver(用户)，与思路上的观察者「用户」定义被观察者「产品」正好相反，稍微有点绕，习惯就好了。

优点：

  1. 观察者模式可以实现表示层和逻辑逻辑层的分离，定义了稳定的消息更新传递机制，抽象了更新接口，可以让不同的表示层充当观察者。
  2. 观察者模式在被观察者和观察者之间建立一个抽象的耦合，观察目标只需要维持一个抽象观察者的集合，无须了解具体的观察者。由于观察目标和观察者之间没有紧密的耦合，因此他们可以分别属于不同的抽象化层级。
  3. 观察者模式支持广播通信，被观察者会向所有已注册的观察者发送通知，简化了一对多系统设计的难度。
  4. 观察者模式满足开闭原则，增加新的具体观察者无须修改原有系统代码，在具体观察者与被观察者之间不存在关联关系的情况下，增加新的观察目标也非常方便。

缺点：

  1. 当一个被观察者有很多观察者时，通知所有的观察者可能需要花费很多时间；
  2. 如果被观察与观察者之间存在循环依赖，会被触发循环调用，可能导致系统崩溃；
  3. 观察者模式没有相应的机制让观察者知道被观察者是因为什么导致发生的变化，仅仅知道被观察者发生了变化。

本文封面图：Photo by Maarten van den Heuvel on Unsplash