1. 說明
觀察者模式（Observer Pattern）是一種行為型設(shè)計模式，用于定義對象之間的一對多依賴關(guān)系，使得當(dāng)一個對象的狀態(tài)發(fā)生改變時，所有依賴于它的對象都能夠自動收到通知并更新自己的狀態(tài)，以保持與被觀察對象的同步。觀察者模式也被稱為發(fā)布-訂閱模式。
觀察者模式包含以下關(guān)鍵角色：
- Subject（被觀察者）：Subject 是被觀察對象，它維護一組觀察者對象，并提供方法來添加、刪除和通知觀察者。當(dāng) Subject 的狀態(tài)發(fā)生改變時，它會通知所有注冊的觀察者。
- Observer（觀察者）：Observer 是觀察者對象，它定義了一個更新方法（通常命名為 update），用于接收被觀察對象的通知并執(zhí)行相應(yīng)的操作。多個觀察者可以訂閱同一個被觀察者。
- ConcreteSubject（具體被觀察者）：ConcreteSubject 是具體的被觀察對象，它實現(xiàn)了 Subject 接口，負(fù)責(zé)維護狀態(tài)并在狀態(tài)發(fā)生改變時通知觀察者。
- ConcreteObserver（具體觀察者）：ConcreteObserver 是具體的觀察者對象，它實現(xiàn)了 Observer 接口，并定義了在接收到通知時要執(zhí)行的具體操作。
觀察者模式的優(yōu)點包括：
- 解耦性：被觀察者和觀察者之間的關(guān)系是松散耦合的，它們可以獨立變化，不會相互影響。
- 可擴展性：可以方便地添加新的觀察者，無需修改被觀察者的代碼。
- 通知機制：當(dāng)被觀察者的狀態(tài)發(fā)生改變時，所有注冊的觀察者會自動收到通知，不需要手動輪詢。
觀察者模式是一種非常有用的模式，它可以幫助實現(xiàn)對象之間的松散耦合，提高系統(tǒng)的可維護性和可擴展性。
2. 使用的場景
觀察者模式在以下情況下特別有用，這些場景通常涉及到對象之間的狀態(tài)變化需要通知其他對象或組件：
- 事件處理和 GUI 開發(fā)： 在圖形用戶界面（GUI）應(yīng)用程序中，用戶交互和事件處理是觀察者模式的經(jīng)典用例。例如，按鈕點擊事件、窗口關(guān)閉事件、鼠標(biāo)移動事件等都可以通過觀察者模式來處理。
- 消息通知系統(tǒng)： 觀察者模式用于構(gòu)建發(fā)布-訂閱模型的消息通知系統(tǒng)，例如電子郵件通知、新聞訂閱、社交媒體通知等。當(dāng)有新消息或更新時，通知系統(tǒng)會通知所有訂閱者。
- 股票市場和金融領(lǐng)域： 在股票市場中，股票價格的變化會通知所有訂閱該股票的投資者。金融領(lǐng)域中也有類似的應(yīng)用，如外匯匯率變化通知。
- 分布式系統(tǒng)： 在分布式系統(tǒng)中，觀察者模式可以用于實現(xiàn)事件驅(qū)動的通信機制。當(dāng)一個節(jié)點的狀態(tài)發(fā)生變化時，可以通知其他節(jié)點或服務(wù)。
- 日志記錄和監(jiān)控系統(tǒng)： 觀察者模式可以用于監(jiān)控系統(tǒng)中，例如服務(wù)器日志記錄和性能監(jiān)控。當(dāng)系統(tǒng)狀態(tài)或日志條目發(fā)生變化時，觀察者可以記錄或報警。
- 實時數(shù)據(jù)更新： 當(dāng)需要在多個地方保持?jǐn)?shù)據(jù)同步時，觀察者模式可以用于實時數(shù)據(jù)更新，確保所有訂閱者都能及時獲得最新數(shù)據(jù)。
- 游戲開發(fā)： 在游戲開發(fā)中，觀察者模式常用于處理游戲中的事件和狀態(tài)變化，如角色狀態(tài)變化、敵人出現(xiàn)等。
總之，觀察者模式適用于任何需要對象之間的松散耦合、動態(tài)通信和狀態(tài)同步的場景。它有助于將系統(tǒng)組件分離，提高代碼的可維護性和可擴展性，并使系統(tǒng)更容易適應(yīng)變化。
3. 應(yīng)用例子
以下是一個使用 Python 實現(xiàn)的觀察者模式示例，模擬了一個簡單的股票市場通知系統(tǒng)：
# 定義觀察者接口
class Observer:
def update(self, message):
pass
# 定義具體觀察者類
class StockInvestor(Observer):
def __init__(self, name):
self.name = name
def update(self, message):
print(f"{self.name} 收到股票市場通知：{message}")
# 定義被觀察者類
class StockMarket:
def __init__(self):
self.investors = [] # 存儲觀察者
def add_investor(self, investor):
self.investors.append(investor)
def remove_investor(self, investor):
self.investors.remove(investor)
def notify_investors(self, message):
for investor in self.investors:
investor.update(message)
if __name__ == "__main__":
# 創(chuàng)建被觀察者對象
stock_market = StockMarket()
# 創(chuàng)建具體觀察者并注冊到被觀察者
investor1 = StockInvestor("投資者1")
investor2 = StockInvestor("投資者2")
stock_market.add_investor(investor1)
stock_market.add_investor(investor2)
# 發(fā)送通知給觀察者
stock_market.notify_investors("股票價格上漲！")
# 移除一個觀察者
stock_market.remove_investor(investor2)
# 再次發(fā)送通知給觀察者
stock_market.notify_investors("股票價格下跌！")
4. 實現(xiàn)要素
觀察者模式的實現(xiàn)要素包括以下幾個部分：
- Subject（被觀察者）： 被觀察者是一個具體的對象，它維護一組觀察者對象的引用，提供方法用于添加、刪除和通知觀察者。通常，被觀察者會維護一個狀態(tài)，當(dāng)狀態(tài)發(fā)生變化時，會通知所有觀察者。
- Observer（觀察者）： 觀察者是一個接口或抽象類，定義了一個更新方法（通常命名為 update），該方法在被觀察者狀態(tài)發(fā)生變化時被調(diào)用。具體的觀察者類實現(xiàn)該接口，以便接收被觀察者的通知并執(zhí)行相應(yīng)的操作。
- ConcreteSubject（具體被觀察者）： 具體被觀察者是被觀察者接口的實現(xiàn)類，它負(fù)責(zé)維護狀態(tài)并在狀態(tài)發(fā)生改變時通知觀察者。通常，具體被觀察者會維護一個觀察者列表，用于存儲注冊的觀察者。
- ConcreteObserver（具體觀察者）： 具體觀察者是觀察者接口的實現(xiàn)類，它定義了在接收到通知時要執(zhí)行的具體操作。每個具體觀察者都可以有不同的實現(xiàn)。
5. UML圖
- Subject 接口定義了 attach（添加觀察者）、detach（刪除觀察者）和 notify（通知觀察者）等方法。
- ConcreteSubject 類實現(xiàn)了 Subject 接口，它維護了一個觀察者列表，并在狀態(tài)發(fā)生變化時調(diào)用 notify 方法通知觀察者。
- Observer 接口定義了 update 方法，用于在被觀察者狀態(tài)發(fā)生變化時接收通知。
- ConcreteObserver 類實現(xiàn)了 Observer 接口，它包含具體的操作邏輯，以響應(yīng)被觀察者的通知。
觀察者模式的關(guān)鍵思想是被觀察者與觀察者之間的松散耦合，被觀察者不需要知道觀察者的具體實現(xiàn)，只需要知道它們實現(xiàn)了共同的接口。這種松散耦合使得系統(tǒng)更易于擴展和維護，符合面向?qū)ο笤O(shè)計原則中的依賴倒置原則。
6. Java/golang/javascrip/C++ 等語言實現(xiàn)方式
6.1 Java實現(xiàn)
上述例子用Java語言實現(xiàn)示例如下：
import java.util.ArrayList;
import java.util.List;
// 定義觀察者接口
interface Observer {
void update(String message);
}
// 定義具體觀察者類
class StockInvestor implements Observer {
private String name;
public StockInvestor(String name) {
this.name = name;
}
@Override
public void update(String message) {
System.out.println(name + " 收到股票市場通知：" + message);
}
}
// 定義被觀察者類
class StockMarket {
private List<Observer> investors = new ArrayList<>();
public void addInvestor(Observer investor) {
investors.add(investor);
}
public void removeInvestor(Observer investor) {
investors.remove(investor);
}
public void notifyInvestors(String message) {
for (Observer investor : investors) {
investor.update(message);
}
}
}
public class ObserverPatternExample {
public static void main(String[] args) {
// 創(chuàng)建被觀察者對象
StockMarket stockMarket = new StockMarket();
// 創(chuàng)建具體觀察者并注冊到被觀察者
Observer investor1 = new StockInvestor("投資者1");
Observer investor2 = new StockInvestor("投資者2");
stockMarket.addInvestor(investor1);
stockMarket.addInvestor(investor2);
// 發(fā)送通知給觀察者
stockMarket.notifyInvestors("股票價格上漲！");
// 移除一個觀察者
stockMarket.removeInvestor(investor2);
// 再次發(fā)送通知給觀察者
stockMarket.notifyInvestors("股票價格下跌！");
}
}
6.2 Golang實現(xiàn)
上述例子用golang實現(xiàn)示例如下：
package main
import "fmt"
// 定義觀察者接口
type Observer interface {
Update(message string)
}
// 定義具體觀察者結(jié)構(gòu)體
type StockInvestor struct {
Name string
}
func (si *StockInvestor) Update(message string) {
fmt.Printf("%s 收到股票市場通知：%s\n", si.Name, message)
}
// 定義被觀察者結(jié)構(gòu)體
type StockMarket struct {
investors []Observer
}
func (sm *StockMarket) AddInvestor(investor Observer) {
sm.investors = append(sm.investors, investor)
}
func (sm *StockMarket) RemoveInvestor(investor Observer) {
for i, obs := range sm.investors {
if obs == investor {
sm.investors = append(sm.investors[:i], sm.investors[i+1:]...)
break
}
}
}
func (sm *StockMarket) NotifyInvestors(message string) {
for _, investor := range sm.investors {
investor.Update(message)
}
}
func main() {
// 創(chuàng)建被觀察者對象
stockMarket := &StockMarket{}
// 創(chuàng)建具體觀察者并注冊到被觀察者
investor1 := &StockInvestor{Name: "投資者1"}
investor2 := &StockInvestor{Name: "投資者2"}
stockMarket.AddInvestor(investor1)
stockMarket.AddInvestor(investor2)
// 發(fā)送通知給觀察者
stockMarket.NotifyInvestors("股票價格上漲！")
// 移除一個觀察者
stockMarket.RemoveInvestor(investor2)
// 再次發(fā)送通知給觀察者
stockMarket.NotifyInvestors("股票價格下跌！")
}
6.3 Javascript實現(xiàn)
上述例子用javascript實現(xiàn)示例如下：
// 定義觀察者接口
class Observer {
update(message) {}
}
// 定義具體觀察者類
class StockInvestor extends Observer {
constructor(name) {
super();
this.name = name;
}
update(message) {
console.log(`${this.name} 收到股票市場通知：${message}`);
}
}
// 定義被觀察者類
class StockMarket {
constructor() {
this.investors = [];
}
addInvestor(investor) {
this.investors.push(investor);
}
removeInvestor(investor) {
const index = this.investors.indexOf(investor);
if (index !== -1) {
this.investors.splice(index, 1);
}
}
notifyInvestors(message) {
this.investors.forEach((investor) => {
investor.update(message);
});
}
}
// 創(chuàng)建被觀察者對象
const stockMarket = new StockMarket();
// 創(chuàng)建具體觀察者并注冊到被觀察者
const investor1 = new StockInvestor("投資者1");
const investor2 = new StockInvestor("投資者2");
stockMarket.addInvestor(investor1);
stockMarket.addInvestor(investor2);
// 發(fā)送通知給觀察者
stockMarket.notifyInvestors("股票價格上漲！");
// 移除一個觀察者
stockMarket.removeInvestor(investor2);
// 再次發(fā)送通知給觀察者
stockMarket.notifyInvestors("股票價格下跌！");
6.4 C++實現(xiàn)
上述例子用C++實現(xiàn)如下：
#include <iostream>
#include <vector>
// 定義觀察者基類
class Observer {
public:
virtual void update(const std::string& message) = 0;
};
// 定義具體觀察者類
class StockInvestor : public Observer {
public:
StockInvestor(const std::string& name) : name(name) {}
void update(const std::string& message) override {
std::cout << name << " 收到股票市場通知：" << message << std::endl;
}
private:
std::string name;
};
// 定義被觀察者類
class StockMarket {
public:
void addInvestor(Observer* investor) {
investors.push_back(investor);
}
void removeInvestor(Observer* investor) {
for (auto it = investors.begin(); it != investors.end(); ++it) {
if (*it == investor) {
investors.erase(it);
break;
}
}
}
void notifyInvestors(const std::string& message) {
for (auto investor : investors) {
investor->update(message);
}
}
private:
std::vector<Observer*> investors;
};
int main() {
// 創(chuàng)建被觀察者對象
StockMarket stockMarket;
// 創(chuàng)建具體觀察者并注冊到被觀察者
StockInvestor investor1("投資者1");
StockInvestor investor2("投資者2");
stockMarket.addInvestor(&investor1);
stockMarket.addInvestor(&investor2);
// 發(fā)送通知給觀察者
stockMarket.notifyInvestors("股票價格上漲！");
// 移除一個觀察者
stockMarket.removeInvestor(&investor2);
// 再次發(fā)送通知給觀察者
stockMarket.notifyInvestors("股票價格下跌！");
return 0;
}
7. 練習(xí)題
假設(shè)你正在開發(fā)一個簡單的天氣應(yīng)用程序，用戶可以訂閱并接收天氣預(yù)報通知。設(shè)計一個觀察者模式來實現(xiàn)這個應(yīng)用程序。
要求：文章來源：http://www.zghlxwxcb.cn/news/detail-726419.html
- 創(chuàng)建一個 WeatherData 類，作為被觀察者，它可以存儲當(dāng)前的天氣信息（例如溫度、濕度、氣壓）。
- 創(chuàng)建一個 Observer 接口，定義一個 update 方法，以便觀察者可以在天氣信息變化時收到通知。
- 創(chuàng)建具體觀察者類 CurrentConditionsDisplay，它實現(xiàn)了 Observer 接口，可以顯示當(dāng)前的溫度、濕度和氣壓。
- 在 WeatherData 類中，實現(xiàn)注冊觀察者、移除觀察者和通知觀察者的方法。
- 編寫一個測試程序，創(chuàng)建一個 WeatherData 對象和一個 CurrentConditionsDisplay 對象，然后模擬天氣信息的變化，觀察 CurrentConditionsDisplay 是否能夠接收并顯示最新的天氣信息。
你可以在評論區(qū)里或者私信我回復(fù)您的答案，這樣我或者大家都能幫你解答，期待著你的回復(fù)~文章來源地址http://www.zghlxwxcb.cn/news/detail-726419.html
到了這里，關(guān)于設(shè)計模式——14. 觀察者模式的文章就介紹完了。如果您還想了解更多內(nèi)容，請在右上角搜索TOY模板網(wǎng)以前的文章或繼續(xù)瀏覽下面的相關(guān)文章，希望大家以后多多支持TOY模板網(wǎng)！
