概念：
观察者模式：
观察者模式定义了对象之间的一对多依赖，这样一来，当一个对象改变状态时，它的所有依赖者都会收到通知并自动更新。–>以松耦合的方式在一系列对象之间沟通状态。
上一篇文章用自定义的代码进行了观察者模式的实现，这一篇文章主要讲解jdk的实现方式，并探究此模式在jdk中实现的优缺点：
业务场景：
有一个气象观测站，能够检测具体的气象数据，如温度，湿度和气压，现在有三个具体的显示面板，每当气象数据更新之后，观察者便能够通知到这三个显示面板实时更新数据。这个业务场景刚好符合我们的观察者模式，气象观测站是主题，而显示面板就是观察者。这次通过jdk内置的Observerable来实现业务：
首先是介绍jdk内置的类和接口：
- public interface Observer {…}
观察者需要实现的接口，里面就只有一个update方法，在接收到主题通知的时候进行调用
/*
package java.util;
public interface Observer {
void update(Observable o, Object arg);
}
- 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接口实现观察者模式的优缺点：
- Observer是一个类，所以你必须设计一个类去继承这个类，而java的类是单一继承的，这个限制了我们的设计思路；
- Observer的setchanged（）是protected的，就是说，你必须在其子类中才能将其进行更改，违反设计原则：多用组合，少用继承；
- 通知观察者的方法是在主线程里面顺序执行的，加入哪一个观察者发了阻塞，后续的观察者都要进行等待，非常不友好；
- 除了以上的缺点，剩下全是优点。
鉴于以上的缺点，我们如果要解决上述问题，最后是自定义一个观察者模式的实现，如果可以接受上面的不足之处，我们便可以复用jdk的代码实现了
扫一扫
4345
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
