Django基础之中间件

1. 引入

在之前学习的过程中，已经学会了给视图函数加装饰器来判断用户是否登录，把没有登录的用户请求跳转到登录页面。

我们通过给几个特定视图函数加装饰器实现了这个需求。

但是以后添加的视图函数可能也需要加上装饰器，这样显得稍微有些繁琐。

但是，通过中间件就可以采用更适宜的方式来实现给所有类似请求都做相同相同操作的功能了。

2. 什么是中间件？

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

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

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

我们一直都在使用中间件，只是没有注意到而已，打开django项目的setting.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',
]

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

3. 自定义中间件

3.1 中间件方法

中间件可以定义五个方法，分别是（主要的是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对象，则直接将该对象返回给用户。

3.2 自定义一个中间件示例

from django.utils.deprecation import MiddlewareMixin

class MD1(MiddlewareMixin):
    def process_request(self, request):
        print("MD1里面的process_request")

    def process_response(self, request, response):
        print("MD1里面的process_response")
        return response

4. process_request

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

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

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

from django.utils.deprecation import MiddlewareMixin

class MD1(MiddlewareMixin):
    def process_request(self, request):
        print("这是MD1中的process_request方法 ")


class MD2(MiddlewareMixin):
    def process_request(self, request):
        print("这是MD2中的process_request方法")

在setting.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',
    "middleware.my_middlewares.MD1",    # 自定义中间件MD1
    "middleware.my_middlewares.MD2",    # 自定义中间件MD2
]

此时，我们访问一个视图，会发现终端中打印如下内容：

这是MD1中的process_request方法 
这是MD2中的process_request方法 
这是index页面 

把MD1和MD2的位置调换一下，把MD2放在MD1的上面，在访问一下视图，会发现终端中打印的内容如下：

这是MD2中的process_request方法 
这是MD1中的process_request方法 
这是index页面 

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

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

from django.utils.deprecation import MiddlewareMixin

class MD1(MiddlewareMixin):
    def process_request(self, request):
        request.a = 13
        print("这是MD1中的process_request方法 ")


class MD2(MiddlewareMixin):
    def process_request(self, request):
        print(request.a)
        print("这是MD2中的process_request方法")

执行结果为：

这是MD1中的process_request方法 
13 
这是MD2中的process_request方法 
这是index页面 

由此我们总结出：

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

5. process_response

process_response有两个参数，一个是request，一个response。

request就是上述例子中一样的对象，response是视图函数返回的HttpResponse对象。

该方法的放回值也必须是HttpResponse对象。

综上所述的M1和M2加上的process_response方法：

from django.utils.deprecation import MiddlewareMixin

class MD1(MiddlewareMixin):
    def process_request(self, request):
        print("这是MD1中的process_request方法 ")

    def process_response(self, request, response):
        print("MD1里面的process_response")
        return response

class MD2(MiddlewareMixin):
    def process_request(self, request):
        print("这是MD2中的process_request方法")

    def process_response(self, request, response):
        print("MD2里面的process_response")
        return response

访问index视图，可以看到终端中的输出内容为：

这是MD1中的process_request方法 
这是MD2中的process_request方法 
这是index页面 
MD2里面的process_response 
MD1里面的process_response 

由结果可知：

process_response方法是在函数之后执行的，并且顺序是MD2比MD1先执行。(此时，setting.py中MD1比MD2先注册)。

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

6. process_view

process_view(self, view_func, view_args,view_kwargs)

该方法有四个参数：

request是HttpRequest对象。

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

view_args是将传递给视图的位置参数的列表。

view_kwargs是将传递给视图的关键字参数的字典。

view_args和view_kwargs都不包含第一个视图参数(request)。

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

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

给MD1和MD2添加process_view方法：

from django.utils.deprecation import MiddlewareMixin

class MD1(MiddlewareMixin):
    def process_request(self, request):
        print("这是MD1中的process_request方法 ")

    def process_response(self, request, response):
        print("MD1里面的process_response")
        return response

    def process_view(self, request, view_func, view_args, view_kwargs):
        print("-"*50)
        print("MD1中的process_view")
        print(view_func, view_func.__name__)



class MD2(MiddlewareMixin):
    def process_request(self, request):
        print("这是MD2中的process_request方法")

    def process_response(self, request, response):
        print("MD2里面的process_response")
        return response

    def process_view(self, request, view_func, view_args, view_kwargs):
        print("-"*50)
        print("MD2中的process_view")
        print(view_func, view_func.__name__)

访问index视图，可以看到终端中的输出内容为：

这是MD1中的process_request方法 
这是MD2中的process_request方法 
-------------------------------------------------- 
MD1中的process_view 
<function index at 0x03E78738> index 
-------------------------------------------------- 
MD2中的process_view 

<function index at 0x03E78738> index 
这是index页面 
MD2里面的process_response 
MD1里面的process_response 

process_view方法就是在process_request之后，视图函数之前执行的，执行顺序按照MIDDLEWARE中的注册顺序从前到后顺序执行的。

7. process_exception

process_exception(self, request, exception)

该方法有两个参数：

一个HttpRequest对象。

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

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

给MD1和MD2添加process_exception方法：

from django.utils.deprecation import MiddlewareMixin

class MD1(MiddlewareMixin):
    def process_request(self, request):
        print("这是MD1中的process_request方法 ")

    def process_response(self, request, response):
        print("MD1里面的process_response")
        return response

    def process_view(self, request, view_func, view_args, view_kwargs):
        print("-"*50)
        print("MD1中的process_view")
        print(view_func, view_func.__name__)

    def process_exception(self, request, exception):
        print(exception)
        print("MD1中的process_exception")

class MD2(MiddlewareMixin):
    def process_request(self, request):
        print("这是MD2中的process_request方法")

    def process_response(self, request, response):
        print("MD2里面的process_response")
        return response

    def process_view(self, request, view_func, view_args, view_kwargs):
        print("-"*50)
        print("MD2中的process_view")
        print(view_func, view_func.__name__)

    def process_exception(self, request, exception):
        print(exception)
        print("MD2中的process_exception")

如果函数视图中无异常，process_exception方法不执行。

想办法，在视图函数中抛出一个异常：

def index(request):
    print("这是index视图")
    raise ValueError("error")
    return HttpResponse("index error")

在MD2的process_exception中返回一个响应对象：

class MD2(MiddlewareMixin):
    def process_request(self, request):
        print("这是MD2中的process_request方法")

    def process_response(self, request, response):
        print("MD2里面的process_response")
        return response

    def process_view(self, request, view_func, view_args, view_kwargs):
        print("-"*50)
        print("MD2中的process_view")
        print(view_func, view_func.__name__)

    def process_exception(self, request, exception):
        print(exception)
        print("MD2中的process_exception")
        return HttpResponse(str(exception))  # 返回一个响应对象

访问index视图，可以看到终端中的输出内容为：

这是MD1中的process_request方法 

这是MD2中的process_request方法 
--------------------------------------------------
MD1中的process_view 
<function index at 0x04748738> index 
--------------------------------------------------
MD2中的process_view 
<function index at 0x04748738> index 
这是index视图 
error 
MD2中的process_exception 
MD2里面的process_response 
MD1里面的process_response 

注意，这里并没有执行MD1的process_exception方法，因为MD2中的process_exception方法直接返回了一个响应对象。

process_exception的执行时间是在view函数之后，process_response之前，按照注册的倒序执行执行。

如果返回值是None，那么就不对错误进行处理，交给下一个中间件进行处理。

如果返回response对象，那么下一个中间的process_exception不执行，直接执行所有中间件的process_response方法。

8. process_template_response（使用的比较少）

process_template_response(self, request, response)

 它的参数，一个是HttpRequest对象，response是TemplateResponse对象（由视图函数或者中间件产生）。

process_template_response是在视图函数执行完成后立即执行，但是它有一个前提条件，那就是视图函数返回的对象有一个render()方法（或者表明该对象是一个TemplateResponse对象或等价方法）。

这是MD1中的process_request方法 

这是MD2中的process_request方法 
-------------------------------------------------
MD1中的process_view 
<function index at 0x04AC8738> index 
--------------------------------------------------
MD2中的process_view 
<function index at 0x04AC8738> index 
这是index视图 
MD2中的process_template_response 
MD1中的process_template_respnose 
in index/render 
MD2里面的process_response 
MD1里面的process_response 

 从结果看出：

视图函数执行完之后，立刻执行了中间件的process_template_response方法，顺序是倒序，先执行MD2的，再执行MD1的，接着执行了视图函数返回的HttpResponse对象的render方法，返回了一个新的HttpResponse对象，接着执行中间件的process_response方法。