java观察者模式之jdk的Observerable的实现

概念：

观察者模式：

观察者模式定义了对象之间的一对多依赖，这样一来，当一个对象改变状态时，它的所有依赖者都会收到通知并自动更新。–>以松耦合的方式在一系列对象之间沟通状态。

上一篇文章用自定义的代码进行了观察者模式的实现，这一篇文章主要讲解jdk的实现方式，并探究此模式在jdk中实现的优缺点：

业务场景：

有一个气象观测站，能够检测具体的气象数据，如温度，湿度和气压，现在有三个具体的显示面板，每当气象数据更新之后，观察者便能够通知到这三个显示面板实时更新数据。这个业务场景刚好符合我们的观察者模式，气象观测站是主题，而显示面板就是观察者。这次通过jdk内置的Observerable来实现业务：
首先是介绍jdk内置的类和接口：

1. public interface Observer {…}
   观察者需要实现的接口，里面就只有一个update方法，在接收到主题通知的时候进行调用

/*
package java.util;
public interface Observer {
    void update(Observable o, Object arg);
}

2. public class Observable {…}
   主题需要继承的类，里面的实现并不难。

package java.util;
public class Observable {
    private boolean changed = false;
    private Vector<Observer> obs;//使用线程安全的Vector类来存储观察者
    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);
    }

	//通知观察者，带参数
    public void notifyObservers(Object arg) {
        Object[] arrLocal;

        synchronized (this) {
            if (!changed)
                return;
            arrLocal = obs.toArray();
            clearChanged();
        }
	//循环遍历，并且在changed为true的时候才会通知
        for (int i = arrLocal.length-1; i>=0; i--)
            ((Observer)arrLocal[i]).update(this, arg);
    }
 	//删除观察者
    public synchronized void deleteObservers() {
        obs.removeAllElements();
    }
	//改变状态，为true才会通知观察者
    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();
    }
}

可以看出，jdk的实现并不难，主题只要去继承Observable 这个类，并在需要通知的地方，调用setChanged（）方法，然后调用notifyObservers（）方法即可，而观察者实现Observer 接口，实现自己的update方法就能达到目的。
下面看这个气象案例的实现代码：

• 具体主题：

package observer.weatherobservable;

import java.util.Observable;

/**
 * 主题，需要继承Observable类
 */
public class WeatherData extends Observable {
    private float temperature;
    private float humidity;
    private float pressure;

    public WeatherData() {

    }

    public void measurementsChanged(){
        setChanged();
        notifyObservers();
    }

    public void setMeasurements(float temperature, float humidity, float pressure) {
        this.temperature = temperature;
        this.humidity = humidity;
        this.pressure = pressure;
        measurementsChanged();
    }

    public float getTemperature() {
        return temperature;
    }

    public float getHumidity() {
        return humidity;
    }

    public float getPressure() {
        return pressure;
    }
}

• 显示面板需要实现的接口：

package observer.weatherobservable;
/**
 * 显示面板需要实现的接口，这个根据具体的场景设计
 */
public interface DisplayElement {
    public void display();
}

• 当前温度显示面板：

package observer.weatherobservable;

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

/**
 * 当前温度面板
 */
public class CurrentConditionsDisplay implements Observer, DisplayElement {
    private Observable observable;
    private float temperature;
    private float humidity;

    public CurrentConditionsDisplay(Observable observable) {
        this.observable = observable;
        observable.addObserver(this);
    }

    @Override
    public void display() {
        System.out.println("当前状态是 " + temperature
                + "华氏度 和 " + humidity + "% 湿度");
    }

    @Override
    public void update(Observable o, Object arg) {
        if (o instanceof WeatherData) {
            WeatherData weatherData = (WeatherData) o;
            this.temperature = weatherData.getTemperature();
            this.humidity = weatherData.getHumidity();
            display();
        }
    }
}

• 预报的显示面板：

package observer.weatherobservable;

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

/**
 * 预报的显示面板
 */
public class ForecastDisplay implements Observer, DisplayElement {
    private float currentPressure = 29.92f;
    private float lastPressure;

    public ForecastDisplay(Observable observable) {
        observable.addObserver(this);
    }

    @Override
    public void display() {
        System.out.print("预报: ");
        if (currentPressure > lastPressure) {
            System.out.println("温度正在上升!");
        } else if (currentPressure == lastPressure) {
            System.out.println("气温没有变化");
        } else if (currentPressure < lastPressure) {
            System.out.println("天气变冷了");
        }
    }
    
    @Override
    public void update(Observable o, Object arg) {
        if (o instanceof WeatherData) {
            WeatherData weatherData = (WeatherData) o;
            lastPressure = currentPressure;
            currentPressure = weatherData.getPressure();
            display();
        }
    }
}

• heat index的显示面板：

package observer.weatherobservable;

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

/**
 * heat index的显示面板
 */
public class HeatIndexDisplay implements Observer, DisplayElement {
    float heatIndex = 0.0f;

    public HeatIndexDisplay(Observable observable) {
        observable.addObserver(this);
    }

    public void update(Observable observable, Object arg) {
        if (observable instanceof WeatherData) {
            WeatherData weatherData = (WeatherData)observable;
            float t = weatherData.getTemperature();
            float rh = weatherData.getHumidity();
            heatIndex = (float)
                    (
                            (16.923 + (0.185212 * t)) +
                                    (5.37941 * rh) -
                                    (0.100254 * t * rh) +
                                    (0.00941695 * (t * t)) +
                                    (0.00728898 * (rh * rh)) +
                                    (0.000345372 * (t * t * rh)) -
                                    (0.000814971 * (t * rh * rh)) +
                                    (0.0000102102 * (t * t * rh * rh)) -
                                    (0.000038646 * (t * t * t)) +
                                    (0.0000291583 * (rh * rh * rh)) +
                                    (0.00000142721 * (t * t * t * rh)) +
                                    (0.000000197483 * (t * rh * rh * rh)) -
                                    (0.0000000218429 * (t * t * t * rh * rh)) +
                                    (0.000000000843296 * (t * t * rh * rh * rh)) -
                                    (0.0000000000481975 * (t * t * t * rh * rh * rh)));
            display();
        }
    }

    public void display() {
        System.out.println("Heat index 是 " + heatIndex);
    }
}

• 温度显示面板：

package observer.weatherobservable;

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

/**
 * 溫度顯示面板
 */
public class StatisticsDisplay implements Observer, DisplayElement {
    private float maxTemp = 0.0f;
    private float minTemp = 200;
    private float tempSum= 0.0f;
    private int numReadings;

    public StatisticsDisplay(Observable observable) {
        observable.addObserver(this);
    }

    public void update(Observable observable, Object arg) {
        if (observable instanceof WeatherData) {
            WeatherData weatherData = (WeatherData)observable;
            float temp = weatherData.getTemperature();
            tempSum += temp;
            numReadings++;

            if (temp > maxTemp) {
                maxTemp = temp;
            }

            if (temp < minTemp) {
                minTemp = temp;
            }

            display();
        }
    }

    public void display() {
        System.out.println("Avg/Max/Min temperature = " + (tempSum / numReadings)
                + "/" + maxTemp + "/" + minTemp);
    }
}

• 测试代码：

package observer.weatherobservable;

/**
 * 測試
 */
public class WeatherStationHeatIndex {
    public static void main(String[] args) {
        WeatherData weatherData = new WeatherData();
        CurrentConditionsDisplay currentConditions = new CurrentConditionsDisplay(weatherData);//当前状态是
        StatisticsDisplay statisticsDisplay = new StatisticsDisplay(weatherData);//Avg/Max/Min
        ForecastDisplay forecastDisplay = new ForecastDisplay(weatherData);//预报:
        HeatIndexDisplay heatIndexDisplay = new HeatIndexDisplay(weatherData);//Heat index 是

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

测试结果：

Heat index 是 82.95535
预报: 温度正在上升!
Avg/Max/Min temperature = 80.0/80.0/80.0
当前状态是 80.0华氏度 和 65.0% 湿度
Heat index 是 86.90124
预报: 天气变冷了
Avg/Max/Min temperature = 81.0/82.0/80.0
当前状态是 82.0华氏度 和 70.0% 湿度
Heat index 是 83.64967
预报: 气温没有变化
Avg/Max/Min temperature = 80.0/82.0/78.0
当前状态是 78.0华氏度 和 90.0% 湿度

当然，这个也能都得到我们想要的观察者模式的结果，当气象站检测天气数据变化时，各个显示面板都可以及时显示最新的气象数据.
但是，你会发现，得到的结果和我们添加观察者的顺序不一致，为什么呢？
仔细查看Observer 源码：你会发现它是倒着遍历集合的，哈哈，不知道为什么？

最后提及下 private boolean changed = false;这个变量的作用，这是为了在需要通知的时候才让我们通知，尽管主题发生了改变，只要这个变量没有更改，我们就无法进行通知。

最后总结下java.util.Observable这个类和Observer接口实现观察者模式的优缺点：

1. Observer是一个类，所以你必须设计一个类去继承这个类，而java的类是单一继承的，这个限制了我们的设计思路；
2. Observer的setchanged（）是protected的，就是说，你必须在其子类中才能将其进行更改，违反设计原则：多用组合，少用继承；
3. 通知观察者的方法是在主线程里面顺序执行的，加入哪一个观察者发了阻塞，后续的观察者都要进行等待，非常不友好；
4. 除了以上的缺点，剩下全是优点。
   鉴于以上的缺点，我们如果要解决上述问题，最后是自定义一个观察者模式的实现，如果可以接受上面的不足之处，我们便可以复用jdk的代码实现了