说到观察者模式，在我脑海中总是闪现，这家伙跟消息队列的主题发布订阅有什么关系，虽然本人对消息队列没有很深的研究，但是凭直觉我就认为消息队列的实现就使用了观察者模式吧，所以本文就来模拟消息队列的丐版实现阐述观察者模式是怎样玩的。

观察者模式的GOF官方解释是： 定义对象间的一种一对多(变化)的依赖关系， 以便当一个对象(Subject)的状态发生改变时，所有依赖于它的对象都得到通知并更新。

观察者模式类图如下：

主要构成就是主题基类， 观察者基类及其他们的实现。接下来我们开始设计属于我们自己的消息队列。

01、 首先设计主题基类

from abc importABCclassSubject(ABC):def __init__(self):

self.observers=list()defadd_observer(self, observer):

self.observers.append(observer)defpop_observer(self, observer):

self.observers.remove(observer)defnotify(self):for observer inself.observers:

observer.update()

在Subject基类中，我们需要定义一个观察者列表用于盛放观察者对象，然后我们需要有添加和删除观察者的方法，最后一个必要的方法就是通知观察者更新。

02、设计我们的主题子类

classGameSubject(Subject):defnotify(self, msg):for observer inself.observers:

observer.update(msg)

我们设计一个游戏主题类，专门给观察者推送游戏消息，所以我们重写了nitify方法。

03、设计我们的观察者子类

from queue importQueueclassObserver:def __init__(self):

self.queue= Queue(100)defupdate(self):pass

在观察者基类中，我们定一个队列用于接收主题发布的消息， 还有声明一个更新方法，用于给子类继承。

04、设计我们的观察者子类

classLolObserver(Observer):def __init__(self, name):

self.name=name

super().__init__()defupdate(self, msg):

self.queue.put(msg)defget_msg(self):while notself.queue.empty():

msg=self.queue.get()print(self.name + "正在读取消息：" + msg)classDNFObserver(Observer):def __init__(self, name):

self.name=name

super().__init__()defupdate(self, msg):

self.queue.put(msg)defget_msg(self):while notself.queue.empty():

msg=self.queue.get()print(self.name + "正在读取消息：" + msg)

在我们的观察者子类中，我们主要定义了，对队列的IO操作。

05、 主程序

if __name__ == "__main__":

game_subject=GameSubject()

lol_observer= LolObserver('lol选手')

dnf_observer= DNFObserver("DNF选手")

game_subject.add_observer(lol_observer)

game_subject.add_observer(dnf_observer)

game_subject.notify("第一届游戏大赛正在开始")

game_subject.notify("我们友情两大游戏金牌选手")

game_subject.notify("谁会是第一名呢？")

game_subject.pop_observer(dnf_observer)

game_subject.notify("会是LOL选手吗？")

game_subject.notify("貌似DNF选手掉线了啊")

game_subject.add_observer(dnf_observer)

game_subject.notify("我们的选手又回来了")

lol_observer.get_msg()print("="*77)

dnf_observer.get_msg()

运行结果如下：

/usr/local/bin/python3.7 /Users/bytedance/PycharmProjects/untitled3/模版设计模式/观察者模式.py

lol选手正在读取消息：第一届游戏大赛正在开始

lol选手正在读取消息：我们友情两大游戏金牌选手

lol选手正在读取消息：谁会是第一名呢？

lol选手正在读取消息：会是LOL选手吗？

lol选手正在读取消息：貌似DNF选手掉线了啊

lol选手正在读取消息：我们的选手又回来了=============================================================================DNF选手正在读取消息：第一届游戏大赛正在开始

DNF选手正在读取消息：我们友情两大游戏金牌选手

DNF选手正在读取消息：谁会是第一名呢？

DNF选手正在读取消息：我们的选手又回来了

Process finished with exit code 0

到此我们的丐版的消息队列就完成了，哈哈，以此类推诸如微信群功能，都可以用此模式去实现，到此感觉观察者模式不像是一种模式，更像是一种业务的实现的技巧，但是它的关键点在于，你在遍历观察者列表处的巧妙，利用面向对象多态的特性，只要你继承自观察者基类，都可以调用update方法，无须是具体的观察者。

07、总结

观察者设计模式使得我们可以独立地改变主题和观察者，从而使二者的依赖关系达到松耦合的目的。

目标发送通知时，我们无须指定接收者，消息自动传播到接受者处。

但是当观察者过多时可能会产生性能问题，因为我们是在遍历观察者列表

最后还是奉上我们的设计模式八大设计原则：

依赖倒置原则(DIP)

高层模块(稳定)不应该依赖于低层模块(变化)，二者都应该依赖于抽象(稳定) 。

抽象(稳定)不应该依赖于实现细节(变化) ，实现细节应该依赖于抽象(稳定)。

开放封闭原则(OCP)

对扩展开放，对更改封闭。

类模块应该是可扩展的，但是不可修改。

单一职责原则(SRP)

一个类应该仅有一个引起它变化的原因。

变化的方向隐含着类的责任。

Liskov 替换原则(LSP)

子类必须能够替换它们的基类(IS-A)。

继承表达类型抽象。

接口隔离原则(ISP)

不应该强迫客户程序依赖它们不用的方法。

接口应该小而完备。

优先使用对象组合，而不是类继承

类继承通常为“白箱复用”，对象组合通常为“黑箱复用” 。

继承在某种程度上破坏了封装性，子类父类耦合度高。

而对象组合则只要求被组合的对象具有良好定义的接口，耦合度低。

封装变化点

使用封装来创建对象之间的分界层，让设计者可以在分界层的一侧进行修改，而不会对另一侧产生不良的影响，从而实现层次间的松耦合。

针对接口编程，而不是针对实现编程

不将变量类型声明为某个特定的具体类，而是声明为某个接口。

客户程序无需获知对象的具体类型，只需要知道对象所具有的接口。

减少系统中各部分的依赖关系，从而实现“高内聚、松耦合”的类型设计方案