headFirst设计模式——观察者模式

一、介绍

　　观察者（Observer）模式可以帮你的对象知悉现况，不会错过该对象感兴趣的事。

　　对象甚至在运行时可决定是否要继续被通知。以及一对多关系，和松耦合。

　　有了观察者，你将会消息灵通。

　　观察者模式定义了对象之间的一对多依赖，这样一来当一个对象改变状态时，

　　它的所有依赖着都会收到通知并自动更新。

　　实现观察者模式的方法不止一种，但是以包含Subject和Observer接口的类设计的做法最常见。

 

二、引入

　　恭喜贵公司获选为敝公司建立下一代Internet气象观测站！

　　该气象站必须建立在我们专利申请中的WeatherData对象

　　上，由WeatherData对象负责追踪目前的天气状况（温度、

　　湿度、气压）。我们希望贵公司能建立一个应用，有三种

　　布告板，分别显示目前的状况、气象统计及简单的预报。

　　当WeatherObject对象获得最新的测量数据时，三种布告板

　　必须实时更新。

　　而且，这是一个可以扩展的气象站，Weather-O-Rama气象

　　站希望公布一组API，好让其他开发人员可以写出自己的

　　气象布告板，并插入此应用中。我们希望贵公司能提供这

　　样的API。

　　Weather-O-Rama气象站有很好的商业营运模式：一旦客

　　户上钩，他们使用每个布告板都要付钱。最好的部分就是，

　　为了感谢贵公司建立此系统，我们将以公司的认股权支付

　　你。

　　我们期待看到你的设计和应用的alpha版本。

　　

　　WeatherData对象知道如何跟物理气象站联系，以取得更新的数据。WeatherData对象随即更新三个布告板的显示：目前状况（温度、湿度、气压）、气象统计和天气预报。

　　我们的工作就是建立一个应用，利用WeatherData对象取得数据，并更新三个布告板：目前状况、气象统计和天气预报。

　　

 　　

　　

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

　　报纸的订阅 出版者+订阅者=观察者模式

　　出版者改称为“主题”（Subject），订阅者改称为“观察者”（Observe）。

　　

 

 

 

 

设计原则：

　　1、为了交互对象之间的松耦合设计而努力。

　　松耦合的设计之所以能让我们建立有弹性的OO系统，能够应对变化，是因为对象之间的互相依赖降到了最低。

 

 三、实现

　　

 

　　Java为观察者模式提供了内置支持，但是许多时候，自己建立这一切会更具弹性。

　　主题

public interface Subject {

    public void registerObserver(Observer o);
    
    public void removeObserver(Observer o);
    
    public void notifyObservers();
}

　　主题实现类

public class WeatherData implements Subject{
    private ArrayList<Observer> observers;
    private float temperature;
    private float humidity;
    private float pressure;

//        我们加上一个ArrayList来纪录观察者，此ArrayList是在构造器中建立的。
    public WeatherData(){
        observers = new ArrayList<Observer>();
    }
    
    @Override
    public void registerObserver(Observer o) {
        observers.add(o);
    }

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

    @Override
    public void notifyObservers() {
        // 在这里，我们把状态告诉每一个观察者。因为观察者都实现了update()，所以我们知道如何通知它们。
        for (int i = 0; i < observers.size(); i++) {
            Observer observer = observers.get(i);
            observer.update(temperature, humidity, pressure);
        }
    }

    public void measurementsChanged(){
        // 当从气象站得到更新观测值 时，我们通知观察者。 
        notifyObservers();
    }
    
    public void setMeasurements(float temperature, float humidity, float pressure) {//模拟从气象站收到数据
         this.temperature = temperature;
         this.humidity = humidity;
         this.pressure = pressure;
         measurementsChanged();
    }
    
}

　　观察者

public interface Observer {

//    暗示：这些观测值的种类和个数在未来有可能改变吗？如果以后会改变，这些变化是否被很好地封装？或者是需要修改许多代码才能办到？
    public void update(float temp, float humidity, float pressure);
}

　　每个观察者必须实现的接口

public interface DisplayElement {

    public void display();
}

　　观察者实现类

public class CurrentConditionsDisplay implements DisplayElement, Observer {
    private float temperature;
    private float humidity;
    private Subject weatherData;

    // 构造器需要 weatherData对象（也就是主题）作为注册用。
    public CurrentConditionsDisplay(Subject weatherData) {
        this.weatherData = weatherData;
        weatherData.registerObserver(this);
    }

    @Override
    public void update(float temperature, float humidity, float pressure) {
        this.temperature = temperature;
        this.humidity = humidity;
        display();                    // 这里并不是调用display()最合适的地方。
    }

    @Override
    public void display() {
        System.out.println("Current conditions: "+ temperature +
            "F degrees and " + humidity +"%humidity");
    }

}

　　测试

public class WeatherStation {

    public static void main(String[] args) {
        // 主题
        WeatherData weatherData = new WeatherData();
        // 订阅者 向 主题 注册
        CurrentConditionsDisplay currentDisplay = new CurrentConditionsDisplay(weatherData);    // Subject引用可能在取消订阅时用到。
        
        // 模拟从气象站取得数据
        weatherData.setMeasurements(80, 65, 30.4f);   // Current conditions: 80.0F degrees and 65.0%humidity
    }
}

 

 

 四、变化

　　JohnnyAHurricane（Weather-O-Rama气象站的CEO）刚刚来电告知，他们还需要酷热指数（HeatIndex）布告板，这是不可或缺的。

　　细节如下：

　　酷热指数是一个结合温度和湿度的指数，用来显示人的温度感受。可以利用温度T和相对湿度RH套用下面的公式来计算酷热指数：

 　　一个关于温度和相对湿度的计算公式。

　

　　新注册一个观察者HeadIndexDisplay

public class HeatIndexDisplay implements Observer, DisplayElement {
    private float tempreture;
    private float humidity;
    private Subject weatherData;
    
    public HeatIndexDisplay(Subject weatherData) {
        this.weatherData = weatherData;
        weatherData.registerObserver(this);
    }

    @Override
    public void display() {
        float T = tempreture;
        float RH = humidity;
                // 公式不对
        float heatIndex =
                (float) (16.923 + 1.85212 * 10-1 * T + 5.37941 * RH - 1.00254 * 10-1 * T 
        * RH + 9.41695 * 10-3 * T*T + 7.28898 * 10-3 * RH*RH + 3.45372 * 10-4
        * T*T * RH - 8.14971 * 10-4 * T * RH*RH + 1.02102 * 10-5 * T*T * RH*RH - 
        3.8646 * 10-5 * T*T*T + 2.91583 * 10-5 * RH*RH*RH + 1.42721 * 10-6 * T*T*T * RH 
        + 1.97483 * 10-7 * T * RH*RH*RH - 2.18429 * 10-8 * T*T*T * RH*RH + 8.43296 * 
        10-10 * T*T * RH*RH*RH - 4.81975 * 10-11 * T*T*T * RH*RH*RH);
        
        System.out.println("HeadIndex is" + heatIndex);
    }

    @Override
    public void update(float tempreture, float humidity, float pressure) {
        // TODO Auto-generated method stub
        this.tempreture = tempreture;
        this.humidity = humidity;
        display();

    }

}

　　

五、讨论

 　　主题和观察者就 使观察者获得状态信息的正确方式：

　　1、主题主动推送数据

　　　  方便不需要再去拉数据，但是有时候不需要的也会推送过来。

　　2、观察者主动取数据

 　　　 用时去取，主题需要封装、再开放setter避免暴露过多信息。

 　　java内置Observer这两种都支持。

 　　java.util包（package）内包含最基本的Observer接口与Observable类，这和Subject接口与Observer接口很相似。

　　Observer接口与Observable类使用上更方便，因为许多功能都已经事先准备好了。

　　甚至可以使用推（push）或拉（pull）的方式传送数据。

 　　

 　　setChanged()方法的作用：

　　　　setChanged()方法可以让你在更新观察者时，有更多的弹性，你可以更适当地通知观察者。

　　比方说，如果没有setChanged()方法，我们的气象站测量是如此敏锐，以致于温度计读数每十分之一度就会更新，

　　这会造成WeatherData对象持续不断地通知观察者，我们并不希望看到这样的事情发生。

　　如果我们希望半度以上才更新，就可以在温度差距到达半度时，调用setChanged()，进行有效的更新。

 　　主题

public class WeatherData extends Observable{
    
    private float temperature;
    private float humidity;
    private float pressure;
    
//    "拉"察者会利用这些方法取得WeatherData对象的状态
    public float getTemperature() {
        return temperature;
    }

    public float getHumidity() {
        return humidity;
    }

    public float getPressure() {
        return pressure;
    }

    public void setMeasurements(float temperature, float humidity, float pressure) {
         this.temperature = temperature;
         this.humidity = humidity;
         this.pressure = pressure;
         measurementsChanged();
    }
    
    public void measurementsChanged(){
        setChanged();
        notifyObservers();  //注意：我们没有调用notifyObservers()传送数据对象，这表示我们采用的做法是“拉”。
    }
}

　　观察者

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

public class CurrentConditionsDisplay implements Observer,DisplayElement {
    
    private float temperature;
    private float humidity;
    Observable o;
    
    public CurrentConditionsDisplay(Observable o) {
        this.o = o;
        o.addObserver(this);
    }
    
    @Override
    public void update(Observable obs, Object arg) {
        if(obs instanceof WeatherData){
            WeatherData weatherData = (WeatherData) obs;
            this.temperature = weatherData.getTemperature();
            this.humidity = weatherData.getHumidity();
            display();
        }
    }
    @Override
    public void display() {
        System.out.println("Current conditions: "+ temperature +
            "F degrees and " + humidity +"%humidity");
    }

}

 

 　　内置观察者模式的问题：

 　　　　1、通知观察者的次序不一定是其注册的次序。

　　　　 可以确定的是，如果我们的代码依赖之前的次序，就是错的。

　　　　一旦观察者/可观察者的实现有所改变，通知次序就会改变，很可能产生错误的结果，也不是我们所认为的松耦合。

　　　　2、java.util.Observable是一个类而不是一个接口

　　　　如果某类想同时具有Observable类和另一个超类的行为，就会陷入两难，毕竟Java不支持多重继承。

　　　　这限制了Observable的复用潜力（而增加复用潜力不正是我们使用模式最原始的动机吗？）。

　　　　再者，因为没有Observable接口，所以你无法建立自己的实现，和Java内置的Observer API搭配使用。

　　　　3、Observable将关键的方法保护起来

　　　　如果你看看Observable API，你会发现setChanged()方法被保护起来了（被定义成protected）。

　　　　这意味着：除非你继承自Observable，否则你无法创建Observable实例并组合到你自己的对象中来。

　　　　这个设计违反了第二个设计原则：“多用组合，少用继承”。

 

六、总结

　　

　　观察者模式定义了对象之间一对多的关系。

 

　　主题（也就是可观察者）用一个共同的接口来更新观察者。

 

　　观察者和可观察者之间用松耦合方式结合（loosecoupling），可观察者不知道观察者的细节，只知道观察者实现了观察者接口。

 

　　使用此模式时，你可从被观察者处推（push）或拉（pull）数据（然而，推得方式被认为更“正确”）。

 

　　有多个观察者时，不可以依赖特定的通知顺序。

 

　　Java有多种观察者模式的实现，包括了通用的java.util.Observable。

 

　　要注意java.util.Observable所带来的的一些问题。

 

　　如果有必要的话，可以实现自己的Observable。

　　

　　设计原则：

　　　　1、封装变化

　　　　2、多用组合，少用继承

　　　　3、针对接口编程，不针对实现编程

　　　　4、为交互之间的松耦合设计儿努力       // 新原则

 

 　　『观察者模式』Obverse Pattern 在对象之间定义一对多的依赖，这样一来，当一个对象改变状态，依赖它的其他对象都会收到通知，并自动更新。

 

　　 一个新的模式，以松耦合方式在一系列对象之间沟通状态。我们目前还没看到观察者模式的代表人物——MVC。