浅谈Django中的Signal

水深无声 2022-06-08 13:37 209阅读 0赞

## 前言 ##

在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

### 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的处理过程如下图所示：

![图1][1]

#### 内建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/][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 便开发完成了。

[1]: /images/20220608/cee55aa7812049fe8b43d8f435e97307.png
[https_docs.djangoproject.com_en_1.9_topics_signals]: https://docs.djangoproject.com/en/1.9/topics/signals/