前言
观察者模式（Observer Pattern）是一种行为型设计模式，它定义了一种一对多的依赖关系，当一个对象的状态发生改变时，其所有依赖者都会收到通知并自动更新。
在观察者模式中，有两种主要的角色：
- 观察者（Observer）：观察者是一个接口或抽象类，它定义了一个更新的接口，使得被观察者在状态发生变化时可以通知观察者进行更新操作。
- 被观察者（Subject）：被观察者是一个类，它维护了一组观察者对象，并提供了添加、删除和通知观察者的方法。当被观察者的状态发生变化时，它会通知所有的观察者进行更新操作。
被观察者对象在状态或内容（数据）发生变化时，会通知所有观察者对象，使它们能够做出相应的变化（如自动更新自己的信息）。
工作原理
- 观察者通过订阅被观察者，注册自己到被观察者的观察者列表中。
- 被观察者维护了一个观察者列表，当自身状态发生变化时，遍历观察者列表，调用每个观察者的更新方法。
- 观察者收到通知后，执行相应的更新操作，通常是从被观察者获取最新的状态信息，并进行相应的处理。
优点
- 解耦性： 观察者模式将观察者和被观察者解耦，使得它们可以独立地变化和复用。
- 可扩展性： 可以根据需要动态地增加和删除观察者，从而实现系统的灵活性和可扩展性。
- 通知机制： 观察者模式提供了一种简单的通知机制，使得被观察者可以在状态发生变化时通知所有的观察者。
缺点
- 可能引起循环依赖： 如果观察者和被观察者之间存在双向依赖关系，可能会导致循环依赖的问题。这样会使系统变得复杂，难以维护和理解。
- 通知顺序不确定： 观察者模式中观察者的通知顺序通常是不确定的，这可能会导致一些问题，特别是在多个观察者对同一事件进行响应时。
- 可能导致性能问题： 如果被观察者对象频繁地改变状态，会导致大量的通知操作，可能会影响系统的性能。
- 可能引发并发问题： 如果在多线程环境下使用观察者模式，可能会引发并发问题，需要额外的同步措施来保证线程安全。
- 过多的细粒度对象： 观察者模式可能会导致系统中存在大量的细粒度的观察者对象，这可能会增加系统的复杂性和内存消耗。
示例代码
Go
代码文件: observer/observer.go
package observer import "fmt" // 观察者接口 type Observer interface { Update(myapp MyAPP) } // 被观察者 type MyAPP struct { observers []Observer serverity int } func (m *MyAPP) GetServerity() int { return m.serverity } func (m *MyAPP) SetServerity(s int) { if s < 0 || s > 3 { fmt.Println("serverity must be an integer between 0 and 3") return } m.serverity = s fmt.Printf("Current severity is %d.\n", m.serverity) m.notify() } func (m *MyAPP) notify() { for _, observer := range m.observers { observer.Update(*m) } } func (m *MyAPP) AddObserver(observer Observer) { m.observers = append(m.observers, observer) } type Employee struct{} func (e *Employee) Update(myapp MyAPP) { if myapp.GetServerity() == 1 { fmt.Println("Employee: I'm notified!") } } type Manager struct{} func (m *Manager) Update(myapp MyAPP) { if myapp.GetServerity() == 2 { fmt.Println("Manager: I'm notified!") } } type Director struct{} func (d *Director) Update(myapp MyAPP) { if myapp.GetServerity() == 3 { fmt.Println("Director: I'm notified!") } }
代码文件: main.go
package main import ( "design-pattern-go/observer" ) func main() { myapp := &observer.MyAPP{} employee := &observer.Employee{} manager := &observer.Manager{} director := &observer.Director{} myapp.AddObserver(employee) myapp.AddObserver(manager) myapp.AddObserver(director) myapp.SetServerity(0) myapp.SetServerity(1) myapp.SetServerity(2) myapp.SetServerity(3) myapp.SetServerity(4) }
运行结果
$ go run main.go Current severity is 0. Current severity is 1. Employee: I'm notified! Current severity is 2. Manager: I'm notified! Current severity is 3. Director: I'm notified! serverity must be an integer between 0 and 3
Python
from abc import ABCMeta, abstractmethod class MyApp: """被观察者""" def __init__(self): self.__observers = [] self.__severity = 0 def get_severity(self): return self.__severity def set_severity(self, severity: int): if not isinstance(severity, int) or severity < 0 or severity > 3: raise ValueError("severity must be an integer between 0 and 3") self.__severity = severity print(f"current severity: {severity}") self.notify() def add_observer(self, observer): self.__observers.append(observer) def notify(self): """遍历观察者列表, 调用每个观察者的update方法""" for o in self.__observers: o.update(self) class Observer(metaclass=ABCMeta): """观察者基类""" @abstractmethod def update(self, myapp: MyApp): pass class Employee(Observer): def update(self, myapp: MyApp): if myapp.get_severity() == 1: print("An employee is notified") class Manager(Observer): def update(self, myapp: MyApp): if myapp.get_severity() == 2: print("A manager is notified") class Director(Observer): def update(self, myapp: MyApp): if myapp.get_severity() == 3: print("A director is notified") if __name__ == "__main__": myapp = MyApp() employee = Employee() manager = Manager() director = Director() myapp.add_observer(employee) myapp.add_observer(manager) myapp.add_observer(director) myapp.set_severity(1) myapp.set_severity(2) myapp.set_severity(3)
运行结果:
$ python .\observer.py current severity: 1 An employee is notified current severity: 2 A manager is notified current severity: 3 A director is notified
