django的中间件:process_request|process_response|process_view|process_exception

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个自定义的中间件
    'middle.md.middle_first',
    'middle.md.middle_second'
]

　　

#Auther Bob
#--*--conding:utf-8 --*--

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

# 中间件就是一个类，下面我们自定义了2个中间件，中间件又叫做管道

class middle_first(MiddlewareMixin):
    def process_request(self,request):
        print("middle_first--process_request",time.time())
        return HttpResponse("大爷慢走")
    def process_response(self,request,response):
        print("middle_first--process_response", time.time())
        print(response, type(response))
        return response

class middle_second(MiddlewareMixin):
    def process_request(self,request):
        print("middle_second--process_request",time.time())

    def process_response(self,request,response):
        print("middle_second--process_response", time.time())
        print(response,type(response))
        return response

　　

中间件函数的参数是固定的

先看process_request方法，参数有一个request

  def process_request(self,request):
        path = request.path_info
        # l = path.split("/")
        # if l[2] in black_list:
        #     return HttpResponse("不能访问")
        re_compile_obj = re.compile("/")

        l = re_compile_obj.split(path)
        for i in l:
            if i in black_list:
                return HttpResponse("不能访问")

　　

在看process_response方法，参数必须要要有个response，这个参数必须要有，而且这个process_response的函数必须要有返回值，如果没有，django会把报错的，最后一个中间件的process_response把返回值返回给倒数第一个中间件的process_response函数，然后在返回倒数第三个中间件的process_response函数，这个参数默认就是视图函数的返回，我们也可以自定义返回值，下面的例子就是我们自定义返回值，process_response是按照注册顺序的倒序执行

    def process_response(self,request,response):
        print("--------->","这个是response的中间件")

        return HttpResponse("中间件直接返回的")

　

结果如下

我们还使用默认的response的返回值，也就是用视图函数的返回值

    def process_response(self,request,response):
        print("--------->","这个是response的中间件")

        # return HttpResponse("中间件直接返回的")
        return response

　　

结果如下

process_view函数，多个中间件的process_view函数是按照注册的正序执行，在执行视图函数之前执行，如果有返回值，则不会执行视图函数的方法，执行返回执行process_response函数，如果没有返回值，则会执行完process_view后在执行视图函数

    def process_view(self,request,view_func,view_args,view_kwargs):
        """

        :param request: 请求对象
        :param view_func: 将要执行的视图函数
        :param view_args:将要执行的函数的位置参数
        :param view_kwargs:将要执行的函数的关键字参数
        :return:
        """

        print("process_view-------->")
        return HttpResponse("process_view返回值")

　　

上面的例子的process_view函数有返回值，我们看下结果，可以看到返回的process_view函数的返回值，没有去执行视图函数

下面这个例子，process_view函数中没有返回值

    def process_view(self,request,view_func,view_args,view_kwargs):
        """

        :param request: 请求对象
        :param view_func: 将要执行的视图函数
        :param view_args:将要执行的函数的位置参数
        :param view_kwargs:将要执行的函数的关键字参数
        :return:
        """

        print("process_view-------->")
        # return HttpResponse("process_view返回值")

　　

结果如下，我们看到返回的是视图的返回值

在看下process_exception的中间件的函数

    def process_exception(self,request,exception):
        """

        :param request: 这个是请求对象
        :param exception: 这个是视图函数返回的错误
        :return:
        """
        print(exception)
        print("这个是中间件exception函数")

        return redirect("https://www.baidu.com")

　　

他的执行顺序是按照在中间件注册的倒序执行的，如果视图函出错，才会执行，下面我们模拟视图函数出错，用raise方法主动抛出错误

def test_forms(request):
    print(request.path_info)
    # for i in range(10):
    #     models.City.objects.create(
    #         name = "北京" + str(i)
    #     )
    print(models.City.objects.all().values("name"))

    if request.method.lower() == "post":
        myform = Myform(request.POST)
        # 把post方式传递过来的数据传递个myform对象

        if myform.is_valid():
            # 对前端发过来的数据做校验，如果合法的话
            name = myform.cleaned_data.get("name")
            pwd = myform.cleaned_data.get("pwd")
            rep_pwd = myform.cleaned_data.get("rep_pwd")
            print(myform.cleaned_data)

        else:
            pass
    else:
        myform = Myform()
    raise ValueError("视图函数执行失败了")

    return render(request,"form1.html",{"myform":myform})

　　

看下打印的信息

视图函数执行失败了
这个是中间件exception函数
---------> 这个是response的中间件

先看下中间件在django整个流程处于哪个阶段

中间件的执行顺序是这样的

按照settings里面MIDDLEWARE的列表中的顺序来执行，先执行第一个中间件的process_request方法，然后执行第二个中间件的process_request方法，直到最后一个中间件的process_request方法，执行完成之后，就到views中的视图函数，然后返回的时候在从最后一个中间件的process_response方法，然后执行倒数第二个process_response方法，一直都第一个中间件的process_response方法

这里我们需要注意，中间件的函数中的request参数，和视图函数中的request参数是一样的，response参数，就是视图函数中return返回的值

我们先看下执行顺序

首先我们在middleware中定义的中间件的顺序是这样的

    # 定义了2个自定义的中间件
    'middle.md.test',
    'middle.md.middle_first',
    'middle.md.middle_second'

　　

我们在看先我们的中间件函数

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

# 中间件就是一个类，下面我们自定义了2个中间件，中间件又叫做管道

class test(MiddlewareMixin):
    def process_request(self,request):
        print("test--process_request", time.time())

    def process_response(self,request,response):
        print("test--process_response", time.time())
        return response

class middle_first(MiddlewareMixin):
    def process_request(self,request):
        print("middle_first--process_request",time.time())
        # return HttpResponse("大爷慢走")
    def process_response(self,request,response):
        print("middle_first--process_response", time.time())
        # print(response, type(response))
        return response

class middle_second(MiddlewareMixin):
    def process_request(self,request):
        print("middle_second--process_request",time.time())

    def process_response(self,request,response):
        print("middle_second--process_response", time.time())
        # print(response,type(response))
        return response

　　

这里我们要注意，在我们定义的3个中间件的类中，process_request方法中都没有return，我们从客户端发起请求，看下中间件函数的执行顺序，和我们上面分析的是一样的

下面我们在在middle_first类中的process_request方法中定义一个return，在看下执行顺序

我们再次通过客户端去访问

我们在看下执行顺序

先执行test的process_request方法，然后执行middle_first的process_request方法，因为这里的方法中我们有定义return，所以就不会在往下执行，直接走middle_first的process_response方法，然后执行test的process_response方法

现在我们对中间件的执行顺序应该已经比较清楚了吧

下面我们通过源代码来分析一下中间件

首先我们先看下类中定义的__call__方法，这个方法什么时候会执行呢？

前面我忘记了，后来测试了一下，现在知道了，我们在回忆一下

class test_call(object):
    def __init__(self,call):
        self.call = call

    def __call__(self, *args, **kwargs):
        print("现在是执行{call}".format(call = self.call))

if __name__ == '__main__':
    t = test_call("cui")

    t()

　　

执行结果

所以__call__方法是在执行类的对象的时候会调用__call__方法

我们看到我们定义的中间件的类都继承了MiddlewareMixin这个类，我们来看下这个类是怎么写的

class MiddlewareMixin(object):
    def __init__(self, get_response=None):
        self.get_response = get_response
        super(MiddlewareMixin, self).__init__()

    def __call__(self, request):
        response = None
        if hasattr(self, 'process_request'):
            response = self.process_request(request)
        if not response:
            response = self.get_response(request)
        if hasattr(self, 'process_response'):
            response = self.process_response(request, response)
        return response

　　

我们重点看下看这里

首先定义response为空，因为中间件的执行顺序是先执行process_request方法，我们这里通过反射的hasattr方法，先来判断是否有定义process_request方法，如果有定义，则执行，执行process_request方法，如果这个方法有返回值，那么就不会执行第二个if中的代码，第二个if中的代码我们后面在说他的意思，如果，有process_request方法，且有返回值，则会执行第三个if中的方法，就会执行这个中间的process_response方法，这样就和我们上面的例子对应上了；

下面我们来说一下第二个if中的代码的作用，他的作用就是执行下一个中间件函数的__call__方法，如果没有下一个中间件，则会执行视图函数中对应的方法

我们推荐大家这样写，自己实现写middlewareMixin类，然后我们自己的中间件类继承我们自己写的middlewareMixin类就可以了

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

class my_MiddlewareMixin(object):
    def __init__(self, get_response=None):
        self.get_response = get_response
        super(my_MiddlewareMixin, self).__init__()

    def __call__(self, request):
        response = None
        if hasattr(self, 'process_request'):
            response = self.process_request(request)
        if not response:
            response = self.get_response(request)
        if hasattr(self, 'process_response'):
            response = self.process_response(request, response)
        return response

# 中间件就是一个类，下面我们自定义了2个中间件，中间件又叫做管道

class test(my_MiddlewareMixin):
    def process_request(self,request):
        print("test--process_request", time.time())

    def process_response(self,request,response):
        print("test--process_response", time.time())
        return response

class middle_first(my_MiddlewareMixin):
    def process_request(self,request):
        print("middle_first--process_request",time.time())
        return HttpResponse("大爷慢走")
    def process_response(self,request,response):
        print("middle_first--process_response", time.time())
        # print(response, type(response))
        return response

class middle_second(my_MiddlewareMixin):
    def process_request(self,request):
        print("middle_second--process_request",time.time())

    def process_response(self,request,response):
        print("middle_second--process_response", time.time())
        # print(response,type(response))
        return response

　　

class test(my_MiddlewareMixin):
    def process_request(self,request):
        print("test--process_request", time.time())

    def process_view(self,request,view_func,view_args,view_kwargs):
        print(view_func, view_args, view_kwargs, sep="-------->")
        print("test--process_view", time.time())

    def process_response(self,request,response):
        print("test--process_response", time.time())
        return response

    def process_exception(self,request,exception):
        """

        :param request:
        :param exception: 只能捕获视图函数中的异常捕获，对中间件中的其他函数的错误是捕获不到的,这里的excetion就是错误的信息
        :return:
        """
        print("test--process_exception", time.time())

　　

如果视图函数中不出错的话，process_exception是永远都不会执行的,比如下面一个正常的访问流程，我们访问的test函数没有出错，按照顺序执行，先执行第一个中间件的process_request方法，然后是第二个中间件的process_request方法，然后是第三个中间件的process_request方法，然后执行第一个中间件的process_view方法，然后是第二个中间件的process_view方法，然后是第三个中间件的process_view方法，然后执行视图函数，在返回的时候，先执行最后一个中间件的process_response方法，然后是倒数第二个process_view方法，然后是倒数第三个中间件的processs_response方法

下面我们看下如何视图函数中有错误的话，会如何执行

我们首先在视图函数中构建了一个错误

def test(request):
    int("hahah")
    print("test------->views",time.time())
    return HttpResponse("last_app1")

　　

再次通过客户端去访问，我们在第二个中间件的process_exception方法中做了return返回

执行顺序是下面这样的

先执行第一个中间件的process_request方法，然后是第二个中间件的process_request方法，最后是第三个中间件的process_request方法，然后执行第一个中间件的process_view方法，然后是第二个中间件的process_view方法，最后是执行第三个中间件的process_view方法，这里很关键，因为我们执行视图函数报错，因为我们人为构建了一个错误，开始执行最后一个中间件的process_exception方法，执行完成后，执行倒数第二个中间件的process_exception方法，执行到这里，这个函数有个return返回值，那么就不会在去执行第一个中间件的process_exception的方法了，这个时候就开始执行最后一个中间件的process_response方法，然后是倒数第二个中间件的process_exception方法，最后是倒数第三个中间件的process_response方法

补一个中间件的小例子，就是黑名单的意思，如果访问的是某个url则直接给返回

下面看下代码

from django.middleware.security import SecurityMiddleware
from django.utils.deprecation import MiddlewareMixin
import re
from django.shortcuts import HttpResponse
from django.shortcuts import render
from django.shortcuts import redirect

black_list = ["publish","add_publish"]

class My_first_mid(MiddlewareMixin):
    def process_request(self,request):
        path = request.path_info
        # l = path.split("/")
        # if l[2] in black_list:
        #     return HttpResponse("不能访问")
        re_compile_obj = re.compile("/")

        l = re_compile_obj.split(path)
        for i in l:
            if i in black_list:
                return HttpResponse("不能访问")

　　

前端访问的效果

首先是可以访问

然后是不能访问

经过上面的学习，我们做下总结

中间件的定义：
wsgi之后 urls.py之前 在全局 操作Django请求和响应的模块！

中间件的使用：
5个固定的方法
process_request(self, request)
执行顺序：
按照注册的顺序（在settings.py里面设置中 从上到下的顺序）
何时执行：
请求从wsgi拿到之后
返回值：
返回None，继续执行后续的中间件的process_request方法
返回response , 不执行后续的中间件的process_request方法

process_response
执行顺序：
按照注册顺序的倒序（在settings.py里面设置中 从下到上的顺序）
何时执行：
请求有响应的时候
返回值：
必须返回一个response对象

process_view(self, request, view_func, view_args, view_kwargs):
执行顺序：
按照注册的顺序（在settings.py里面设置中 从上到下的顺序）
何时执行：
在urls.py中找到对应关系之后 在执行真正的视图函数之前
返回值：
返回None，继续执行后续的中间件的process_view方法
返回response,

process_exception(self, request, exception)
执行顺序：
按照注册顺序的倒序（在settings.py里面设置中 从下到上的顺序）
何时执行：
视图函数中抛出异常的时候才执行
返回值：
返回None,继续执行后续中间件的process_exception
返回response，

process_template_response(self, request, response)
执行顺序：
按照注册顺序的倒序（在settings.py里面设置中 从下到上的顺序）
何时执行：
视图函数执行完，在执行视图函数返回的响应对象的render方法之前
返回值：
返回None,继续执行后续中间件的process_exception
返回response，

Django调用 注册的中间件里面五个方法的顺序：
1. process_request
urls.py
2. process_view
view
3. 有异常就执行 process_exception
4. 如果视图函数返回的响应对象有render方法,就执行process_template_response
5. process_response