设计模式学习——观察者模式（Observer Pattern）

0. 前言

　　观察者模式在许多地方都能够用到，特别是作为MVC模式的一部分，在MVC中，模型（M）：存放数据，视图（V）：显示数据。当模型中的数据发生改变时，视图会得到通知，这是典型的观察者模式。

1. 定义

　　观察者模式：定义了一对多的关系，一个对象作为主题，它维护了一系列的依赖对象，当主题的状态发生改变时，会自动地通知依赖对象（通常通过调用依赖对象的方法来实现）。

　　官方定义：wiki

2. 应用

　　这里通过《Head first 设计模式》中的例子来实现观察者模式。这里有一个气象数据和公布栏，当气象数据发生改变时，会通知公布栏，使其更新数据。

源码：

主题Subject接口：

 package ObserverPattern;

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

观察者Observer接口

 package ObserverPattern;

 public interface Observer {
     public void update(Object obj);
 }

气象数据实现：

 package ObserverPattern;

 import java.util.ArrayList;
 import java.util.Iterator;

 public class WeatherData implements Subject {

     private ArrayList<Observer> observers = null;
     private double temperature;
     private double humidity;
     private double pressure;

     public WeatherData(  )
     {
         observers = new ArrayList<>();
     }

     public double getTemperature() {
         return temperature;
     }

     public double getHumidity() {
         return humidity;
     }

     public double getPressure() {
         return pressure;
     }

     public void SetWeather( double temperature, double humidity, double pressure )
     {
         this.temperature = temperature;
         this.humidity = humidity;
         this.pressure = pressure;
         mesurementsChanged();
     }

     public void mesurementsChanged()
     {
         notifyObservers();
     }

     @Override
     public void registerObserver(Observer observer) {
         observers.add(observer);
     }

     @Override
     public void removeObserver(Observer observer) {
         observers.remove(observer);
     }

     @Override
     public void notifyObservers() {

         for ( Iterator<Observer> iterator = observers.iterator();  iterator.hasNext(); ) {
             Observer observer = (Observer) iterator.next();
             observer.update(this);
         }
     }

 }

显示接口：

 package ObserverPattern;

 public interface DisplayBoard {
     public void display();
 }

公布栏实现：

 package ObserverPattern;

 public class CurrentWeatherBoard implements Observer, DisplayBoard {

     private double temperature;

     public CurrentWeatherBoard( Subject subject ) {
         subject.registerObserver(this);
     }

     @Override
     public void update(Object obj) {
         if ( obj instanceof WeatherData ) {
             WeatherData weatherData = (WeatherData)obj;
             this.temperature = weatherData.getTemperature();
             display();
         }
     }

     @Override
     public void display() {
         System.out.println(this.getClass().getName() + ":" +  this.temperature);
     }

 }

3. JDK中Observable类分析

　　在JDK中提供了Observable类以及Observer接口方便实现观察者模式，但是这里的主题是Observable是一个类，需要通过继承来实现，所以很大的限制了它的使用。

　　Observable类的添加观察者方法，通过synchronized实现同步，其Observable内部维护着一个Vector容器，用于存放观察者对象。　　

  public synchronized void addObserver(Observer o) {
         if (o == null)
             throw new NullPointerException();
         if (!obs.contains(o)) {
             obs.addElement(o);
         }
     }

　　

　　通知函数，这里会判断一个标识，所以在调用通知时需要先调用 setChanged 方法，然后将其观察者保存到一个数组中，这里会有一个问题，即当调用删除一个观察者的时候，如果正在调用notifyObservers时，依然会通知到被删除的观察者。对于添加来说也是一样的，会错过这一次的通知。

 public void notifyObservers(Object arg) {

         Object[] arrLocal;

         synchronized (this) {
             if (!changed)
                 return;
             arrLocal = obs.toArray();
             clearChanged();
         }

         for (int i = arrLocal.length-1; i>=0; i--)
             ((Observer)arrLocal[i]).update(this, arg);
     }