【觀察者設計模式詳解】C/Java/JS/Go/Python/TS不同語言實現

刀法如飛發表於2023-04-21
設計模式JavaJSGoPython

簡介

觀察者模式（Observer Pattern）是一種行為型模式。它定義物件間的一種一對多的依賴關係，當一個物件的狀態發生改變時，所有依賴於它的物件都得到通知並被自動更新。

觀察者模式使用三個類Subject、Observer和Client。Subject物件帶有繫結觀察者到Client物件和從Client物件解綁觀察者的方法。我們建立Subject類、Observer抽象類和擴充套件了抽象類Observer的實體類。

作用

  1. 一個物件狀態更新，其他依賴物件收到通知和自動更新的機制。
  2. 實現模組化分離，實現主題與觀察者互動物件之間的松耦合。
    1）觀察者定義了物件之間一對多的關係。
    2）被觀察者(主題)用一個共同的介面來更新觀察者。
    3）觀察者和被觀察者用松耦合方式結合，被觀察者不知道觀察者的細節，只知道觀察者實現了觀察者介面。

實現步驟

  1. 建立觀察者observer基礎介面，包含主題和更新方法
  2. 建立主題subject抽象類，包含observer列表以及新增和刪除方法
  3. 建立具體的主題類，實現通知方法，釋出通知時輪詢通知全部觀察者
  4. 建立多個具體觀察者，與主題關聯，並實現自己的更新方法
  5. 客戶呼叫時先宣告主題，再將觀察者分別新增到主題，當主題釋出通知時，觀察者自動更新

UML

 

 

Java程式碼

觀察者介面

// ObserverAPI.java 觀察者介面，Java 9已經預設支援Observer介面
// 這裡避免衝突採取ObserverAPI命名
public interface ObserverAPI {
   public Subject subject = null;
   public void update(String content);
}

具體觀察者

// ConcreteObserver.java 具體的觀察者實現類，也可以看成訂閱者，關聯對應的主題類。
// 不同的觀察者也可以對應多個主題
public class ConcreteObserver implements ObserverAPI {

   public Subject subject;

   // 給觀察者繫結主題，同時把觀察者新增到主題列表
   public ConcreteObserver(Subject subject) {
      this.subject = subject;
      this.subject.register((ObserverAPI) this);
   }

   // 觀察者發出更新通知，不用單獨告訴訂閱者，由訂閱者自行監聽
   public void update(String content) {
      System.out.println(String.format("%s::update() [subject.name = %s content = %s]",
            this.getClass().getName(),
            this.subject.getName(), content));
   }
}

// ConcreteObserver2.java 具體的觀察者實現類，也可以看成訂閱者，關聯對應的主題類。
// 不同的觀察者可以對應不同的主題。
public class ConcreteObserver2 implements ObserverAPI {

  // 這裡沒有在構造器就繫結某個主題，而是從客戶角度去註冊觀察者
  public ConcreteObserver2() {
  }

  // 觀察者發出更新通知，觀察者自行監聽
  public void update(String content) {
    System.out.println(String.format("%s::update() [content = %s]",
        this.getClass().getName(), content));
  }
}

抽象主題類

// Subject.java 定義抽象主題類或者介面，供具體主題類繼承
public abstract class Subject {
   private String name;
   // protected Set<ObserverAPI> observers = new HashSet<>();
   protected List<ObserverAPI> observers = new ArrayList<>();

   public String getName() {
      return name;
   }

   public void setName(String name) {
      this.name = name;
   }

   public void register(ObserverAPI observer) {
      System.out.println(this.getClass().getName() + "::register() [observer = " + observer.getClass().getSimpleName() + "]");
      observers.add(observer);
   }

   public void remove(ObserverAPI observer) {
      observers.remove(observer);
   }

   // 通知由具體類來實現邏輯
   public abstract void notify(String name);
}

具體主題類

// ConcreteSubject.java 觀察者主題類，也是釋出者，重寫具體的通知方法。不同主題可以關聯不同的觀察者。
public class ConcreteSubject extends Subject {

   public ConcreteSubject(String name) {
      this.setName(name);
   }

   // 不同的主題類有自己的通知方法，批次通知繫結的觀察者
   @Override
   public void notify(String content) {
      System.out.println(this.getClass().getName() + "::notify() [content = " + content + "]");
      for (Object observer : this.observers) {
         ((ObserverAPI) observer).update(content);
      }

   }

}

測試呼叫

    /**
     * 觀察者模式應用非常廣泛，主要是觀察者提前繫結到釋出者
     * 當釋出者釋出訊息時，批次廣播通知，而無需逐一通知
     * 觀察者監聽到訊息後自己決定採取哪一種行為
     */

    // 定義一個主題，也就是釋出者
    Subject concreteSubject = new ConcreteSubject("subject1");
    // 再宣告觀察者，透過構造器註冊到主題上
    ObserverAPI observer1 = new ConcreteObserver(concreteSubject);

    // 也可以單獨給主題註冊一個新的觀察者
    concreteSubject.register(new ConcreteObserver2());
    // 可以移除觀察者物件，可以開啟註釋試下
    // concreteSubject.remove(observer1);

    // 主題開始釋出新通知，各觀察者自動更新
    concreteSubject.notify("hello, this is broadcast.");

Python程式碼

觀察者介面

# ObserverAPI.py 觀察者抽象父類，定義一些公共方法
class ObserverAPI:

    def __init__(self, name):
        self.name = name

    # 觀察者發出更新通知，觀察者自行監聽
    def update(self, content):
        print(self.__class__.__name__ + '::update() [content = ' + content + ']')

    def set_name(self, name):
        self.name = name

具體觀察者

# ConcreteObserver.py 具體的觀察者實現類，也可以看成訂閱者，關聯對應的主題類。
# 不同的觀察者也可以對應多個主題
from src.ObserverAPI import ObserverAPI

# 具體的觀察者實現類，也可以看成訂閱者，關聯對應的主題類。
# 不同的觀察者也可以對應多個主題


class ConcreteObserver(ObserverAPI):
    # 給觀察者繫結主題，同時把觀察者新增到主題列表
    def __init__(self, subject, name):
        ObserverAPI.__init__(self, name)
        
        # python3支援的父類呼叫
        # super(ConcreteObserver, self).__init__(name)
        # super().__init__(name)

        self.subject = subject
        subject.register(self)

    # 觀察者發出更新通知，不用單獨告訴訂閱者，由訂閱者自行監聽
    def update(self, content):
        print(self.__class__.__name__ + '::update() [subject.name = ' +
              self.subject.name + ' content = ' + content + ']')

# ConcreteObserver2.py 具體的觀察者實現類，也可以看成訂閱者，關聯對應的主題類。
# 不同的觀察者可以對應不同的主題。
from src.ObserverAPI import ObserverAPI


# 具體的觀察者實現類，也可以看成訂閱者，關聯對應的主題類。
# 不同的觀察者可以對應不同的主題。
class ConcreteObserver2(ObserverAPI):
    # 這裡沒有在構造器就繫結某個主題，而是從客戶角度去註冊觀察者
    # 觀察者發出更新通知，觀察者自行監聽

    # def update(self, content):
    #     print(self.__class__.__name__ + '::update() [content = ' + content +']')
    
    pass

抽象主題類

# Subject.py 定義抽象主題類或者介面，供具體主題類繼承
class Subject:

    def __init__(self, name):
        self.name = name
        self.observers = []

    def get_name(self):
        return self.name

    def set_name(self, name):
        self.name = name

    def register(self, observer):
        print(self.__class__.__name__ + '::register() [observer = ' +
              observer.__class__.__name__ + ']')

        self.observers.append(observer)

    def remove(self, observer):
        self.observers.remove(observer)

    # 通知由具體類來實現邏輯
    def notify(self, name):
        pass

具體主題類

// ConcreteSubject.py 觀察者主題類，也是釋出者，重寫具體的通知方法。不同主題可以關聯不同的觀察者。
from src.Subject import Subject


# 觀察者主題類，也是釋出者，重寫具體的通知方法。不同主題可以關聯不同的觀察者。
class ConcreteSubject(Subject):
    # 不同的主題類有自己的通知方法，批次通知繫結的觀察者
    def notify(self, content):
        print(self.__class__.__name__ + '::notify() [content = ' + content +
              ']')
        for observer in self.observers:
            observer.update(content)

測試呼叫

import sys
import os

os_path = os.getcwd()
sys.path.append(os_path)

from src.ConcreteSubject import ConcreteSubject
from src.ConcreteObserver import ConcreteObserver
from src.ConcreteObserver2 import ConcreteObserver2


def test():
    '''
    * 觀察者模式應用非常廣泛，主要是觀察者提前繫結到釋出者
    * 當釋出者釋出訊息時，批次廣播通知，而無需逐一通知
    * 觀察者監聽到訊息後自己決定採取哪一種行為
    '''

    # 定義一個主題，也就是釋出者
    concrete_subject = ConcreteSubject('subject1')
    # 再宣告觀察者，透過構造器註冊到主題上
    observer1 = ConcreteObserver(concrete_subject, 'observer1')
    # 也可以單獨給主題註冊一個新的觀察者
    observer2 = ConcreteObserver2('observer2')
    concrete_subject.register(observer2)
    # 可以移除觀察者物件
    # concrete_subject.remove(observer1)

    # 主題開始釋出新通知，各觀察者自動更新
    concrete_subject.notify('hello, this is broadcast.')


if __name__ == '__main__':
    print(__file__)
    print("test start:")
    test()

更多語言版本

不同語言實現設計模式：https://github.com/microwind/design-pattern

相關文章