设计模式（2）观察者模式

观察者模式

概念：

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

介绍

意图：定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。

主要解决：一个对象状态改变给其他对象通知的问题，而且要考虑到易用和低耦合，保证高度的协作。

何时使用：一个对象（目标对象）的状态发生改变，所有的依赖对象（观察者对象）都将得到通知，进行广播通知。

如何解决：使用面向对象技术，可以将这种依赖关系弱化。

关键代码：在抽象类里有一个 ArrayList 存放观察者们。

应用实例： 1、拍卖的时候，拍卖师观察最高标价，然后通知给其他竞价者竞价。 2、西游记里面悟空请求菩萨降服红孩儿，菩萨洒了一地水招来一个老乌龟，这个乌龟就是观察者，他观察菩萨洒水这个动作。

优点： 1、观察者和被观察者是抽象耦合的。 2、建立一套触发机制。

缺点： 1、如果一个被观察者对象有很多的直接和间接的观察者的话，将所有的观察者都通知到会花费很多时间。 2、如果在观察者和观察目标之间有循环依赖的话，观察目标会触发它们之间进行循环调用，可能导致系统崩溃。 3、观察者模式没有相应的机制让观察者知道所观察的目标对象是怎么发生变化的，而仅仅只是知道观察目标发生了变化。

使用场景：

一个抽象模型有两个方面，其中一个方面依赖于另一个方面。将这些方面封装在独立的对象中使它们可以各自独立地改变和复用。
一个对象的改变将导致其他一个或多个对象也发生改变，而不知道具体有多少对象将发生改变，可以降低对象之间的耦合度。
一个对象必须通知其他对象，而并不知道这些对象是谁。
需要在系统中创建一个触发链，A对象的行为将影响B对象，B对象的行为将影响C对象……，可以使用观察者模式创建一种链式触发机制。
注意事项： 1、JAVA 中已经有了对观察者模式的支持类。 2、避免循环引用。 3、如果顺序执行，某一观察者错误会导致系统卡壳，一般采用异步方式。

实现

• 基础观察者模式类图：

以一个简单的气象观测软件实现为例：

具体依赖图

代码实现如下：

首先为观测者模式的主题建立一个Subject接口

package observepattern;

/**
 * @author liw
 * @date 2020-01-05
 */
public interface Subject {
    public void registerObserver (Observe observe);
    public void removeObserver(Observe observe);
    public void notifyObserves( );
}

并具体取实现

package observepattern;

import java.util.ArrayList;

/**
 * @author liw
 * @date 2020-01-05
 */
public class WeatherData implements Subject {
    private ArrayList observers ;
    private float temperature ;
    private float humidity ;
    private float presure ;

    //初始化观察者列表
    public WeatherData() {
        observers = new ArrayList<>() ;
    }

    //添加观察者
    @Override
    public void registerObserver(Observe o) {
        observers.add(o);
    }

    //删除观察者
    @Override
    public void removeObserver(Observe o){
        int i = observers.indexOf(o);
        if (i > 0){
            observers.remove(i);
        }
    }

    //迭代观察者列表通知观察者
    public void notifyObserves() {
        for (int i = 0;i<observers.size();i++){
            Observe observe = (Observe) observers.get(i);
            observe.update(temperature,humidity,presure);
        }
    }

    //从气象站获得气象时通知观察者
    public void measurementsChanged (){
        notifyObserves();
    }

    //获取气象值
    public void setMeasurements (float temperature,float humidity, float presure){
        this.temperature = temperature ;
        this.humidity = humidity ;
        this.presure = presure ;
        measurementsChanged();
    }

}

package observepattern;

/**
 * @author liw
 * @date 2020-01-05
 */
public interface Observe {
    public void update(float temperature, float humidity, float presure) ;
}

package observepattern;

/**
 * @author liw
 * @date 2020-01-05
 */
public interface DisplayElement {
    public void display ();
}

观察者 气象观测发布板

package observepattern;

/**
 * @author liw
 * @date 2020-01-05
 */
public class CurrentConditionDisplay implements Observe, DisplayElement {

    private float temterature;
    private float humidity;
    private Subject weatherData;

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

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

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

测试类：

package observepattern;

/**
 * @author liw
 * @date 2020-01-05
 */
public class WeatherStation {
    public static void main(String[] args) {
        WeatherData weatherDate = new WeatherData();
        CurrentConditionDisplay currentConditionDisplay = new CurrentConditionDisplay(weatherDate) ;
        weatherDate.setMeasurements(90,80,20);
    }
}

执行结果：

Current conditions :90.0F degrees and80.0%humidity

使用java内置观察者模式

java.util包内包含最基本的Observer接口和Observerable类，可以实现观察者模式。
还以上述天气播报的形式来简单应用下java内置的观察者模式应用。

主题代码实现

package observepattern2;

import java.util.Observable;

/**
 * @author liw
 * @date 2020-01-05
 */
//主题要继承Observable 类
public class WeatherData extends Observable {
    private float temperature ;
    private float hunidity ;
    private float pressure ;

    public WeatherData() {
    }

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

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

    public float getTemperature() {
        return temperature;
    }

    public float getHunidity() {
        return hunidity;
    }

    public float getPressure() {
        return pressure;
    }
}

观察者实现代码，观察者实现Observer接口

package observepattern2;

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

/**
 * @author liw
 * @date 2020-01-05
 */
public class CurrentConditionDisplay implements Observer {

    Observable observable;
    private float temperature;
    private float humidity;

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

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

    public void display() {
        System.out.println(temperature +"++"+ humidity);
    }
}

测试类：

package observepattern2;

/**
 * @author liw
 * @date 2020-01-05
 */
public class WeatherStation {
    public static void main(String[] args) {
        WeatherData weatherData = new WeatherData() ;
        CurrentConditionDisplay currentConditionDisplay = new CurrentConditionDisplay(weatherData) ;
        weatherData.setmeasureements(90,80,70);

    }
}

运行结果

90.0++80.0
Process finished with exit code 0