Java设计模式之观察者模式的两种实现

     观察者模式就是定义对象之间的一对多依赖，这样一来，当一个对象状态发生改变时，它的所有依赖者都会收到通知并自动更新。  这样的好处就是两个或多个对象之间松耦合，它们依然可以交互，但不太清楚彼此的细节。观察者模式提供了一种对象的设计，让主题和观察者之间松耦合。松耦合的设计可以让我们建立有弹性的OO系统，能够应对变化，是因为对象之间的互相依赖降到了最低。

      现在我们用一个简单的案例来熟悉观察者模式是怎么实现的。我们设计一个气象站，气象站提供天气数据，天气数据更新后，要实时显示在公告板上。

我们分别用自定义的观察者模式和Java内置的观察者模式两种方式来实现。首先是第一种。

定义主题接口，所有的主题都实现主题接口

package com.example.demo.observer.customize;

/**
 * 主题对象
 */
public interface Subject {

    /**
     * 添加观察者
     * @param observer
     */
    public void addObserver(Observer observer);

    /**
     * 删除指定观察者
     * @param observer
     */
    public void deleteObserver(Observer observer);

    /**
     * 通知所有观察者
     */
    public void notifyObservers();


}

实现我们的主题类，也就是我们的被观察者

    package com.example.demo.observer.customize;
    
    import java.util.ArrayList;
    
    /**
     * 被观察者对象，实现主题接口
     */
    public class WeatherData implements Subject {
    
         //温度
        private float temperature;
        //湿度
        private float humidity;
        //气压
        private float airpressure;

        //观察者列表
        private ArrayList<Observer> observerArrayList;
    
        public WeatherData() {
            this.observerArrayList = new ArrayList<Observer>();
        }
    
        /**
         * 添加指定观察者对象
         * @param observer
         */
        @Override
        public void addObserver(Observer observer) {
            this.observerArrayList.add(observer);
        }
    
        /**
         * 删除指定观察者对象
         * @param observer
         */
        @Override
        public void deleteObserver(Observer observer) {
            int i;
            if((i = observerArrayList.indexOf(observer)) != -1) {
                this.observerArrayList.remove(i);
            }
        }
    
        /**
         * 通知观察者
         */
        @Override
        public void notifyObservers() {
            for(Observer observer : this.observerArrayList) {
                observer.update(this.temperature, this.humidity, this.airpressure);
            }
        }
    
        /**
         * 被观察者数据发生改变
         * @param temperature
         * @param humidity
         * @param airpressure
         */
        public void setMeasurements(float temperature, float humidity, float airpressure) {
            this.temperature = temperature;
            this.humidity = humidity;
            this.airpressure = airpressure;
            this.measurementsChanged();
        }
    
        /**
         * 修改后，通知观察者
         */
        public void measurementsChanged() {
            this.notifyObservers();
        }
    }

定义我们的观察者接口，所有的观察者都实现此接口，称为观察者对象

package com.example.demo.observer.customize;

/**
 * 观察者接口
 */
public interface Observer {

    /**
     * 调用观察者者更新接口
     * @param temperature
     * @param humidity
     * @param airpressure
     */
    public void update(float temperature, float humidity, float airpressure);
}

定义一个公告板显示接口，观察者要实现此接口来显示在公告板上

package com.example.demo.observer.customize;

public interface DisplayElement {

    public void display();
}

定义观察者对象：观察者对象，在初始化构造的时候，注册主题（成为观察主题的对象）

package com.example.demo.observer.customize;

public class CurrentConditionsDisplay implements Observer, DisplayElement {

    private float temperature;
    private float humidity;
    private float airpressure;
    private Subject subject;

    public CurrentConditionsDisplay(Subject subject) {
        this.subject = subject;
        this.subject.addObserver(this);
    }

    @Override
    public void update(float temperature, float humidity, float airpressure) {
        this.temperature = temperature;
        this.humidity = humidity;
        this.airpressure = airpressure;
        this.display();
    }

    @Override
    public void display() {
        System.out.println("气温："+ this.temperature+"\t"+"湿度："+this.humidity+"\t"+"气压："+this.airpressure);
    }
}

package com.example.demo.observer.customize;

public class ForecastDisplay implements Observer, DisplayElement {

    private float temperature;
    private float humidity;
    private float airpressure;
    private Subject subject;

    public ForecastDisplay(Subject subject) {
        this.subject = subject;
        this.subject.addObserver(this);
    }

    @Override
    public void update(float temperature, float humidity, float airpressure) {
        this.temperature = temperature;
        this.humidity = humidity;
        this.airpressure = airpressure;
        this.display();
    }

    @Override
    public void display() {
        System.out.println("气温："+ this.temperature+"\t"+"湿度："+this.humidity+"\t"+"气压："+this.airpressure);
    }
}

package com.example.demo.observer.customize;

public class StatisticsDisplay implements Observer, DisplayElement {

    private float temperature;
    private float humidity;
    private float airpressure;
    private Subject subject;

    public StatisticsDisplay(Subject subject) {
        this.subject = subject;
        this.subject.addObserver(this);
    }

    @Override
    public void update(float temperature, float humidity, float airpressure) {
        this.temperature = temperature;
        this.humidity = humidity;
        this.airpressure = airpressure;
        this.display();
    }

    @Override
    public void display() {
        System.out.println("气温："+ this.temperature+"\t"+"湿度："+this.humidity+"\t"+"气压："+this.airpressure);
    }
}

测试我们的观察者模式

package com.example.demo.observer.customize;

public class WeatherMain {

    public static void main(String[] args) {

        //被观察者
        WeatherData weatherData = new WeatherData();

        //观察者对象
        CurrentConditionsDisplay conditionsDisplay = new CurrentConditionsDisplay(weatherData);
        StatisticsDisplay statisticsDisplay = new StatisticsDisplay(weatherData);
        ForecastDisplay forecastDisplay = new ForecastDisplay(weatherData);

        weatherData.setMeasurements(80, 85, 90);

    }
}

第二种实现方式，用Java的内置的API实现观察者模式，主题对象继承Observable类，观察者对象实现Observer接口即可和以上方法类似。修改我们的主题对象。

package com.example.demo.observer.internal;

import java.util.Observable;

public class WeatherData extends Observable {

    private float temperature;
    private float humidity;
    private float airpressure;

    public WeatherData() {
    }

    /**
     * 被观察者数据发生改变
     * @param temperature
     * @param humidity
     * @param airpressure
     */
    public void setMeasurements(float temperature, float humidity, float airpressure) {
        this.temperature = temperature;
        this.humidity = humidity;
        this.airpressure = airpressure;
        this.measurementsChanged();
    }

    /**
     * 修改后，通知观察者
     */
    public void measurementsChanged() {
        super.setChanged();
        super.notifyObservers();
    }

    public float getTemperature() {
        return temperature;
    }

    public float getHumidity() {
        return humidity;
    }

    public float getAirpressure() {
        return airpressure;
    }

}

Observable可以主动推（push）数据给观察者对象，也可以让观察者对象拉（pull）数据。

package com.example.demo.observer.internal;

import com.example.demo.observer.customize.DisplayElement;

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

public class CurrentConditionsDisplay implements Observer, DisplayElement {

    private float temperature;
    private float humidity;
    private float airpressure;
    private Observable observable;

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

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

    @Override
    public void display() {
        System.out.println("气温："+ this.temperature+"\t"+"湿度："+this.humidity+"\t"+"气压："+this.airpressure);
    }
}

package com.example.demo.observer.internal;

import com.example.demo.observer.customize.DisplayElement;

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

public class ForecastDisplay implements Observer, DisplayElement {

    private float temperature;
    private float humidity;
    private float airpressure;
    private Observable observeable;

    public ForecastDisplay(Observable observeable) {
        this.observeable = observeable;
        this.observeable.addObserver(this);
    }

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

    @Override
    public void display() {
        System.out.println("气温："+ this.temperature+"\t"+"湿度："+this.humidity+"\t"+"气压："+this.airpressure);
    }

}

package com.example.demo.observer.internal;

import com.example.demo.observer.customize.DisplayElement;

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

public class StatisticsDisplay implements Observer, DisplayElement {

    private float temperature;
    private float humidity;
    private float airpressure;
    private Observable observable;

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

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

    @Override
    public void display() {
        System.out.println("气温："+ this.temperature+"\t"+"湿度："+this.humidity+"\t"+"气压："+this.airpressure);
    }
}

测试方法同上。  和自定义观察者模式的区别在于，通知观察者前首先要调用setChanged()方法，修改主题对象的标识，该标识的好处是可以自由的控制主题对象和观察者之间的交互，比如一些微小的数据修改不通知观察者，就可以通过该方法来控制；还有观察者update(Observable o, Object arg)接口的第一个参数Observable o是可以让观察者知道是哪个主题调用它，也可以通过该主题对象，去主题拉取数据。Object arg参数是主题对象推送过来的数据对象，观察者直接可以获取主题对象发送的数据进行处理。

经过测试我们可以观察到，通过Java内置的观察者模式，我们发现Observalbe的notifyObservers()方法通知观察者的时候和我们自定义观察者模式的顺序是不一样的，但如果我们的代码依赖这样的次序，这种实现就是错的。通知次序的改变，很可能会产生错误的结果。

另一方面，Observable是一个类，并不是一个接口，它限制了我们的复用，也违反了我们的OO设计原则（针对接口编程，而非针对实现编程）。如果主题对象要想继承其他超类，就会陷入两难的境地，毕竟Java不支持多继承，限制了Observable的复用潜力。再者，因为没有Observable接口，所以也无法建立自己的实现，和Java内置Observer API搭配使用。而且也违反了我们的设计原则：多用组合，少用继承。

所以不管用哪种方法都可以实现观察者模式，前提是根据我们的业务场景来。