一、引言
在软件工程、软件开发的世界里，设计模式如同建筑蓝图中的经典结构，帮助开发者构建更加灵活、可维护和可扩展的软件系统。观察者模式就是其中一种极为重要的行为型设计模式，它在处理对象间的一对多关系时展现出独特的魅力。
二、定义与描述
观察者模式定义了对象之间的一种一对多依赖关系。其中有一个被观察的对象（称为主题Subject）和多个观察该对象的观察者（Observer）。主题对象负责维护一组观察者对象，并在自身状态发生改变时通知所有观察者。这种模式使得对象之间的耦合度降低，主题和观察者可以独立地进行扩展和修改。
三、抽象背景
在很多实际的软件场景中，存在着对象状态变化需要通知其他对象的需求。例如，在一个新闻发布系统中，当有新的新闻发布（新闻对象状态改变）时，订阅了该新闻频道的用户（观察者）需要及时得到通知；或者在一个游戏开发中，当游戏角色的某些属性（如生命值、位置等）发生变化时，与之相关的UI界面元素（观察者）需要更新显示。
四、适用场景与现实问题解决
- 事件驱动系统
- 在图形用户界面（GUI）开发中，用户的操作（如点击按钮、输入文本等）会触发事件。这些事件可以看作是主题的状态变化，而处理这些事件的各个组件（如菜单更新、数据显示等）就是观察者。通过观察者模式，可以很方便地实现事件的分发和处理，使不同的组件能够独立地响应事件。
- 股票市场监测
- 当股票价格发生变化（主题状态改变）时，多个投资者（观察者）需要得到通知以便做出相应的决策。使用观察者模式可以高效地实现这种通知机制，而不需要在股票价格变化的代码中硬编码每个投资者的通知逻辑。
观察者模式的现实生活的例子">五、观察者模式的现实生活的例子
- 社交媒体平台
- 当一个用户（主题）发布了一条新的动态时，他的好友（观察者）会收到通知。这里，用户是被观察的对象，好友们是观察者。社交平台负责维护好友关系（即主题中的观察者列表），并在用户发布新动态时通知所有好友。
- 气象站与订阅者
- 气象站（主题）负责收集气象数据并检测天气状态的变化。当天气状态发生变化（如温度、湿度、气压等数据变化）时，气象站会通知所有订阅了气象信息的用户（观察者），如农民、飞行员、户外运动爱好者等。
六、初衷与问题解决
- 初衷
- 观察者模式的初衷是为了实现对象之间的松耦合关系。在没有这种模式的情况下，如果一个对象的状态变化需要通知其他对象，可能会导致高度耦合的代码，即变化的对象需要直接调用其他对象的方法来通知它们。这使得代码难以维护和扩展，因为任何一个相关对象的改变都可能影响到其他对象。
- 问题解决
- 通过观察者模式，主题和观察者之间通过抽象的接口进行交互。主题只需要维护一个观察者列表，并在状态变化时调用观察者的抽象通知方法。这样，主题不需要知道具体的观察者类型，观察者也不需要知道主题的具体实现细节。当有新的观察者或主题需要加入系统时，只需要实现相应的接口即可，不会影响到其他部分的代码。
七、代码示例
Java示例
import java.util.ArrayList;
import java.util.List;
// 观察者接口
interface Observer {
void update(String message);
}
// 主题类
class Subject {
private List<Observer> observers = new ArrayList<>();
private String state;
public void attach(Observer observer) {
observers.add(observer);
}
public void detach(Observer observer) {
observers.remove(observer);
}
public void setState(String state) {
this.state = state;
notifyAllObservers();
}
private void notifyAllObservers() {
for (Observer observer : observers) {
observer.update(state);
}
}
}
// 具体观察者类
class ConcreteObserver implements Observer {
private String name;
public ConcreteObserver(String name) {
this.name = name;
}
@Override
public void update(String message) {
System.out.println(name + " received message: " + message);
}
}
public class Main {
public static void main(String[] args) {
Subject subject = new Subject();
Observer observer1 = new ConcreteObserver("Observer 1");
Observer observer2 = new ConcreteObserver("Observer 2");
subject.attach(observer1);
subject.attach(observer2);
subject.setState("New state!");
}
}类图：
Subject类与Observer接口之间是一对多的关系（Subject可以有多个Observer）ConcreteObserver类实现了Observer接口。
C++示例
#include <iostream>
#include <vector>
// 观察者抽象类
class Observer {
public:
virtual void update(std::string message) = 0;
};
// 主题类
class Subject {
private:
std::vector<Observer*> observers;
std::string state;
public:
void attach(Observer* observer) {
observers.push_back(observer);
}
void detach(Observer* observer) {
for (auto it = observers.begin(); it!= observers.end(); ++it) {
if (*it == observer) {
observers.erase(it);
break;
}
}
}
void setState(std::string state) {
this.state = state;
notifyAllObservers();
}
void notifyAllObservers() {
for (auto observer : observers) {
observer->update(state);
}
}
};
// 具体观察者类
class ConcreteObserver : public Observer {
private:
std::string name;
public:
ConcreteObserver(std::string name) : name(name) {}
void update(std::string message) override {
std::cout << name << " received message: " << message << std::endl;
}
};
int main() {
Subject subject;
Observer* observer1 = new ConcreteObserver("Observer 1");
Observer* observer2 = new ConcreteObserver("Observer 2");
subject.attach(observer1);
subject.attach(observer2);
subject.setState("New state!");
return 0;
}Python示例
# 观察者抽象类
class Observer:
def update(self, message):
pass
# 主题类
class Subject:
def __init__(self):
self.observers = []
self.state = None
def attach(self, observer):
self.observers.append(observer)
def detach(self, observer):
self.observers.remove(observer)
def setState(self, state):
self.state = state
self.notifyAllObservers()
def notifyAllObservers(self):
for observer in self.observers:
observer.update(self.state)
# 具体观察者类
class ConcreteObserver(Observer):
def __init__(self, name):
self.name = name
def update(self, message):
print(f"{self.name} received message: {message}")
if __name__ == "__main__":
subject = Subject()
observer1 = ConcreteObserver("Observer 1")
observer2 = ConcreteObserver("Observer 2")
subject.attach(observer1)
subject.attach(observer2)
subject.setState("New state!")Go示例
package main
import (
"fmt"
)
// 观察者接口
type Observer interface {
update(message string)
}
// 主题结构体
type Subject struct {
observers []Observer
state string
}
// 附加观察者
func (s *Subject) attach(observer Observer) {
s.observers = append(s.observers, observer)
}
// 分离观察者
func (s *Subject) detach(observer Observer) {
for i, obs := range s.observers {
if obs == observer {
s.observers = append(s.observers[:i], s.observers[i+1:]...)
break
}
}
}
// 设置状态并通知观察者
func (s *Subject) setState(state string) {
s.state = state
s.notifyAllObservers()
}
// 通知所有观察者
func (s *Subject) notifyAllObservers() {
for _, observer := range s.observers {
observer.update(s.state)
}
}
// 具体观察者结构体
type ConcreteObserver struct {
name string
}
// 具体观察者实现更新方法
func (co *ConcreteObserver) update(message string) {
fmt.Printf("%s received message: %s\n", co.name, message)
}
func main() {
subject := Subject{}
observer1 := ConcreteObserver{name: "Observer 1"}
observer2 := ConcreteObserver{name: "Observer 2"}
subject.attach(&observer1)
subject.attach(&observer2)
subject.setState("New state!")
}观察者模式的优缺点">八、观察者模式的优缺点
- 优点
- 松耦合：主题和观察者之间是松耦合的关系。主题不需要知道观察者的具体实现，只需要调用观察者的抽象接口。这使得在系统中添加或删除观察者非常容易，不会影响到主题的代码。
- 可扩展性：可以很容易地增加新的观察者，只需要实现观察者接口即可。同样，主题也可以在不影响观察者的情况下进行扩展。
- 支持广播通信：一个主题可以通知多个观察者，实现了一对多的消息传递，适合于需要将信息广播给多个对象的场景。
- 缺点
- 可能存在通知顺序问题：如果有多个观察者，当主题通知观察者时，可能会存在通知顺序不确定的问题。这在某些对顺序有严格要求的场景下可能会导致问题。
- 性能开销：如果观察者数量较多，当主题状态发生变化时，通知所有观察者可能会带来一定的性能开销。特别是在观察者的更新操作比较复杂时，这种开销会更加明显。
观察者模式的升级版" style="background-color:transparent;">九、观察者模式的升级版
- 事件委托模型
- 在传统的观察者模式中，主题直接通知所有的观察者。而在事件委托模型中，引入了事件源、事件和事件处理程序的概念。事件源（类似于主题）产生事件，事件包含了关于状态变化的信息，事件处理程序（类似于观察者）负责处理事件。事件委托模型更加灵活，可以根据事件的类型、优先级等因素来决定如何处理事件，而不是简单地通知所有观察者。
- 反应式编程中的观察者模式扩展
