设计模式--观察者模式

本文的结构如下：

• 什么是观察者模式
• 为什么要用该模式
• 模式的结构
• 代码示例
• 推模型和拉模型
• 优点和缺点
• 适用环境
• 模式应用
• 总结

一、什么是观察者模式

观察者模式定义了对象之间的一对多依赖，这样一来，当一个对象改变状态时，它的所有依赖者都会收到通知并自动更新。观察者模式又叫做发布-订阅（Publish/Subscribe）模式、模型-视图（Model/View）模式、源-监听器（Source/Listener）模式或从属者（Dependents）模式。

上面是比较官方的定义，可以用订阅杂志的模式来通俗理解观察者模式。

如上图，现有一本文学杂志，一一、二二、三三都喜欢文学，所以花钱订阅了该杂志，四四不喜欢文学，在其他三人订阅杂志的时候，他选择躲在窝里睡大觉。

新的一月到来，杂志发布了最新的一期，这天一大早，杂志社就把杂志分别送到了一一、二二、三三手中，三人坐着椅子上，一边喝着热牛奶，一边翻看着绝世好文章，四四只能落寞躲在角落上，偷偷打起农药。

这就是观察者模式的通俗解释，一个“主题”，有一个或多个“观察者”，“观察者”订阅“主题”，“主题”更新，订阅了该“主题”的“观察者”都能收到通知，并进行相应的行为。

二、为什么要用该模式

软件系统常常要求建立一种对象与对象之间的依赖关系，一个对象发生改变时将自动通知其他对象，其他对象将相应做出反应。做到这一点的设计方案有很多，但是为了使系统能够易于复用，应该选择低耦合度的设计方案。减少对象之间的耦合有利于系统的复用，但是同时需要使这些低耦合度的对象之间能够维持行动的协调一致，保证高度的协作。观察者模式是满足这一要求的各种设计方案中最重要的一种。

三、模式的结构

这是摘自《HeadFirst 设计模式》一书中的类图。从图中应该能很清楚看出观察者模式涉及的角色：

• 抽象主题(Subject)角色：抽象主题角色把所有对观察者对象的引用保存在一个聚集（比如ArrayList对象）里，每个主题都可以有任何数量的观察者。抽象主题提供一个接口，可以增加和删除观察者对象，抽象主题角色又叫做抽象被观察者(Observable)角色。
• 具体主题(ConcreteSubject)角色：将有关状态存入具体观察者对象；在具体主题的内部状态改变时，给所有登记过的观察者发出通知。具体主题角色又叫做具体被观察者(Concrete Observable)角色。
• 抽象观察者(Observer)角色：为所有的具体观察者定义一个接口，在得到主题的通知时更新自己，这个接口叫做更新接口。
• 具体观察者(ConcreteObserver)角色：存储与主题的状态自恰的状态。具体观察者角色实现抽象观察者角色所要求的更新接口，以便使本身的状态与主题的状态相协调。如果需要，具体观察者角色可以保持一个指向具体主题对象的引用。

四、代码示例

用代码实现“订阅报纸”，观察者模式运用如下：

1.首先有抽象主题

/**
 * 抽象主题
 *
 * Created by w1992wishes on 2017/10/17.
 */
public interface Subject {
    void registerObserver(Observer observer);
    void removeObserver(Observer observer);
    void notifyObservers();
}

2.有实现抽象主题的具体主题

/**
 * 具体主题
 *
 * Created by w1992wishes on 2017/10/17.
 */
public class Maganize implements Subject {

    private List<Observer> observers;
    private String flag;

    public Maganize(){
        observers = new ArrayList<Observer>();
    }

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

    public void removeObserver(Observer observer) {
        int i = observers.indexOf(observer);
        if (i > 0){
            observers.remove(i);
        }
    }

    public void notifyObservers() {
        for (int i=0; i<observers.size(); i++){
            Observer observer = (Observer)observers.get(i);
            observer.update(flag);
        }
    }

    public void publishNewMaganize(String flag){
        this.flag = flag;
        System.out.println("publish new maganize: " + flag);
        notifyObservers();
    }
}

3.还有抽象观察者

/**
 * 抽象观察者
 *
 * Created by w1992wishes on 2017/10/17.
 */
public interface Observer {
    void update(String flag);
}

4.还有实现抽象观察者的三个具体观察者

/**
 * 具体观察者一一
 * Created by w1992wishes on 2017/10/17.
 */
public class Yiyi implements Observer {

    private String flag;

    public void update(String flag) {
        this.flag = flag;
        System.out.println("I am yiyi, now reading maganize: " + flag);
    }
}

/**
 * 具体观察者--二二
 *
 * Created by w1992wishes on 2017/10/17.
 */
public class Erer implements  Observer {

    private String flag;

    public void update(String flag) {
        this.flag = flag;
        System.out.println("I am erer, now reading maganize: " + flag);
    }
}

/**
 * 具体观察者三三
 *
 * Created by w1992wishes on 2017/10/17.
 */
public class Sansan implements Observer {

    private String flag;

    public void update(String flag) {
        this.flag = flag;
        System.out.println("I am sansan, now reading maganize: " + flag);
    }
}

5.最后有客户端

/**
 * 客户端
 *
 * Created by w1992wishes on 2017/10/17.
 */
public class Client {
    public static void main(String[] args) {
        //创建主题对象
        Maganize maganize = new Maganize();

        //创建观察者
        Observer yiyi = new Yiyi();
        Observer erer = new Erer();
        Observer sansan = new Sansan();

        //将观察者对象登记到主题对象上
        maganize.registerObserver(yiyi);
        maganize.registerObserver(erer);
        maganize.registerObserver(sansan);

        //改变主题对象的状态（发布新杂志）
        maganize.publishNewMaganize("October New");
    }
}

显示结果如下：
publish new maganize: October New
I am yiyi, now reading maganize: October New
I am erer, now reading maganize: October New
I am sansan, now reading maganize: October New

在运行时，这个客户端首先创建了具体主题类的实例，以及三个观察者对象。然后，它调用主题对象的registerObserver()方法，将观察者对象向主题对象登记，也就是将它加入到主题对象的聚集中去。

这时，客户端调用主题的publishNewMaganize()方法，改变了主题对象的内部状态。主题对象在状态发生变化时，调用超类的notifyObservers()方法，通知所有登记过的观察者对象。

五、推模型和拉模型

6.1、推模型

在观察者模式中，又分为推模型和拉模型两种方式。

• 推模型

主题对象向观察者推送主题的详细信息，不管观察者是否需要，推送的信息通常是主题对象的全部或部分数据。

• 拉模型

主题对象在通知观察者的时候，只传递少量信息。如果观察者需要更具体的信息，由观察者主动到主题对象中获取，相当于是观察者从主题对象中拉数据。一般这种模型的实现中，会把主题对象自身通过update()方法传递给观察者，这样在观察者需要获取数据的时候，就可以通过这个引用来获取了。

根据上面的描述，发现前面的例子就是典型的推模型，下面给出一个拉模型的实例。

6.2、拉模型

1.拉模型通常都是把主题对象当做参数传递。

/**
 * 拉模型 抽象观察者
 *
 * Created by w1992wishes on 2017/10/17.
 */
public interface Observer {
    /**
     * update 方法
     *
     * @param subject  传入主题对象，方面获取相应的主题对象的状态
     */
    void update(Subject subject);
}

2.拉模型的具体观察者类

/**
 * 拉模型 具体观察者一一
 * Created by w1992wishes on 2017/10/17.
 */
public class Yiyi implements Observer {

    private String flag;

    public void update(Subject subject) {
        this.flag = ((Maganize) subject).getFlag();
        System.out.println("I am yiyi, now reading maganize: " + flag);
    }
}

/**
 * 拉模型 具体观察者--二二
 *
 * Created by w1992wishes on 2017/10/17.
 */
public class Erer implements  Observer {

    private String flag;

    public void update(Subject subject) {
        this.flag = ((Maganize) subject).getFlag();
        System.out.println("I am erer, now reading maganize: " + flag);
    }
}

/**
 * 拉模型 具体观察者三三
 *
 * Created by w1992wishes on 2017/10/17.
 */
public class Sansan implements Observer {

    private String flag;

    public void update(Subject subject) {
        this.flag = ((Maganize) subject).getFlag();
        System.out.println("I am sansan, now reading maganize: " + flag);
    }
}

3.拉模型 拉模型的具体主题类

拉模型的主题类主要的改变是nodifyObservers()方法。在循环通知观察者的时候，也就是循环调用观察者的update()方法的时候，传入的参数不同了。

/**
 * 具体主题
 *
 * Created by w1992wishes on 2017/10/17.
 */
public class Maganize implements Subject {

    private List<Observer> observers;
    private String flag;

    public Maganize(){
        observers = new ArrayList<Observer>();
    }

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

    public void removeObserver(Observer observer) {
        int i = observers.indexOf(observer);
        if (i > 0){
            observers.remove(i);
        }
    }

    public void notifyObservers() {
        for (int i=0; i<observers.size(); i++){
            Observer observer = (Observer)observers.get(i);
            observer.update(this);
        }
    }

    public void publishNewMaganize(String flag){
        this.flag = flag;
        System.out.println("publish new maganize: " + flag);
        notifyObservers();
    }

    public String getFlag() {
        return flag;
    }
}

6.3、两种模式的比较

• 推模型是假定主题对象知道观察者需要的数据；而拉模型是主题对象不知道观察者具体需要什么数据，没有办法的情况下，干脆把自身传递给观察者，让观察者自己去按需要取值。
• 推模型可能会使得观察者对象难以复用，因为观察者的update()方法是按需要定义的参数，可能无法兼顾没有考虑到的使用情况。这就意味着出现新情况的时候，就可能提供新的update()方法，或者是干脆重新实现观察者；而拉模型就不会造成这样的情况，因为拉模型下，update()方法的参数是主题对象本身，这基本上是主题对象能传递的最大数据集合了，基本上可以适应各种情况的需要。

六、优点和缺点

6.1、优点

• 观察者模式可以实现表示层和数据逻辑层的分离，并定义了稳定的消息更新传递机制，抽象了更新接口，使得可以有各种各样不同的表示层作为具体观察者角色。
• 观察者模式在观察目标和观察者之间建立一个抽象的耦合。
• 观察者模式支持广播通信。
• 观察者模式符合“开闭原则”的要求。

6.2、缺点

• 如果一个观察目标对象有很多直接和间接的观察者的话，将所有的观察者都通知到会花费很多时间。
• 如果在观察者和观察目标之间有循环依赖的话，观察目标会触发它们之间进行循环调用，可能导致系统崩溃。
• 观察者模式没有相应的机制让观察者知道所观察的目标对象是怎么发生变化的，而仅仅只是知道观察目标发生了变化。

七、适用环境

在以下情况下可以使用观察者模式：

• 一个抽象模型有两个方面，其中一个方面依赖于另一个方面。将这些方面封装在独立的对象中使它们可以各自独立地改变和复用。
• 一个对象的改变将导致其他一个或多个对象也发生改变，而不知道具体有多少对象将发生改变，可以降低对象之间的耦合度。
• 一个对象必须通知其他对象，而并不知道这些对象是谁。
• 需要在系统中创建一个触发链，A对象的行为将影响B对象，B对象的行为将影响C对象……，可以使用观察者模式创建一种链式触发机制。

八、模式应用

观察者模式在软件开发中应用非常广泛，如某电子商务网站可以在执行发送操作后给用户多个发送商品打折信息，某团队战斗游戏中某队友牺牲将给所有成员提示等等，凡是涉及到一对一或者一对多的对象交互场景都可以使用观察者模式。

九、总结

• 观察者模式定义对象间的一种一对多依赖关系，使得每当一个对象状态发生改变时，其相关依赖对象皆得到通知并被自动更新。观察者模式又叫做发布-订阅模式、模型-视图模式、源-监听器模式或从属者模式。观察者模式是一种对象行为型模式。
• 观察者模式包含四个角色：目标又称为主题，它是指被观察的对象；具体目标是目标类的子类，通常它包含有经常发生改变的数据，当它的状态发生改变时，向它的各个观察者发出通知；观察者将对观察目标的改变做出反应；在具体观察者中维护一个指向具体目标对象的引用，它存储具体观察者的有关状态，这些状态需要和具体目标的状态保持一致。
• 观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个目标对象，当这个目标对象的状态发生变化时，会通知所有观察者对象，使它们能够自动更新。
• 观察者模式的主要优点在于可以实现表示层和数据逻辑层的分离，并在观察目标和观察者之间建立一个抽象的耦合，支持广播通信；其主要缺点在于如果一个观察目标对象有很多直接和间接的观察者的话，将所有的观察者都通知到会花费很多时间，而且如果在观察者和观察目标之间有循环依赖的话，观察目标会触发它们之间进行循环调用，可能导致系统崩溃。
• 观察者模式适用情况包括：一个抽象模型有两个方面，其中一个方面依赖于另一个方面；一个对象的改变将导致其他一个或多个对象也发生改变，而不知道具体有多少对象将发生改变；一个对象必须通知其他对象，而并不知道这些对象是谁；需要在系统中创建一个触发链。
• 在JDK的java.util包中，提供了Observable类以及Observer接口，它们构成了Java语言对观察者模式的支持。