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

結構
--

參與類別
----

參與本模式的各類別列出如下。成員函式以模擬的方式列出。

### 抽象目標類別

此抽象類別提供一個界面讓觀察者進行添附與解附作業。此類別內有個不公開的觀察者串鍊，並透過下列函式(方法)進行作業

* 添附(Attach)：新增觀察者到串鍊內，以追蹤目標物件的變化。
* 解附(Detach)：將已經存在的觀察者從串鍊中移除。
* 通知(Notify)：利用觀察者所提供的更新函式來通知此目標已經產生變化。

添附函式包涵了一個觀察者物件參數。也許是觀察者類別的虛擬函式(即更新函式)，或是在非物件導向的設定中所使用的函式指標(更廣泛來講，函式子或是函式物件)。

### 目標類別

此類別提供了觀察者欲追蹤的狀態。也利用其源類別(例如前述的抽象目標類別)所提供的方法,來通知所有的觀察者其狀態已經更新。此類別擁有以下函式

* 取得狀態(GetState)：回傳該目標物件的狀態。

### 抽象觀察者介面

抽象觀察者類別是一個必須被實做的抽象類別。這個類別定義了所有觀察者都擁有的更新用介面，此介面是用來接收目標類別所發出的更新通知。此類別含有以下函式

* 更新(Update)：會被實做的一個抽象(虛擬)函式。

### 觀察者類別

這個類別含有指向目標類別的參考(reference)，以接收來自目標類別的更新狀態。此類別含有以下函式

* 更新(Update)：是前述抽象函式的實做。當這個函式被目標物件呼叫時，觀察者物件將會呼叫目標物件的取得狀態函式，來其所擁有的更新目標物件資訊。

每個觀察者類別都要實做它自己的更新函式，以應對狀態更新的情形。

當目標物件改變時，會通過呼叫它自己的通知函式來將通知送給每一個觀察者物件，這個通知函式則會去呼叫已經添附在串鍊內的觀察者更新函式。通知與更新函式可能會有一些參數，好指明是目前目標物件內的何種改變。這麼作將可增進觀察者的效率(只更新那些改變部份的狀態)。

用途
--

* 當抽象個體有兩個互相依賴的層面時。封裝這些層面在單獨的物件內將可允許程式設計師單獨地去變更與重複使用這些物件，而不會產生兩者之間交互的問題。
* 當其中一個物件的變更會影響其他物件，卻又不知道多少物件必須被同時變更時。
* 當物件應該有能力通知其他物件，又不應該知道其他物件的實做細節時。

觀察者模式通常與 MVC 範式有關係。在 MVC 中，觀察者模式被用來降低 model 與 view 的耦合程度。一般而言， model 的改變會觸發通知其他身為觀察者的 model 。而這些 model 實際上是 view 。 Java Swing 就是個範例，示意了 model 預期會透過 PropertyChangeNotification 架構以送出改變的通知給其他 view 。 Model 類別是 Java bean 類別的一員，並擁有與上述目標類別同樣的行為。 View 類別則繫結了一些 GUI 中的可視元素，並擁有與上述觀察者類別同樣的行為。當應用程式在執行時。使用者將因 view 做出相應的更新而看見 model 所產生的變更。

示例
--

### Python

  

```
class AbstractSubject(object):
    def register(self, listener):
        raise NotImplementedError("Must subclass me")
 
    def deregister(self, listener):
        raise NotImplementedError("Must subclass me")
 
    def notify\_listeners(self, event):
        raise NotImplementedError("Must subclass me")
 
class Listener(object):
    def \_\_init\_\_(self, name, subject):
        self.name = name
        subject.register(self)
 
    def notify(self, event):
        print(self.name, "received event", event)
 
class Subject(AbstractSubject):
    def \_\_init\_\_(self):
        self.listeners = []
        self.data = None

    def getUserAction(self):
        self.data = raw\_input('Enter something to do:')
        return self.data

    # Implement abstract Class AbstractSubject

    def register(self, listener):
        self.listeners.append(listener)
 
    def deregister(self, listener):
        self.listeners.remove(listener)
 
    def notify\_listeners(self, event):
        for listener in self.listeners:
            listener.notify(event)

 
if \_\_name\_\_=="\_\_main\_\_":
    # make a subject object to spy on
    subject = Subject()
 
    # register two listeners to monitor it.
    listenerA = Listener("<listener A>", subject)
    listenerB = Listener("<listener B>", subject)
 
    # simulated event
    subject.notify\_listeners ("<event 1>")
    # outputs:
    # <listener A> received event <event 1>
    # <listener B> received event <event 1>
 
    action = subject.getUserAction()
    subject.notify\_listeners(action)
    #Enter something to do:hello
    # outputs:
    # <listener A> received event hello
    # <listener B> received event hello

```

### C#

C#和其他使用.NET Framework的語言一般無需使用接口和類實現典型的觀察者模式，但是這裡依然給一個例子。

```
using System;
using System.Collections;

namespace Wikipedia.Patterns.Strategy
{
 // IObserver --> interface for the observer
 public interface IObserver
 {
 // called by the subject to update the observer of any change
 // The method parameters can be modified to fit certain criteria
 void Update(string message);
 }

 public class Subject
 {
 // use array list implementation for collection of observers
 private ArrayList observers;

 // constructor
 public Subject()
 {
 observers = new ArrayList();
 }

 public void Register(IObserver observer)
 {
 // if list does not contain observer, add
 if (!observers.Contains(observer))
 {
 observers.Add(observer);
 }
 }

 public void Deregister(IObserver observer)
 {
 // if observer is in the list, remove
 if (observers.Contains(observer))
 {
 observers.Remove(observer);
 }
 }

 public void Notify(string message)
 {
 // call update method for every observer
 foreach (IObserver observer in observers)
 {
 observer.Update(message);
 }
 }
 }

 // Observer1 --> Implements the IObserver
 public class Observer1 : IObserver
 {
 public void Update(string message)
 {
 Console.WriteLine("Observer1:" + message);
 }
 }

 // Observer2 --> Implements the IObserver
 public class Observer2 : IObserver
 {
 public void Update(string message)
 {
 Console.WriteLine("Observer2:" + message);
 }
 }

 // Test class
 public class ObserverTester
 {
 [STAThread]
 public static void Main()
 {
 Subject mySubject = new Subject();
 IObserver myObserver1 = new Observer1();
 IObserver myObserver2 = new Observer2();

 // register observers
 mySubject.Register(myObserver1);
 mySubject.Register(myObserver2);

 mySubject.Notify("message 1");
 mySubject.Notify("message 2");
 }
 }
}

```

### C++

```
#include <list>
#include <vector>
#include <algorithm>
#include <iostream>
using namespace std;

// The Abstract Observer
class ObserverBoardInterface
{
public:
 virtual void update(float a,float b,float c) = 0;
};

// Abstract Interface for Displays
class DisplayBoardInterface
{
public:
 virtual void show() = 0;
};

// The Abstract Subject
class WeatherDataInterface
{
public:
 virtual void registerob(ObserverBoardInterface\* ob) = 0;
 virtual void removeob(ObserverBoardInterface\* ob) = 0;
 virtual void notifyOb() = 0;
};

// The Concrete Subject
class ParaWeatherData: public WeatherDataInterface
{
public:
 void SensorDataChange(float a,float b,float c)
 {
 m\_humidity = a;
 m\_temperature = b;
 m\_pressure = c;
 notifyOb();
 }

 void registerob(ObserverBoardInterface\* ob)
 {
 m\_obs.push\_back(ob);
 }

 void removeob(ObserverBoardInterface\* ob)
 {
 m\_obs.remove(ob);
 }
protected:
 void notifyOb()
 {
 list<ObserverBoardInterface\*>::iterator pos = m\_obs.begin();
 while (pos != m\_obs.end())
 {
 ((ObserverBoardInterface\* )(\*pos))->update(m\_humidity,m\_temperature,m\_pressure);
 (dynamic\_cast<DisplayBoardInterface\*>(\*pos))->show();
 ++pos;
 }
 }

private:
 float m\_humidity;
 float m\_temperature;
 float m\_pressure;
 list<ObserverBoardInterface\* > m\_obs;
};

// A Concrete Observer
class CurrentConditionBoard : public ObserverBoardInterface, public DisplayBoardInterface
{
public:
 CurrentConditionBoard(WeatherDataInterface& a):m\_data(a)
 {
 m\_data.registerob(this);
 }
 void show()
 {
 cout<<"\_\_\_\_\_CurrentConditionBoard\_\_\_\_\_"<<endl;
 cout<<"humidity: "<<m\_h<<endl;
 cout<<"temperature: "<<m\_t<<endl;
 cout<<"pressure: "<<m\_p<<endl;
 cout<<"\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_"<<endl;
 }

 void update(float h, float t, float p)
 {
 m\_h = h;
 m\_t = t;
 m\_p = p;
 }

private:
 float m\_h;
 float m\_t;
 float m\_p;
 WeatherDataInterface& m\_data;
};

// A Concrete Observer
class StatisticBoard : public ObserverBoardInterface, public DisplayBoardInterface
{
public:
 StatisticBoard(WeatherDataInterface& a):m\_maxt(-1000),m\_mint(1000),m\_avet(0),m\_count(0),m\_data(a)
 {
 m\_data.registerob(this);
 }

 void show()
 {
 cout<<"\_\_\_\_\_\_\_\_StatisticBoard\_\_\_\_\_\_\_\_\_"<<endl;
 cout<<"lowest temperature: "<<m\_mint<<endl;
 cout<<"highest temperature: "<<m\_maxt<<endl;
 cout<<"average temperature: "<<m\_avet<<endl;
 cout<<"\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_"<<endl;
 }

 void update(float h, float t, float p)
 {
 ++m\_count;
 if (t>m\_maxt)
 {
 m\_maxt = t;
 }
 if (t<m\_mint)
 {
 m\_mint = t;
 }
 m\_avet = (m\_avet \* (m\_count-1) + t)/m\_count;
 }

private:
 float m\_maxt;
 float m\_mint;
 float m\_avet;
 int m\_count;
 WeatherDataInterface& m\_data;
};

int main(int argc, char \*argv[])
{
 
 ParaWeatherData \* wdata = new ParaWeatherData;
 CurrentConditionBoard\* currentB = new CurrentConditionBoard(\*wdata);
 StatisticBoard\* statisticB = new StatisticBoard(\*wdata);

 wdata->SensorDataChange(10.2, 28.2, 1001);
 wdata->SensorDataChange(12, 30.12, 1003);
 wdata->SensorDataChange(10.2, 26, 806);
 wdata->SensorDataChange(10.3, 35.9, 900);

 wdata->removeob(currentB);

 wdata->SensorDataChange(100, 40, 1900); 
 
 delete statisticB;
 delete currentB;
 delete wdata;

 return 0;
}

```

### PHP

**class STUDENT**

```
<?php

class Student implements SplObserver{
    protected $tipo = "Student";
    private $nome;
    private $endereco;
    private $telefone;
    private $email;
    private $\_classes = array();

    public function GET\_tipo() {
        return $this->tipo;
    }

    public function GET\_nome() {
        return $this->nome;
    }

    public function GET\_email() {
        return $this->email;
    }

    public function GET\_telefone() {
        return $this->nome;
    }

    function \_\_construct($nome) {
        $this->nome = $nome;
    }

    public function update(SplSubject $object){
        $object->SET\_log("Comes from ".$this->nome.": I'm a student of ".$object->GET\_materia());
    }

}

?>

```

**class TEACHER**

```
<?php

class Teacher implements SplObserver{
    protected $tipo = "Teacher";
    private $nome;
    private $endereco;
    private $telefone;
    private $email;
    private $\_classes = array();

    public function GET\_tipo() {
        return $this->tipo;
    }

    public function GET\_nome() {
        return $this->nome;
    }

    public function GET\_email() {
        return $this->email;
    }

    public function GET\_telefone() {
        return $this->nome;
    }

    function \_\_construct($nome) {
        $this->nome = $nome;
    }

    public function update(SplSubject $object){
        $object->SET\_log("Comes from ".$this->nome.": I teach in ".$object->GET\_materia());
    }
}

?>

```

**Class SUBJECT**

```
<?php

class Subject implements SplSubject {
    private $nome\_materia;
    private $\_observadores = array();
    private $\_log = array();

    public function GET\_materia() {
        return $this->nome\_materia;
    }

    function SET\_log($valor) {
        $this->\_log[] = $valor ;
    }
    function GET\_log() {
        return $this->\_log;
    }

    function \_\_construct($nome) {
        $this->nome\_materia = $nome;
        $this->\_log[] = "Subject $nome was included";
    }
    /\* Adiciona um observador \*/
    public function attach(SplObserver $classes) {
        $this->\_classes[] = $classes;
        $this->\_log[] = "The ".$classes->GET\_tipo()." ".$classes->GET\_nome()." was included";
    }

    /\* Remove um observador \*/
    public function detach(SplObserver $classes) {
        foreach ($this->\_classes as $key => $obj) {
            if ($obj == $classes) {
                unset($this->\_classes[$key]);
                $this->\_log[] = "The ".$classes->GET\_tipo()." ".$classes->GET\_nome()." was removed";
            }
        }
    }

    /\* Notifica os observadores \*/
    public function notify(){
        foreach ($this->\_classes as $classes) {
            $classes->update($this);
        }
    }
}
?>

```

**Application**

```
<?php
require\_once("teacher.class.php");
require\_once("student.class.php");
require\_once("subject.class.php");

$subject = new Subject("Math");
$marcus = new Teacher("Marcus Brasizza");
$rafael = new Student("Rafael");
$vinicius = new Student("Vinicius");

// Include observers in the math Subject
$subject->attach($rafael);
$subject->attach($vinicius);
$subject->attach($marcus);

$subject2 = new Subject("English");
$renato = new Teacher("Renato");
$fabio = new Student("Fabio");
$tiago = new Student("tiago");

// Include observers in the english Subject
$subject2->attach($renato);
$subject2->attach($vinicius);
$subject2->attach($fabio);
$subject2->attach($tiago);

// Remove the instance "Rafael from subject"
$subject->detach($rafael);

// Notify both subjects
$subject->notify();
$subject2->notify();

echo "First Subject <br />";
echo "<pre>";
print\_r($subject->GET\_log());
echo "</pre>";
echo "<hr>";
echo "Second Subject <br />";
echo "<pre>";
print\_r($subject2->GET\_log());
echo "</pre>";
?>

```

**OUTPUT**

*First Subject* 

Array
(

```
   [0] =>  Subject Math was included
   [1] =>  The Student Rafael was included
   [2] =>  The Student Vinicius was included
   [3] =>  The Teacher Marcus Brasizza was included
   [4] =>  The Student Rafael was removed
   [5] => Comes from Vinicius: I'm a student of Math
   [6] => Comes from Marcus Brasizza: I teach in Math
```

)

  


---

Second Subject 

Array
(

```
   [0] =>  Subject English was included
   [1] =>  The Teacher Renato was included
   [2] =>  The Student Vinicius was included
   [3] =>  The Student Fabio was included
   [4] =>  The Student tiago was included
   [5] => Comes from Renato: I teach in English
   [6] => Comes from Vinicius: I'm a student of English
   [7] => Comes from Fabio: I'm a student of English
   [8] => Comes from tiago: I'm a student of English
```

)

亦可參考

  


|  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| 

| * 
* 论
* 编
软件设计模式 |
| --- |
|  |
| 设计模式 | 

|  |  |
| --- | --- |
| 创建型 | 
* 抽象工厂
* 生成器
* 工厂方法
* 惰性初始
* 原型
* 单例

 |
|  |
| 结构型 | 
* 适配器
* 桥接
* Composite（英语：）
* 修饰
* 外观
* 享元
* 代理

 |
|  |
| 行为型 | 
* 责任链
* 命令
* Interpreter（英语：）
* 迭代器
* 中介者
* Memento（英语：）
* 观察者
* Specification（英语：）
* State（英语：）
* 策略
* 模板方法
* 访问者

 |

 |
|  |
| 并行模式 | 
* 主动对象（英语：）
* 阻止（英语：）
* Binding properties（英语：）
* 双重检查锁定模式
* 异步方法调用
* Future与promise
* Guarded suspension（英语：）
* Join（英语：）
* 锁
* Messaging（英语：）
* 监视器
* Proactor（英语：）
* 反应器
* 读写锁
* 调度
* 线程池
* 线程局部存储

 |
|  |
| 架构模式 | 
* ADR（英语：）
* 主动记录
* Broker（英语：）
* 主從式架構
* cbd
* DAO
* DDD
* Data transfer object（英语：）
* Front controller（英语：）
* Identity map（英语：）
* Interceptor（英语：）
* 控制反转
* MVC
* 微服務
* MVP
* 單體式應用程式
* 多层架构
* *n*-tier（英语：）
* Naked objects（英语：）
* P2P
* 发布/订阅
* REST
* SOA
* Specification（英语：）

 |
|  |
| 云分布式 | 
* 断路器
* CQRS（英语：）
* 补偿交易（英语：）
* 索引表
* 领导者选举（英语：）
* MapReduce
* 物化视图（英语：）
* 管道
* 过滤器（英语：）
* 发布/订阅
* 分片（英语：）
* 节流（英语：）

 |
|  |
| 其他模式 | 
* Blackboard（英语：）
* Business delegate（英语：）
* Composite entity（英语：）
* 委托
* 依赖注入
* Intercepting filter（英语：）
* 惰性載入
* Method chaining（英语：）
* 模拟对象
* 空对象
* 对象池
* Servant（英语：）
* Twin（英语：）
* Type tunnel（英语：）

 |
|  |
| 书籍 | 
* 设计模式：可复用面向对象软件的基础
* 代碼大全
* 企业集成模式（英语：）

 |
|  |
| 人物 | 
* 克里斯托佛·亚历山大
* 埃里希·伽瑪
* Ralph Johnson（英语：）
* John Vlissides（英语：）
* 葛來迪·布區
* 肯特·貝克
* 沃德·坎宁安
* 马丁·福勒
* Robert Martin（英语：）
* Jim Coplien（英语：）
* Douglas Schmidt（英语：）
* Linda Rising

 |
|  |
| 社区 | 
* The Hillside Group（英语：）
* The Portland Pattern Repository（英语：）

 |

 |