Fork me on GitHub

Django:中间件

1.MIDDLEWARE中间件

  • 中间件介于request与response处理之间的一道处理过程，中间件是一个轻量，低级别的插件系统，用于在全局范围内改变django的数据和输出，实际作用就是试图函数执行之前与之后做一些额外操作。

  • 中间件定义：

    如果你想修改请求，例如被传送到view中的HttpRequest对象。 或者你想修改view返回的HttpResponse对象，这些都可以通过中间件来实现。
	说的直白一点中间件是帮助我们在视图函数执行之前和执行之后都可以做一些额外的操作，它本质上就是一个自定义类，类中定义了几个方法，Django框架会在请求的特定的时间去执行这些方法。

2自定义中间件

  • 中间件可以定义五个方法：
    • 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)
这五种方法常用的process_request，process_view，process_response
这五种方法返回值返回值可以是None或一个HttpResponse对象，如果是None,则继续按照django定义的规则继续执行，如果是HttpResponse对象，则直接将该对象返回用户
  • 用户发请求会一次经过所有中间件，此时请求porcess_request,最后到大views的函数中，views函数处理后，再一次穿过中间件，此时为process_response,最后返回给请求者。

1.简单的自定义中间件

  • 在项目创建一个包，名字utils(名字随意起)，再创建一个py文件。这里试验middlewares.py

    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
#自定义中间件，不是必须要有下面这两个方法，有request方法说明请求来了要处理，有response方法说明响应出去时需要处理，不是非要写这两个方法，如果你没写process_response方法，那么会一层一层的往上找，哪个中间件有process_response方法就将返回对象给哪个中间件

  • 在settgings.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',
    'utils.middlewares.MD1',
]

2.process_request

  • process_request

    • 执行：

      执行顺序 执行时间
      按照注册顺序执行 视图函数之前

    • 参数:request

    • 返回值：按照注册的顺序 顺序执行

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

  • 示例：

    #middlewares.py  自定义中间件函数
from django.utils.deprecation import MiddlewareMixin
class MD1(MiddlewareMixin):
    def process_request(self,request):#执行MD1  process_request 就会打印
        print("MD1 process_request")

class MD2(MiddlewareMixin):
    def process_request(self,request):#执行MD2  process_request 就会打印
        print("MD2 process_request")
        
#views.py   视图函数
def index(request):
    print("index 视图函数")
    return render(request,"index.html")
#settings.py  注册侧MD1,MD2自定义中间件
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',
    'utils.middlewares.MD1',
    'utils.middlewares.MD2',
]
#结果：
#MD1 process_request
#MD2 process_request
#index 视图函数
#如果MD1和MD2位置交换则结果：
#MD2 process_request
#MD1 process_request
#index 视图函数
    • 由此可以总结：
      • 中间件process_request方法是在执行视图函数之前执行
      • 当配置多个中间件，会按照MIDDLEWARE中的注册顺序，列表从前到后依次执行
      • 不同中间件之间传递的request都是同一个对象，通过id(request)可以验证

3.process_response

  • process_response

    • 执行：

      执行顺序 执行时间
      按照注册的顺序 倒叙执行 视图函数之后

    • 参数：request,response

    • 返回值：

      返回值 效果
      return response response是视图函数返回的HttpResponse对象

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

  • 示例

    • 注意：
      • 在定义process_response时，必须request和response两个参数必须有。
      • 在定义process_response时，必须有返回值，写return response ，否则你上层的中间件就没有拿到httpresponse对象，就会报错：AttributeError: 'NoneType' object has no attribute 'get'
      • 使用response.content可以看到响应体里面内容。由于response是个变量，直接点击看源码是看不到的。
    from django.utils.deprecation import MiddlewareMixin
class MD1(MiddlewareMixin):
    def process_request(self,request):
        print("MD1 process_request")
        # print(id(request))
    def process_response(self,request,response):
        print(response.content)
        print("MD1 process_response")


class MD2(MiddlewareMixin):
    def process_request(self,request):
        print("MD2 process_request")
        # print(id(request))
    def process_response(self,request,response):
        print("MD1 process_response")

#MD1 process_request
#MD2 process_request
#index 视图函数
#MD2 process_response
#MD1 process_response
    • 当我们把MD1的process_request方法设置一个return HttpResponse("hello")
    
from django.shortcuts import HttpResponse
from django.utils.deprecation import MiddlewareMixin
class MD1(MiddlewareMixin):
    def process_request(self,request):
        print("MD1 process_request")
        # print(id(request))
        return HttpResponse("hello")
    def process_response(self,request,response):
        print("MD1 process_response")
        print(response.content)
        return response
# MD1 process_request
#MD1 process_response
#b'hello'   响应体输出的内容response.content

#process_request方法里面不写返回值，默认也是返回None，如果你自己写了return None，也是一样的效果，不会中断你的请求，但是如果你return 的一个httpresponse对象，那么就会在这个方法中断你的请求，直接返回给用户，这就成了非正常的流程了。并且，如果你在这里return了httpresponse对象，那么会从你这个中间件类中的process_response方法开始执行返回操作，所以这个类里面只要有process_response方法，肯定会执行

    • 流程图：

  • 练习题：设置路径白名单，只要访问的是login登陆路径，就不做这个cookie认证

    from django.urls import reverse
class MD3(MiddlewareMixin):
    def process_request(self,request):
        if request.path not in [reverse('login')]:
            print("中间件MD3")
            is_login = request.COOKies.get("is_login",False)
            if is_login:
                pass
            else:
                return redirect(reverse("login"))
        else:
            return None

    def process_response(self,request,response):
        print("MD3响应")
        return response

4.process_view

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

    • 执行：

      执行顺序 执行时间
      按照注册顺序执行 视图函数之前，process_request之后

    • 参数：

      参数 解释
      request 是HttpRequest对象
      view_func 是Django即将使用的视图函数（它是实际的函数对象，而不是函数的名称作为字符串）
      view_args 是将传递给视图的位置参数的列表
      view_kwargs 是将传递给视图的关键字参数的字典

    • 返回值：

      返回值 效果
      None Django将继续处理这个请求
      return response Django不会调用对应的视图函数,它将执行中间件的process_response方法并将应用到该HttpResponse并返回结果

    • 流程图

  • 给MD1和MD2添加process_view方法：

    from django.shortcuts import HttpResponse,redirect,render
from django.utils.deprecation import MiddlewareMixin
class MD1(MiddlewareMixin):
    def process_request(self,request):
        print("MD1 process_request")
        # print(id(request))
    def process_response(self,request,response):
        print("MD1 process_response")
        # print("响应体",response.content)
        return response
    def process_view(self,request,view_func,view_args,view_):
        print("*"*32)
        print("MD1  process_view")
        print(view_func, view_func.__name__)
		ret = view_func(request) #提前执行视图函数.不用上图的试图函数的位置再执行，如果你视图函数有参数的话，可以这么写 view_func(request,view_args,view_kwargs)
        return ret#直接就在MD1中间件这里这个类的process_response给返回了,就不会去找到视图函数里面的这个函数去执行了

class MD2(MiddlewareMixin):
    def process_request(self,request):
        print("MD2 process_request")
        # print(id(request))
    def process_response(self,request,response):
        print("MD2 process_response")
        return response
    def process_view(self,request,view_func,view_args,view_):
        print("*"*32)
        print("MD2  process_view")
        print(view_func, view_func.__name__)#url映射到的那个视图函数，也就是说每个中间件的这个process_view已经提前拿到了要执行的那个视图函数


#MD1 process_request
#MD2 process_request
#********************************
#MD1  process_view
#<function index at 0x0000022D0146E378> index
#********************************
#MD2  process_view
#<function index at 0x0000022D0146E378> index
#index 视图函数
#MD2 process_response
#MD1 process_response
    • process_view方法是在process_reuqest之后，process_response之前，视图函数之前，执行顺序按照MIDDLEWARE中的注册顺序从前到后顺序执行的。

5.process_exception

  • process_exception(self,request,exception)

    • 执行：

      执行顺序 执行时间
      按照注册顺序倒序执行 视图层有错才执行（需要触发）

    • 参数：

    参数 解释
    request request对象
    exception 视图函数异常产生的Exception对象
    • 返回值
    返回值 效果
    None 交给下一个中间件的process_exception方法来处理异常。它的执行顺序也是按照中间件注册顺序的倒序执行。
    return response 是HttpResponse对象，Django将调用模板和中间件中的process_response方法，并返回给浏览器，否则将默认处理异常

  • 流程图：

  • 在MD1，MD2中添加process_exception

    from django.shortcuts import HttpResponse,redirect,render
from django.utils.deprecation import MiddlewareMixin
class MD1(MiddlewareMixin):
    def process_request(self,request):
        print("MD1 process_request")
        # print(id(request))
    def process_response(self,request,response):
        print("MD1 process_response")
        # print("响应体",response.content)
        return response
    def process_view(self,request,view_func,view_args,view_):
        print("*"*32)
        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")
        # print(id(request))
    def process_response(self,request,response):
        print("MD2 process_response")
        return response
    def process_view(self,request,view_func,view_args,view_):
        print("*"*32)
        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("自己触发异常")
    return render(request,"index.html")
    • 在MD1的process_exeception中返回一个响应对象
    class MD1(MiddlewareMixin):
    def process_request(self,request):
        print("MD1 process_request")
        # print(id(request))
    def process_response(self,request,response):
        print("MD1 process_response")
        # print("响应体",response.content)
        return response
    def process_view(self,request,view_func,view_args,view_):
        print("*"*32)
        print("MD1  process_view")
        print(view_func, view_func.__name__)
    def process_exception(self,request,exception):
        print(exception)
        print("MD1 中的process_exception")
        return HttpResponse(str(exception))#返回一个字符串
# MD1 process_request
# MD2 process_request
# ********************************
# MD1  process_view
# <function index at 0x000001E9C0C9E378> index
# ********************************
# MD2  process_view
# <function index at 0x000001E9C0C9E378> index
# index 视图函数
# MD2 中的process_exception
# 自己触发异常
# MD1 中的process_exception
# MD2 process_response
# MD1 process_response
    • 代码流程图：

6.process_template_response

  • process_template_response(self, request, response)

    • 执行：

      执行顺序 执行时间
      按照注册的顺序 倒叙执行 视图返回的是一个templateResponse对象（触发）

    • 参数：

      参数 解释
      request 一个HttpRequest对象
      return response TemplateResponse对象（由视图函数或者中间件产生）

    • 返回值：

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

    • 示例

      from django.shortcuts import HttpResponse,redirect,render
from django.utils.deprecation import MiddlewareMixin
class MD1(MiddlewareMixin):
    def process_request(self,request):
        print("MD1 process_request")
        # print(id(request))
    def process_response(self,request,response):
        print("MD1 process_response")
        # print("响应体",response.content)
        return response
    def process_view(self,request,view_func,view_args,view_):
        print("*"*32)
        print("MD1  process_view")
        print(view_func, view_func.__name__)
    def process_exception(self,request,exception):
        print(exception)
        print("MD1 中的process_exception")
        return HttpResponse(str(exception))
    def process_template_response(self,request,response):
        print("MD1 中process_template_response")
        return response


class MD2(MiddlewareMixin):
    def process_request(self,request):
        print("MD2 process_request")
        # print(id(request))
    def process_response(self,request,response):
        print("MD2 process_response")
        return response
    def process_view(self,request,view_func,view_args,view_):
        print("*"*32)
        print("MD2  process_view")
        print(view_func, view_func.__name__)

    def process_exception(self, request, exception):
        # print(exception)

        print("MD2 中的process_exception")

    def process_template_response(self,request,response):
        response.template_name = "login.html"#更改页面
        response.context_data["name"] = "haha"#更改传入值
        print("MD2 中process_template_response")
        return response

      views.py

      from django.template.response import TemplateResponse
def index(request):
    print("index 视图函数")
    return TemplateResponse(request,"index.html",{"name":"xjk"})
      • 视图函数执行完毕后，立即执行了中间件的process_template_response方法，顺序是倒序，先执行MD2的，再执行MD1的。MD2的process_template_response方法，返回一个新的HttpResponse对象，接着执行中间件的process_response方法

3.中间件的执行流程

  • 请求到达中间件之后，先按照正序执行每个注册中间件的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两个方法的触发是有条件的，执行顺序也是倒序。总结所有的执行流程如下：

posted @ 2019-11-13 14:30  是阿凯啊  阅读(154)  评论(0)  编辑  收藏  举报