设计模式：第二篇--观察者模式

作者: Jorgezhong | 来源:发表于2018-09-18 15:18 被阅读73次

定义：观察者模式定义了一系列一对多的关系，当一个对象改变状态，其他依赖者都会收到通知。

从类图上看其实就是一个Subject(主题)依赖多个Observer（观察者），一个Observer依赖一个Subject。一对多的关系。Subject定义了观察者注册和注销的方。以及主题改变时通知在线观察者的方法。Observer定义了当主题改变式，被通知时要调用的update方法。关键在这个依赖。当Observer被实例化的时候，会告诉调用Subject的registerObserver()注册到Subject。当Subject更新的时候会最终调用Observer的update方法通知到观察者。

松耦合设计原则：连个对象之间要交互，暴露的东西越少越好。只需要知道对方能干嘛，而不需要知道具体怎么实现的。本例中。Observer不需要知道Subject怎么通知我的，只需要知道，通知我update方法被调用了即可。反过来。Subject不需要知道Observer具体是谁，做了什么。只需要知道它是个Observer即可。

案例：气象站的设计

案例：气象站的设计

需求：目前已经有WeatherData类。里面有获取温度、湿度、气压的方法。当新的数据备妥时measurementsChanged方法会被调用。现在需要增加三个使用天气数据的的布告板，分别是“目前状况”布告、“天气预报”布告、“气象统计”布告。并且要求这些布告是可以拓展的，也就是可以删除也可以增加其他布告板。

错误的代码设计：面向过程（直接怼代码）

既然知道了当数据更新的时候measurementsChanged方法会被调用，那直接在上面写代码就可以实现需求了。于是写出了类似下面的代码。简称“直接怼”。这就很不友好了。这样的后果就是日后如果气象站有所变更，我需要直接修改代码。在公共的代码区域直接修改代码会造成意想不到的结果。比如所有被通知的布告板，出现了不该出现的数据。

public class WeatherData {


    public String getTemperature(){

        return "温度";
    }

    public String getHumidity(){
        return "湿度";
    }

    public String getPressure(){
        return "气压";
    }

    /**
     * 新的测量数据备好后会被调用
     */
    public void measurementssChanged(){


        String temperature = getTemperature();
        String humidity = getHumidity();
        String pressure = getPressure();

        //目前
        currentConditionsDisplay.update(temperature,humidity,pressure);
        //统计
        statisticsDisplay.update(temperature, humidity, pressure);
        //预报
        forecastDisplay.update(temperature, humidity, pressure);


    }

}

使用观察者模式

思考：该需求很适合使用观察者模式，气象站需要给布告板数据，而布告板展示数据。这不就是观察者模式的经典吗。

1、定义被观察者接口：主题

/**
 * Project <demo-project>
 * Created by jorgezhong on 2018/9/18 9:10.
 *
 * 主题接口：对象使用此接口注册为观察者。或者把自己是删除。
 */
public interface Subject {

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

    /**
     * 从观察者列表里删除（注销）
     */
    void removeObserver(Observer observer);

    /**
     * 通知当前所有观察者，主题状态改变
     */
    void notifyObserver();

}

2、定义观察者接口

/**
 * Project <demo-project>
 * Created by jorgezhong on 2018/9/18 9:14.
 *
 * 观察者接口：所有潜在的观察者必须实现观察者接口，该demo中只有update一个方法，当Subject状态改变时，它被调用
 */
public interface Observer {

    void udpate(float temp, float humidity,float pressure);

}

3、定义业务功能接口

/**
 * Project <demo-project>
 * Created by jorgezhong on 2018/9/18 9:31.
 */
public interface DisplayElement {

    /**
     * 布告板展示时调用此方法
     */
    void display();

}

4、实现具体主题

/**
 * Project <demo-project>
 * Created by jorgezhong on 2018/9/14 16:48.
 */
public class WeatherData implements Subject{

    //依赖观察者：subject包含多个Observer
    private ArrayList<Observer> observers;
    
    //温度    
    private float temperature;
    //湿度
    private float humidity;
    //气压
    private float pressure;


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


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

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

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

    /**
     * 新的测量数据备好后会被调用
     */
    public void measurementsChanged(){

        notifyObserver();

    }


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


}

5、实现具体观察者

/**
 * Project <demo-project>
 * Created by jorgezhong on 2018/9/18 9:32.
 */
public class CurrentConditionDisplay implements Observer, DisplayElement {
    //依赖具体被观察者（主题）
    private Subject weatherData;

    private float temperature;
    private float humidity;
    private float pressure;
    
    public CurrentConditionDisplay(Subject weatherData) {
        this.weatherData = weatherData;
        //注册
        weatherData.registerObserver(this);
    }

    @Override
    public void display() {
        System.out.println("CurrentCondition:");
        System.out.println("temperature = " + temperature);
        System.out.println("humidity = " + humidity);
        System.out.println("pressure = " + pressure);

    }

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

/**
 * Project <demo-project>
 * Created by jorgezhong on 2018/9/18 9:32.
 */
public class ForecastDisplay implements Observer, DisplayElement {

    private Subject weatherData;

    private float temperature;
    private float humidity;
    private float pressure;

    public ForecastDisplay(Subject weatherData) {
        this.weatherData = weatherData;
        //注册
        weatherData.registerObserver(this);
    }


    @Override
    public void display() {
        System.out.println("Forecast:");
        System.out.println("temperature = " + temperature);
        System.out.println("humidity = " + humidity);
        System.out.println("pressure = " + pressure);

    }

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

/**
 * Project <demo-project>
 * Created by jorgezhong on 2018/9/18 9:32.
 */
public class StatisticDisplay implements Observer, DisplayElement {

    private Subject weatherData;

    private float temperature;
    private float humidity;
    private float pressure;

    public StatisticDisplay(Subject weatherData) {
        this.weatherData = weatherData;
        //注册
        weatherData.registerObserver(this);
    }

    @Override
    public void display() {
        System.out.println("Statistic:");
        System.out.println("temperature = " + temperature);
        System.out.println("humidity = " + humidity);
        System.out.println("pressure = " + pressure);

    }

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

6、测试

public class Test {

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

        CurrentConditionDisplay currentConditionDisplay = new CurrentConditionDisplay(weatherData);
        StatisticDisplay statisticDisplay = new StatisticDisplay(weatherData);
        ForecastDisplay forecastDisplay = new ForecastDisplay(weatherData);

        weatherData.setMeasurements(12,12,12);
        weatherData.setMeasurements(13,13,13);

    }
}

总结

思考：
观察者模式的核心思想小编理解是松耦合的实现思想。相互依赖，仅仅暴露需要传输的部分，其他隐藏在各自的区域中。相互只知道相互需要知道的东西，一点不多一点不少。利用组合的思想。面向接口编程。方便拓展并且实现了解耦，主题和观察者解耦，业务和观察者解耦。代码是相互独立的，使用是相互依赖的。

缺点：
本例后，当我们尝试去拓展一个新的Subject的时候，我们会发现我们写了重复的代码。注册删除和通知Observer这些方法在每一个实现类当中都需要去实现。关于这个，使用jdk8的小伙伴们说很容易解决的啦。jdk8支持接口方法的默认实现嘛，子类可以不实现这些方法。比如这样。

public interface Subject {

    ArrayList<Observer> observers = new ArrayList<Observer>();

    /**
     * 注册为观察者
     */
    default void registerObserver(Observer observer){
        observers.add(observer);
    }

    /**
     * 从观察者列表里删除（注销）
     */
    default void removeObserver(Observer observer){
        if (observers.indexOf(observer) >= 0) {
            observers.remove(observer);
        }
    }

    /**
     * 通知当前所有观察者，主题状态改变
     */
    void notifyObserver();

}

public class WeatherData implements Subject {

    private float temperature;
    private float humidity;
    private float pressure;


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

    /**
     * 新的测量数据备好后会被调用
     */
    public void measurementsChanged() {

        notifyObserver();

    }

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

JDK内置观察者模式

其实在java.util下已经内置好咯额观察者模式供我们使用。只不过不同于上面的案例。我们可以看一下具体区别在哪。

JDK定义Observable类为被观察者，对，没看错，这个是类，比起之前我们自己定义的Subject，多了一个状态changed属性，调用setChanged方法设置为true，调用notifyObservers方法的时候设置为false，changed的设计可以让我们更有效的控制变化的通知频率，更加灵活。观察者是接口Observer。update方法接受一个具体被观察者以及Object类型的参数。接受的参数就包含了依赖的被观察者，第二个参数方便我们根据业务传入其他的参数。

使用JDK内置观察者模式改造气象站

import java.util.Observable;

public class WeatherData extends Observable {


    private float temperature;
    private float humidity;
    private float pressure;


    public WeatherData() {
    }


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


    /**
     * 新的测量数据备好后会被调用
     */
    public void measurementsChanged() {
        setChanged();
        notifyObservers();

    }

    public float getPressure() {
        return pressure;
    }

    public float getTemperature() {
        return temperature;
    }

    public float getHumidity() {
        return humidity;
    }
}

import com.example.observer.demo5.DisplayElement;
import com.example.observer.demo5.subject.WeatherData;

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

/**
 * Project <demo-project>
 * Created by jorgezhong on 2018/9/18 9:32.
 */
public class CurrentConditionDisplay implements Observer, DisplayElement {

    private Observable observable;

    private float temperature;
    private float humidity;
    private float pressure;

    public CurrentConditionDisplay(Observable observable) {
        this.observable = observable;
        //注册
        observable.addObserver(this);
    }

    @Override
    public void display() {
        System.out.println("CurrentCondition:");
        System.out.println("temperature = " + temperature);
        System.out.println("humidity = " + humidity);
        System.out.println("pressure = " + pressure);

    }

    @Override
    public void update(Observable observable, Object arg) {
        if (observable instanceof WeatherData) {
            WeatherData weatherData = (WeatherData) observable;
            this.temperature = weatherData.getTemperature();
            this.humidity = weatherData.getHumidity();
            this.pressure = weatherData.getPressure();
            display();
        }

    }
}

image.png

案例总结：

JDK内置的观察者模式考虑的会多一点，比如changed的设置。比如Observer接收Observable和参数Object会更加适合实际应用。但是由于被观察者使用的是继承，我们的设计原则是多用组合少用继承。既然可以用接口改造那就用接口改造好了。jdk8也支持接口方法的默认实现。还有一点区别，用jdk的实现是无法保证通知顺序的，因此不要选择依赖通知的顺序。

设计原则：

松耦合:所有的设计都尽量松耦合。设计为此而努力

开闭原则：对拓展开放，对修改关闭。观察者模式中我们可以通过拓展被观察者而实现拓展，不对旧的代码做出修改符合开闭原则。

-重点设计：我们发现使用了设计模式会大量使用接口抽象方法。抽象多了，层次就会增多。同样的，遵循开闭原则的代码一般都会引入新的抽象层次，增加代码的复杂性，太复杂的代码往往都不好理解，失去了其意义。因此对重点进行设计，避免过度设计。

设计模式：第二篇--观察者模式

案例：气象站的设计

错误的代码设计：面向过程（直接怼代码）

使用观察者模式

总结

JDK内置观察者模式

使用JDK内置观察者模式改造气象站

案例总结：

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

Android设计模式

设计模式

后端资源精选

思想

Java

修炼之旅

设计模式

设计模式