Django

前戏：

前面的内容已经学会了给视图函数加装饰器来判断是用户是否登录，把没有登录的用户请求跳转到登录页面。我们通过给几个特定视图函数加装饰器实现了这个需求。但是以后添加的视图函数可能也需要加上装饰器，这样是不是稍微有点繁琐。

学完今天的内容之后呢，我们就可以用更适宜的方式来实现类似给所有请求都做相同操作的功能了。

一、中间件介绍

什么是中间件？

官方的说法：中间件是一个用来处理Django的请求和响应的框架级别的钩子。它是一个轻量、低级别的插件系统，用于在全局范围内改变Django的输入和输出。每个中间件组件都负责做一些特定的功能。

但是由于其影响的是全局，所以需要谨慎使用，使用不当会影响性能。

说的直白一点中间件是帮助我们在视图函数执行之前和执行之后都可以做一些额外的操作，它本质上就是一个自定义类，类中定义了几个方法，Django框架会在请求的特定的时间去执行这些方法。

我们一直都在使用中间件，只是没有注意到而已，打开Django项目的Settings.py文件，看到下图的MIDDLEWARE配置项。

MIDDLEWARE = [
    'django.middleware.security.SecurityMiddleware',
    'django.contrib.sessions.middleware.SessionMiddleware',
    'django.middleware.common.CommonMiddleware',
    'django.middleware.csrf.CsrfViewMiddleware',
    'django.contrib.auth.middleware.AuthenticationMiddleware',
    'django.contrib.messages.middleware.MessageMiddleware',
    'django.middleware.clickjacking.XFrameOptionsMiddleware',

    # 导入自定义中间件
    'app01.my_middlewares.CustomerMiddleware1',
    'app01.my_middlewares.CustomerMiddleware2',

    # 用户登录认证中间件
    'app01.my_middlewares.AuthMiddleware',
]

MIDDLEWARE配置项是一个列表，列表中是一个个字符串，这些字符串其实是一个个类，也就是一个个中间件。

我们之前已经接触过一个csrf相关的中间件了？我们一开始让大家把他注释掉，再提交post请求的时候，就不会被forbidden了，后来学会使用csrf_token之后就不再注释这个中间件了。

那接下来就学习中间件中的方法以及这些方法什么时候被执行。

　　每一个中间件都有具体的功能。

　   django默认7个中间件，其实就是一个类。

 　  django请求周期

接收到了socket，拿到了请求信息，wsgire做了一个封装request的操作（解析数据，解析成一个request的对象）----------------->>>会进入中间件，执行每一个中间件的process_request，它是依次执行的。------>

路由层做分发，分发完了交给视图进行处理，视图要响应一个值，如果是字符串就原路返回了，它返回的时候是依次执行process_response这个方法 走出中间件 ---->

wsgiref封装了数据，（http协议必须按照响应体的响应格式进行发，如果不按照那个格式发浏览器无法解析；wsgiref封装协议，响应首行、响应体、响应体）

把请求体交给浏览器----》拿到响应体浏览器解析为一个页面给用户看。

中间件不管你访问的请求路径是什么，只要请求访问的是这个服务器就必然会通过这个中间件来的时候经过process_response，回去的时候经过process_request，属于全局性逻辑处理。

二、自定义中间件

 中间件可以定义五个方法，分别是：（主要的是process_request和process_response）

• process_request(self,request)

• process_view(self, request, view_func, view_args, view_kwargs)

• process_template_response(self,request,response)

• process_exception(self, request, exception)

• process_response(self, request, response)

　　 以上方法的返回值可以是None或一个HttpResponse对象，如果是None，则继续按照django定义的规则向后继续执行，如果是HttpResponse对象，则直接将该对象返回给用户。

上述截图中的中间件都是django中的，我们也可以自己定义一个中间件，我们可以自己写一个类，但是必须继承MiddlewareMixin

需要导入

from django.utils.deprecation import MiddlewareMixin

三、process_request

process_request有一个参数，就是request，这个request和视图函数中的request是一样的。

它的返回值可以是None也可以是HttpResponse对象。返回值是None的话，按正常流程继续走，交给下一个中间件处理，如果是HttpResponse对象，Django将不执行视图函数，而将相应对象返回给浏览器。

我们来看看多个中间件时，Django是如何执行其中的process_request方法的。

自定义中间件示例：

from django.utils.deprecation import MiddlewareMixin

class CustomerMiddleware1(MiddlewareMixin): #让它继承下这个类

    def process_request(self, request):
        print('CustomerMiddleware1 process_request')   #默认返回None；然后比如你访问index页面，它就会执行这句话了，走了precess_request


class CustomerMiddleware2(MiddlewareMixin):

    def process_request(self, request):
        print('CustomerMiddleware2 process_request')

'app01.my_middlewares.CustomerMiddleware',  #在settins里边的MIDDLEWARE把它加进去。
'app01.my_middlewares.CustomerMiddleware2',

#这两个中间件里边的process_request依次执行； 它是全局的逻辑处理

打印：

CustomerMiddleware1 process_request
CustomerMiddleware2 process_request
index  #先走中间件，再进视图函数打印它

把CustomerMiddleware1和CustomerMiddleware2的位置调换一下，再访问一个视图，会发现终端中打印的内容如下：

CustomerMiddleware2 process_request
CustomerMiddleware1 process_request
index  #先走中间件，再进视图函数打印它

看结果我们知道：视图函数还是最后执行的，CustomerMiddleware1比CustomerMiddleware2先执行自己的process_request方法。

在打印一下两个自定义中间件中process_request方法中的request参数，会发现它们是同一个对象。

由此总结一下：

1. 中间件的process_request方法是在执行视图函数之前执行的。
2. 当配置多个中间件时，会按照MIDDLEWARE中的注册顺序，也就是列表的索引值，从前到后依次执行的。
3. 不同中间件之间传递的request都是同一个对象

多个中间件中的process_response方法是按照MIDDLEWARE中的注册顺序倒序执行的，也就是说第一个中间件的process_request方法首先执行，而它的process_response方法最后执行，最后一个中间件的process_request方法最后一个执行，它的process_response方法是最先执行。

中间件的作用：

大部分视图要做的工作，我们可以放到中间件里边去，比如关于session的验证：好像视图函数必须是在登录之后才能看这个页面，必须在每个视图函数里边加判断或者加装饰器，二三十个视图函数都挂一个装饰器login_request，如果把校验放到中间件里边去，在这里边定义一次，所有的请求都进来之后都会校验它是否登录了 

四、process_response

它有两个参数，一个是request，一个是response，request就是上述例子中一样的对象，response是视图函数返回的HttpResponse对象。该方法的返回值也必须是HttpResponse对象。

给上述的CustomerMiddleware1和CustomerMiddleware2加上process_response方法

from django.utils.deprecation import MiddlewareMixin
class CustomerMiddleware1(MiddlewareMixin):

    def process_request(self, request):
        print('CustomerMiddleware1 process_request')

    def process_response(self, request,response): #response就是HttpResponse（INDEX）相应体对象
        print('CustomerMiddleware1 process_response')
        return response  #它必须要有返回值，就像接力棒一层层传给别人；在process_request里边必须要写返回值。

class CustomerMiddleware2(MiddlewareMixin):

    def process_request(self, request):
        print('CustomerMiddleware2 process_request')

    def process_response(self, request,response):
        print('CustomerMiddleware2 process_response')
        return response

打印：

CustomerMiddleware1 process_request
CustomerMiddleware2 process_request
index
CustomerMiddleware2 process_response
CustomerMiddleware1 process_response

看结果可知：

process_response方法是在视图函数之后执行的，并且顺序是CustomerMiddleware2比CustomerMiddleware1先执行。

多个中间件中的process_response方法是按照MIDDLEWARE中的注册顺序倒序执行的，也就是说第一个中间件的process_request方法首先执行，而它的process_response方法最后执行，最后一个中间件的process_request方法最后一个执行，它的process_response方法是最先执行。

如果非要在process_request加个返回值，

from django.utils.deprecation import MiddlewareMixin
from django.shortcuts import HttpResponse

class CustomerMiddleware(MiddlewareMixin):

    def process_request(self, request):
        print('CustomerMiddleware1 process_request')
        return HttpResponse('forbidden..')

    def process_response(self, request,response): #response就是HttpResponse（INDEX）相应体对象
        print('CustomerMiddleware1 process_response')
        return response  #它必须要有返回值，就像接力棒一层层传给别人

class CustomerMiddleware2(MiddlewareMixin):

    def process_request(self, request):
        print('CustomerMiddleware2 process_request')

    def process_response(self, request,response):
        print('CustomerMiddleware2 process_response')
        return response

打印：

CustomerMiddleware1 process_request
CustomerMiddleware1 process_response

#访问http://127.0.0.1:8000/index/打印的是forbidden..，

没有执行中间件2的内容，也没有执行视图。

　　 url请求中间件1的process_request的时候，一旦加了返回值，直接把响应体交给自己的process_response，交给浏览器。一下子给拦截了。

　　 应用场景：拦截，你的ip频率太高；session进行校验的时候没有登录也给你拦截下来。

五、process_view

process_view(self, request, callback, callback_args, callback_kwargs)

该方法有四个参数

request是HttpRequest对象。

callback是Django即将使用的视图函数。 （它是实际的函数对象，而不是函数的名称作为字符串。）

callback_args是将传递给视图的位置参数的列表.

callback_kwargs是将传递给视图的关键字参数的字典。 callback_args和callback_kwargs都不包含第一个视图参数（request）。

Django会在调用视图函数之前调用process_view方法。

它应该返回None或一个HttpResponse对象。 如果返回None，Django将继续处理这个请求，执行任何其他中间件的process_view方法，然后在执行相应的视图。 如果它返回一个HttpResponse对象，Django不会调用适当的视图函数。 它将执行中间件的process_response方法并将应用到该HttpResponse并返回结果。

加了process_view之后打印执行的顺序：

CustomerMiddleware1 process_request
CustomerMiddleware2 process_request
CustomerMiddleware1:process_view
CustomerMiddleware2:process_view
index
CustomerMiddleware2 process_response
CustomerMiddleware1 process_response

from django.utils.deprecation import MiddlewareMixin
from django.shortcuts import HttpResponse
class CustomerMiddleware(MiddlewareMixin):
    def process_request(self, request):
        print('CustomerMiddleware1 process_request')
        #return HttpResponse('forbidden..')
    def process_view(self, request, callback, callback_args, callback_kwargs):
        print("CustomerMiddleware1:process_view")

    def process_response(self, request,response): #response就是HttpResponse（INDEX）相应体对象
        print('CustomeerMiddleware1 process_response')
        return response  #它必须要有返回值，就像接力棒一层层传给别人

class CustomerMiddleware2(MiddlewareMixin):
    def process_request(self, request):
        print('CustomerMiddleware2 process_request')
    def process_response(self, request,response):
        print('CustomeerMiddleware2 process_response')
        return response

    def process_view(self, request, callback, callback_args, callback_kwargs):
        #print("===>",callback) #===> <function index at 0x0000000003DE11E0> 视图函数
        #在进入到2的视图函数的时候，把响应体体返回了 123，那么视图函数就不执行了，接着往下执行process_response
        print("===>",callback(callback_args)) #不走视图函数了我提前拿到它的响应结果

        print("CustomerMiddleware2:process_view")
        ret = callback(callback_args)      ###可以进行拦截。
        return ret  #把它的结果返回了就可以拿到视图函数里边的index了
        #return HttpResponse('123') # 没有走index,返回123

打印：

上边的执行结果
CustomerMiddleware1 process_request
CustomerMiddleware2 process_request
CustomerMiddleware1:process_view
===> <HttpResponse status_code=200, "text/html; charset=utf-8">
CustomerMiddleware2:process_view
index
CustomerMiddleware2 process_response
CustomerMiddleware1 process_response

六、process_exception

process_exception(self, request, exception)

该方法两个参数:

一个HttpRequest对象

一个exception是视图函数异常产生的Exception对象。

这个方法只有在视图函数中出现异常了才执行，它返回的值可以是一个None也可以是一个HttpResponse对象。如果是HttpResponse对象，Django将调用模板和中间件中的process_response方法，并返回给浏览器，否则将默认处理异常。如果返回一个None，则交给下一个中间件的process_exception方法来处理异常。它的执行顺序也是按照中间件注册顺序的倒序执行。

 给CustomerMiddleware1和MCustomerMiddleware2添加上这个方法：

from django.utils.deprecation import MiddlewareMixin
from django.shortcuts import HttpResponse
class CustomerMiddleware(MiddlewareMixin):
    def process_request(self, request):
        print('CustomerMiddleware1 process_request')
        #return HttpResponse('forbidden..')
    def process_view(self, request, callback, callback_args, callback_kwargs):
        print("CustomerMiddleware1:process_view")

    def process_response(self, request,response): #response就是HttpResponse（INDEX）相应体对象
        print('CustomerMiddleware1 process_response')
        return response  #它必须要有返回值，就像接力棒一层层传给别人
    def process_exception(self, request, exception):
        print('CustomeerMiddleware1 process_exception')

class CustomerMiddleware2(MiddlewareMixin):
    def process_request(self, request):
        print('CustomerMiddleware2 process_request')
    def process_response(self, request,response):
        print('CustomerMiddleware2 process_response')
        return response

    def process_view(self, request, callback, callback_args, callback_kwargs):
        #print("===>",callback) #===> <function index at 0x0000000003DE11E0> 视图函数
        #在进入到2的视图函数的时候，把相应体返回了 123，那么视图函数就不执行了，接着往下执行process_response
        #print("===>",callback(callback_args))

        print("CustomerMiddleware2:process_view")
        # ret = callback(callback_args)
        # return ret  #把它的结果返回了就可以拿到index了
        #return HttpResponse('123')
    def process_exception(self, request, exception):
        print('CustomeerMiddleware2 process_exception')
        return HttpResponse(exception)  #一旦有一个return了，后边1的process_exception就不执行了；把它的错误信息给返回了呗

打印：

CustomerMiddleware1 process_request
CustomerMiddleware2 process_request
CustomerMiddleware1:process_view
CustomerMiddleware2:process_view
index
CustomeerMiddleware2 process_exception #直接检测完，把它的错误捕捉到交给响应体返回了，就不执行1的process_exception了
CustomeerMiddleware2 process_response
CustomeerMiddleware1 process_response

如果把return写到1里边，2不要，return HttpResponse(exception) 

CustomerMiddleware1 process_request
CustomerMiddleware2 process_request
CustomerMiddleware1:process_view
CustomerMiddleware2:process_view
index
CustomeerMiddleware2 process_exception
CustomeerMiddleware1 process_exception
CustomeerMiddleware2 process_response
CustomeerMiddleware1 process_response

七、通过中间件进行登录验证

如果用户访问的是login视图（放过）

如果访问其他视图，需要检测是不是有session认证，已经有了放行，没有返回login，这样就省得在多个视图函数上写装饰器了！

　　my_middlewares.py

from django.utils.deprecation import MiddlewareMixin
from django.shortcuts import HttpResponse,redirect
from authDemo import settings

class AuthMiddleware(MiddlewareMixin):  #认证
    def process_request(self, request):
        white_list = settings.WHITE_LIST #先拿到那个白名单
        if request.path in white_list:
            return None                  #相当于通过校验
        if not request.user.is_authenticated:
            return redirect("/login/")

　　settings.py

MIDDLEWARE = [
    'django.middleware.security.SecurityMiddleware',
    'django.contrib.sessions.middleware.SessionMiddleware',
    'django.middleware.common.CommonMiddleware',
    'django.middleware.csrf.CsrfViewMiddleware',
    'django.contrib.auth.middleware.AuthenticationMiddleware',
    'django.contrib.messages.middleware.MessageMiddleware',
    'django.middleware.clickjacking.XFrameOptionsMiddleware',
    'app01.my_middlewares.AuthMiddleware', #把它加上去

]

LOGIN_URL = "/login/"  #跳转到哪里由我自己决定;

WHITE_LIST = ["/login/","/reg/","logout/"] #设置下白名单

八、中间件的执行流程

上一部分，我们了解了中间件中的5个方法，它们的参数、返回值以及什么时候执行，现在总结一下中间件的执行流程。

请求到达中间件之后，先按照正序执行每个注册中间件的process_reques方法，process_request方法返回的值是None，就依次执行，如果返回的值是HttpResponse对象，不再执行后面的process_request方法，而是执行当前对应中间件的process_response方法，将HttpResponse对象返回给浏览器。也就是说：如果MIDDLEWARE中注册了6个中间件，执行过程中，第3个中间件返回了一个HttpResponse对象，那么第4,5,6中间件的process_request和process_response方法都不执行，顺序执行3,2,1中间件的process_response方法。

process_request方法都执行完后，匹配路由，找到要执行的视图函数，先不执行视图函数，先执行中间件中的process_view方法，process_view方法返回None，继续按顺序执行，所有process_view方法执行完后执行视图函数。加入中间件3 的process_view方法返回了HttpResponse对象，则4,5,6的process_view以及视图函数都不执行，直接从最后一个中间件，也就是中间件6的process_response方法开始倒序执行。

process_template_response和process_exception两个方法的触发是有条件的，执行顺序也是倒序。总结所有的执行流程如下：

 

 

Django请求流程图