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

定义

观察者模式（有时又被称为发布（publish）-订阅（Subscribe）模式，在此种模式中，一个目标物件管理所有相依于它的观察者物件，并且在它本身的状态改变时主动发出通知。这通常透过呼叫各观察者所提供的方法来实现。此种模式通常被用来实现事件处理系统（摘自百度百科）。

关键词：发布-订阅

为什么只有一个关键词？因为我觉得一个关键词足够说明问题了。观察者模式适用于，一个对象改变时，需要通知一个或多个其他对象，而需要通知的对象的特点是：数量不清楚，类型不清楚（仅实现了一个通用接口），具体处理方式不清楚。

举个例子来说明：

小花：你好，我开发过很多erp系统，是一位经验丰富的女司机，现在想找一份java程序员的工作...（成熟稳重型）

猎头：好的，我已经把你加入到我的程序员清单里面了，不要打电话给我，我会通知你的（好莱坞原则）

小明：本人学识渊博、经验丰富，代码风骚、效率恐怖，c/c++、java、php无不精通，熟练掌握各种框架，深山苦练20余年，一天只睡4小时，电话通知出bug后秒登vpn，千里之外定位问题，瞬息之间修复上线。 身体强壮、健步如飞，可连续编程100小时不休息，讨论技术方案5小时不喝水，上至带项目、出方案，下至盗账号、威胁pm，什么都能干......（花式装逼型）

猎头：666，我已经把你加入到我的程序员清单里面了，不要打电话给我，我会通知你的(小明和小花注册为观察者)

小花和小明继续过着自己的日子，因为他们已经在猎头的清单里面了，有工作会收到通知的。

猎头：小花同学，小明同学，这里需要一个资深的全栈工程师，创业型，弹性工作制，股票期权，年终分红...（通知所有观察者）

小明：好的（随后凭借着小明的机智，获得了这份工作）

猎头：请把介绍费汇到我的银行卡

又过了一段日子，小花凭借着自己丰富的经验，找到了工作，并没有依靠猎头，所以也就没有什么介绍费

小花：我已经找到工作了，请不要再给我发招聘信息了(移除观察者)

10年之后...

小花娶妻生子，迎娶白富美，出任CEO，走上人生巅峰，孩子已经快要1米高了....(等等，好像有什么地方不对)

小明由于天天加班，1天只睡4个小时，坟头草已经1米高了...

当然这个是后话

以上就是订阅和发布的解释，当然，我可以实话告诉你，这个和我下面要贴的代码并没有什么关系。

一个气象监测应用的需求

概述：建立一个气象观测的应用，从气象站获取数据，并实时更新三个布告板：目前状况，天气统计，天气预报

目前状况：温度，湿度，气压

天气统计：平均温度，最低温度，最高温度

天气预报：明天下雨吗？

以下是具体实现，涉及到的设计原则：

1，针对抽象编程，不针对实现编程

2，多用组合少用继承

3，开闭原则，对扩展开放，对修改关闭（所有设计模式都是围绕这个终极目标来对不同场景进行设计的）

package observer;
/**
 * 观察主题
 */
public interface Observable{
    public void addObserver(Observer observer);//添加观察者
    public void removeObserver(Observer observer);//移除观察者
    public void notifyObservers(WeatherData data);//通知所有观察者
}

观察主题也可以是抽象类，具体可以参考java.util.Observable，这里就不展开来bb了。

那么什么时候选择抽象类，什么时候选择接口呢？

我的理解是，这个就要看，代价高不高了，抽象类的好处就是，可以少写代码，实现复用。接口可以应对各种不同的变化，因为观察者并不一定有共同使用的实现类，可能它们完全就是不同的东西。

这个地方我只有一个主题，我想用什么就用什么，就是这么任性，如果以后出了第二个或者第三个主题，那么就可以考虑具体是抽象类还是接口了，当然也不排除两种都用的情况。当然这是后话，程序本来就是不断变化的，适当的时候用适当的设计才是王道。

package observer;
/**
 * 观察者
 */
public interface Observer {
    public abstract void update(WeatherData data);
}

package observer;
/**
 * 天气数据
 */
public class WeatherData {
    private float temperature;
    private float humidity;
    private float pressure;
    public WeatherData(){
 
    }
    public WeatherData(float temperature, float humidity, float pressure){
        this.temperature = temperature;
        this.humidity = humidity;
        this.pressure = pressure;
    }
}

getter,setter省略，不然篇幅太长了

在Observer这个接口里面，我的update()方法里面带了一个 WeatherData对象，为什么不是Object呢，为什么不是直接三个参数，温度，湿度，气压呢？我当时想了很久（我也是一边看书，一遍写的，不是把所有的都学完了才来写博客的，所以不懂的多了去了）

用Object的好处当然是不仅更新天气可以用这个，以后更新其他什么的也可以用，而且，如果我update方法里面的需求有了新的变化，比如，我要更新时间，那么，这个参数总不能放在WeatherData里面吧，好不符合逻辑啊，强迫症怎么受得了？？？

思来想去我的理解是这样的：

1，这个是一个气象站应用，那么应该就是存气象数据吧，这个总没问题嘛

2，写一个Object会不会被后面接替我工作的同事砍死啊，Object里面是什么，通过方法名根本就看不出来，必须去具体的代码里面看，万一我逻辑有点复杂，注释再少点，那他不就懵逼了？

3，不直接用三个参数也是为了以后的变化，万一变成5个参数咋办？改都改死人，而且要是5个都是float类型，好容易在传的时候传错，发现得早还好，万一传错了，但是又通过测试了怎么办呢？

肯定有人觉得这不可能，那我举个例子

接口的定义是:

void test(int a, int b, int c);

实现是 void test(int a, int c, int b){...}

调用接口的时候，传入的是test.test(a, c, b);那么请问，这个能通过测试吗？可以的。后面的人会掉坑里吗？我觉得他只要去改代码，那么就很有可能，嘿嘿嘿

package observer;
/**
 * 显示
 */
public interface DisplayElement {
    void display();
}

这个接口没什么解释的，就是显示用的，下面我要大段贴代码了

package observer;
/**
 * 当前天气状况*/
public class CurrentConditionsDisplay implements DisplayElement, Observer {
    Observable observable;
    public CurrentConditionsDisplay(Observable observable) {
        this.observable = observable;
    }
    WeatherData data = new WeatherData();
    @Override
    public void display() {
        System.out.println("当前的天气状况： " +
                            "温度(℉)：" + data.getTemperature() + " " +
                            "湿度：" + data.getHumidity() + " " +
                            "气压：" + data.getPressure());
    }
    @Override
    public void update(WeatherData data) {
        this.data = data;
        display();
    }
}

package observer;
/**
 * 天气统计
 *
 */
public class StatisticsDisplay implements DisplayElement, Observer {
 
    private Float average;
    private Float highest;
    private Float lowest;
    @Override
    public void display() {
        System.out.println("天气统计：" +
                            "平均温度(℉)：" + average + " " +
                            "最高温度(℉)：" + highest + " " +
                            "最低温度(℉)：" + lowest);
    }
    @Override
    public void update(WeatherData data) {
        float temperature = data.getTemperature();
        average = null == average ? temperature :
                        (average + temperature) / 2;
        highest = null == highest ? temperature :
                        (highest > temperature ? highest : temperature);
        lowest = null == lowest ? temperature :
                        (lowest > temperature ? temperature : lowest);
        display();
    }
 
}

package observer;
/**
 * 天气预报*/
public class ForecastDisplay implements DisplayElement, Observer {
    private float pressure;
    @Override
    public void update(WeatherData data) {
        pressure = data.getPressure();
        display();
    }
    @Override
    public void display() {
        System.out.println("天气预测：" + forecast());
    }
    private static final float INFRABAR = 28.5f;//气压低就会下雨
    private String forecast(){
        return INFRABAR < pressure ? "明天不下雨" : "明天要下雨";
    }
}

package observer;

import java.util.ArrayList;
import java.util.List;
/**
 * 天气主题
 *
 */
public class Weather implements Observable {
    private List<Observer> observers = new ArrayList<>();;
    public void addObserver(Observer observer) {
        observers.add(observer);
    }
    public void removeObserver(Observer observer) {
        observers.remove(observer);
    }
    public void notifyObservers(WeatherData data) {
        for (Observer observer : observers)
            observer.update(data);
    }
}

package observer;
/**
 * 测试
 * @author Skysea
 *
 */
public class Client {
 
    public static void main(String[] args) {
        Observable observable = new Weather();
        Observer currentCondition = new CurrentConditionsDisplay(observable);
        Observer statistics = new StatisticsDisplay();
        Observer forecast = new ForecastDisplay();
        observable.addObserver(currentCondition);
        observable.addObserver(statistics);
        observable.addObserver(forecast);
        observable.notifyObservers(new WeatherData(80, 65, 30.4f));
        observable.notifyObservers(new WeatherData(82, 70, 29.2f));
        observable.notifyObservers(new WeatherData(78, 90, 25.1f));
    }
}

运行结果：

在测试代码中，添加观察者到主题这些代码，也是可以放在观察者中去实现的，在初始化的时候就把自己加入到主题的列表中

在实际的使用中，如使用Spring的依赖注入之类的，还是很好用的，也可以省很多事情，最后的交互方式大概是这个样子

package observer;
/**
 * 测试2
 */
public class Client2 {
    @Autowired
    private Observable observable;
    public static void main(String[] args) {
        observable.notifyObservers(new WeatherData(80, 65, 30.4f));
        observable.notifyObservers(new WeatherData(82, 70, 29.2f));
        observable.notifyObservers(new WeatherData(78, 90, 25.1f));
    }
}

嗯，没错，什么初始化都没有了，观察者在启动的时候就注入到主题中了，只需要调用主题的接口就好了，而主题也仅仅是持有了一个List<Observer> observers;具体的观察者是谁它也不知道，但是它们还是可以相互交互，是不是很酷？

好了，我bb完了，本系列的大部分所有例子，都是在看headfirst设计模式时，看到的，并加入自己的理解写下来的（当然我也编了一些），写这段话的目的也是为了避免一些不必要的误会，以后的每期我都会复制这段话，哈哈哈