Django中的Signal代码详解-创新互联
本文研究的主要是Django开发中的signal 的相关内容，具体如下。
前言
在web开发中， 你可能会遇到下面这种场景:
在用户完成某个操作后， 自动去执行一些后续的操作. 譬如用户完成修改密码后，
你要发送一份确认邮件.
当然可以把逻辑写在一起，但是有个问题是，触发操作一般不止一种(如用户更改了其它信息的确认邮件)，这时候这个逻辑会需要写多次，所以你可能会想着DRY(Don't repeat yourself)，于是你把它写到了一个函数中，每次调用。当然这是没问题的.
但是， 如果你换个思路你会发现另一个完全不同的方案， 即:
- 类似于daemon的程序监听着特定的事件
- 前置操作来触发相应的事件
- 监听程序执行对应的操作
这样的好处是什么呢?
- 松耦合(不用把后续操作写在主逻辑中)
- 便于复用(这也是为什么django本身，及第三方应用如pinax大量使用此技术的原因)，在各种高级语言中都会有类似的特性，如java，javascript等，而在django中我们使用signal。
观察者模式
Siganl是Django框架中提供的一个 “信号分发器”。它是设计模式中经常提到的观察者模式的一个实现应用。
在此种模式中，一个目标物件管理所有相依于它的观察者物件，并且在它本身的状态改变时主动发出通知。这通常透过呼叫各观察者所提供的方法来实现。
观察者模式的使用场景
- 关联行为场景，需要注意的是，关联行为是可拆分的，而不是“组合”关系。
- 事件多级触发场景。
- 跨系统的消息交换场景，如消息队列、事件总线的处理机制。
优点
1.解除耦合，让耦合的双方都依赖于抽象，从而使得各自的变换都不会影响另一边的变换。
它在被观察者和观察者之间建立一个抽象的耦合。被观察者角色所知道的只是一个具体观察者列表，每一个具体观察者都符合一个抽象观察者的接口。被观察者并不认识任何一个具体观察者，它只知道它们都有一个共同的接口。
由于被观察者和观察者没有紧密地耦合在一起，因此它们可以属于不同的抽象化层次。这种耦合性使得代码的可读性、维护性大大提高。
2.观察者模式实现了动态联动；
由于观察者模式对观察者注册实行管理，那就可以在运行期间，通过动态的控制注册的观察者来控制某个动作的联动范围，从而实现动态联动。
3.观察者模式支持广播通信。
目标发送通知给观察者是面向所有注册的观察者，所以目标每次通知的信息就要对所有注册的观察者进行广播，也可以在目标上添加新的方法来限制广播的范围。
Django 中Siganl 机制的典型应用是，框架为 Models 创建了 pre_save、post_save等与Model的某些方法调用相关联的信号，如pre_save 和 post_save 分别会在 Modle的save()方法的调用之前和之后通知观察者，从而让观察者进行一系列操作。
django signal的处理是同步的，勿用于处理大批量任务。
django signal对程序的解耦、代码的复用及维护性有很大的帮助。
Signal 机制的实现方式
Siganl的源码位于django dispatch包下，主要的代码位于 dispatcher.py中。
在dispatcher中定义了Signal类，以及一个用于使用Python装饰器的方式来连接信号以及信号接受者的方法receiver(signal,**kwargs)。
class Signal(object):
"""
Base class for all signals
Internal attributes:
receivers
{ receiverkey (id) : weakref(receiver) }
"""
def __init__(self, providing_args=None, use_caching=False):
"""
创建一个新的Signal
providing_args 参数，指定这个Siganl 在发出事件（调用send方法）时，可以提供给观察者的信息参数
比如 post_save（）会带上 对应的instance对象，以及update_fields等
"""
self.receivers = []
if providing_args is None:
providing_args = []
self.providing_args = set(providing_args)
self.lock = threading.Lock()
self.use_caching = use_caching
# For convenience we create empty caches even if they are not used.
# A note about caching: if use_caching is defined, then for each
# distinct sender we cache the receivers that sender has in
# 'sender_receivers_cache'. The cache is cleaned when .connect() or
# .disconnect() is called and populated on send().
self.sender_receivers_cache = weakref.WeakKeyDictionary() if use_caching else {}
self._dead_receivers = False
def connect(self, receiver, sender=None, weak=True, dispatch_uid=None):
from django.conf import settings
if dispatch_uid:
lookup_key = (dispatch_uid, _make_id(sender))
else:
lookup_key = (_make_id(receiver), _make_id(sender))
if weak:
ref = weakref.ref
receiver_object = receiver
# Check for bound methods
# 构造弱引用的的receiver
if hasattr(receiver, '__self__') and hasattr(receiver, '__func__'):
ref = WeakMethod
receiver_object = receiver.__self__
if sys.version_info >= (3, 4):
receiver = ref(receiver)
weakref.finalize(receiver_object, self._remove_receiver)
else:
receiver = ref(receiver, self._remove_receiver)
with self.lock:
#clear掉 由于弱引用 已被垃圾回收期回收的receivers
self._clear_dead_receivers()
for r_key, _ in self.receivers:
if r_key == lookup_key:
break
else:
self.receivers.append((lookup_key, receiver))
self.sender_receivers_cache.clear()
def disconnect(self, receiver=None, sender=None, weak=True, dispatch_uid=None):
if dispatch_uid:
lookup_key = (dispatch_uid, _make_id(sender))
else:
lookup_key = (_make_id(receiver), _make_id(sender))
disconnected = False
with self.lock:
self._clear_dead_receivers()
for index in range(len(self.receivers)):
(r_key, _) = self.receivers[index]
if r_key == lookup_key:
disconnected = True
del self.receivers[index]
break
self.sender_receivers_cache.clear()
return disconnected
def has_listeners(self, sender=None):
return bool(self._live_receivers(sender))
def send(self, sender, **named):
responses = []
if not self.receivers or self.sender_receivers_cache.get(sender) is NO_RECEIVERS:
return responses
for receiver in self._live_receivers(sender):
response = receiver(signal=self, sender=sender, **named)
responses.append((receiver, response))
return responses
def send_robust(self, sender, **named):
responses = []
if not self.receivers or self.sender_receivers_cache.get(sender) is NO_RECEIVERS:
return responses
# Call each receiver with whatever arguments it can accept.
# Return a list of tuple pairs [(receiver, response), ... ].
for receiver in self._live_receivers(sender):
try:
response = receiver(signal=self, sender=sender, **named)
except Exception as err:
if not hasattr(err, '__traceback__'):
err.__traceback__ = sys.exc_info()[2]
responses.append((receiver, err))
else:
responses.append((receiver, response))
return responses
def _clear_dead_receivers(self):
# Note: caller is assumed to hold self.lock.
if self._dead_receivers:
self._dead_receivers = False
new_receivers = []
for r in self.receivers:
if isinstance(r[1], weakref.ReferenceType) and r[1]() is None:
continue
new_receivers.append(r)
self.receivers = new_receivers
def _live_receivers(self, sender):
"""
过滤掉 已经被 垃圾回收的receiver
"""
receivers = None
# 如果使用了cache , 并且没有调用过_remove_receiver 函数 则去 sender_receivers_cache中查找
if self.use_caching and not self._dead_receivers:
receivers = self.sender_receivers_cache.get(sender)
# We could end up here with NO_RECEIVERS even if we do check this case in
# .send() prior to calling _live_receivers() due to concurrent .send() call.
if receivers is NO_RECEIVERS:
return []
if receivers is None:
with self.lock:
self._clear_dead_receivers()
senderkey = _make_id(sender)
receivers = []
for (receiverkey, r_senderkey), receiver in self.receivers:
if r_senderkey == NONE_ID or r_senderkey == senderkey:
receivers.append(receiver)
if self.use_caching:
if not receivers:
self.sender_receivers_cache[sender] = NO_RECEIVERS
else:
# Note, we must cache the weakref versions.
self.sender_receivers_cache[sender] = receivers
non_weak_receivers = []
for receiver in receivers:
if isinstance(receiver, weakref.ReferenceType):
# Dereference the weak reference.
receiver = receiver()
if receiver is not None:
non_weak_receivers.append(receiver)
else:
non_weak_receivers.append(receiver)
return non_weak_receivers
def _remove_receiver(self, receiver=None):
self._dead_receivers = True另外有需要云服务器可以了解下创新互联scvps.cn，海内外云服务器15元起步，三天无理由+7*72小时售后在线，公司持有idc许可证，提供“云服务器、裸金属服务器、高防服务器、香港服务器、美国服务器、虚拟主机、免备案服务器”等云主机租用服务以及企业上云的综合解决方案，具有“安全稳定、简单易用、服务可用性高、性价比高”等特点与优势，专为企业上云打造定制，能够满足用户丰富、多元化的应用场景需求。
分享文章：Django中的Signal代码详解-创新互联
网址分享：http://ybzwz.com/article/ehpjh.html
