簡說設計模式——觀察者模式

一、什么是觀察者模式

　　觀察者一般可以看做是第三者，比如在學校上自習的時候，大家肯定都有過交頭接耳、各種玩耍的經歷，這時總會有一個“放風”的小伙伴，當老師即將出現時及時“通知”大家老師來了。再比如，拍賣會的時候，大家相互叫價，拍賣師會觀察最高標價，然后通知給其它競價者競價，這就是一個觀察者模式。

　　對於觀察者模式而言，肯定有觀察者和被觀察者之分。比如在一個目錄下建立一個文件，這時系統會通知目錄管理器增加目錄，並通知磁盤減少空間，在這里，文件就是觀察者，目錄管理器和磁盤就是被觀察者。

　　觀察者模式（Observer），又叫發布-訂閱模式（Publish/Subscribe），定義對象間一種一對多的依賴關系，使得每當一個對象改變狀態，則所有依賴於它的對象都會得到通知並自動更新。UML結構圖如下：

 　　其中，Subject類是主題，它把所有對觀察者對象的引用文件存在了一個聚集里，每個主題都可以有任何數量的觀察者。抽象主題提供了一個接口，可以增加和刪除觀察者對象；Observer類是抽象觀察者，為所有的具體觀察者定義一個接口，在得到主題的通知時更新自己；ConcreteSubject類是具體主題，將有關狀態存入具體觀察者對象，在具體主題內部狀態改變時，給所有登記過的觀察者發出通知；ConcreteObserver是具體觀察者，實現抽象觀察者角色所要求的更新接口，以便使本身的狀態與主題的狀態相協同。

　　1. 主題Subject

　　首先定義一個觀察者數組，並實現增、刪及通知操作。它的職責很簡單，就是定義誰能觀察，誰不能觀察，用Vector是線程同步的，比較安全，也可以使用ArrayList，是線程異步的，但不安全。

public class Subject {

    //觀察者數組
    private Vector<Observer> oVector = new Vector<>();
    
    //增加一個觀察者
    public void addObserver(Observer observer) {
        this.oVector.add(observer);
    }
    
    //刪除一個觀察者
    public void deleteObserver(Observer observer) {
        this.oVector.remove(observer);
    }
    
    //通知所有觀察者
    public void notifyObserver() {
        for(Observer observer : this.oVector) {
            observer.update();
        }
    }
    
}

　　2. 抽象觀察者Observer

　　觀察者一般是一個接口，每一個實現該接口的實現類都是具體觀察者。

public interface Observer {
    //更新
    public void update();
}

 　　3. 具體主題

　　繼承Subject類，在這里實現具體業務，在具體項目中，該類會有很多變種。

public class ConcreteSubject extends Subject {

    //具體業務
    public void doSomething() {
        //...
        super.notifyObserver();
    }
    
}

 　　4. 具體觀察者

　　實現Observer接口。

public class ConcreteObserver implements Observer {

    @Override
    public void update() {
        System.out.println("收到消息，進行處理");
    }

}

 　　5. Client客戶端

　　首先創建一個被觀察者，然后定義一個觀察者，將該被觀察者添加到該觀察者的觀察者數組中，進行測試。

public class Client {
    
    public static void main(String[] args) {
        //創建一個主題
        ConcreteSubject subject = new ConcreteSubject();
        //定義一個觀察者
        Observer observer = new ConcreteObserver();
        //觀察
        subject.addObserver(observer);
        //開始活動
        subject.doSomething();
    }
    
}

 　　運行結果如下：

　　

二、觀察者模式的應用

　　1. 何時使用

• 一個對象狀態改變，所有的依賴對象都將得到通知

 　　2. 方法

• 使用面向對象技術

 　　3. 優點

• 觀察者和被觀察者是抽象耦合的
• 建立了一套觸發機制

 　　4. 缺點

• 如果一個被觀察者對象有很多的直接和間接的觀察者的話，將所有的觀察者都通知到會花費很多時間
• 如果觀察者和觀察目標間有循環依賴，可能導致系統崩潰
• 沒有相應的機制讓觀察者知道所觀察的目標對象是怎么發生變化的

 　　5. 使用場景

• 關聯行為場景
• 事件多級觸發場景
• 跨系統的消息變換場景，如消息隊列的處理機制

　　6. 應用實例

• 手機丟了，委托別人給其他人發消息通知
• 通知老師/老板來了
• 拍賣，拍賣師觀察最高標價，然后通知給其它競價者競價
• 在一個目錄下建立一個文件，會同時通知目錄管理器增加目錄，並通知磁盤減少空間，文件是被觀察者，目錄管理器和磁盤管理器是觀察者
• 貓叫了一聲，嚇着了老鼠，也驚到了主人，貓是被觀察者，老鼠和人是觀察者

　　7. 注意事項

• 避免循環引用
• 如果順序執行，某一觀察者錯誤會導致系統卡殼，一般采用異步方式

三、觀察者模式的實現

　　下面舉一個具體實例，假設上班時間有一部分同事在看股票，一部分同事在看NBA，這時老板回來了，前台通知了部分同事老板回來了，這些同事及時關閉了網頁沒被發現，而沒被通知到的同事被抓了個現行，被老板親自“通知”關閉網頁，UML圖如下：

　　1. 通知者接口

public interface Subject {

    //增加
    public void attach(Observer observer);
    //刪除
    public void detach(Observer observer);
    //通知
    public void notifyObservers();
    
    //狀態
    public void setAction(String action);
    public String getAction();
    
}

 　　2. 觀察者

public abstract class Observer {

    protected String name;
    protected Subject subject;
    
    public Observer(String name, Subject subject) {
        this.name = name;
        this.subject = subject;
    }
    
    public abstract void update();
    
}

　　3. 具體通知者

　　前台Secretary和老板Boss作為具體通知者，實現Subject接口。這里只給出Secretary類的代碼，Boss類與之類似。

public class Secretary implements Subject {

    //同事列表
    private List<Observer> observers = new LinkedList<>();
    private String action;

    //添加
    @Override
    public void attach(Observer observer) {
        observers.add(observer);
    }

    //刪除
    @Override
    public void detach(Observer observer) {
        observers.remove(observer);
    }

    //通知
    @Override
    public void notifyObservers() {
        for(Observer observer : observers) {
            observer.update();
        }
    }

    //前台狀態
    @Override
    public String getAction() {
        return action;
    }

    @Override
    public void setAction(String action) {
        this.action = action;
    }
    
}

 　　4. 具體觀察者

　　StockObserver是看股票的同事，NBAObserver是看NBA的同事，作為具體觀察者，繼承Observer類。這里只給出StockObserver類的代碼，NBAObserver類與之類似。

public class StockObserver extends Observer {
    
    public StockObserver(String name, Subject subject) {
        super(name, subject);
    }

    @Override
    public void update() {
        System.out.println(subject.getAction() + "\n" + name + "關閉股票行情，繼續工作");
    }

}

 　　5. 前台作為通知者進行通知（Client）

　　前台作為通知者，通知觀察者。這里添加adam和tom到通知列表，並從通知列表中刪除了adam，測試沒在通知列表中的對象不會收到通知。

public class Client {

    public static void main(String[] args) {
        //前台為通知者
        Secretary secretary = new Secretary();
        
        StockObserver observer = new StockObserver("adam", secretary);
        NBAObserver observer2 = new NBAObserver("tom", secretary);
        
        //前台通知
        secretary.attach(observer);
        secretary.attach(observer2);
        
        //adam沒被前台通知到，所以被老板抓了個現行
        secretary.detach(observer);
        
        //老板回來了
        secretary.setAction("小心！Boss回來了！");
        //發通知
        secretary.notifyObservers();
    }
    
}

 　　運行結果如下，只有tom接收到了通知：

　　

　　6. 老板作為通知者進行通知（Client）

　　老板作為通知者，通知觀察者。這里將tom從老板的通知列表中移除，老板只通知到了adam。

public class Client {

    public static void main(String[] args) {
        //老板為通知者
        Boss boss = new Boss();
        
        StockObserver observer = new StockObserver("adam", boss);
        NBAObserver observer2 = new NBAObserver("tom", boss);
        
        //老板通知
        boss.attach(observer);
        boss.attach(observer2);
        
        //tom沒被老板通知到，所以不用挨罵
        boss.detach(observer2);
        
        //老板回來了
        boss.setAction("咳咳，我大Boss回來了！");
        //發通知
        boss.notifyObservers();
    }
    
}

　　運行結果如下，只有adam挨罵了：　

　　

 

　　當一個對象的改變需要同時改變其它對象，並且它不知道具體有多少對象有待改變的時候，應該考慮使用觀察者模式。

　　而使用觀察者模式的動機在於：將一個系統分割成一系列相互協作的類有一個很不好的副作用，就是需要維護相關對象間的一致性，我們不希望為了維持一致性而使各類緊密耦合，這樣會給維護、擴展和重用都帶來不便，而觀察者模式所做的工作就是在解除耦合。

 

　　源碼地址：https://gitee.com/adamjiangwh/GoF