观察者模式（一）--《Head First DesignPattern》

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

我们先看下类图：

首先我们自己创建Subject接口，定义了注册观察者，移除观察者和通知观察者三个函数。

 package headfirst.observer.weather;

 public interface Subject {
     public void registerObserver(Observer o);
     public void removeObserver(Observer o);
     public void notifyObservers();
 }

而WeatherData实现了这个接口，内部维护的是一个ArrayList的Observer。

 package headfirst.observer.weather;

 import java.util.*;

 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 removeObserver(Observer o) {
         int i = observers.indexOf(o);
         if (i >= 0) {
             observers.remove(i);
         }
     }

     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 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;
     }
 }

DisplayElement接口只包含了一个方法，也就是display()。但布告板需要显示时，调用此方法。

 package headfirst.observer.weather;

 public interface DisplayElement {
     public void display();
 }

Observer接口定义了update函数，当Subject的内容发生改变时，会调用update函数来通知观察者更新状态值。

 package headfirst.observer.weather;

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

观察者需要存储Subject的引用，通过这个引用来进行注册。

 package headfirst.observer.weather;

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

     //构造函数的参数为Subject
     public CurrentConditionsDisplay(Subject weatherData) {
         this.weatherData = weatherData;
         //把自己注册给Subject
         weatherData.registerObserver(this);
     }

     //更新时调用相应的display函数
     public void update(float temperature, float humidity, float pressure) {
         this.temperature = temperature;
         this.humidity = humidity;
         display();
     }

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

其他两个差不多:

ForecastDisplay

 package headfirst.observer.weather;

 import java.util.*;

 public class ForecastDisplay implements Observer, DisplayElement {
     private float currentPressure = 29.92f;
     private float lastPressure;
     private WeatherData weatherData;

     public ForecastDisplay(WeatherData weatherData) {
         this.weatherData = weatherData;
         weatherData.registerObserver(this);
     }

     public void update(float temp, float humidity, float pressure) {
                 lastPressure = currentPressure;
         currentPressure = pressure;

         display();
     }

     public void display() {
         System.out.print("Forecast: ");
         if (currentPressure > lastPressure) {
             System.out.println("Improving weather on the way!");
         } else if (currentPressure == lastPressure) {
             System.out.println("More of the same");
         } else if (currentPressure < lastPressure) {
             System.out.println("Watch out for cooler, rainy weather");
         }
     }
 }

StatisticsDisplay

 package headfirst.observer.weather;

 import java.util.*;

 public class StatisticsDisplay implements Observer, DisplayElement {
     private float maxTemp = 0.0f;
     private float minTemp = 200;
     private float tempSum= 0.0f;
     private int numReadings;
     private WeatherData weatherData;

     public StatisticsDisplay(WeatherData weatherData) {
         this.weatherData = weatherData;
         weatherData.registerObserver(this);
     }

     public void update(float temp, float humidity, float pressure) {
         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);
     }
 }

HeadDisplay

 package headfirst.observer.weather;

 public class HeatIndexDisplay implements Observer, DisplayElement {
     float heatIndex = 0.0f;
     private WeatherData weatherData;

     public HeatIndexDisplay(WeatherData weatherData) {
         this.weatherData = weatherData;
         weatherData.registerObserver(this);
     }

     public void update(float t, float rh, float pressure) {
         heatIndex = computeHeatIndex(t, rh);
         display();
     }

     private float computeHeatIndex(float t, float rh) {
         float index = (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)));
         return index;
     }

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

接下来就是main函数了。

 package headfirst.observer.weather;

 import java.util.*;

 public class WeatherStationHeatIndex {

     public static void main(String[] args) {
         WeatherData weatherData = new WeatherData();
         CurrentConditionsDisplay currentDisplay = new CurrentConditionsDisplay(weatherData);
         StatisticsDisplay statisticsDisplay = new StatisticsDisplay(weatherData);
         ForecastDisplay forecastDisplay = new ForecastDisplay(weatherData);
         HeatIndexDisplay heatIndexDisplay = new HeatIndexDisplay(weatherData);

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

可以看到这里实现的Observer模式有两个要注意的地方

1. “推”模式，Subject内容一有变化，就主动向Observer推送消息。它是通过在Subject中的notifyObservers中对每个Observer调用update来实现的。如果要实现“拉”模式，因为在Observer保存了Subject的引用，所以可以通过定时的方式，向Subject拉取数据。
2. 可以看到update函数是依赖于具体实现的，可以看到参数是什么温度，湿度等等。这样的接口是无法面向所有的应用的。不过Java内置了观察者模式相关的接口，可以在下一篇看到相关的实现。