2. 程式人生 > >【原創】自己動手循序漸進實現觀察者模式

【原創】自己動手循序漸進實現觀察者模式

阿新 • • 發佈：2018-04-29
接口 定義 。。 推導 ole com package exce ++

引言

自上一篇《自己動手實現牛逼的單例模式》問世之後，得到了不錯的評價。於是博主在五一放棄出去遊玩機會，趕制了這篇《自己動手循序漸進實現觀察者模式》，依然還是一步一步推導出最終版的觀察者模式。

觀察者模式的定義

在許多設計中，經常涉及多個對象都對一個特殊對象中的數據變化感興趣，而且這多個對象都希望跟蹤那個特殊對象中的數據變化，在這樣的情況下就可以使用觀察者模式。
在這裏，我們以母親觀察寶寶為例子，寶寶正在睡覺，醒來後，母親做出相應的餵食行為。

觀察者V1

先定義一個Baby類，baby先睡五秒，五秒後醒來，代碼如下所示

package rjzheng.observer1;
public class Baby implements Runnable {
    // 默認是睡著
    private boolean wakeup = false;
    // 醒來的行為
    public void wakeUp() {
        this.wakeup = true;
    }
    public boolean isWakeup() {
        return wakeup;
    }
    public void setWakeup(boolean wakeup) {
        this.wakeup = wakeup;
    }
    @Override
    public void run() {
        // TODO Auto-generated method stub
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        wakeUp();
    }
}

而母親類即Mother類，則一直監聽寶寶的狀態，寶寶一醒來就餵食，代碼如下所示

package rjzheng.observer1;
public class Mother implements Runnable {
    private Baby baby;
    public Mother(Baby baby) {
        this.baby = baby;
    }
    public void feed(Baby baby){
        System.out.println("已經給寶貝餵食");
    }
    @Override
    public void run(){
        while(!baby.isWakeup()){
            for(int i=0;i<5;i++){
                try {
                    Thread.sleep(1000);
                    System.out.println("寶寶還有"+(5-i)+"秒醒來");
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
        this.feed(baby);
    }
}

然後寫一個ObserverTest1測試一下，代碼如下所示

package rjzheng.observer1;

public class ObserverTest1 {
    public static void main(String[] args) {
        Baby baby =new Baby();
        new Thread(baby).start();
        new Thread(new Mother(baby)).start();
        
    }
}

輸出如下

寶寶還有5秒醒來
寶寶還有4秒醒來
寶寶還有3秒醒來
寶寶還有2秒醒來
寶寶還有1秒醒來
已經給寶貝餵食

觀察者V2

可是上一版，母親要一直看著寶寶，母親覺得太累了，母親要是想中間聊個微信啥的，多不方便，於是V2版出現了。我們能不能孩子醒來後，主動告訴給母親呢。於是修改Baby的wakeUp方法，即醒來狀態改變後，增加一個通知母親的方法。
綜上所述，Baby類做如下幾點修改

  1. 持有Mother的引用，修改構造函數
  2. 在wakeUp方法中增加，通知母親的邏輯
  3. 在run方法中，自己五秒後醒來，自己修改自己的狀態
package rjzheng.observer2;
public class Baby implements Runnable {
    // 默認是睡著
    private boolean wakeup = false;
    
    private Mother mother;
    //1. 持有Mother的引用，修改構造函數
    public Baby(Mother mother){
        this.mother = mother;
    }
    
    //2. 在wakeUp方法中增加，通知母親的邏輯
    public void wakeUp() {
        wakeup = true;
        this.mother.feed(this);
    }
    public boolean isWakeup() {
        return wakeup;
    }
    public void setWakeup(boolean wakeup) {
        this.wakeup = wakeup;
    }
    //3. 在run方法中，自己五秒後醒來，自己修改自己的狀態
    @Override
    public void run() {
        while(!this.isWakeup()){
            for(int i=0;i<5;i++){
                try {
                    Thread.sleep(1000);
                    System.out.println("寶寶還有"+(5-i)+"秒醒來");
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
            this.wakeUp();
        }
    }
}

而Mother類，則不需要做線程操作，Baby類通知Mother類後，做出相應處理即可。因此，Mother類修改如下

  1. 刪除run方法等線程相關操作
  2. 增加一個無參構造方法(因為Mother類不需要持有Baby類的引用了)
    綜上所述，Mother類的代碼如下
package rjzheng.observer2;
public class Mother{
    private Baby baby;
    public Mother(){
        
    }
    public Mother(Baby baby) {
        this.baby = baby;
    }
    public void feed(Baby baby){
        System.out.println("已經給寶貝餵食");
    }
}

測試類ObserverTest2的代碼如下

package rjzheng.observer2;

public class ObserverTest2 {
    public static void main(String[] args) {
        Baby baby =new Baby(new Mother());
        new Thread(baby).start();
        
    }
}

輸出如下所示

寶寶還有5秒醒來
寶寶還有4秒醒來
寶寶還有3秒醒來
寶寶還有2秒醒來
寶寶還有1秒醒來
已經給寶貝餵食

觀察者V3

這個時候，寶寶的父親回來了。父親覺得，在寶寶醒來後，應該帶寶寶出去玩。於是就和孩子他媽約定，根據孩子醒來的時間決定，帶孩子做什麽。如果醒來的時間是飯點，就給孩子餵食；如果醒來的時間不是飯點，就帶孩子出去玩。
那麽重點來了，醒來的時間是否為飯點這個屬性，放在父親類裏，不大合適；放在寶寶類裏也不大合適；放母親類裏也不大合適。根據面向對象的設計原則，我們定義一個醒來的事件類WakeUpEvent,將醒來的時間是否為飯點放在WakeUpEvent裏。除此之外，再定義一個事件源source屬性，那麽WakeUpEvent類如下所示

package rjzheng.observer3;
/**
 * 醒來的事件對象
 * @author zhengrongjun
 *
 */
public class WakeUpEvent {
    //醒來時間是否為飯點
    private boolean isFoodTime;
    //事件源
    private Baby source;
    public WakeUpEvent(boolean isFoodTime,Baby source){
        this.isFoodTime = isFoodTime;
        this.source = source;
    }
    public boolean isFoodTime() {
        return isFoodTime;
    }
    public void setFoodTime(boolean isFoodTime) {
        this.isFoodTime = isFoodTime;
    }
    public Baby getSource() {
        return source;
    }
    public void setSource(Baby source) {
        this.source = source;
    }
}

那麽，接下來,Father類擁有一個帶寶貝出去玩的方法，如下所示

package rjzheng.observer3;

public class Father {
    
    public void play(WakeUpEvent wakeUpEvent){
        if(!wakeUpEvent.isFoodTime()){
            System.out.println("抱寶貝出去玩");
        }
    }
}

自然，Mother類擁有一個給寶貝餵食的方法，如下所示

package rjzheng.observer3;
public class Mother{
    public void feed(WakeUpEvent wakeUpEvent){
        if(wakeUpEvent.isFoodTime()){
            System.out.println("給寶貝餵食");
        }
    }
}

那麽在這種情況下Baby類修改為如下所示

package rjzheng.observer3;

public class Baby implements Runnable {

    private Mother mother;
    private Father father;

    public Baby(Mother mother,Father father) {
        this.mother = mother;
        this.father = father;
    }

    public void wakeUp() {
        this.mother.feed(new WakeUpEvent(true, this));
        this.father.play(new WakeUpEvent(true, this));
    }

    @Override
    public void run() {
        boolean flag = true;
        while (flag) {
            for (int i = 0; i < 5; i++) {
                try {
                    Thread.sleep(1000);
                    System.out.println("寶寶還有" + (5 - i) + "秒醒來");
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
            this.wakeUp();
            flag=false;
        }
    }
}

測試類ObserverTest3如下所示

package rjzheng.observer3;

public class ObserverTest3 {
    public static void main(String[] args) {
        Baby baby =new Baby(new Mother(),new Father());
        new Thread(baby).start();
        
    }
}

運行結果如下

寶寶還有5秒醒來
寶寶還有4秒醒來
寶寶還有3秒醒來
寶寶還有2秒醒來
寶寶還有1秒醒來
給寶貝餵食

觀察者V4

又過了幾天，孩子不樂意了。。。。孩子覺得，我每次還要去記爸爸能帶我幹嘛，媽媽能帶我幹嘛，太麻煩了。以後，爺爺奶奶來來了，我難道還要去記你們能幹嘛，再通知相應的人嘛。不如這樣，我把你們全部叫來，你們自己商量好，該帶我幹嘛吧。

OK。。這也是觀察者V3版的缺點，代碼復用性太差。如果多一個爺爺GrandFather類，那Baby類裏頭還要多一個Grandfather類的引用，並且在wakeup裏增加通知邏輯，太麻煩。索性，定義一個WakeUpListener接口，繼承這個接口的人，代表都具有處理WakeUpEvent事件的能力

那麽WakeUpListener接口的源碼如下

package rjzheng.observer4;

public interface WakeUpListener {
    public void actiontoWakenUp(WakeUpEvent wakeUpEvent);
}

這時Father類和Mother類代碼如下，都實現了WakeUpListener接口

package rjzheng.observer4;

public class Father implements WakeUpListener {

    @Override
    public void actiontoWakenUp(WakeUpEvent wakeUpEvent) {
        // TODO Auto-generated method stub
        if(!wakeUpEvent.isFoodTime()){
            System.out.println("抱寶貝出去玩");
        } 
    }
}
package rjzheng.observer4;
public class Mother implements WakeUpListener{

    @Override
    public void actiontoWakenUp(WakeUpEvent wakeUpEvent) {
        if(wakeUpEvent.isFoodTime()){
            System.out.println("給寶貝餵食");
        }
    }
}

這時的Baby類如下所示

package rjzheng.observer4;

import java.util.ArrayList;
import java.util.List;

public class Baby implements Runnable {

    private List<WakeUpListener> wakeUpListeners = new ArrayList(); 

    public void addListeners(WakeUpListener wakeUpListener){
        this.wakeUpListeners.add(wakeUpListener);
    }

    public void wakeUp() {
        for(WakeUpListener listener : wakeUpListeners)
            listener.actiontoWakenUp(new WakeUpEvent(true, this));
    }

    @Override
    public void run() {
        boolean flag = true;
        while (flag) {
            for (int i = 0; i < 5; i++) {
                try {
                    Thread.sleep(1000);
                    System.out.println("寶寶還有" + (5 - i) + "秒醒來");
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
            this.wakeUp();
            flag=false;
        }
    }
}

測試類ObserverTest4為

package rjzheng.observer4;

public class ObserverTest4 {
    public static void main(String[] args) {
        Baby baby =new Baby();
        baby.addListeners(new Father());
        baby.addListeners(new Mother());
        new Thread(baby).start();
    }
}

最後結果如下

寶寶還有5秒醒來
寶寶還有4秒醒來
寶寶還有3秒醒來
寶寶還有2秒醒來
寶寶還有1秒醒來
給寶貝餵食

總結

本篇文章給出了四種觀察者模式，一般都是用V4版啦。。前面V1,V2,V3都只是鋪墊，為了引出最後一版的觀察者模式，希望大家有所收獲。

【原創】自己動手循序漸進實現觀察者模式

相關推薦

【原創】自己動手循序漸進實現觀察者模式

接口 定義 。。 推導 ole com package exce ++ 引言 自上一篇《自己動手實現牛逼的單例模式》問世之後，得到了不錯的評價。於是博主在五一放棄出去遊玩機會，趕制了這篇《自己動手循序漸進實現觀察者模式》，依然還是一步一步推導出最終版的觀察者模式。 觀察者模

【原創】自己動手實現牛逼的單例模式

pre adr 關鍵字 LV trace ack 也會 code exceptio 引言 其實寫這篇文章之前，我猶豫了一下，畢竟單例大家都知道，寫這麽一篇文章會不會讓人覺得老掉牙。後來想想，就當一種記錄吧。先來一副漫畫吧，如下圖所示 ok，我們回顧下小灰的遭遇，上述漫畫所

【原創】自己動手寫一個服務網關

exception 負責 lis world 前置 create ble ddr load 引言 什麽是網關？為什麽需要使用網關？ 如圖所示，在不使用網關的情況下，我們的服務是直接暴露給服務調用方。當調用方增多，勢必需要添加定制化訪問權限、校驗等邏輯。當添加API網關後，

【原創】自己手寫實現Boost序列化簡易版

設計思路   在與多個系統進行網路互動時，序列化是不可缺少的技術。編寫一個C++語言的序列化實現，是練習運用模板超程式設計的絕佳案例，理解C++模板是如何"面向編譯期程式設計"的（業內好像沒有這個說法）。序列化物件處理基礎資料型別和類型別，boost的序列化功能劃分得更細緻，基本支援了C++語言

【眼見為實】自己動手實踐理解READ COMMITTED && MVCC

開啟 see 查找 學習感悟 鏈表 user 應該 復讀 llb 【眼見為實】自己動手實踐理解 READ COMMITTED && MVCC 首先設置數據庫隔離級別為讀已提交（READ COMMITTED）: set global transaction i

【原創】利用“程序注入”實現無檔案不死webshell

引子   上週末，一個好兄弟找我說一個很重要的目標shell丟了，這個shell之前是通過一個S2程式碼執行的漏洞拿到的，現在漏洞還在，不過web目錄全部不可寫，問我有沒有辦法搞個webshell繼續做內網。正好我之前一直有個通過“程序注入”來實現記憶體webshell的想法，於是就趁這個機會以Java為例做

【原創】在java下實現的平衡二叉樹--轉載請註明出處

1.本篇部落格所研究的內容為平衡二叉樹，平衡二叉樹的特性為利用快速的利用二分法進行查詢資料，資料結構如下圖所示： 在上圖中，節點4為TreeMap的根節點，根節點為我們進行定址所使用的最初的節點，每個節點都具有左右兩個節點的引用，左側節點引用的物件是一個在比較時小於節點本身的值，

【設計模式】使用unity實現觀察者模式(delegate,event)

最近開發的時候，發現要用到設計模式中的觀察者模式，所以就找了一些資料來看看，然後自己結合Unity來實現了一下觀察者模式， 由於本人是初學者，寫的不好，望請指導。 首先，擺好如圖所示的UI的介面： 然後建立如下的指令碼： 1、Subject（這個指令碼是事件的派發類，

【一起學設計模式】觀察者模式實戰：真實專案中屢試不爽的瓜娃EventBus到底如何實現觀察者模式的？

申明 本文章首發自本人公眾號：壹枝花算不算浪漫，如若轉載請標明來源! 感興趣的小夥伴可關注個人公眾號：壹枝花算不算浪漫 22.jpg 前言 之前出過一個設計模式的系列文章，這些文章和其他講設計模式的文章 有些不同 文章沒有拘泥於講解設計模式的原理，更多的是梳理工作中實際用到的一些設計模式，並提取出對應業務模

使用util包裏自帶的接口和類實現觀察者模式

註意 簡化 響應 cat pan hang sys ext main 之前的關於觀察者模式的文章，是用自己寫的Observable接口和Observer接口，然後進行實現。其實官方的util包下自帶有實現觀察者模式對應的接口和類，可以簡化我們的代碼結構。 比如我們可

Vue雙向繫結原理實現——觀察者模式

前言 Vue 框架是一種 MVVM 框架，它有一個很大的特點就是資料雙向繫結，在開發過程中我們只需要操作 Model ，而不需要修改 View ，使用起來 VR 因吹斯汀。但是它的實現原理並不複雜，主要是運用了設計模式中的觀察者模式，也可以說是加了鉤子函式。下面用原生 JS 實現一下。

Proxy 實現觀察者模式

以下參考阮老師的《ECMAScript 6 入門》 需求：給定一個物件，當物件的屬性發生賦值時，列印最新的值。 思路： observable 函式返回一個原始物件的 Proxy 代理，攔截賦值操作，觸發充當觀察者的各個函式。 //初始化觀察者佇列 const u

C++ 11標準簡單實現觀察者模式

觀察者模式簡單理解：被觀察者的狀態發生變化，觀察者的行為同時也發生變化。 觀察者模式的簡單應用：           1.宣告被觀察者物件。           2.觀察者向被觀察者註冊訊息相應函式。           3.觀察者屬性發生變化，同時註冊上的觀察者出發

原生JavaScript實現觀察者模式

什麼是觀察者模式 維基百科對觀察者模式的定義如下： 觀察者模式是軟體設計模式的一種。在此種模式中，一個目標物件管理所有相依於它的觀察者物件，並且在它本身的狀態改變時主動發出通知。這通常透過呼叫各觀察者所提供的方法來實現。此種模式通常被用來實時事件處理系

js如何實現觀察者模式

定義：觀察者模式，又叫釋出訂閱者模式，又叫訊息系統，又叫訊息機制，又叫自定義事件，解決主體與觀察者之間的耦合問題 特點： 1 解決的是耦合問題（類與類之間，物件之間，類與物件之間，模組之間） 2 對於任何一個觀察者來說，其他觀察者的改變不會影響自身 3 對於任何一個物

在.NET中實現觀察者模式（3種技術）

目錄 介紹 背景 示例場景 實現 觀察者模式（在.NET 4.0之前版本） <技術＃1> <技術＃2> <技術＃3> 在.NET中實現觀察者模式的多種技術 下載原始碼 - 79.8 KB 介紹 我們

如何使用 Java8 實現觀察者模式？（下）

【編者按】本文作者是 BAE 系統公司的軟體工程師 Justin Albano。在本篇文章中，作者通過在 Java8 環境下實現觀察者模式的例項，進一步介紹了什麼是觀察者模式、專業化及其命名規則，供大家參考學習。本文系國內 ITOM 管理平臺 OneAPM 工程

設計模式實現——觀察者模式

觀察者模式簡介 又稱釋出——訂閱模式，主要用於類物件之間訊息通知。當主要物件發生資訊變更後，與之相關聯的資訊也應該變更顯示。 主要的操作: 1、先建立主體subject； 2、建立觀察者，同時告訴它要關注的主體subuject。 3、主體subject要知道哪些人關注了它

微信發個朋友圈沒有想到也可以用設計模式來實現——觀察者模式

觀察者模式的概念         觀察者模式(Observer Pattern)：定義物件之間的一種一對多依賴關係，使得每當一個物件狀態發生改變時，其相關依賴物件皆得到通知並被自動更新。觀察者模式的別名包括髮布-訂閱（Publish/Subscribe）模式、模型-檢視（M

使用php標準庫spl在實現觀察者模式

上次使用了純php實現了一個觀察者模式（php觀察者模式）， 現在使用php標準庫spl在次實現觀察者模式，好處是：隨意的生成您想使用的觀察者！ <?php /** * Created by PhpStorm. * User: evolution * Date