观察者模式

观察者模式定义了对象之间的一对多依赖，当一个对象改变状态，它的所有依赖者都会收到通知并自动更新。

主题和观察者定义了一对多的关系。观察者依赖于此主题，只要主题状态一有变化。观察者就会被通知。

利用观察者模式，主题是具有状态的对象，是真正拥有数据的对象，并且可以控制这些状态。另一方面，观察者使用这些状态，虽然这些状态并不属于他们。

设计原则：保证交互对象之间的松耦合，将彼此依赖降到最低。

需求实例：利用主题WeatherData对象取得目前天气状况（温度、湿度，气压）数据，并建立三个布告板显示目前的状况、气象统计和天气预报。当WeatherData获得最新数据，三个布告板必须实时更新。

方法一：自己实现一整套观察者模式

1、建立接口

//主题接口
    //代码的复用性
public interface Subject {
    //注册观察者
    public void registerObserver(Observer o);
    //删除观察者
    public void removeObserver(Observer o);
    //通知观察者
    public void notifyObserver();
}

//观察者接口
public interface Observer {
   //更新观察者状态
    public void update(float temp,float humidity,float pressure);
}

//布告板展示接口
public interface DisplayElement {
    public void display();
}

2、具体实现类
关于观察者的一切，主题只知道观察者实现了某个接口，不需要知道观察者的具体类是谁。当有新类型的观察者出现时，主题的代码不需要修改。主题只会发送通知给所有实现了观察者接口的对象。

//主题实现类
public class WeatherData implements Subject {
    //主题唯一依赖的是一个实现Observer接口的观察者对象列表
    //使用该列表可以方便增加和删除观察者
    private ArrayList observers;
    //主题的状态信息
    private float temp;
    private float humidity;
    private float pressure;

    //利用构造函数对list引用实例化
    public WeatherData(){
        observers=new ArrayList();
    }

    //注册观察者
    public void registerObserver(Observer o) {
        observers.add(o);
    }

    //删除观察者
    public void removeObserver(Observer o) {
        int i=observers.indexOf(o);
        if(i>0){
            observers.remove(i);
        }
    }

    //通知观察者
    public void notifyObserver() {
        for(int i=0;i<observers.size();i++){
            Observer observer=(Observer)observers.get(i);
            observer.update(temp,humidity,pressure);
        }
    }

    //更新观测值时，通知观察者
    public void measurementChanged(){
        notifyObserver();
    }

    //更新观测值
    public void setMeasurement(float temp,float humidity,float pressure){
        this.temp=temp;
        this.humidity=humidity;
        this.pressure=pressure;
        measurementChanged();
    }

}

当有新的具体类需要当观察者，不需要为了兼容新类型而修改主题的代码，在主题中，将这部分变换的代码封装起来。我们所要做的就是在新的类里实现此观察者接口，然后注册为观察者即可。

//当前状态布告板实现类，其他两个布告板类似
public class CurrentConditionDisplay implements Observer,DisplayElement {
    //要显示的信息
    private float tmp;
    private float humidity;
    private float pressure;
    //主题引用
    private Subject weatherData;

    //利用构造器,实现一个主题对象，方便后面注册和取消观察者
    public CurrentConditionDisplay(Subject weatherData){
        this.weatherData=weatherData;
        //注册观察者
        weatherData.registerObserver(this);
    }

    //更新状态数据

    public void update(float temp, float humidity, float pressure) {
        //对于不同的布告板，并不一定所有数据都是有用的
        this.tmp=temp;
        this.humidity=humidity;
        //展示数据
        display();
    }

    public void display() {
        System.out.println("Current condition: "+tmp);
    }
}

测试运行

public class WeatherStation {
    public static void main(String[] args) {
        //建立一个主题对象
        WeatherData weatherData=new WeatherData();
        //建立布告板对象
        CurrentConditionDisplay current=new CurrentConditionDisplay(weatherData);

        //改变主题的状态
        weatherData.setMeasurement(90,65,44.54f);
    }
}
//结果
Current condition: 90.0

通过上例，主题主动推送所有的状态数据给每个观察者，但是如果某个观察者只是需要一点点数据，就会被强迫收到一堆数据。

方法二、利用Java内置的观察者模式
内置的观察者模式可以由观察者主动拉取（pull）数据，也可以由主题主动推送（push）数据。

java.util.Observable 类与主题很类似，只要继承Observable，就会继承一些增加、删除、通知观察者的方法以及其他方法。

//java.util.Observable类中代码
public class Observable {
    private boolean changed = false;
    private Vector<Observer> obs;
    public Observable() {
        obs = new Vector<>();
    }
     public synchronized void addObserver(Observer o) {
        if (o == null)
            throw new NullPointerException();
        if (!obs.contains(o)) {
            obs.addElement(o);
        }
    }
    public synchronized void deleteObserver(Observer o) {
        obs.removeElement(o);
    }
    //从主题（可观测者）中拉取数据
    public void notifyObservers() {
        notifyObservers(null);
    }
    //推送数据给观察者，将数据当做数据对象传递给notifyObservers
     public void notifyObservers(Object arg) {
        Object[] arrLocal;
         synchronized (this) {
         if (!changed)
                return;
            arrLocal = obs.toArray();
            clearChanged();
        }

        for (int i = arrLocal.length-1; i>=0; i--)
      //方法签名update与之前有差异update(Observable,dataObject)
            ((Observer)arrLocal[i]).update(this, arg);
    }
    public synchronized void deleteObservers() {
        obs.removeAllElements();
    }
    //标记状态已经改变的事实。保证适当地通知观察者
    protected synchronized void setChanged() {
        changed = true;
    }
    protected synchronized void clearChanged() {
        changed = false;
    }
    public synchronized boolean hasChanged() {
        return changed;
    }
    public synchronized int countObservers() {
        return obs.size();
    }
}

1、继承Observable类，重写主题（可观察者）WeatherData

import java.util.Observable;
import java.util.Observer;

public class WeatherNewData extends Observable {
    //状态信息
    private float tmp;
    private float humidity;
    private float pressure;

    //不再需要保存观察者的列表list，因为从Observable中继承了
    public WeatherNewData(){}

    //改变状态信息
    public void setmeasurement(float tmp,float humidity,float pressure){
        this.tmp=tmp;
        this.humidity=humidity;
        this.pressure=pressure;
        //通知观察者
        measureChanged();
    }
    public void measureChanged(){
        //先检查状态值是否发生改变
        setChanged();
        //不传参数，由观察者自己拉取数据
        notifyObservers();

    }

    //拉取数据，所以要提供get方法
    public float getTmp() {
        return tmp;
    }

    public float getHumidity() {
        return humidity;
    }

    public float getPressure() {
        return pressure;
    }
}

实现java.util.Observer接口，可以把对象变成观察者。

//java.util.Observer接口，只有一个方法
public interface Observer {
   void update(Observable o, Object arg);
}

2、观察者实例

import java.util.Observable;
import java.util.Observer;

public class CurrentNewConditionDisplay implements Observer, DisplayElement{
    //状态信息,并不是所有的信息
    private float tmp;
    private float humidity;
    //主题（可观察者）引用
    private Observable observable;

    //注册观察者
    public CurrentNewConditionDisplay(Observable obs){
        this.observable=obs;
        observable.addObserver(this);
    }

    public void update(Observable observable,Object arg) {
        if(observable instanceof WeatherNewData){
            WeatherNewData weatherNewData=new WeatherNewData();
            //拉取数据
            this.tmp=weatherNewData.getTmp();
            this.humidity=weatherNewData.getHumidity();
            display();
        }

    }

    public void display() {
        System.out.println("");
    }
}

在观察者模式中，会改变的是主题的状态，已经观察者的数目和类型。将变化部分和不变部分分离，使用观察者模式，可以改变依赖于主题状态的对象，却不必改变主题。

主题和观察者都使用接口，观察者利用主题的接口向主题注册；而主题利用观察者的接口通知观察者。