【设计模式】观察者模式

前言

1. 单例模式（Singleton Pattern）：保证一个类只有一个实例，并提供一个全局的访问点。

2. 工厂模式（Factory Pattern）：定义一个创建对象的接口，但由子类决定要实例化的类是哪一个。

3. 观察者模式（Observer Pattern）：定义对象之间的一对多依赖关系，使得当一个对象的状态发生改变时，所有依赖于它的对象都会被自动通知并更新。

4. 装饰器模式（Decorator Pattern）：动态地给一个对象添加一些额外的职责，而不会影响到其他对象。

5. 策略模式（Strategy Pattern）：定义一系列的算法，将每个算法封装起来，并使它们可以相互替换。

6. 命令模式（Command Pattern）：将请求封装成一个对象，从而使用户可以用不同的请求对客户进行参数化。

7. 适配器模式（Adapter Pattern）：将一个类的接口转换成客户希望的另外一个接口，使得原本由于接口不兼容而不能一起工作的类能够一起工作。

8. 外观模式（Facade Pattern）：为子系统中的一组接口提供一个统一的接口，从而使得子系统更加容易使用。

9. 状态模式（State Pattern）：允许一个对象在其内部状态改变时改变其行为。

10. 模板方法模式（Template Method Pattern）：定义一个操作中的算法的骨架，而将一些步骤延迟到子类中实现。

这些是Python中常用的设计模式，通过使用这些设计模式可以提高代码的可读性、可维护性和重用性。
 

观察者模式是一种行为设计模式，它定义了一种一对多的关系，使得当一个对象的状态发生改变时，所有依赖于它的对象都能够得到通知并自动更新。在观察者模式中，有两个主要角色：主题（Subject）和观察者（Observer）。

1. 主题（Subject）： 负责维护一组观察者对象，以及通知它们状态变化的方法。

2. 观察者（Observer）： 定义一个更新接口，以便在主题状态变化时得到通知并进行相应的操作。

观察者模式

观察者模式的结构

• 抽象主题（AbstractSubject）：也叫抽象目标类，它提供了一个用于保存观察者对象的聚集类和增加、删除观察者对象的方法，以及通知所有观察者的抽象方法。
• 具体主题（Subject）：也叫具体目标类，它实现抽象目标中的通知方法，当具体主题的内部状态发生改变时，通知所有注册过的观察者对象。
• 抽象观察者（AbstractObserver）：它是一个抽象类或接口，它包含了一个更新自己的抽象方法，当接到具体主题的更改通知时被调用。
• 具体观察者（Observer）：实现抽象观察者中定义的抽象方法，以便在得到目标的更改通知时更新自身的状态。

代码实现

第一种模板

import abc


class AbstractSubject(metaclass=abc.ABCMeta):
    """
    抽象主题（抽象目标类）:
        定义增加、删除观察者的方法
        通知观察者的抽象方法
    """

    def __init__(self):
        self.observers = []

    def add(self, observer):
        if observer not in self.observers:
            self.observers.append(observer)
        else:
            print("%s observer is exist, add failed" % observer)

    def remove(self, observer):
        if observer in self.observers:
            self.observers.remove(observer)
        else:
            print("%s observer is not exist, remove failed" % observer)

    @abc.abstractmethod
    def notify(self):
        pass


class Subject(AbstractSubject):
    """具体主题（具体目标类）"""

    def __init__(self, name):
        super().__init__()
        self.name = name
        self._data = None

    @property
    def data(self):
        return self._data

    @data.setter
    def data(self, new_data):
        """当数据更新时，去通知观察者"""
        self._data = new_data
        self.notify()

    def notify(self):
        """通知观察者的具体方法"""
        for obs in self.observers:
            obs.notify(self._data)


class AbstractObserver(metaclass=abc.ABCMeta):
    """抽象观察者"""

    @abc.abstractmethod
    def notify(self, data, *args, **kwargs):
        pass


class Observer1(AbstractObserver):
    """具体观察者-1"""

    def notify(self, data, *args, **kwargs):
        print("发布的消息是：%s" % data)


class Observer2(AbstractObserver):
    """具体观察者-2"""

    def notify(self, data, *args, **kwargs):
        print("发布的消息是：%s" % data)


# 具体主题(消息发布者)
sub = Subject("ming")

# 具体观察者
obs1 = Observer1()
obs2 = Observer2()

# 添加观察者
sub.add(obs1)
sub.add(obs2)

# 发布消息后，观察者得到消息
sub.data = "号外号外！"

第二种模板 

# 主题
class Subject:
    def __init__(self):
        self._observers = []

    def add_observer(self, observer):
        if observer not in self._observers:
            self._observers.append(observer)

    def remove_observer(self, observer):
        self._observers.remove(observer)

    def notify_observers(self, message):
        for observer in self._observers:
            observer.update(message)

# 观察者
class Observer:
    def update(self, message):
        pass

# 具体观察者
class ConcreteObserver(Observer):
    def update(self, message):
        print(f"Received message: {message}")

# 使用观察者模式
subject = Subject()

observer1 = ConcreteObserver()
observer2 = ConcreteObserver()

subject.add_observer(observer1)
subject.add_observer(observer2)

subject.notify_observers("Hello, observers!")

优点 

它实现了松耦合，主题和观察者相互独立，可以轻松添加或删除观察者，而不会影响到主题或其他观察者。这使得代码更加灵活、可维护。

应用场景

1. 在分布式系统中实现事件服务
2. 用作新闻机构的框架
3. 股票市场也是观察者模式的一个大型场景
4. 用户界面可以作为一个观察者，业务数据是被观察者，用户界面观察业务数据的变化，发现数据变化后，就显示在界面上。

参考链接

https://www.cnblogs.com/Zzbj/p/15779727.html