WEB框架Django之中间件/缓存/CBV/信号

一Djano的中间件

1 中间件的概念

中间件顾名思义，是介于request与respose处理之间的一道处理过程，相对比较轻量级，并且全局上改变django的输入与输出。因为改变是全局，
所有需要谨慎使用，用不好会影响到性能

2 自定义中间件

中间件中一般有四个方法：
   process_request
   process_view
   process_exception
   process_response

当用户发起请求的时候依次讲过所有的中间件，这个时候的请求时process_request,最后到达views的函数中,views函数处理后，在依次穿过中间件，
这个时候process_response最后返回给请求者
我们自己定义一个中间件首先需要定义一个类再继承MiddlewareMixin

from django.utils.deprecation import MiddlewareMixin

class CustomerMiddleware1(MiddlewareMixin):
     def process_request(self, request):
           print('CustomerMiddleware process_request1.....')
                
     def process_response(self, request, response):
          print("中间件....返回1”）
          return response
        
        
 class CustomerMiddleware2(MiddlewareMixin):
       def process_request(self, request):
           print('CustomerMiddleware process_request2.....')
                
       def process_response(self, request, response):
           print("中间件....返回2”）
           return response
        
 执行顺序：
  CustomerMiddleware process_request
  CustomerMiddleware process_request2.....
  Index
  中间件....返回2
  中间件....返回1

3  process_view

当最后一个中间的process_request到达路由映射之后,返回到中间件1的process_view, 然后依次往下到达views函数
最后通过process_responese依次返回到达用户

from django.utils.deprecation import MiddlewareMixin
from django.shortcuts import HttpResponse
        
class Md1(MiddlewareMixin)
            
    def process_request(self,request)：
           print("Md1请求")
           # return HttpResponse("MD1中断")
            
    def process_response(self,request, response)
           print("MD1返回")
           return response
            
    def process_view(self, request, callback, callback_args, callback_kwargs)
           # callback 要执行的那个视图函数
           # callback_args  函数的参数
           print("Md1view")
            
Class Md2(MiddlewareMixin)
            def process_request(self, request)
                print("Md2请求")
                return HttpResponse("Md2中断")
            
            def process_response(self, request, response)
                print("Md2返回")
                return response
            
            def process_view(self, request, callback, callback_args, callback_kwargs)
                print("Md2view")
                

4  process_exception

如果在执行视图函数中出现错误，会依次走process_exception

from django.utils.deprecation import MiddlewareMixin
 from django.shortcuts import HttpResponse
        
class Md1(MiddlewareMixin)
            
    def process_request(self,request)：
            print("Md1请求")
            # return HttpResponse("MD1中断")
            
    def process_response(self,request, response)
            print("MD1返回")
            return response
            
    def process_view(self, request, callback, callback_args, callback_kwargs)
           print("Md1view")
                
    def process_exception(self, exception):
          print("md1 process_exception")
            
Class Md2(MiddlewareMixin)
    def process_request(self, request)
          print("Md2请求")
          return HttpResponse("Md2中断")
            
    def process_response(self, request, response)
          print("Md2返回")
          return response
            
    def process_view(self, request, callback, callback_args, callback_kwargs)
          print("Md2view")
                
    def process_exception(self, exception):
          print("md2 process_exception")

二 缓存

由于Django是动态网站，所以每次请求均会去数据库进行响应的操作，当程序访问量大时，耗时必然会更加明显。使用缓存讲一个或某个view的返回值保存在内存或者memcache中，5分钟内有人来访问时则不再去执行view中的操作，而是直接从
内存或者redis之类的缓存中拿到内容并返回
Django中提供了6中缓存方式
    1 开发调试
    2 内存
    3 文件
    4 数据库
    5 Memcache缓存(python-memcached模块)
    6 Memcache缓存(pylibmc模块)

1 开发测试

此为开始调试用，实际内部不做任何操作

 CACHES = {
            'default': {
                'BACKEND': 'django.core.cache.backends.dummy.DummyCache',     # 引擎
                'TIMEOUT': 300,                                               # 缓存超时时间（默认300，None表示永不过期，0表示立即过期）
                'OPTIONS':{
                    'MAX_ENTRIES': 300,                                       # 最大缓存个数（默认300）
                    'CULL_FREQUENCY': 3,                                      # 缓存到达最大个数之后，剔除缓存个数的比例，即：1/CULL_FREQUENCY（默认3）
                },
                'KEY_PREFIX': '',                                             # 缓存key的前缀（默认空）
                'VERSION': 1,                                                 # 缓存key的版本（默认1）
                'KEY_FUNCTION' 函数名                                          # 生成key的函数（默认函数会生成为：【前缀:版本:key】）
            }
        }

配置

自定义key

def default_key_func(key, key_prefix, version):
            """
            Default function to generate keys.

            Constructs the key used by all other methods. By default it prepends
            the `key_prefix'. KEY_FUNCTION can be used to specify an alternate
            function with custom key making behavior.
            """
            return '%s:%s:%s' % (key_prefix, version, key)

def get_key_func(key_func):
            """
            Function to decide which key function to use.

            Defaults to ``default_key_func``.
            """
            if key_func is not None:
                if callable(key_func):
                    return key_func
                else:
                    return import_string(key_func)
            return default_key_func

2 内存

此缓存将内容保存至内存的变量中

CACHES = {
            'default': {
                    'BACKEND': 'django.core.cache.backends.locmem.LocMemCache',
                    'LOCATION': 'unique-snowflake',
                }
            }

配置

注：其他配置同开发调试版本

3 文件

此缓存将内容保存至文件

    CACHES = {
            'default': {
                    'BACKEND': 'django.core.cache.backends.filebased.FileBasedCache',
                    'LOCATION': '/var/tmp/django_cache',
                }
            }
    # 注：其他配置同开发调试版本

配置

4 数据库

 此缓存将内容保存至数据库

    CACHES = {
            'default': {
                    'BACKEND': 'django.core.cache.backends.db.DatabaseCache',
                    'LOCATION': 'my_cache_table', # 数据库表
                }
            }
     注：执行创建表命令 python manage.py createcachetable

配置

5 Memcache缓存（python-memcached模块）

此缓存使用python-memcached模块连接memcache

ACHES = {
            'default': {
                'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache',
                'LOCATION': '127.0.0.1:11211',
            }
        }

        CACHES = {
            'default': {
                'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache',
                'LOCATION': 'unix:/tmp/memcached.sock',
            }
        }   

        CACHES = {
            'default': {
                'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache',
                'LOCATION': [
                    '172.19.26.240:11211',
                    '172.19.26.242:11211',
                ]
            }
        }

配置

6  Memcache缓存（pylibmc模块）

此缓存使用pylibmc模块连接memcache

            CACHES = {
                'default': {
                    'BACKEND': 'django.core.cache.backends.memcached.PyLibMCCache',
                    'LOCATION': '127.0.0.1:11211',
                }
            }

            CACHES = {
                'default': {
                    'BACKEND': 'django.core.cache.backends.memcached.PyLibMCCache',
                    'LOCATION': '/tmp/memcached.sock',
                }
            }   

            CACHES = {
                'default': {
                    'BACKEND': 'django.core.cache.backends.memcached.PyLibMCCache',
                    'LOCATION': [
                        '172.19.26.240:11211',
                        '172.19.26.242:11211',
                    ]
                }
            }

配置

三 信号量

Django中提供了“信号调度”，用于在框架执行操作时解耦。通俗来讲，就是一些动作发生的时候，信号允许特定的发送者去提醒一些接受者。

1 Django内置信号

 1 Model signals
 2     pre_init                    # django的modal执行其构造方法前，自动触发
 3     post_init                   # django的modal执行其构造方法后，自动触发
 4     pre_save                    # django的modal对象保存前，自动触发
 5     post_save                   # django的modal对象保存后，自动触发
 6     pre_delete                  # django的modal对象删除前，自动触发
 7     post_delete                 # django的modal对象删除后，自动触发
 8     m2m_changed                 # django的modal中使用m2m字段操作第三张表（add,remove,clear）前后，自动触发
 9     class_prepared              # 程序启动时，检测已注册的app中modal类，对于每一个类，自动触发
10 Management signals
11     pre_migrate                 # 执行migrate命令前，自动触发
12     post_migrate                # 执行migrate命令后，自动触发
13 Request/response signals
14     request_started             # 请求到来前，自动触发
15     request_finished            # 请求结束后，自动触发
16     got_request_exception       # 请求异常后，自动触发
17 Test signals
18     setting_changed             # 使用test测试修改配置文件时，自动触发
19     template_rendered           # 使用test测试渲染模板时，自动触发
20 Database Wrappers
21     connection_created          # 创建数据库连接时，自动触发

对于Django内置的信号，仅需注册指定信号，当程序执行相应操作时，自动触发注册函数：

    from django.core.signals import request_finished
    from django.core.signals import request_started
    from django.core.signals import got_request_exception

    from django.db.models.signals import class_prepared
    from django.db.models.signals import pre_init, post_init
    from django.db.models.signals import pre_save, post_save
    from django.db.models.signals import pre_delete, post_delete
    from django.db.models.signals import m2m_changed
    from django.db.models.signals import pre_migrate, post_migrate

    from django.test.signals import setting_changed
    from django.test.signals import template_rendered

    from django.db.backends.signals import connection_created


    def callback(sender, **kwargs):
        print("xxoo_callback")
        print(sender,kwargs)

    xxoo.connect(callback)
    # xxoo指上述导入的内容

View Code

from django.core.signals import request_finished
from django.dispatch import receiver

@receiver(request_finished)
def my_callback(sender, **kwargs):
    print("Request finished!")

View Code

2 自定义信号

a. 定义信号

1 import django.dispatch
2 pizza_done = django.dispatch.Signal(providing_args=["toppings", "size"])

b. 注册信号

1 def callback(sender, **kwargs):
2     print("callback")
3     print(sender,kwargs)
4  
5 pizza_done.connect(callback)

c. 触发信号

1 from 路径 import pizza_done
2 pizza_done.send(sender='seven',toppings=123, size=456)