設計模式系列—觀察者模式

作者：一角錢技術 2020-10-26 08:45:39

開發前端

本篇和大家一起來學習觀察者模式相關內容。

前言

23種設計模式速記
單例（singleton）模式
工廠方法（factory method）模式
抽象工廠（abstract factory）模式
建造者/構建器（builder）模式
原型（prototype）模式
享元（flyweight）模式
外觀（facade）模式
適配器（adapter）模式
裝飾（decorator）模式
持續更新中......

23種設計模式快速記憶的請看上面第一篇，本篇和大家一起來學習觀察者模式相關內容。

模式定義
定義了對象之間的一對多依賴，讓多個觀察者對象同時監聽某一個主題對象，當主題對象發生變化時，它的所有依賴者都會收到通知并更新。這種模式有時又稱作發布-訂閱模式、模型-視圖模式，它是對象行為型模式。

觀察者模式是對象之間一對多的一種模式，被依賴的對象是Subject，依賴的對象是Observer，Subject通知Observer變化，Subject為1，Observer為多。

解決的問題
一個對象狀態改變給其他對象通知的問題，而且要考慮到易用和低耦合，保證高度的協作。

模式組成

實例說明
實例概況
某天下午班主任通知某班學生和老師將要聽一節課，以此來對老師的授課質量進行評分。

老師和學生收到后開始安排相關的課程；
上課期間老師和班主任通過觀察學生的神情來預判課程的講的好壞
老師觀察到學生皺眉頭可以適當調節課程氣氛
班主任觀察到學生課堂氛圍好轉，給予高分
課程結束后，班主任和老師回到辦公室，一起回顧這節開心的課程。

使用步驟
步驟1：構建一個課程實體類

class Course { 
 
    // 上課時間:time 
    private Date time; 
    // 上課地點:place 
    private String place; 
    // 上課內容:content 
    private String content; 
 
    // 省略get/set... 
 
    public Course() { 
    } 
 
    public Course(Date time, String place, String content) { 
        this.time = time; 
        this.place = place; 
        this.content = content; 
    } 
}

步驟2：構建一個發現者的抽象類以及相關的實現類，老師和班主任都分別繼承了該接口并重寫相關方法

abstract class Observer { 
    abstract void update(Object args); 
 
    public Observer(String identity) { 
        this.identity = identity; 
    } 
 
    private String identity; 
 
    public String getIdentity() { 
        return identity; 
    } 
 
    public void setIdentity(String identity) { 
        this.identity = identity; 
    } 
}

步驟3：創建一個具體的觀察者角色，老師拿著教材開始來上課

/** 
 * 老師類 
 * - 觀察者之一 
 * - 觀察學生的上課情況 
 */ 
class TeacherObserver extends Observer { 
 
    private Course course; 
 
    @Override 
    public void update(Object args) { 
        DateFormat df = DateFormat.getTimeInstance(DateFormat.LONG, Locale.CHINA); 
        System.out.println("我是王老師,正在講課中..."); 
         
        course = new Course(new Date(), "A棟教學樓", "高等數學"); 
        System.out.println("今天上課時間:" + df.format(course.getTime()) + " 地點:" + course.getPlace() + " 上課內容:" + course.getContent()); 
    } 
 
    public TeacherObserver(String identity) { 
        super(identity); 
    } 
}

步驟4：創建一個具體的觀察者角色，班主任來聽課

/** 
 * 班主任來聽課 
 * - 觀察者之一 
 * - 觀察學生的上課情況 
 */ 
class HeadTeacherObserver extends Observer { 
    @Override 
    public void update(Object args) { 
        System.out.println("我是班主任來聽課了,正在檢查課程質量..."); 
        System.out.println("學生反饋課程質量為:" + args); 
    } 
 
    public HeadTeacherObserver(String identity) { 
        super(identity); 
    } 
}

步驟5：創建被觀察者抽象主題角色

/** 
 * 主體類 
 * - 模擬被觀察者主體 
 */ 
abstract class Subject { 
    /** 
     * 修改通知 
     */ 
    abstract void doNotify(); 
 
    /** 
     * 添加被觀察者 
     */ 
    abstract void addObservable(Observer o); 
 
    /** 
     * 移除被觀察者 
     */ 
    abstract void removeObservable(Observer o); 
}

步驟6：創建具體的被觀察者主體角色，學生主體為被觀察對象

/** 
 * 學生主體 
 * - 被觀察的對象 
 */ 
class StudentSubject extends Subject { 
    /** 
     * 上課狀態 
     */ 
    private String state; 
  
    public String getState() { 
        return state; 
    } 
 
    public void setState(String state) { 
        this.state = state; 
    } 
    private List<Observer> observableList = new ArrayList<>(); 
 
    @Override 
    public void doNotify() { 
        for (Observer observer : observableList) { 
            observer.update(state); 
        } 
    } 
 
    @Override 
    public void addObservable(Observer observable) { 
        observableList.add(observable); 
    } 
 
    @Override 
    public void removeObservable(Observer observable) { 
        try { 
            if (observable == null) { 
                throw new Exception("要移除的被觀察者不能為空"); 
            } else { 
                if (observableList.contains(observable) ) { 
                    System.out.println("下課了,"+observable.getIdentity()+" 已回到辦公室"); 
                    observableList.remove(observable); 
                } 
            } 
        } catch (Exception e) { 
            e.printStackTrace(); 
        } 
    } 
}

步驟7：開始上課，開始記錄報告

/** 
 * 觀察者模式 
 */ 
public class ObserverPattern { 
 
    public static void main(String[] args) { 
        // 創建學生主體 
        StudentSubject studentSubject = new StudentSubject(); 
 
        // 創建觀察者老師 
        TeacherObserver teacherObversable = new TeacherObserver("王老師"); 
 
        // 創建觀察者班主任 
        HeadTeacherObserver headTeacherObserver = new HeadTeacherObserver("班主任"); 
 
        // 學生反映上課狀態 
        studentSubject.setState("講的不錯,很好!"); 
        studentSubject.addObservable(teacherObversable); 
        studentSubject.addObservable(headTeacherObserver); 
 
        // 開始上課 
        studentSubject.doNotify(); 
 
        // 上課結束 
        studentSubject.removeObservable(headTeacherObserver); 
        studentSubject.removeObservable(teacherObversable); 
    } 
}

輸出結果

我是王老師,正在講課中...
今天上課時間:下午11時57分01秒地點:A棟教學樓上課內容:高等數學
我是班主任來聽課了,正在檢查課程質量...
學生反饋課程質量為:講的不錯,很好!
下課了,班主任已回到辦公室
下課了,王老師已回到辦公室

優點

符合開閉原則
降低了目標與觀察者之間的耦合關系，兩者之間是抽象耦合關系；
目標與觀察者之間建立了一套觸發機制。

缺點

目標與觀察者之間的依賴關系并沒有完全解除，而且有可能出現循環引用；
當觀察者對象很多時，通知的發布會花費很多時間，影響程序的效率。

應用場景
當更改一個對象的狀態可能需要更改其他對象，并且實際的對象集事先未知或動態更改時，請使用觀察者模式。

注意事項： 1、JAVA 中已經有了對觀察者模式的支持類。 2、避免循環引用。 3、如果順序執行，某一觀察者錯誤會導致系統卡殼，一般采用異步方式。

源碼中的應用

#JDK: 
java.util.Observable 
 
#Spring: 
org.springframework.context.ApplicationListener

Observable源碼分析
Observable接口

public interface Observer { 
 void update(Observable o, Object arg); 
}

Observable類

public class Observable { 
 private Vector<Observer> obs; 
 
 //添加觀察者 
 public synchronized void addObserver(Observer o) { 
        if (o == null) 
            throw new NullPointerException(); 
        if (!obs.contains(o)) { 
            obs.addElement(o); 
        } 
    } 
 
 //刪除觀察者 
 public synchronized void deleteObserver(Observer o) { 
        obs.removeElement(o); 
    } 
  
 //通知所有觀察者 
 public void notifyObservers() { 
        notifyObservers(null); 
    } 
 
 public void notifyObservers(Object arg) { 
        /* 
         * a temporary array buffer, used as a snapshot of the state of 
         * current Observers. 
         */ 
        Object[] arrLocal; 
 
        synchronized (this) { 
            /* We don't want the Observer doing callbacks into 
             * arbitrary code while holding its own Monitor. 
             * The code where we extract each Observable from 
             * the Vector and store the state of the Observer 
             * needs synchronization, but notifying observers 
             * does not (should not).  The worst result of any 
             * potential race-condition here is that: 
             * 1) a newly-added Observer will miss a 
             *   notification in progress 
             * 2) a recently unregistered Observer will be 
             *   wrongly notified when it doesn't care 
             */ 
            if (!changed) 
                return; 
            arrLocal = obs.toArray(); 
            clearChanged(); 
        } 
 
        for (int i = arrLocal.length-1; i>=0; i--) 
            ((Observer)arrLocal[i]).update(this, arg); 
    } 
}

使用JDK提供的類實現觀察者模式
通過使用JDK的類來實現上面實例相關的觀察模式，自帶的觀察者的類有Observer接口和Observable類，使用這兩個類中的方法可以很好的完成觀察者模式，而且JDK幫我們做了相關的加鎖操作，保證了線程安全，整體來說會對我們上面的例子進行改進和簡化操作，代碼如下：

package com.niuh.designpattern.observer.v2; 
 
import java.text.DateFormat; 
import java.util.Date; 
import java.util.Locale; 
import java.util.Observable; 
import java.util.Observer; 
 
/** 
 * 觀察者模式 
 */ 
public class ObserverPattern { 
 
    // 步驟6：開始上課，開始記錄報告 
    public static void main(String[] args) { 
        // 創建學生主體 
        StudentSubject studentSubject = new StudentSubject(); 
 
        // 創建觀察者老師 
        TeacherObserver teacherObversable = new TeacherObserver(); 
 
        // 創建觀察者班主任 
        HeadTeacherObserver headTeacherObserver = new HeadTeacherObserver(); 
 
        // 學生反映上課狀態 
        studentSubject.setState("講的不錯,很好!"); 
        studentSubject.addObserver(teacherObversable); 
        studentSubject.addObserver(headTeacherObserver); 
 
        // 開始上課 
        studentSubject.doNotify(); 
 
        // 上課結束 
        studentSubject.deleteObserver(headTeacherObserver); 
        studentSubject.deleteObserver(teacherObversable); 
    } 
} 
 
 
/** 
 * 課程類 
 */ 
class Course { 
 
    // 上課時間:time 
    private Date time; 
    // 上課地點:place 
    private String place; 
    // 上課內容:content 
    private String content; 
 
    public Date getTime() { 
        return time; 
    } 
 
    public void setTime(Date time) { 
        this.time = time; 
    } 
 
    public String getPlace() { 
        return place; 
    } 
 
    public void setPlace(String place) { 
        this.place = place; 
    } 
 
    public String getContent() { 
        return content; 
    } 
 
    public void setContent(String content) { 
        this.content = content; 
    } 
 
    public Course() { 
    } 
 
    public Course(Date time, String place, String content) { 
        this.time = time; 
        this.place = place; 
        this.content = content; 
    } 
} 
 
 
 
 
 
/** 
 * 老師類 
 * - 觀察者之一 
 * - 觀察學生的上課情況 
 */ 
class TeacherObserver implements Observer { 
 
    private Course course; 
 
    @Override 
    public void update(Observable o, Object arg)  { 
        DateFormat df = DateFormat.getTimeInstance(DateFormat.LONG, Locale.CHINA); 
        System.out.println("我是王老師,正在講課中..."); 
 
        course = new Course(new Date(), "A棟教學樓", "高等數學"); 
        System.out.println("今天上課時間:" + df.format(course.getTime()) + " 地點:" + course.getPlace() + " 上課內容:" + course.getContent()); 
    } 
} 
 
/** 
 * 班主任來聽課 
 * - 觀察者之一 
 * - 觀察學生的上課情況 
 */ 
class HeadTeacherObserver implements Observer { 
    @Override 
    public void update(Observable o, Object arg) { 
        System.out.println("我是班主任來聽課了,正在檢查課程質量..."); 
        System.out.println("學生反饋課程質量為:" + arg); 
    } 
} 
 
 
/** 
 * 學生主體 
 * - 被觀察的對象 
 */ 
class StudentSubject extends Observable { 
    /** 
     * 上課狀態 
     */ 
    private String state; 
 
    public String getState() { 
        return state; 
    } 
 
    public void setState(String state) { 
        this.state = state; 
    } 
 
    public void doNotify() { 
        // 設置標志 
        this.setChanged(); 
        // 通知觀察者做出相應動作 
        this.notifyObservers(state); 
    } 
}

輸出結果：

我是班主任來聽課了,正在檢查課程質量...
學生反饋課程質量為:講的不錯,很好!
我是王老師,正在講課中...
今天上課時間:上午12時04分27秒地點:A棟教學樓上課內容:高等數學

PS：以上代碼提交在 Github ：

https://github.com/Niuh-Study/niuh-designpatterns.git

責任編輯：姜華來源：今日頭條

觀察者模式

成人免费xxxxx在线视频软件_久久精品久久久_亚洲国产精品久久久_天天色天天色_亚洲人成一区_欧美一级欧美三级在线观看

設計模式系列—觀察者模式