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内置信号

Model signals
    pre_init                    # django的modal执行其构造方法前，自动触发
    post_init                   # django的modal执行其构造方法后，自动触发
    pre_save                    # django的modal对象保存前，自动触发
    post_save                   # django的modal对象保存后，自动触发
    pre_delete                  # django的modal对象删除前，自动触发
    post_delete                 # django的modal对象删除后，自动触发
    m2m_changed                 # django的modal中使用m2m字段操作第三张表（add,remove,clear）前后，自动触发
    class_prepared              # 程序启动时，检测已注册的app中modal类，对于每一个类，自动触发
Management signals
    pre_migrate                 # 执行migrate命令前，自动触发
    post_migrate                # 执行migrate命令后，自动触发
Request/response signals
    request_started             # 请求到来前，自动触发
    request_finished            # 请求结束后，自动触发
    got_request_exception       # 请求异常后，自动触发
Test signals
    setting_changed             # 使用test测试修改配置文件时，自动触发
    template_rendered           # 使用test测试渲染模板时，自动触发
Database Wrappers
    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指上述导入的内容

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

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

2 自定义信号

a. 定义信号

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

b. 注册信号

def callback(sender, **kwargs):
    print("callback")
    print(sender,kwargs)
 
pizza_done.connect(callback)

c. 触发信号

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

四 CBV

我们之前往往在django中将一个路径对应到一个视图函数执行，这种模型简称为FBV。那么如果要使用到类的方式那么就要使用到CBV了
使用CBV是在django url控制器添加一条 path('login/', views.Login.as_view()), # 调用的Login 类下的as_view方法

它的原理: 在进入视图之前添加装饰器

• 全部请求: 在进入dispatch方法之前
• 特定请求: 在特定视图上用 @方法
• 注意: 必须要使用method_decorator(my_decorator), 不能直接加my_decorator

1 使用CBV写一个登录认证

# 注意每个类继承views.View, 父类下的dispatch会根据http的不同方法执行类下的方法
from django views.View
class Login(views.View):
    msg = ''

    def get(self, request, *args, **kwargs):
         return render(request,'login.html', {"msg": self.msg})

    def post(self, request, *args, **kwargs):
        username = request.POST.get('username')
        password = request.POST.get('password')
        print(username, password)
        user_obj = UserInfo.objects.filter(username=username, password=password).first()
        print(user_obj)
        if user_obj:
                request.session['is_login'] = True
                request.session['username'] = username
                return render(request, "index.html", {'username': username})
        self.msg = '用户名或密码错误'
        return render(request, 'login.html', {'msg': self.msg})

2 给类加装饰器

首先导入django的装饰器工具 from django.utils.decorators import method_decorator

自己写的装饰：
def login_require(func):
    def inner(req, *args, **kwargs):
        is_login = req.session.get('is_login')
        print(is_login)
        username = req.session.get('username')
        if is_login:
            return func(req, username, *args, **kwargs)
        return redirect('/login/')
    return inner

给index的get方法添加装饰器
class Index(views.View):
    @method_decorator(login_require)
    def get(self, request, username, *args, **kwargs):
            print(username)
            return render(request, 'index.html', {'username': username})

3 父类的dispatch方法

如果要是想在父类的方法执行之前，先执行某个自定义的功能，可以通过继承dispatch方法实现

class Order(views.View):
    def dispatch(self, request, *args, **kwargs):
            is_login = request.session.get('is_login')
            print(is_login)
            username = request.session.get('username')
            if is_login:
                ret = super(Order, self).dispatch(request, *args, **kwargs)
                return ret
            else:
                return redirect('/login/')

    def get(self, request, *args, **kwargs):
            return render(request, 'Order.html')

#补充：如果多个类需要在执行get或post等方法执行额外功能，可以在每个类的dispatch方法前面加一个装饰器    
class Buy(views.View):
        @method_decorator(login_require)
        def dispatch(self, request, *args, **kwargs):
            ret = super(Buy,self).dispatch(request, *args, **kwargs) 
            return ret

4 method_decorator装饰器还支持使用name参数指明被装饰的方法

# 为全部请求方法添加装饰器
@method_decorator(my_decorator, name='dispatch')
class DemoView(View):
    def get(self, request):
        print('get方法')
        return HttpResponse('ok')

    def post(self, request):
        print('post方法')
        return HttpResponse('ok')


# 为特定请求方法添加装饰器
@method_decorator(my_decorator, name='get')
class DemoView(View):
    def get(self, request):
        print('get方法')
        return HttpResponse('ok')

    def post(self, request):
        print('post方法')
        return HttpResponse('ok')