django -- 中间件

Posted 2022-06-14 zouzou-busy

前戏

在前面我们给index和home页面通过加装饰器的方法来判断是不是登录过，如果没登录就返回登录页面。想想也没有什么问题，但是如果我们的视图函数有几百个呢？难道要给这几百个视图函数都加上装饰器吗？答案当然是否定的。我们可以通过中间件的方式来实现。

什么是中间件

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

用大白话说就是在视图函数执行之前和执行之后可以做一些额外的操作，本质上就是一个自定义类，类中定义了几个方法，Django会在处理请求的特定时间去执行这些方法。

注意：因为中间件影响的是全局，所以需要谨慎使用，使用不当会影响性能。

其实我们一直在使用中间件，来看下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‘,
]

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

自定义中间件

中间件可以定义五个方法，分别是

1. process_request(self,request)
2. process_view(self,request,view_func,view_args,view_kwargs)
3. process_template_response(self,request,response)
4. process_exception(self,request,exception)
5. process_response(self,request,response)

以上方法的返回值可以是一个None或一个HttpResponse对象，如果是None，则继续按照Django定义的规则向后继续执行，如果是HttpResponse对象，则直接将该对象返回给用户，就不执行视图里的函数了

process_request

process_request有一个参数，就是request，这个request和视图函数中的request是一样的，可以使用id(request)查看一下。

我们先来写一个中间件，在app下创建个py文件，里面写如下代码

from django.utils.deprecation import MiddlewareMixin


class Middle1(MiddlewareMixin):  # 需要继承这个类
    def process_request(self, request):
        print(id(request))
        print(‘这是中间件1中的process_request方法‘)

这就是我们自定义的中间件了，写好之后，需要在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‘,

    ‘appTest01.mymiddleware.Middle1‘,  # 自定义的中间件
]

然后我们去在视图函数里写个视图，如下

def test(request):
    print(id(request))
    print(‘我是test视图。。。‘)
    return HttpResponse(‘ok‘)

用浏览器去访问

结果：

74576400
这是中间件1中的process_request方法
74576400
我是test视图。。。

我们可以从上面的结果中得到一下信息

1.process_request的执行时间，在视图函数执行之前执行

2.process_request里的参数request和视图函数里的request是一样的

那如果有两个中间件，他们的执行顺序是什么呢？，在添加一个中间件，在注册的时候，放到上面

from django.utils.deprecation import MiddlewareMixin
from django.shortcuts import HttpResponse, render, redirect


class Middle1(MiddlewareMixin):  # 需要继承这个类
    def process_request(self, request):
        print(id(request))
        print(‘这是中间件1中的process_request方法‘)
        return HttpResponse(‘middle1‘)


class Middle2(MiddlewareMixin):
    def process_request(self, request):
        print(‘这是中间件2中的process_request方法‘)

然后我们再用浏览器请求test视图，会发现浏览器页面显示了middle1，控制台输出了

这是中间件2中的process_request方法
72082704
这是中间件1中的process_request方法

这是因为中间件的执行顺序是我们在setting.py注册时写的顺序，先执行middle2，在执行middle1，而中间件middle1里有返回一个response，所以Django就不往下执行了

总结：

1.process_request的执行时间，在视图函数执行之前执行

2.process_request里的参数request和视图函数里的request是一样的

3.process_request的执行顺序是按照settings.py里的注册顺序执行的

4.如果中间件的返回值为None，则按照正常的流程走，如果中间件有返回response对象，当前中间件后面的中间件的process_request和process_response方法、视图函数都不执行，执行当前中间的process_response方法以及之前的中间的process_response方法

process_response

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

from django.utils.deprecation import MiddlewareMixin
from django.shortcuts import HttpResponse, render, redirect


class Middle1(MiddlewareMixin):  # 需要继承这个类
    def process_request(self, request):
        print(‘这是中间件1中的process_request方法‘)

    def process_response(self, request, response):
        print(‘这是中间件1中的process_response方法‘)
        return response


class Middle2(MiddlewareMixin):
    def process_request(self, request):
        print(‘这是中间件2中的process_request方法‘)

    def process_response(self, request, response):
        print(‘这是中间件2中的process_response方法‘)
        return response

结果：

这是中间件2中的process_request方法
这是中间件1中的process_request方法
我是test视图。。。
这是中间件1中的process_response方法
这是中间件2中的process_response方法

因为我们中间件的注册是middle2在上面，所以请求来了之后先执行middle2的process_request方法，然后执行middle1的process_request方法，在执行视图函数，视图函数执行完之后在从注册的中间件里从下往上执行，因为middle1在最下面，所以先执行middle1的process_response方法。

我们在middle1里的process_request里加个return，在来看看效果

class Middle1(MiddlewareMixin):
    def process_request(self, request):
        print(‘这是中间件1中的process_request方法‘)
        return HttpResponse(‘middle1‘)  # 增加这句

    def process_response(self, request, response):
        print(‘这是中间件1中的process_response方法‘)
        return response

结果：页面返回了middle1

这是中间件2中的process_request方法
这是中间件1中的process_request方法
这是中间件1中的process_response方法
这是中间件2中的process_response方法

这是因为请求执行middle2中的process_request方法，然后执行middle1里的process_request方法，因为middle1的process_request方法里有return，所以就不执行视图函数，接着按照注册中间件的逆序执行process_response方法

 

那我们把这句放到middle2里的process_request里，在来看看

class Middle2(MiddlewareMixin):
    def process_request(self, request):
        print(‘这是中间件2中的process_request方法‘)
        return HttpResponse(‘middle2‘)  # 增加这句

    def process_response(self, request, response):
        print(‘这是中间件2中的process_response方法‘)
        return response

结果：

这是中间件2中的process_request方法
这是中间件2中的process_response方法

代码解释：请求来了之后，先执行middle2里的process_request方法，因为这里有return，所以就直接执行这里的process_response方法，然后再执行这个中间件上面的process_response方法

总结：

1.process_response在视图函数执行之后执行

2.process_response的参数，request，视图函数中用到的request，response，视图函数中返回的response

3.返回值必须是response对象，不能为None

4.process_response的执行执行顺序是按照注册顺序倒序执行

process_view

process_view有四个参数

request是HttpRequest对象，和之前的是一样的

view_func是Django即将使用的视图函数

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

view_kwargs是传递给视图函数的关键字参数

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

from django.utils.deprecation import MiddlewareMixin
from django.shortcuts import HttpResponse, render, redirect


class Middle1(MiddlewareMixin):  # 需要继承这个类
    def process_request(self, request):
        print(‘这是中间件1中的process_request方法‘)

    def process_response(self, request, response):
        print(‘这是中间件1中的process_response方法‘)
        return response

    def process_view(self, request, view_func, view_args, view_kwargs):
        print(‘这是中间件1中的process_view方法‘)


class Middle2(MiddlewareMixin):
    def process_request(self, request):
        print(‘这是中间件2中的process_request方法‘)

    def process_response(self, request, response):
        print(‘这是中间件2中的process_response方法‘)
        return response

    def process_view(self, request, view_func, view_args, view_kwargs):
        print(‘这是中间件2中的process_view方法‘)

结果：

这是中间件2中的process_request方法
这是中间件1中的process_request方法
这是中间件2中的process_view方法
这是中间件1中的process_view方法
我是test视图。。。
这是中间件1中的process_response方法
这是中间件2中的process_response方法

process_view是在process_request方法执行之后，视图函数执行之前执行的，是按照中间件注册顺序从上往下执行的

在process_view加个return来看看

from django.utils.deprecation import MiddlewareMixin
from django.shortcuts import HttpResponse, render, redirect


class Middle1(MiddlewareMixin):
    def process_request(self, request):
        print(‘这是中间件1中的process_request方法‘)

    def process_response(self, request, response):
        print(‘这是中间件1中的process_response方法‘)
        return response

    def process_view(self, request, view_func, view_args, view_kwargs):
        print(‘这是中间件1中的process_view方法‘)



class Middle2(MiddlewareMixin):
    def process_request(self, request):
        print(‘这是中间件2中的process_request方法‘)

    def process_response(self, request, response):
        print(‘这是中间件2中的process_response方法‘)
        return response

    def process_view(self, request, view_func, view_args, view_kwargs):
        print(‘这是中间件2中的process_view方法‘)
        return HttpResponse(‘view2‘)  # 增加这句

结果：

这是中间件2中的process_request方法
这是中间件1中的process_request方法
这是中间件2中的process_view方法
这是中间件1中的process_response方法
这是中间件2中的process_response方法

代码解释：

先按照中间件的注册顺序，从上往下执行process_request方法（没有return，有return，直接执行该中间件对应的process_response方法）。然后从上往下执行process_view方法，如果某一个process_view方法里有return，则不执行后面的process_view方法，直接从下往上执行process_response方法

 总结：

1.process_view的执行时间，是在process_request之后，以及路由匹配之后，在视图函数之前执行

2.参数：request和之前的一样，view_func要执行的视图函数，view_args视图函数的位置参数，view_kwargs视图函数的关键字参数

3.返回值：None正常走，HttpResponse对象，后面的process_view不执行，直接执行process_response方法（从下往上）

4.执行顺序按照中间件的注册顺序从上往下执行

process_exception

process_exception有两个参数，一个上HttpRequest对象，一个exception上视图函数异常产生的Exception对象

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

from django.utils.deprecation import MiddlewareMixin
from django.shortcuts import HttpResponse, render, redirect


class Middle1(MiddlewareMixin):
    def process_request(self, request):
        print(‘这是中间件1中的process_request方法‘)

    def process_response(self, request, response):
        print(‘这是中间件1中的process_response方法‘)
        return response

    def process_view(self, request, view_func, view_args, view_kwargs):
        print(‘这是中间件1中的process_view方法‘)


    def process_exception(self,request, exception):
        print(‘这是中间件1中的process_exception方法‘)



class Middle2(MiddlewareMixin):
    def process_request(self, request):
        print(‘这是中间件2中的process_request方法‘)

    def process_response(self, request, response):
        print(‘这是中间件2中的process_response方法‘)
        return response

    def process_view(self, request, view_func, view_args, view_kwargs):
        print(‘这是中间件2中的process_view方法‘)


    def process_exception(self,request, exception):
        print(‘这是中间件2中的process_exception方法‘)

视图函数如果正常的话

这是中间件2中的process_request方法
这是中间件1中的process_request方法
这是中间件2中的process_view方法
这是中间件1中的process_view方法
我是test视图。。。
这是中间件1中的process_response方法
这是中间件2中的process_response方法

往视图函数里写点异常在看看结果

def test(request):
    print(‘我是test视图。。。‘)
    int(‘weewe‘)
    return HttpResponse(‘ok‘)

结果：

这是中间件2中的process_request方法
这是中间件1中的process_request方法
这是中间件2中的process_view方法
这是中间件1中的process_view方法
我是test视图。。。
这是中间件1中的process_exception方法
这是中间件2中的process_exception方法
Internal Server Error: /test/
Traceback (most recent call last):
  File "C:\\Users\\Administrator\\AppData\\Local\\Programs\\Python\\Python36-32\\lib\\site-packages\\django\\core\\handlers\\exception.py", line 41, in inner
    response = get_response(request)
  File "C:\\Users\\Administrator\\AppData\\Local\\Programs\\Python\\Python36-32\\lib\\site-packages\\django\\core\\handlers\\base.py", line 187, in _get_response
    response = self.process_exception_by_middleware(e, request)
  File "C:\\Users\\Administrator\\AppData\\Local\\Programs\\Python\\Python36-32\\lib\\site-packages\\django\\core\\handlers\\base.py", line 185, in _get_response
    response = wrapped_callback(request, *callback_args, **callback_kwargs)
  File "E:\\django-project\\orm_project\\appTest01\\views.py", line 55, in test
    int(‘weewe‘)
ValueError: invalid literal for int() with base 10: ‘weewe‘
这是中间件1中的process_response方法
这是中间件2中的process_response方法
[26/Jul/2019 23:12:45] "GET /test/ HTTP/1.1" 500 69084

执行视图函数，遇到异常之后执行process_exception方法，按注册的顺序从下往上执行，执行完之后在执行process_response（从上往下）

 

那如果有return了呢，因为是从下往上执行的，我们给middle1加上return

结果：

这是中间件2中的process_request方法
这是中间件1中的process_request方法
这是中间件2中的process_view方法
这是中间件1中的process_view方法
我是test视图。。。
这是中间件1中的process_exception方法
这是中间件1中的process_response方法
这是中间件2中的process_response方法

当遇到process_exception里的return时，注册顺序之前的中间件的process_exception方法不走了。执行所有中间件的process_response方法

总结：

1.process_exception的执行条件是有异常时才会执行，在视图函数之后，在process_response之前

2.参数exception错误对象信息

3.返回值：None，正常走。HttpResponse对象，注册顺序之前的中间件的process_exception方法不走了。执行所有中间件的process_response方法，把process_exception里的返回值显示在浏览器上

4.执行顺序：按照注册顺序倒序执行

process_template_response

process_template_response(self, request, response)

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

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

from django.utils.deprecation import MiddlewareMixin
from django.shortcuts import HttpResponse, render, redirect


class Middle1(MiddlewareMixin):
    def process_request(self, request):
        print(‘这是中间件1中的process_request方法‘)

    def process_response(self, request, response):
        print(‘这是中间件1中的process_response方法‘)
        return response

    def process_view(self, request, view_func, view_args, view_kwargs):
        print(‘这是中间件1中的process_view方法‘)


    def process_exception(self,request, exception):
        print(‘这是中间件1中的process_exception方法‘)


    def process_template_response(self, request, response):
        print("这是中间件1中的process_template_response方法")
        return response




class Middle2(MiddlewareMixin):
    def process_request(self, request):
        print(‘这是中间件2中的process_request方法‘)

    def process_response(self, request, response):
        print(‘这是中间件2中的process_response方法‘)
        return response

    def process_view(self, request, view_func, view_args, view_kwargs):
        print(‘这是中间件2中的process_view方法‘)


    def process_exception(self,request, exception):
        print(‘这是中间件2中的process_exception方法‘)
        return HttpResponse(str(exception))

    def process_template_response(self, request, response):
        print("这是中间件2中的process_template_response方法")
        return response

视图函数

def test(request):
    print(‘我是test视图。。。‘)
    def render():
        print("我是render")
        return HttpResponse("render。。。")
    res = HttpResponse("OK")
    res.render = render
    return res

结果：

这是中间件2中的process_request方法
这是中间件1中的process_request方法
这是中间件2中的process_view方法
这是中间件1中的process_view方法
我是test视图。。。
这是中间件1中的process_template_response方法
这是中间件2中的process_template_response方法
我是render
这是中间件1中的process_response方法
这是中间件2中的process_response方法

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

 中间件的执行流程

我们了解了中间件的五个方法，以及什么时候执行，参数，返回值

请求在到达中间件之后，先按照正序执行每个中间件中的process_request方法，如果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方法执行完 后执行视图函数。假如中间件中的第三个process_view方法返回了一个httpResponse对象，则4，5，6的processs_view以及视图函数都不执行，直接从最后一个中间件，也就是中间件6的process_response方法开始倒序执行

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

Django请求流程图