Django中的Signal代码详解_Python

本文研究的主要是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)。

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

									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

connect方法

connect方法用于连接信号和信号处理函数，类似的概念相当于为某个事件（信号发出表示一个事件）注册观察者（处理函数），函数参数中receiver就是信号处理函数（函数也是对象，这太方便了），sender表示信号的发送者，比如Django框架中的post_save()这个信号，任何一个模型在save()函数调用之后都会发出这个信号，但是我们只想关注某一个模型 save()方法调用的事件发生，就可以指定sender为我们需要关注的模型类。

weak参数表示是否将receiver转换成弱引用对象，Siganl中默认会将所有的receiver转成弱引用，所以如果你的receiver是个局部对象的话，那么receiver可能会被垃圾回收期回收，receiver也就变成一个dead_receiver了，Siganl会在connect和disconnect方法调用的时候，清除dead_receiver。

dispatch_uid，这个参数用于唯一标识这个receiver函数，主要的作用是防止receiver函数被注册多次，这样会导致receiver函数会执行多次，这可能是我们不想要的一个结果。

disconnect方法

　　disconnect方法用于断开信号的接收器，函数内首先会生成根据sender和receiver对象构造出的一个标识lookup_key，在遍历receiver数组时，根据lookup_key找到需要disconnect的receiver然后从数组中删除这个receiver。

send和send_robust

send和send_robust方法都是用于发送事件的函数，不同点在于send_robust函数中会捕获信号接收函数发生的异常，添加到返回的responses数组中。

Siganl类的使用

Django signal的处理过程如下图所示：

Django中的Signal代码详解

内建signal的使用

模型相关：

pre_save 对象save前触发
post_save 对象save后触发
pre_delete 对象delete前触发
post_delete 对象delete后触发
m2m_changed ManyToManyField 字段更新后触发

请求相关：

request_started 一个request请求前触发
request_finished request请求后触发

针对django自带的signal，我们只需要编写receiver 即可，使用如下。

第一步，编写receiver并绑定到signal

									# myapp/signals/handlers.py

									from django.dispatch import receiver

									from django.core.signals import request_finished

									## decorators 方式绑定

									@receiver(request_finished, dispatch_uid="request_finished")

									def my_signal_handler(sender, **kwargs):

									  print("Request finished!================================")

									# 普通绑定方式

									def my_signal_handler(sender, **kwargs):

									  print("Request finished!================================")

									request_finished.connect(my_signal_handler)

									#####################################################

									# 针对model 的signal 

									from django.dispatch import receiver

									from django.db.models.signals import post_save

									from polls.models import MyModel

									@receiver(post_save, sender=MyModel, dispatch_uid="mymodel_post_save")

									def my_model_handler(sender, **kwargs):

									 print('Saved: {}'.format(kwargs['instance'].__dict__))

用dispatch_uid确保此receiver只调用一次

第二步，加载signal

									# myapp/__init__py

									default_app_config = 'myapp.apps.MySendingAppConfig'

									# myapp/apps.py

									from django.apps import AppConfig

									class MyAppConfig(AppConfig):

									  name = 'myapp'

									  def ready(self):

									    # signals are imported, so that they are defined and can be used

									    import myapp.signals.handlers

到此，当系统受到request 请求完成后，便会执行receiver。

其他内建的signal，参考官方文档：

https://docs.djangoproject.com/en/1.9/topics/signals/

自定义signal的使用

自定义signal，需要我们编写signal和receiver。

第一步,编写signal

									myapp.signals.signals.py

									importdjango.dispatch

									my_signal = django.dispatch.Signal(providing_args=["my_signal_arg1", "my_signal_arg_2"])

第二步，加载signal

									# myapp/__init__py

									default_app_config = 'myapp.apps.MySendingAppConfig'

									myapp/apps.py

									from django.apps import AppConfig

									class MyAppConfig(AppConfig):

									  name = 'myapp'

									  def ready(self):

									    # signals are imported, so that they are defined and can be used

									    import myapp.signals.handlers

第三步，事件触发时，发送signal

									# myapp/views.py

									from .signals.signals import my_signal

									my_signal.send(sender="some function or class",

									        my_signal_arg1="something", my_signal_arg_2="something else"])

自定义的signal，django已经为我们编写了此处的事件监听。

第四步，收到signal，执行receiver

									# myapp/signals/handlers.py

									from django.dispatch import receiver

									from myapp.signals.signals import my_signal

									@receiver(my_signal, dispatch_uid="my_signal_receiver")

									def my_signal_handler(sender, **kwargs):

									  print('my_signal received')

此时，我们自定义的signal 便开发完成了。

总结

以上就是本文关于Django中的Signal代码详解的全部内容，希望对大家有所帮助。感兴趣的朋友可以继续参阅本站其他相关专题，如有不足之处，欢迎留言指出。感谢朋友们对本站的支持！

原文链接：http://blog.csdn.net/u013007900/article/details/78110891

Django中的Signal代码详解

相关文章

热门资讯