Django——中间件

1.概念

中间件是介于视图函数接收用户请求和返回数据之间的一道工序，所以说中间件可以搞很多小动作，可以说“欺上瞒下”，所以需要谨慎实用，用不好会影响到性能。

了解中间件是是什么以后，你就可以修改请求，例如被传送到view中的HttpRequest对象。 或者修改view返回的HttpResponse对象，这些都可以通过中间件来实现。

其实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',
]

这些中间件的功能后续可以慢慢了解。

 2.自定义中间件

虽然Django自带了一些中间件，但有时为了实现一些额外的功能（文末有示例），需要我们自己写中间件，下面简单看下中间件的工作原理，以及如何写一个简单的中间件。

中间件其实就是一个python类，一般需要定义以下四种方法：

process_request
process_view
process_exception
process_response

2.1

 先来看下process_request和process_response方法，它们一个控制“进来”，一个控制“出去”，如下图：

 当用户发起请求的时候会依次经过所有的的中间件，这个时候的请求时process_request,最后到达views的函数中，views函数处理后，在依次穿过中间件，这个时候是process_response,最后返回给请求者。

 好，那我们就先试着写一个简单的中间件，在“进来”和“出去”的时候搞些小动作。

首先在app的同级目录下新建一个名为“my_mid.py”的文件，这就是我们自己的中间件了！

在文件开头写上下面一句：

from django.utils.deprecation import MiddlewareMixin
# 因为我们要自定义的中间件必须继承MiddlewareMixin (按规矩办事)

 然后把下面的代码敲进去（我们要先看效果，再回来分析）

# my_mid.py

from django.utils.deprecation import MiddlewareMixin


class Md1(MiddlewareMixin):

    def process_request(self,request):     # 进来时的方法
        print("Md1请求进来")

    def process_response(self,request,response):    # 出去时的方法
        print("Md1返回出去")
        return response       # 出去的方法需要return


class Md2(MiddlewareMixin):

    def process_request(self,request):
        print("Md2请求进来")

    def process_response(self,request,response):
        print("Md2返回出去")
        return response

 定义好之后一定要到settings.py文件中注册自己的中间件

然后简单定义一个路由和视图

# views.py

def index(request):
    print("view已阅")
    return HttpResponse("Okk")


# urls.py

path("index/",views.index)

 运行结果：

Md1请求进来
Md2请求进来
view已阅
Md1返回出去
Md2返回出去

                      

 所以中间件的执行大致就像上面的流程图的样子，需要注意的是：

1. process_request方法不需要return，django会帮我们传递下去，如果加了return，那么请求就无法到达视图函数，也就是你把人家拒之门外了！
2. process_response方法需要return，传递给下一个中间件，如果不加就会导致返回中断报错！

2.2

在前面的基础上，我们再把process_view加上：

做之前，我们先简单了解一下它：

process_view(self, request, callback, callback_args, callback_kwargs)
"""
把这堆参数解释下：
request：用户请求
callback：要执行的视图函数名（这里就是index，等下我们输出看下）
callback_args：视图函数的位置参数
callback_kwargs：视图函数的关键字参数
"""

另外process_view方法可以有返回值，也可以无返回值(返回None)，我们分别测试。

下面修改我们的中间件：

# my_mid.py

from django.utils.deprecation import MiddlewareMixin


class Md1(MiddlewareMixin):

    def process_request(self,request):     # 进来时的方法
        print("Md1请求进来")

    def process_response(self,request,response):    # 出去时的方法
        print("Md1返回出去")
        return response       # 出去的方法需要return

    def process_view(self,request，callback,callback_args,callback_kwargs):
        print('这是Md1的process_view函数')
        print(callback, type(callback))      # 打印callback看下


class Md2(MiddlewareMixin):

    def process_request(self,request):
        print("Md2请求进来")

    def process_response(self,request,response):
        print("Md2返回出去")
        return response

    def process_view(self,request,callback,callback_args,callback_kwargs):
        print('这是Md2的process_view函数')

访问http://127.0.0.1:8000/index/

        

运行结果：

         

看结果callback确实是index。

然后再给process_view加上返回值，看下

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


class Md1(MiddlewareMixin):

    def process_request(self,request):     # 进来时的方法
        print("Md1请求进来")

    def process_response(self,request,response):    # 出去时的方法
        print("Md1返回出去")
        return response       # 出去的方法需要return

    def process_view(self,request,callback,*callback_args,**callback_kwargs):
        print('这是Md1的process_view函数')
        print(callback, type(callback))
        return HttpResponse('这是Md1返回的HttpRsponse')

class Md2(MiddlewareMixin):

    def process_request(self,request):
        print("Md2请求进来")

    def process_response(self,request,response):
        print("Md2返回出去")
        return response

    def process_view(self,request,callback,*callback_args,**callback_kwargs):
        print('这是Md2的process_view函数')
        return HttpResponse('这是Md2返回的HttpRsponse')

再次访问http://127.0.0.1:8000/index/

运行结果：

当然process_view也可以用来调用视图函数

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


class Md1(MiddlewareMixin):

    def process_request(self,request):     # 进来时的方法
        print("Md1请求进来")

    def process_response(self,request,response):    # 出去时的方法
        print("Md1返回出去")
        return response       # 出去的方法需要return

    def process_view(self,request,callback,callback_args,callback_kwargs):
        print('这是Md1的process_view函数')
        response = callback(request, *callback_args,**callback_kwargs)
        return response

class Md2(MiddlewareMixin):

    def process_request(self,request):
        print("Md2请求进来")

    def process_response(self,request,response):
        print("Md2返回出去")
        return response

    def process_view(self,request,callback,callback_args,callback_kwargs):
        print('这是Md2的process_view函数')
        return HttpResponse('这是Md2返回的HttpRsponse')

执行流程：

首先执行 process_request 函数，然后在执行视图函数之前执行 process_view 函数，然后执行视图函数，最后执行 process_response 函数

 

 

     

process_request 只返回 None，都执行完之后，就匹配路由，找到要执行的视图函数，在执行视图函数之前先执行中间件的 process_view 函数

如果 process_view 返回 None，就继续执行后续的中间件的 process_view 方法，执行完所有的 process_view 函数之后就执行视图函数

如果其中有个 process_view 返回了 HttpResponse，就不执行后续的 process_view 函数，会跳到第一个 process_response 函数，并继续往下执行

2.3

接着看process_exception方法

process_exception(self, request, exception) 函数有两个参数，exception 是视图函数异常产生的 Exception 对象

process_exception 函数的执行顺序是按照 settings.py 中设置的中间件的顺序的倒序执行

process_exception 函数只在视图函数中出现异常的时候才执行，它返回的值可以是 None，也可以是一个 HttpResponse 对象

如果返回 None，则继续由下一个中间件的 process_exception 方法来处理异常

如果返回 HttpResponse，将调用中间件中的 process_response 方法

修改中间件：

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


class Md1(MiddlewareMixin):

    def process_request(self,request):     # 进来时的方法
        print("Md1请求进来")

    def process_response(self,request,response):    # 出去时的方法
        print("Md1返回出去")
        return response       # 出去的方法需要return

    def process_view(self,request,callback,callback_args,callback_kwargs):
        print('这是Md1的process_view函数')
        # response = callback(request, *callback_args,**callback_kwargs)
        # return response

    def process_exception(self, request, exception):
        print('这是Md1的process_exception')

class Md2(MiddlewareMixin):

    def process_request(self,request):
        print("Md2请求进来")

    def process_response(self,request,response):
        print("Md2返回出去")
        return response

    def process_view(self,request,callback,callback_args,callback_kwargs):
        print('这是Md2的process_view函数')
        # return HttpResponse('这是Md2返回的HttpRsponse')

    def process_exception(self, request, exception):
        print('这是Md2的process_exception')

注意，这样直接运行不会触发process_exception方法，这里我们修改下views.py

def index(request):
    print('已阅')
    raise ValueError('添加一个错误')       # 让视图函数抛出一个错误
    return HttpResponse('okk')

再次访问http://127.0.0.1:8000/index/

运行结果：

process_exception的应用

在视图函数执行出错时，返回错误信息。这样页面就不会 报错了！

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


class Md1(MiddlewareMixin):

    def process_request(self,request):     # 进来时的方法
        print("Md1请求进来")

    def process_response(self,request,response):    # 出去时的方法
        print("Md1返回出去")
        return response       # 出去的方法需要return

    def process_view(self,request,callback,callback_args,callback_kwargs):
        print('这是Md1的process_view函数')
        # response = callback(request, *callback_args,**callback_kwargs)
        # return response

    def process_exception(self, request, exception):
        print('这是Md1的process_exception')

class Md2(MiddlewareMixin):

    def process_request(self,request):
        print("Md2请求进来")

    def process_response(self,request,response):
        print("Md2返回出去")
        return response

    def process_view(self,request,callback,callback_args,callback_kwargs):
        print('这是Md2的process_view函数')
        # return HttpResponse('这是Md2返回的HttpRsponse')

    def process_exception(self, request, exception):
        print('这是Md2的process_exception')
        return HttpResponse('出错了兄弟！！！')     # 加上这句

 3.中间件应用

由于中间件工作在 视图函数执行前、执行后（就像所有视图函数的装饰器！）适合所有的请求/一部分请求做批量处理

1、做IP限制

放在 中间件类的列表中，阻止某些IP访问了；

2、URL访问过滤

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

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

3、缓存

客户端请求来了，中间件去缓存看看有没有数据，有直接返回给用户，没有再去逻辑层 执行视图函数

最后留个坑！