观察者模式

前言

观察者模式（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

参考

罗伟富《人人都懂设计模式》

前言​

工作原理​

优点​

缺点​

应用场景​

示例代码​

Go​

Python​

参考​

前言

工作原理

优点

缺点

应用场景

示例代码

Go

Python

参考