《Head First 设计模式》之观察者模式——天气显示

观察者模式（Observer）

　　——在对象之间定义一对多的依赖，这样一来，当一个对象改变状态，依赖它的对象都会收到通知，并自动更新。

（出版者Subject+订阅者Observer=观察者模式）

• 特点：定义并维护对象之间的一对多关系

• 原则：为交互对象之间的松耦合设计而努力

• 示例（气象站类图）

三个接口：

public interface Subject{
    public void registerObserver(Observer o);//注册观察者
    public void removeOberver(Observer o);//删除观察者
    public void notifyObserver();//通知观察者
}

public interface Observer{
    public void update(float temp, float humidity, float pressure);
}

public interface DisplayElement{
    public void display();
}

在WeatherData中实现主题接口：

public class WeatherData implements Subject{
    private ArrayList observers;//记录观察者
    private float temperature;
    private float humidity;
    private float pressure;
    
    public WeatherData(){
        observers = new ArrayList();
    }
    
    public void registerObserver(Observer o){//注册观察者
        observers.add(o);
    }
    public void removeOberver(Observer o){//删除观察者
        int i = observers.indexOf(o);
        if(i >= 0){
            observers.remove(0);
        }
    }
    public void notifyObservers(){
        for(int i = 0; i < observers.size(); i++){ //通知每一个观察者
            Observer observer = (Observer)observers.get(i);
            observer.update(temperature, humidity, pressure);
        }
    }
    public void measurementsChanged(){
        notifyObservers();
    }
    public void setMeasurements(float temp, float hum, float pre){
        this.temperature = temp;
        this.humidity = hum;
        this.pressure = pre;
        measurementsChanged();
    }
}

实现CurrentConditionDisplay.java

public class CurrentConditionsDisplay implements Observer, DisplayElement{
    private float temperature;
    private float humidity;
    private Subject weatherData;
    
    public CurrentConditionsDisplay(Subject weatherData){//构造器需要weatherData对象作为注册之用
        this.weatherData = weatherData;
        weatherData.registerObserver(this);
    }
    public void update(float temp, float humidity, float pressure){
        this.temperature = temp;
        this.humidity = humidity;
        display();
    }
    public void display(){
        //输出
    }
}

测试程序：

public class WeatherStation {

        public static void main(String[] args) {
            WeatherData weatherData = new WeatherData();//建立weatherData对象

            CurrentConditionsDisplay currentDisplay = new CurrentConditionsDisplay(weatherData);
            StatisticsDisplay statisticsDisplay = new StatisticsDisplay(weatherData);
            ForecastDisplay forecastDisplay = new ForecastDisplay(weatherData);//将对象传给三个Observer，即add观察者

            weatherData.setMeasurements(80, 65, 30.4f);
            weatherData.setMeasurements(82, 70, 29.2f);
            weatherData.setMeasurements(78, 90, 29.2f);
        }
    }

 

---

 

Java内置的观察者模式

　　上述示例实现信息由Subject “推送（push）” 至Observer，使用Java内置的观察者模式可以使用推（push）或拉（pull）的方式传送数据。不同的是WeatherData现在扩展自Observable类，并继承到一些add、delete、notify观察者的方法。

Subject -> java.util.Observable(类)

Observer -> java.util.Observer(接口)

Observable如何送出通知？

　　首先需要利用扩展 java.util.Observable 接口产生“可观察者”类（想要进行通知，则必须调用Observable类的setChanged方法，但是Observable的setChanged方法为protected，故只能使用继承来实现自己的主题对象），然后：

1. 调用setChanged()，标记状态已经改变的事实；
2. 调用notifyObservers()中的一个：notifyObservers() 或 notifyObservers(Object arg)

Observer如何接收通知？

update(Observable o, Object arg)  ：主题Observable作为第一变量，好让观察者知道是哪个主题通知它的。Object arg正是传入notifyObservers(Object arg)的数据对象，如果没有说明则为空。

若想push数据给观察者，可以把数据作数据对象传送给notifyObservers(Object arg)方法。否则，观察者就必须从可观察者对象中pull数据。如何拉数据？

 WeatherData.java

public class WeatherData extends Observable{
    private float temperature;
    private float humidity;
    private float pressure;
    
    public WeatherData(){ } //无需建立观察者列表ArrayList了
    public void measurementsChanged(){
        setChanged();//状态已经改变
        notifyObservers();//pull
    }
    public void setMeasurements(float temp, float hum, float pre){
        this.temperature = temp;
        this.humidity = hum;
        this.pressure = pre;
        measurementsChanged();
    }
    public float getTemperature(){
        return temperature;
    }
    public float gethumidity(){
        return humidity;
    }
    public float getpressure(){
        return pressure;
    }
}

CurrentConditionDisplay.java

public class CurrentConditionsDisplay implements Observer, DisplayElement{
    private float temperature;
    private float humidity;
    Observable observable;
    
    public CurrentConditionsDisplay(Observable observable){
        this.observable = observable;
        observable.addObserver(this);
    }
    public void update(Observable o, Object arg){
        if(o instanceof WeatherData){
            WeatherData weatherData = (WeatherData)o;
            this.temperature = weatherData.getTemperature();
            this.humidity = weatherData.gethumidity();
            display();
        }
    }
    public void display(){
        //输出
    }
}

notice：

1. 不想推送的时候，不调用setChanged()方法即可
2. 通知顺序不依赖于注册的顺序（即主题通知观察者的顺序与添加观察者的顺序无关）
3. setChanged()方法的必要性：若无，则温度计读数每十分之一度就会更新，造成WeatherData对象持续不断地通知观察者。若希望温差达到半度时更新，就调用setChanged()。有更多的弹性，更适当地通知观察者。

使用Java自带的观察者模式的缺点：

1. Observable是一个类，而不是一个接口，导致Observable类的扩展性不高，不如自己实现的观察者模式灵活
2. Observable将某些方法保护了起来(setChanged()和clearChanged()为protected)，这意味着除非继承自Observable，否则将有关键的方法不能调用。导致无法通过组合的方式使其它类获得Observable类的功能。违反了设计原则“多用组合，少用继承”。