观察者模式（Observer Pattern）

定义

观察者模式是对象的行为模式，又叫发布-订阅(Publish/Subscribe)模式、模型-视图(Model/View)模式、源-监听器(Source/Listener)模式或从属者(Dependents)模式。

观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态上发生变化时，会通知所有观察者对象，使它们能够自动更新自己。

设计原则

1. 封装变化。
2. 少用继承，多用组合。
3. 针对接口编程，不针对实现编程，更易于维护和扩展，更有条理。
4. 交互对象之间的松耦合设计，是程序更具有弹性。

结构图

组成对象

• 抽象主题(Subject)角色：抽象主题角色把所有对观察者对象的引用保存在一个聚集（比如ArrayList对象）里，每个主题都可以有任何数量的观察者。抽象主题提供一个接口，可以增加和删除观察者对象，抽象主题角色又叫做抽象被观察者(Observable)角色。

• 具体主题(ConcreteSubject)角色：将有关状态存入具体观察者对象；在具体主题的内部状态改变时，给所有登记过的观察者发出通知。具体主题角色又叫做具体被观察者(Concrete Observable)角色。

• 抽象观察者(Observer)角色：为所有的具体观察者定义一个接口，在得到主题的通知时更新自己，这个接口叫做更新接口。

• 具体观察者(ConcreteObserver)角色：存储与主题的状态自恰的状态。具体观察者角色实现抽象观察者角色所要求的更新接口，以便使本身的状态与主题的状态 像协调。如果需要，具体观察者角色可以保持一个指向具体主题对象的引用。

参考代码

抽象主题角色类——Subject

import java.util.Vector;/** * 抽象主题类 * @author: Yang Gao * @date: 2017-4-12 下午2:51:47 * @version: 1.0 */public abstract class Subject {    // 对此主题的所有观察者集合    private Vector<Observer> obs = new Vector<Observer>();    // 添加观察者    public synchronized void addObserver(Observer observer) {        if (!obs.contains(observer)) {            obs.addElement(observer);            System.out.println("主题添加观察者："  + observer.getName());        }    }    // 移除观察者    public synchronized void removeObserver(Observer observer) {        if (obs.contains(observer)) {            obs.removeElement(observer);        }    }    // 同步所有观察者数据    public void notifyAllObserver(Object data) {        Object[] allObs = obs.toArray();        for (int i = 0; i < allObs.length; i++) {            ((Observer) allObs[i]).update(data);        }    }}

具体主题类——ConcreteSubject

/** * 具体主题类 * @author: Yang Gao * @date: 2017-4-12 下午3:07:36 * @version: 1.0 */public class ConcreteSubject extends Subject {    private Object data;// 主题数据    public Object getData() {        return data;    }    public void setData(Object data) {        this.data = data;    }    // 模拟主题数据变化    public void changeData(Object data) {        this.setData(data);        System.out.println("主题数据：" + getData());        this.notifyAllObserver(data);    }}

抽象观察者类——Observer

/** * 抽象观察者接口 * @author: Yang Gao * @date: 2017-4-12 下午2:52:45 * @version: 1.0 */public interface Observer {     // 观察者名称    public abstract String getName();    // 观察者同步被观察的主题数据    public abstract void update(Object data);}

具体观察者类——ConcreteObserver

/** * 具体观察者类 * @author: Yang Gao * @date: 2017-4-12 下午3:10:02 * @version: 1.0 */public class ConcreteObserver implements Observer {    private String name;// 观察者名称    public ConcreteObserver(String name) {        this.name = name;    }    @Override    public String getName() {        return this.name;    }    @Override    public void update(Object data) {        System.out.println(this.name + "同步数据：" + data);    }}

客户端，测试类——Client

/** * 客户端 * @author: Yang Gao * @date: 2017-4-12 下午3:11:19 * @version: 1.0 */public class Client {    public static void main(String[] args) {        // 1.主题        ConcreteSubject subject = new ConcreteSubject();        // 2.观察者        Observer observer = new ConcreteObserver("观察者1");        Observer observer2 = new ConcreteObserver("观察者2");        // 3.观察者注册主题        subject.addObserver(observer);        subject.addObserver(observer2);        // 4.模拟主题数据变化，观察者自动同步数据        subject.changeData("new data");    }}

运行结果

延伸

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

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

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

很明显，上面的参考示例是采用推模型，所以下面给出一个拉模型的实例。

拉模型的抽象观察者类

/** * 抽象观察者接口 * @author: Yang Gao * @date: 2017-4-12 下午2:52:45 * @version: 1.0 */public interface Observer {    // 观察者名称    public abstract String getName();    /**     * 观察者同步被观察的主题数据      * 拉模型通常都是把主题对象当做参数传递。     * @param subject     * @Author: Yang Gao     * @date: 2017-4-12 下午3:48:00     */    public abstract void update(Subject subject);}

拉模型的具体观察者类

/** * 具体观察者类 * @author: Yang Gao * @date: 2017-4-12 下午3:10:02 * @version: 1.0 */public class ConcreteObserver implements Observer {    private String name;// 观察者名称    public ConcreteObserver(String name) {        this.name = name;    }    @Override    public String getName() {        return this.name;    }    @Override    public void update(Object data) {        System.out.println(this.name + "同步数据：" + data);    }}

拉模型的抽象主题类

import java.util.Vector;/** * 抽象主题类 * @author: Yang Gao * @date: 2017-4-12 下午2:51:47 * @version: 1.0 */public abstract class Subject {    // 对此主题的所有观察者集合    private Vector<Observer> obs = new Vector<Observer>();    // 主题名称    private String name;    // 添加观察者    public synchronized void addObserver(Observer observer) {        if (!obs.contains(observer)) {            obs.addElement(observer);            System.out.println(this.getSubName() + "添加：" + observer.getName());        }    }    // 移除观察者    public synchronized void removeObserver(Observer observer) {        if (obs.contains(observer)) {            obs.removeElement(observer);        }    }    // 获取主题名称    public String getSubName() {        return this.name;    }    // 设置主题名称    public void setSubName(String name) {        this.name = name;    }    // 同步所有观察者数据    public void notifyAllObserver(Object data) {        Object[] allObs = obs.toArray();        for (int i = 0; i < allObs.length; i++) {            ((Observer) allObs[i]).update(this);        }    }}

拉模型的具体主题类

/** * 具体主题类 * @author: Yang Gao * @date: 2017-4-12 下午3:07:36 * @version: 1.0 */public class ConcreteSubject extends Subject {    private Object data;// 主题数据    public ConcreteSubject(String name) {        setSubName(name);    }    public Object getData() {        return data;    }    public void setData(Object data) {        this.data = data;    }    // 模拟主题数据变化    public void changeData(Object data) {        this.setData(data);        System.out.println(this.getSubName() + "新数据：" + this.getData());        this.notifyAllObserver(data);    }}

拉模型客户端，测试类

/** * 客户端 * @author: Yang Gao * @date: 2017-4-12 下午3:11:19 * @version: 1.0 */public class Client {    public static void main(String[] args) {        // 1.主题        ConcreteSubject subject = new ConcreteSubject("主题1");        // 2.观察者        Observer observer = new ConcreteObserver("观察者1");        Observer observer2 = new ConcreteObserver("观察者2");        // 3.观察者注册主题        subject.addObserver(observer);        subject.addObserver(observer2);        // 4.模拟主题数据变化，观察者自动同步数据        subject.changeData("new data");    }}

运行结果

两种模式的比较

• 推模型是假定主题对象知道观察者需要的数据；而拉模型是主题对象不知道观察者具体需要什么数据，没有办法的情况下，干脆把自身传递给观察者，让观察者自己去按需要取值。

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