headfirst設計模式（2）—觀察者模式

定義觀察者模式（有時又被稱為發佈（publish）-訂閱（Subscribe）模式，在此種模式中，一個目標物件管理所有相依於它的觀察者物件，並且在它本身的狀態改變時主動發出通知。這通常透過呼叫各觀察者所提供的方法來實現。此種模式通常被用來實現事件處理系統（摘自百度百科）。關鍵詞：發佈-訂閱為什 ...

定義

觀察者模式（有時又被稱為發佈（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設計模式時，看到的，並加入自己的理解寫下來的（當然我也編了一些），寫這段話的目的也是為了避免一些不必要的誤會，以後的每期我都會複製這段話，哈哈哈