设计模式之观察者模式

观察者模式

概念

观察者模式（有时又被称为模型（Model）-视图（View）模式、源-收听者(Listener)模式或从属者模式）是软件设计模式的一种。在此种模式中，一个目标物件管理所有相依于它的观察者物件，并且在它本身的状态改变时主动发出通知。这通常透过呼叫各观察者所提供的方法来实现。此种模式通常被用来实现事件处理系统。

优缺点

观察者模式的主要的作用就是对对象解耦，将观察者和被观察者完全隔离。

1、观察者模式的优点

观察者模式解除了主题和具体观察者的耦合，让耦合的双方都依赖于抽象，而不是依赖具体。

2、观察者模式的缺点

在应用观察者模式时需要考虑一下开发小路问题，程序中包括一个被观察者和多个被观察者，开发和调试比较复杂，而且Java中的消息的通知默认是顺序执行的，一个观察者的卡顿会影响整体的执行效率。在这种情况下，一般考虑采用异步的方式。

观察者模式应用

引入一个很常见的案例。现在有一家气象站负责发布气象消息。客户希望气象站能够建立一个应用，有三种布告板，分别显示目前的状况，气象统计以及简单的预报。当获得最新的测量数据的时候，三种布告板必须实时更新。而且要求这是一个可以扩展的气象站，气象站需要公布一组API，好让其他开发人员可以写出自己的气象布告板并且插入此应用中。

此系统中的三个部分是气象站（获取实际气象数据的物理装置）、WeatherData对象（追踪来自气象站的数据，并更新布告板）和布告板（显示目前天气状况给用户看）。

如果了解报纸的订阅是怎么回事，其实就可以理解观察者模式是怎回事了，只是名称不太一样。对于报纸的订阅来说：

1、报社的业务就是出版报纸

2、向某家报社订阅报纸，只要他们有新报纸出版，就会给你送来。只要你是他们的门户，你就会一直收到新报纸。

3、当你不再想看报纸的时候，取消订阅，他们就不会再送新报纸来。

4、只要报社还在运营，就会一直有人向他们订阅报纸或者取消订阅报纸。

接下来按照观察者模式的思路来实现气象站：

首先创建观察者和主题的接口和展示数据的接口

public interface Observer {
    /**
     * 更新数据
     */
    void update(float temp, float humidity, float pressure);
}

public interface Subject {

    /**
     * 注册一个观察者
     */
    void registerObserver(Observer observer);

    /**
     * 移除一个观察者
     */

    void removeObserver(Observer observer);

    /**
     * 更新后提醒
     */

    void notifyObservers();
}

public interface DisplayElement {
    /**
     * 展示数据
     */
    public void display();
}

创建气象站类，并实现主题的接口：

import java.util.ArrayList;

public class WeatherData implements Subject {

    private float temperature;

    private float humidity;

    private float pressure;

    private ArrayList<Observer> observers;

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


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

    @Override
    public void removeObserver(Observer observer) {
        int i = observers.indexOf(observer);
        if (i >= 0) {
            observers.remove(observer);
        }
    }

    @Override
    public void notifyObservers() {
        for (Observer observer : observers) {
            observer.update(temperature, humidity, pressure);
        }
    }

    public void measurementsChanged() {
        notifyObservers();
    }

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


}

创建观察者类并实现接口：

public class ConcreteObserver implements Observer ,DisplayElement{

    private float tempreature;

    private float humidity;

    private float pressure;

    private Subject weatherData;
    public ConcreteObserver(Subject weatherData){
        this.weatherData = weatherData;
        weatherData.registerObserver(this);
    }

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

    @Override
    public void display() {
        System.out.println("tempreature = " + tempreature + " humidity = " + humidity + " pressure =" + pressure);
    }
}

创建测试类：

public class WeatherStation {
    public static void main(String[] args) {
        WeatherData weatherData = new WeatherData();

        ConcreteObserver concreteObserver = new ConcreteObserver(weatherData);
        weatherData.setMeasurements(50, 42, 30);
    }
}

Java内置的观察者模式

在java.util包中，包含了最基本的Observer接口和Observable类，并且已经事先准备好了许多功能，你甚至可以用push或者pull的方式传送数据。

利用内置的观察者模式重做气象站：

package obser;
import observe.DisplayElement;

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

public class ConcreteObserver implements Observer, DisplayElement {

    float tempreature;

    float humidity;

    float pressure;

    private Observable observable;

    public ConcreteObserver(Observable observable) {

        this.observable = observable;
        observable.addObserver(this);
    }


    @Override
    public void display() {
        System.out.println("tempreature = " + tempreature + " humidity = " + humidity + " pressure =" + pressure);
    }

    @Override
    public void update(Observable observable, Object o) {

        if (o instanceof WeatherData) {
            WeatherData weatherData = (WeatherData) o;
            this.tempreature = weatherData.getTemperature();
            this.humidity = weatherData.getHumidity();
            this.pressure = weatherData.getPressure();
            display();
        }
    }
}

package obser;
import java.util.Observable;
import java.util.Observer;

public class WeatherData extends Observable {
    private float temperature;

    private float humidity;

    private float pressure;

    public WeatherData() {
    }

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

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

    public float getTemperature() {
        return temperature;
    }

    public float getHumidity() {
        return humidity;
    }

    public float getPressure() {
        return pressure;
    }
}

package obser;
public class Main {
    public static void main(String[] args) {
        WeatherData weatherData = new WeatherData();
        ConcreteObserver concreteObserver = new ConcreteObserver(weatherData);
        weatherData.setMeasurements(502, 42, 30);
    }
}

java.util.Observable的缺点

Observable是一个类而不是一个接口，如果想使用Observable就必须继承他，如果某类想同时具有Observable的行为和另一个超类的行为就会陷入两难，因为java不支持多继承。这限制了Observable的复用潜力。

Observable将setChanged()方法定义为了protected，意味着除非继承Observable，否则无法创建Observable实例并组合到自己的对象中来。

总结

观察者模式定义了对象之间的一对多依赖，这样一来，当一个对象改变状态时，他的所有依赖者都会收到通知并自动更新。观察者模式提供了一种对象设计，让主题和观察者之间松耦合，但是他们可以进行交互，只是双方不清楚彼此的细节。在任何时候我们都可以增加新的观察者，因为主题唯一的以来的东西是一个实现了观察者接口的对象列表，所以我们可以随时增加观察者。事实上，在运行时我们可以用新的观察者取代现有的观察者，主题不会受到任何影响。同样的也可以在任何时候删除某些观察者。松耦合的设计之所以让我们建立富有弹性的OO系统，能够应对变化是因为对象之间的互相依赖降到了最低。