目录¶
1. 观察者模式简介¶
观察者模式(Observer Pattern)是一种行为型设计模式,用于建立对象之间的一种一对多的依赖关系。当一个对象的状态发生变化时,所有依赖于它的对象都会得到通知并自动更新。该模式通过 观察者(Observer) 和 被观察者(Subject) 之间的交互,实现了对象间的松散耦合。
关键点:
一对多关系:一个被观察者可以有多个观察者。
松散耦合:被观察者不需要知道观察者的具体信息,反之亦然。
自动通知:被观察者状态变化时,自动通知所有观察者。
2. 观察者模式的意图¶
观察者模式的主要目的是:
建立一对多的依赖关系:当一个对象(被观察者)的状态发生变化时,所有依赖于它的对象(观察者)都会被自动通知和更新。
实现松散耦合:被观察者不需要知道具体的观察者,实现了对象之间的低耦合。
支持动态的观察者管理:可以在运行时动态地增加或移除观察者,增强系统的灵活性和可扩展性。
简化对象间的通信:通过中介机制(被观察者),简化了对象间的直接通信。
3. 观察者模式的结构¶
3.1. 结构组成¶
观察者模式主要由以下四个角色组成:
Subject(被观察者):知道它的观察者,提供添加和删除观察者的方法,并在自身状态发生变化时通知观察者。
ConcreteSubject(具体被观察者):实现了Subject接口,维护了具体的状态,通知所有观察者其状态变化。
Observer(观察者):定义一个更新接口,用于接收被观察者的通知。
ConcreteObserver(具体观察者):实现了Observer接口,维护一个指向被观察者的引用,并在被观察者状态变化时更新自身状态。
角色关系:
Subject 持有一系列 Observer 的引用。
ConcreteSubject 在自身状态变化时,调用 Observer 的更新方法。
ConcreteObserver 通过 Subject 接收通知并更新自身状态。
3.2. UML类图¶
以下是观察者模式的简化UML类图:
+-----------------------------+ +--------------------+
| Subject |<>--------| Observer |
+-----------------------------+ +--------------------+
| + attach(o: Observer): void | | |
| + detach(o: Observer): void | | |
| + notify(): void | | |
+-----------------------------+ | + update(): void |
+--------------------+
^
|
+--------------------+
| ConcreteObserver |
+--------------------+
| - state: String |
| - subject: Subject |
+--------------------+
| + update(): void |
+--------------------+
+-----------------------------+
| ConcreteSubject |
+-----------------------------+
| - state: String |
| - observers: List<Observer> |
+-----------------------------+
| + attach(o: Observer): void |
| + detach(o: Observer): void |
| + notify(): void |
| + getState(): String |
| + setState(s: String): void |
+-----------------------------+
说明:
Subject 接口定义了观察者管理的方法和通知方法。
ConcreteSubject 实现了 Subject 接口,维护了状态和观察者列表,并在状态变化时通知所有观察者。
Observer 接口定义了
update()
方法,供被观察者调用以通知状态变化。ConcreteObserver 实现了 Observer 接口,维护了对 Subject 的引用,并在
update()
方法中获取被观察者的状态以更新自身。
4. 观察者模式的实现¶
观察者模式的实现需要确保被观察者与观察者之间的松散耦合。以下示例将展示如何在Java和Python中实现观察者模式。以一个简单的股票价格发布系统为例,实现被观察者(股票)和观察者(投资者)之间的交互。
4.1. Java 实现示例¶
示例说明¶
我们将实现一个简单的股票价格发布系统,被观察者为股票,观察者为投资者。当股票价格发生变化时,所有投资者都会收到通知。
代码实现¶
// Observer接口
public interface Observer {
void update(String stockName, double stockPrice);
}
// Subject接口
public interface Subject {
void attach(Observer o);
void detach(Observer o);
void notifyObservers();
}
// ConcreteSubject类
import java.util.ArrayList;
import java.util.List;
public class Stock implements Subject {
private String name;
private double price;
private List<Observer> observers = new ArrayList<>();
public Stock(String name, double price){
this.name = name;
this.price = price;
}
public void setPrice(double price){
this.price = price;
System.out.println(name + " 的价格已更新为: " + this.price);
notifyObservers();
}
public double getPrice(){
return this.price;
}
public String getName(){
return this.name;
}
@Override
public void attach(Observer o){
observers.add(o);
}
@Override
public void detach(Observer o){
observers.remove(o);
}
@Override
public void notifyObservers(){
for(Observer o : observers){
o.update(this.name, this.price);
}
}
}
// ConcreteObserver类
public class Investor implements Observer {
private String name;
public Investor(String name){
this.name = name;
}
@Override
public void update(String stockName, double stockPrice){
System.out.println("投资者 " + name + " 收到通知: " + stockName + " 的最新价格为 " + stockPrice);
}
}
// 客户端代码
public class ObserverPatternDemo {
public static void main(String[] args) {
Stock apple = new Stock("Apple", 150.00);
Investor investor1 = new Investor("Tom");
Investor investor2 = new Investor("Jerry");
apple.attach(investor1);
apple.attach(investor2);
apple.setPrice(155.00);
apple.setPrice(160.50);
apple.detach(investor1);
apple.setPrice(165.75);
}
}
输出¶
Apple 的价格已更新为: 155.0
投资者 Tom 收到通知: Apple 的最新价格为 155.0
投资者 Jerry 收到通知: Apple 的最新价格为 155.0
Apple 的价格已更新为: 160.5
投资者 Tom 收到通知: Apple 的最新价格为 160.5
投资者 Jerry 收到通知: Apple 的最新价格为 160.5
Apple 的价格已更新为: 165.75
投资者 Jerry 收到通知: Apple 的最新价格为 165.75
代码说明¶
Observer接口:定义了
update()
方法,供被观察者调用以通知观察者。Subject接口:定义了
attach()
,detach()
, 和notifyObservers()
方法,用于管理观察者和通知。Stock类(ConcreteSubject):实现了 Subject 接口,维护了股票名称、价格和观察者列表。当股票价格变化时,调用
notifyObservers()
方法通知所有观察者。Investor类(ConcreteObserver):实现了 Observer 接口,定义了
update()
方法,接收被观察者的通知并打印信息。ObserverPatternDemo类:客户端,创建了被观察者(股票)和观察者(投资者),并演示了观察者的添加、通知和移除过程。
4.2. Python 实现示例¶
示例说明¶
同样,实现一个简单的股票价格发布系统,被观察者为股票,观察者为投资者。当股票价格发生变化时,所有投资者都会收到通知。
代码实现¶
from abc import ABC, abstractmethod
# Observer抽象类
class Observer(ABC):
@abstractmethod
def update(self, stock_name: str, stock_price: float):
pass
# Subject抽象类
class Subject(ABC):
@abstractmethod
def attach(self, observer: Observer):
pass
@abstractmethod
def detach(self, observer: Observer):
pass
@abstractmethod
def notify_observers(self):
pass
# ConcreteSubject类
class Stock(Subject):
def __init__(self, name: str, price: float):
self._name = name
self._price = price
self._observers = []
def set_price(self, price: float):
self._price = price
print(f"{self._name} 的价格已更新为: {self._price}")
self.notify_observers()
def get_price(self) -> float:
return self._price
def get_name(self) -> str:
return self._name
def attach(self, observer: Observer):
self._observers.append(observer)
def detach(self, observer: Observer):
self._observers.remove(observer)
def notify_observers(self):
for observer in self._observers:
observer.update(self._name, self._price)
# ConcreteObserver类
class Investor(Observer):
def __init__(self, name: str):
self._name = name
def update(self, stock_name: str, stock_price: float):
print(f"投资者 {self._name} 收到通知: {stock_name} 的最新价格为 {stock_price}")
# 客户端代码
def observer_pattern_demo():
apple = Stock("Apple", 150.00)
investor1 = Investor("Tom")
investor2 = Investor("Jerry")
apple.attach(investor1)
apple.attach(investor2)
apple.set_price(155.00)
apple.set_price(160.50)
apple.detach(investor1)
apple.set_price(165.75)
if __name__ == "__main__":
observer_pattern_demo()
输出¶
Apple 的价格已更新为: 155.0
投资者 Tom 收到通知: Apple 的最新价格为 155.0
投资者 Jerry 收到通知: Apple 的最新价格为 155.0
Apple 的价格已更新为: 160.5
投资者 Tom 收到通知: Apple 的最新价格为 160.5
投资者 Jerry 收到通知: Apple 的最新价格为 160.5
Apple 的价格已更新为: 165.75
投资者 Jerry 收到通知: Apple 的最新价格为 165.75
代码说明¶
Observer抽象类:定义了
update()
方法,供被观察者调用以通知观察者。Subject抽象类:定义了
attach()
,detach()
, 和notify_observers()
方法,用于管理观察者和通知。Stock类(ConcreteSubject):实现了 Subject 抽象类,维护了股票名称、价格和观察者列表。当股票价格变化时,调用
notify_observers()
方法通知所有观察者。Investor类(ConcreteObserver):实现了 Observer 抽象类,定义了
update()
方法,接收被观察者的通知并打印信息。observer_pattern_demo函数:客户端,创建了被观察者(股票)和观察者(投资者),并演示了观察者的添加、通知和移除过程。
5. 观察者模式的适用场景¶
观察者模式适用于以下场景:
一对多的关系:一个被观察者需要通知多个观察者,如新闻发布系统、股票价格变动通知等。
对象间的松散耦合:被观察者和观察者之间不需要了解彼此的具体实现,只通过接口进行通信。
需要动态添加或移除观察者:在运行时可以根据需求增加或减少观察者,如订阅/取消订阅通知的用户。
需要广播通信:当被观察者状态变化时,需要向所有相关观察者广播通知。
实现发布-订阅机制:在系统中实现发布者与订阅者之间的通信,如事件驱动系统。
示例应用场景:
图形用户界面(GUI)系统:按钮点击事件通知相关的监听器。
事件驱动系统:系统中发生特定事件时,通知所有注册的事件处理器。
社交媒体平台:用户发布新内容时,通知所有关注者。
实时数据监控系统:数据变化时,通知所有监控模块。
MVC架构中的视图更新:模型(Model)变化时,视图(View)自动更新。
6. 观察者模式的优缺点¶
6.1. 优点¶
松散耦合:被观察者和观察者之间通过接口进行通信,降低了对象间的依赖关系。
动态响应:可以在运行时动态地添加或移除观察者,增强系统的灵活性。
支持广播通信:被观察者可以同时通知多个观察者,适用于一对多的通信场景。
提高系统的可扩展性:通过增加新的观察者类,可以轻松扩展系统功能,而无需修改被观察者类。
简化对象间的通信:观察者模式通过中介机制(被观察者)简化了对象间的直接通信。
6.2. 缺点¶
可能导致性能问题:当观察者数量较多时,被观察者在通知所有观察者时可能会影响系统性能。
可能导致系统复杂性增加:在某些情况下,过多的观察者会使系统的逻辑变得复杂,难以维护。
可能引发循环依赖:如果设计不当,观察者和被观察者之间可能会形成循环依赖,导致系统行为异常。
难以调试:由于观察者模式的动态通知机制,可能会使系统的行为难以预测和调试。
缺乏通知的顺序控制:观察者模式通常没有规定通知观察者的顺序,可能导致一些问题。
7. 观察者模式的常见误区与解决方案¶
7.1. 误区1:观察者过多导致系统性能下降¶
问题描述: 当被观察者拥有大量观察者时,每次状态变化都需要通知所有观察者,可能导致性能问题,尤其是在实时系统中。
解决方案:
优化通知机制:只通知那些真正需要更新的观察者,避免不必要的通知。
使用异步通知:通过异步方式通知观察者,减少同步操作对系统性能的影响。
批量处理:将多次状态变化合并为一次通知,减少通知次数。
限制观察者数量:根据系统需求合理限制观察者的数量,避免过度订阅。
7.2. 误区2:观察者和被观察者之间形成循环依赖¶
问题描述: 如果观察者在更新过程中再次修改被观察者的状态,可能导致循环依赖,甚至引发无限递归。
解决方案:
设计良好的更新逻辑:避免在观察者的
update()
方法中直接修改被观察者的状态。引入状态标识:通过标识来判断是否需要继续通知,避免无限循环。
使用双向依赖管理:明确观察者和被观察者之间的依赖关系,避免循环引用。
7.3. 误区3:忽视观察者的异常处理¶
问题描述: 当某个观察者在更新过程中抛出异常时,可能影响被观察者和其他观察者的通知流程。
解决方案:
异常捕获:在被观察者的
notifyObservers()
方法中,捕获每个观察者的异常,确保一个观察者的异常不会影响其他观察者。日志记录:记录观察者的异常信息,便于后续的调试和维护。
观察者的自我保护:在观察者的
update()
方法中,妥善处理可能的异常,避免将异常抛给被观察者。
8. 观察者模式的实际应用实例¶
8.1. 股票价格发布系统¶
示例说明¶
实现一个简单的股票价格发布系统,被观察者为股票,观察者为投资者。当股票价格发生变化时,所有投资者都会收到通知。
Java实现¶
(请参考观察者模式的Java实现示例)
Python实现¶
(请参考观察者模式的Python实现示例)
8.2. 图形用户界面(GUI)事件监听¶
示例说明¶
在GUI系统中,按钮点击、文本框内容变化等事件通常使用观察者模式来实现。各个组件作为观察者,监听特定事件并作出响应。
Java实现示例¶
import javax.swing.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.ArrayList;
import java.util.List;
// Observer接口
interface ButtonClickObserver {
void onButtonClick(String message);
}
// Subject类
class ButtonSubject {
private List<ButtonClickObserver> observers = new ArrayList<>();
public void attach(ButtonClickObserver observer){
observers.add(observer);
}
public void detach(ButtonClickObserver observer){
observers.remove(observer);
}
public void notifyObservers(String message){
for(ButtonClickObserver observer : observers){
observer.onButtonClick(message);
}
}
public void clickButton(){
// 模拟按钮点击事件
notifyObservers("按钮被点击了!");
}
}
// ConcreteObserver类
class LabelUpdater implements ButtonClickObserver {
private JLabel label;
public LabelUpdater(JLabel label){
this.label = label;
}
@Override
public void onButtonClick(String message){
label.setText(message);
}
}
// 客户端代码
public class ObserverPatternGUI {
public static void main(String[] args) {
JFrame frame = new JFrame("观察者模式示例");
frame.setSize(300, 200);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
JButton button = new JButton("点击我");
JLabel label = new JLabel("按钮未被点击");
frame.setLayout(null);
button.setBounds(100, 50, 100, 30);
label.setBounds(100, 100, 200, 30);
frame.add(button);
frame.add(label);
// 创建被观察者和观察者
ButtonSubject buttonSubject = new ButtonSubject();
LabelUpdater labelUpdater = new LabelUpdater(label);
buttonSubject.attach(labelUpdater);
// 添加按钮点击事件监听
button.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
buttonSubject.clickButton();
}
});
frame.setVisible(true);
}
}
输出¶
当用户点击按钮时,标签的文本会更新为“按钮被点击了!”
8.3. 实时数据监控系统¶
示例说明¶
在实时数据监控系统中,数据源(被观察者)实时更新数据,多个监控模块(观察者)需要即时接收并处理数据变化。
Python实现示例¶
from abc import ABC, abstractmethod
import time
import threading
# Observer抽象类
class DataObserver(ABC):
@abstractmethod
def update(self, data):
pass
# Subject类
class DataSource:
def __init__(self):
self._observers = []
self._data = 0
self._running = False
def attach(self, observer: DataObserver):
self._observers.append(observer)
def detach(self, observer: DataObserver):
self._observers.remove(observer)
def notify_observers(self):
for observer in self._observers:
observer.update(self._data)
def start(self):
self._running = True
threading.Thread(target=self._run).start()
def stop(self):
self._running = False
def _run(self):
while self._running:
self._data += 1
print(f"数据源更新数据: {self._data}")
self.notify_observers()
time.sleep(1)
# ConcreteObserver类
class Display(DataObserver):
def __init__(self, name):
self.name = name
def update(self, data):
print(f"显示器 {self.name} 显示数据: {data}")
# 客户端代码
def observer_pattern_monitoring_demo():
data_source = DataSource()
display1 = Display("A")
display2 = Display("B")
data_source.attach(display1)
data_source.attach(display2)
data_source.start()
# 运行5秒后停止
time.sleep(5)
data_source.stop()
if __name__ == "__main__":
observer_pattern_monitoring_demo()
输出¶
数据源更新数据: 1
显示器 A 显示数据: 1
显示器 B 显示数据: 1
数据源更新数据: 2
显示器 A 显示数据: 2
显示器 B 显示数据: 2
数据源更新数据: 3
显示器 A 显示数据: 3
显示器 B 显示数据: 3
数据源更新数据: 4
显示器 A 显示数据: 4
显示器 B 显示数据: 4
数据源更新数据: 5
显示器 A 显示数据: 5
显示器 B 显示数据: 5
代码说明¶
DataObserver抽象类:定义了
update()
方法,供被观察者调用以通知观察者。DataSource类(Subject):实现了 Subject 抽象类,维护了数据和观察者列表。通过线程模拟实时数据更新,并在数据变化时通知所有观察者。
Display类(ConcreteObserver):实现了 DataObserver 抽象类,接收被观察者的通知并显示数据。
observer_pattern_monitoring_demo函数:客户端,创建了数据源和显示器对象,启动数据源的实时更新,并在5秒后停止。
8.4. 社交媒体平台的通知系统¶
示例说明¶
在社交媒体平台中,用户可以关注其他用户,当被关注的用户发布新内容时,所有关注者都会收到通知。
Java实现示例¶
// Observer接口
public interface Follower {
void update(String userName, String content);
}
// Subject接口
public interface User {
void follow(Follower follower);
void unfollow(Follower follower);
void notifyFollowers();
void postContent(String content);
String getName();
String getContent();
}
// ConcreteSubject类
import java.util.ArrayList;
import java.util.List;
public class ConcreteUser implements User {
private String name;
private String content;
private List<Follower> followers = new ArrayList<>();
public ConcreteUser(String name){
this.name = name;
}
@Override
public void follow(Follower follower){
followers.add(follower);
}
@Override
public void unfollow(Follower follower){
followers.remove(follower);
}
@Override
public void notifyFollowers(){
for(Follower follower : followers){
follower.update(this.name, this.content);
}
}
@Override
public void postContent(String content){
this.content = content;
System.out.println(this.name + " 发布新内容: " + this.content);
notifyFollowers();
}
@Override
public String getName(){
return this.name;
}
@Override
public String getContent(){
return this.content;
}
}
// ConcreteObserver类
public class UserFollower implements Follower {
private String followerName;
public UserFollower(String followerName){
this.followerName = followerName;
}
@Override
public void update(String userName, String content){
System.out.println("关注者 " + followerName + " 收到通知: " + userName + " 发布了新内容 - " + content);
}
}
// 客户端代码
public class ObserverPatternSocialMediaDemo {
public static void main(String[] args) {
User alice = new ConcreteUser("Alice");
User bob = new ConcreteUser("Bob");
Follower follower1 = new UserFollower("Tom");
Follower follower2 = new UserFollower("Jerry");
Follower follower3 = new UserFollower("Lily");
alice.follow(follower1);
alice.follow(follower2);
bob.follow(follower3);
alice.postContent("Hello, this is Alice!");
bob.postContent("Bob's first post.");
alice.postContent("Alice's second post.");
}
}
输出¶
Alice 发布新内容: Hello, this is Alice!
关注者 Tom 收到通知: Alice 发布了新内容 - Hello, this is Alice!
关注者 Jerry 收到通知: Alice 发布了新内容 - Hello, this is Alice!
Bob 发布新内容: Bob's first post.
关注者 Lily 收到通知: Bob 发布了新内容 - Bob's first post.
Alice 发布新内容: Alice's second post.
关注者 Tom 收到通知: Alice 发布了新内容 - Alice's second post!
关注者 Jerry 收到通知: Alice 发布了新内容 - Alice's second post!
代码说明¶
Follower接口(Observer):定义了
update()
方法,供被观察者调用以通知观察者。User接口(Subject):定义了关注、取消关注、通知观察者和发布内容的方法。
ConcreteUser类(ConcreteSubject):实现了 User 接口,维护了用户名称、内容和关注者列表。当用户发布新内容时,通知所有关注者。
UserFollower类(ConcreteObserver):实现了 Follower 接口,接收被观察者的通知并打印信息。
ObserverPatternSocialMediaDemo类:客户端,创建了被观察者(用户)和观察者(关注者)对象,演示了关注、发布内容和通知的过程。
9. 观察者模式与其他模式的比较¶
9.1. 观察者模式 vs. 发布-订阅模式¶
观察者模式是一种对象之间的一对多的通信机制,通常在同一系统内部使用。
发布-订阅模式(Pub/Sub)是一种消息传递的模式,允许消息的发布者和订阅者解耦,通常通过中介者(如消息队列)进行通信,可以跨系统使用。
关键区别:
耦合度:观察者模式的观察者和被观察者之间存在直接的引用关系,而发布-订阅模式的发布者和订阅者通过中介者进行通信,耦合度更低。
应用范围:观察者模式适用于单一应用内部的通信,发布-订阅模式适用于分布式系统或跨系统的消息传递。
实现方式:观察者模式通常由被观察者维护观察者列表,发布-订阅模式通过消息代理实现消息的分发。
9.2. 观察者模式 vs. 策略模式¶
观察者模式用于建立对象之间的一对多的通信机制,当被观察者状态变化时,自动通知所有观察者。
策略模式用于定义一系列算法,并使得它们可以相互替换,算法的变化不会影响使用它的客户。
关键区别:
目的不同:观察者模式关注对象间的通信与通知,策略模式关注算法的封装与替换。
结构不同:观察者模式涉及被观察者和多个观察者的交互,策略模式涉及上下文和单个策略的替换。
应用场景不同:观察者模式适用于事件驱动的场景,策略模式适用于需要动态选择算法的场景。
9.3. 观察者模式 vs. 适配器模式¶
观察者模式用于建立对象之间的一对多的通信机制,自动通知观察者状态变化。
适配器模式用于将一个类的接口转换成客户希望的另一个接口,使得原本由于接口不兼容而无法一起工作的类可以一起工作。
关键区别:
目的不同:观察者模式关注对象间的通信与通知,适配器模式关注接口的转换与兼容。
结构不同:观察者模式涉及被观察者和多个观察者,适配器模式涉及目标接口和适配者接口之间的转换。
应用场景不同:观察者模式适用于需要事件通知的场景,适配器模式适用于接口不兼容的类之间的集成。
9.4. 观察者模式 vs. 装饰者模式¶
观察者模式用于建立对象之间的一对多的通信机制,自动通知观察者状态变化。
装饰者模式用于动态地为对象添加新功能,通过装饰者对象包装原有对象,增强其功能。
关键区别:
目的不同:观察者模式关注对象间的通信与通知,装饰者模式关注对象功能的动态扩展。
结构不同:观察者模式涉及被观察者和多个观察者,装饰者模式涉及被装饰者和多个装饰者的层叠结构。
应用场景不同:观察者模式适用于事件驱动的场景,装饰者模式适用于需要动态增加对象功能的场景。
10. 观察者模式的扩展与变体¶
观察者模式在实际应用中可以根据需求进行一些扩展和变体,以适应不同的场景和需求。
10.1. 事件过滤器¶
在某些情况下,观察者可能只对特定类型的事件感兴趣。通过引入事件过滤器,观察者可以只接收自己关心的事件类型,避免不必要的处理。
实现方式:
事件类型标识:被观察者在通知时带上事件类型信息,观察者根据事件类型决定是否处理。
过滤器接口:定义一个过滤器接口,观察者可以实现该接口以指定感兴趣的事件类型。
通知机制调整:被观察者在通知观察者时,传递事件类型和相关数据。
10.2. 双向观察¶
在传统的观察者模式中,通信是单向的,即被观察者通知观察者。双向观察允许观察者在接收通知后,能够影响被观察者的状态。
实现方式:
双向引用:观察者持有对被观察者的引用,可以调用被观察者的方法。
更新策略调整:在观察者的
update()
方法中,可以执行对被观察者的修改操作。
注意事项:
避免循环依赖:确保观察者对被观察者的修改不会导致无限循环通知。
明确职责划分:观察者对被观察者的影响应有限,避免观察者承担过多职责。
10.3. 推模型与拉模型¶
观察者模式可以分为推模型(Push Model)和拉模型(Pull Model),根据通知方式的不同进行分类。
推模型:被观察者在通知观察者时,直接将数据推送给观察者。观察者在接收通知时,已经获得了更新的数据。
拉模型:被观察者在通知观察者时,只发送通知信号,观察者需要主动从被观察者获取更新的数据。
实现方式:
推模型:
update()
方法带有数据参数,被观察者在通知时传递更新的数据。拉模型:
update()
方法不带数据参数,观察者在接收通知后,通过调用被观察者的方法获取最新数据。
优缺点对比:
推模型:效率更高,减少了通信次数,但增加了被观察者与观察者之间的数据依赖。
拉模型:更加灵活,观察者可以根据需要获取数据,但可能导致多余的数据获取。
10.4. 基于主题的观察者¶
在复杂系统中,一个被观察者可能涉及多个主题(主题可以理解为不同的事件或状态类别)。通过引入主题管理机制,观察者可以订阅感兴趣的特定主题,接收相关的通知。
实现方式:
主题分类:将被观察者的通知按主题分类。
主题管理:被观察者维护不同主题的观察者列表。
通知机制调整:在通知时指定主题,观察者根据订阅的主题接收通知。
优缺点对比:
优点:提高了通知的针对性,减少了观察者的无关通知。
缺点:增加了被观察者的复杂性,管理多个主题需要更复杂的逻辑。
11. 总结¶
观察者模式(Observer Pattern) 通过建立对象之间的一对多的通信机制,使得被观察者状态变化时,能够自动通知所有观察者,实现了对象间的松散耦合和灵活交互。该模式广泛应用于事件驱动系统、实时数据监控、用户界面组件交互等场景,提升了系统的可扩展性和维护性。
关键学习点回顾:
理解观察者模式的核心概念:建立一对多的通信机制,实现对象间的自动通知。
掌握观察者模式的结构:包括Subject、ConcreteSubject、Observer和ConcreteObserver之间的关系。
识别适用的应用场景:事件驱动系统、实时数据监控、用户界面组件交互等。
认识观察者模式的优缺点:松散耦合、动态响应、支持广播通信;但可能导致性能问题、系统复杂性增加、循环依赖等。
理解常见误区及解决方案:优化通知机制、避免循环依赖、加强异常处理等。
实际应用中的观察者模式实例:股票价格发布系统、GUI事件监听、实时数据监控、社交媒体通知系统等。
观察者模式的扩展与变体:事件过滤器、双向观察、推模型与拉模型、基于主题的观察者等。