Python 设计模式——观察者模式

发表于 | 分类于 | | 阅读次数:
字数统计: 4.5k | 阅读时长 ≈ 0:05

行为型模式中的观察者模式

创建型模式（比如单例模式）是基于对象的创建机制的，这些模式隔离了对象的创建细节，使得实现这些细节的代码能够与要创建的对象类型相互独立。
结构型模式（比如门面模式）用于设计对象和类的结构，使得它们能够相互协作以形成更大的结构。重点是结构的简化以及识别类和对象之间的关系。
行为型模式（比如观察者模式）主要关注的是对象的责任，处理对象之间的交互，以实现更复杂的功能。对象之间应该可以彼此交互，且应该是松耦合的。

在观察者设计模式中，对象（主题）维护了一个依赖（观察者）列表，以便主题可以使用观察者定义的任何方法通知所有观察者它所发生的变化。

在分布式应用中，多个服务通常是通过彼此交互来实现更大型的操作的。服务可以执行多种操作，但它们执行的操作会直接或很大程度上取决于其交互的服务对象的状态。
比如用户注册的示例，其中用户服务负责响应用户在网站上的各种操作。假设有另一个电子邮件的服务，其作用是监视用户的状态并向用户发送电子邮件。若用户刚刚注册，则用户服务将调用电子邮件服务的方法，向用户发送邮件进行账户验证。若账户经过了验证，但信用度较低，则电子邮件服务将监视用户服务并向用户发送信用度过低的电子邮件警报。

因此，若应用中存在一个许多其他服务所依赖的核心服务，该核心服务就会成为观察者必须观察/监视变化的主题。当主题发生变化时，观察者应该改变自身对象状态，或者采取某些动作。
从属服务监视核心服务的状态变化是观察者设计模式的经典情境。

观察者模式的主要目标

  • 定义了对象之间的一对多依赖关系，使得对象中的任何更改都将自动通知给其他依赖对象
  • 封装了主题的核心组件

观察者模式的基本实现

UML

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
class Subject:
    def __init__(self):
        self.__observers = []

    def register(self, observer):
        self.__observers.append(observer)

    def notifyAll(self, *args, **kwargs):
        for observer in self.__observers:
            observer.notify(subject, *args, **kwargs)


class Observer1:
    def __init__(self, subject):
        subject.register(self)

    def notify(self, subject, *args):
        print(type(self).__name__, ':: Got', args, 'From', subject)


class Observer2:
    def __init__(self, subject):
        subject.register(self)

    def notify(self, subject, *args):
        print(type(self).__name__, ':: Got', args, 'From', subject)


subject = Subject()
observer1 = Observer1(subject)
observer2 = Observer2(subject)
subject.notifyAll('notification')
# => Observer1 :: Got ('notification',) From <__main__.Subject object at 0x7f9a1276fa60>
# => Observer2 :: Got ('notification',) From <__main__.Subject object at 0x7f9a1276fa60>

现实中的观察者模式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
class NewsPublisher:
    def __init__(self):
        self.__subscribers = []
        self.__latestNews = None

    def attach(self, subscriber):
        self.__subscribers.append(subscriber)

    def detach(self):
        return self.__subscribers.pop()

    def subscribers(self):
        return [type(x).__name__ for x in self.__subscribers]

    def notifySubscribers(self):
        for sub in self.__subscribers:
            sub.update()

    def addNews(self, news):
        self.__latestNews = news

    def getNews(self):
        return "Got News: "  + self.__latestNews


from abc import ABCMeta, abstractmethod

class Subscriber(metaclass=ABCMeta):
    @abstractmethod
    def update(self):
        pass


class SMSSubscriber(Subscriber):
    def __init__(self, publisher):
        self.publisher = publisher
        self.publisher.attach(self)

    def update(self):
        print(type(self).__name__, self.publisher.getNews())


class EmailSubscriber(Subscriber):
    def __init__(self, publisher):
        self.publisher = publisher
        self.publisher.attach(self)

    def update(self):
        print(type(self).__name__, self.publisher.getNews())


class AnyOtherSubscriber:
    def __init__(self, publisher):
        self.publisher = publisher
        self.publisher.attach(self)

    def update(self):
        print(type(self).__name__, self.publisher.getNews())


if __name__ == '__main__':
    news_publisher = NewsPublisher()
    for Subscriber in [SMSSubscriber, EmailSubscriber, AnyOtherSubscriber]:
        Subscriber(news_publisher)
    print("\nSubscribers: ", news_publisher.subscribers())

    news_publisher.addNews('Hello World')
    news_publisher.notifySubscribers()

    print("\nDetached: ", type(news_publisher.detach()).__name__)
    print("\nSubscribers: ", news_publisher.subscribers())

    news_publisher.addNews('My second news')
    news_publisher.notifySubscribers()

# => Subscribers:  ['SMSSubscriber', 'EmailSubscriber', 'AnyOtherSubscriber']
# => SMSSubscriber Got News: Hello World
# => EmailSubscriber Got News: Hello World
# => AnyOtherSubscriber Got News: Hello World

# => Detached:  AnyOtherSubscriber

# => Subscribers:  ['SMSSubscriber', 'EmailSubscriber']
# => SMSSubscriber Got News: My second news
# => EmailSubscriber Got News: My second news

松耦合与观察者模式

松耦合架构的特性：

  • 降低了一个元素内发生的更改可能对其他元素产生意外影响的风险
  • 使得测试、维护和故障排除工作更加简单
  • 系统可以轻松地分解为可定义的元素

观察者模式提供了一种实现主体和观察者松耦合的对象设计模式：

  • 主题对观察者唯一的了解就是它实现的一个特定的接口
  • 可以随时添加任意的新观察者
  • 添加新观察者时，完全无需修改主题
  • 观察者或主题没有绑定在一起，可以彼此独立使用。观察者可以在任何地方重复使用
  • 主题或观察者中的变化不会相互影响

观察者模式的优缺点
优点：

  • 使得彼此交互的对象之间保持松耦合
  • 使得可以在无需对主题或观察者进行任何修改的情况下高效地发送数据到其他对象
  • 可以随时添加/删除观察者

缺点：

  • 观察者接口必须由具体观察者实现，涉及继承，且无法进行组合
  • 若实现不当的话，观察者可能会增加复杂性，导致性能降低
  • 在软件应用中，通知有时是不可靠的，并导致竞争条件不一致