观察者模式（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(Subject subject) {
        System.out.println(this.name + "同步数据：" + subject.getData());
    }
}

拉模型的抽象主题类

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[] 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();
    }
}

拉模型客户端，测试类

/**
 * 客户端
 * @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()方法的参数是主题对象本身，这基本上是主题对象能传递的最大数据集合了，基本上可以适应各种情况的需要。