HeadFirst设计模式2-观察者模式

1. 为何需要观察者模式（why)

在我们的开发工作中，经常会遇到这样的问题。例如：对于A，对象B，C在原来引用了A。现在对象A的属性发生了变化，我们的需求是B，C能够同时感应到这种变化。且新增的对象D，也要引用A对象，那如何在不改变原来代码的基础上，如何做到呢。此时，观察者模式就能够很好的解决这个问题。

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

下面通过一个和实例逐步弄清楚什么是观察者模式。

2. 如何实现观察者模式（通过实例来讲解how）

某气象站有这样一个应用：它实时检测当地温度，适度，压强。并让第一号布告板，第二号布告板，第三号布告板或者其他第三方接入Api都能实时更新相应的数据。气象站提供的数据结构如下。

public class WeatherData {
    float temp;
    float humidity;
    float pressture;
//省略get,set方法
}

我们想到的办法就是让第一号布告板，第二号布告板，第三号布告板或者其他第三方接入Api都成为气象站的观察者，他们只需要在气象站注册，当气象站的数据发生变化的时候，会遍历每个观察者，调用update（）实现更新操作。
step1:定义抽象接口

public interface Subject {  //主题，即气象站的抽象接口
    //注册观察者
    public void registerObserver(Observer o);
    //取消观察者
    public void removeObserver(Observer o);
    //通知观察者执行更新操作
    public void notifyObservers();


}

public interface Observer {
    //更新操作，等待Subject调用就实现了通知
    public void update(float temp,float humidy,float pressure);
}

public interface DisplayElement {
    //对更新进行展示
    public void display();
}

上述是接口，便于代码重用和面向接口编程，而不是面向实现编程。
step2:实现具体的类

public class WeatherData implements Subject {

    private ArrayList observers;

    private float temperature;

    private float humidity;

    private float pressture;

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


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

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

    }

    @Override
    public void notifyObservers() {
        observers.stream().forEach((observer)->observer.update(temperature,humidity,pressture));
    }
    
    public void measurementsChanged(){//通知
        notifyObservers();
    }
    
    //属性改变了
    public void setMeasurements(float temperature,float humidity,float pressture){
        this.temperature=temperature;
        this.humidity=humidity;
        this.pressture=pressture;
        measurementsChanged();
    }
}

step3:Observer这里只提供一种实现，剩下的可以同样生成。

**
 * Created by maskwang on 2017/10/5 0005.
 * 时间原因这里只提供一种实现
 */
public class CurrentConditionsDisplay implements Observer,DisplayElement {
    //这个观察者只在乎以下两个属性
    private float temperature;

    private float humidity;

    private Subject weatherData;

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


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

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

step4:测试类

public class WeatherStation {
    public static void main(String[] args) {
        WeatherData weatherData=new WeatherData();
        //订阅那个Object
        CurrentConditionsDisplay currentConditionsDisplay=new CurrentConditionsDisplay(weatherData);

        weatherData.setMeasurements(80,65,30.2f);

        weatherData.setMeasurements(82,70,28.4f);

        weatherData.setMeasurements(83,72,27.5f);
    }
}

Uml类图如下：

observer.png

结果如下：

image.png

可以看到每次Subject变化，Observer跟着变化。

3. 观察者模式总结（conclusion）

以上实例可以看出来，观察者模式实现了Obseerver和Subject的解耦，Subject可以增删任意Observer,而Observer可以订阅任意的Subject。很好的满足了这种需求。这让我activemq，它其中就有一种发布订阅模式，在这里面生产者产生的消息，都能理解被消费者立即订阅到。可以看的出来这种思想应用的还是很广的。
附上对应的github地址：

https://github.com/maskwang520/designpattern.git