观察者模式

观察者模式

定义

​ 定义对象间的一种一对多的依赖关系，使得每当一个对象状态发生改变时，其相关依赖对象皆能收到通知并自动更新。

​ 观察者模式又叫做发布-订阅模式(Publish/Subscribe)；模型-视图模式(Model/View)；源-监听器模式(Source/Listener)；从属者模式(Dependents)。

​ 观察者模式可以类比我们现在比较常见的微信订阅号。当我们订阅了某个订阅号之后，当该订阅有了新的文章都会在第一时间发送到我们的微信上。这里的订阅号就属于发布者，我们的就属于订阅者。一对多就是一个订阅号对应多个订阅用户。

组成角色

• Subject：主题/目标；一般为抽象类或者是接口。它就是我们的抽象的发布者，观察者观察的目标。它一般会包含一些抽象方法。比如：注册观察者；解除观察者，更新观察者等。
• ConcreteSubject：具体的主题/目标；它是Subject的实现类，是具体的的发布者。
• Observer：观察者；一般为抽象类或者是接口。它是抽象的接收者。它至少会包含一个抽象方法，那就是更新自己的方法。
• ConcreteObserver：具体观察者；该类为具体的观察者。它是具体的接收者。

它的结构图如下：

时序图如下：

具体示例

抽象的主题：

public abstract class Subject {    //记录当前的状态；将该状态分发给各个观察者    protected String mState;    //将观察者 注册、依附 到主题    public abstract void attach(Observer observer);    //将观察者从主题分离    public abstract void detach(Observer observer);    //主题发生改变通知所有的观察者更新    public abstract void notifyAllObserver(Subject subject);    //当前主题的状态，会将该状态分发给观察者    public abstract String getState();    //设置当前主题的状态    public abstract void setState(String state);}

具体的主题：

public class ConcreteSubject extends Subject {    @Override    public String getState() {        return mState;    }    @Override    public void setState(String state) {        this.mState = state;    }    private List<Observer> mObservers = new ArrayList<>();    @Override    public void attach(Observer observer) {        if (observer != null) {            mObservers.add(observer);        }    }    @Override    public void detach(Observer observer) {        if (observer != null && mObservers.contains(observer)) {            mObservers.remove(observer);        }    }    @Override    public void notifyAllObserver(Subject subject) {        for (Observer o : mObservers) {            o.update(subject);        }    }}

抽象的观察者：

public abstract class Observer {    public abstract void update(Subject subject);}

具体观察者：

public class ConcreteObserver extends Observer {    @Override    public void update(Subject subject) {        System.out.println("当前的状态 = " + subject.getState());    }}   

所有的代码都写完。我们在主题里添加了两个额外的方法，由来设置和获取当前的主题状态。然后把设置的状态分发给各个观察者。我们在具体观察者里更新获取的状态。

我们测试一下：

    Subject subject1 = new ConcreteSubject();    Observer observer1 = new ConcreteObserver();    Observer observer2 = new ConcreteObserver();    Observer observer3 = new ConcreteObserver();    subject1.attach(observer1);    subject1.attach(observer2);    subject1.attach(observer3);    subject1.setState("当前Subject1的状态");    subject1.notifyAllObserver(subject1);    System.out.println("----- Subject1 和 Subject2 的分割线 -----");    Subject subject2 = new ConcreteSubject();    subject2.attach(observer1);    subject2.attach(observer2);    subject2.attach(observer3);    subject2.setState("当前Subject2的状态");    subject2.notifyAllObserver(subject2);}

这里使用的两个主题。两个主题设置不同的状态，然后把两个状态分发给观察者。输出内容如下：

当前的状态 = 当前Subject1的状态
当前的状态 = 当前Subject1的状态
当前的状态 = 当前Subject1的状态
——– Subject1 和 Subject2 的分割线 ——–
当前的状态 = 当前Subject2的状态
当前的状态 = 当前Subject2的状态
当前的状态 = 当前Subject2的状态

优点

• 观察者和观察目标之间是抽象耦合；符合开闭原则
• 使表示层和数据逻辑层分离。并定义了稳定的消息更新传递机制，抽象了更新接口，使得可以有各种各样不同的表示层作为具体观察者角色。

缺点

• 如果观察者过多，将会花费过多的性能和时间
• 观察者无法得知它的观察目标是如何发生变化的，而只是得到了通知
• 如果在观察者和观察目标之间有循环依赖的话，观察目标会触发它们之间进行循环调用，可能导致系统崩溃。
• 如果顺序执行，某一观察者错误会导致系统卡壳，一般采用异步方式。

模式拓展

• 如果主题类型仅有一宗，那抽象的主题可以省略掉。直接使用具体的主题。
• 在Android中的广播跟这个模式类似。

使用场景

• 一对多；一个对象的改变将导致其他一个或多个对象也发生改变，而不知道具体有多少对象将发生改变，可以降低对象之间的耦合度。
• 一个对象必须通知其他对象，而并不知道这些对象是谁。

本文参考：http://design-patterns.readthedocs.io/zh_CN/latest/creational_patterns/builder.html

本文中的结构图和时序图来自：http://design-patterns.readthedocs.io/zh_CN/latest/creational_patterns/builder.html