14. Django 中间件

Django 中间件

版权声明：本博客来自路飞学城Python全栈开发培训课件，仅用于学习之用，严禁用于商业用途。
欢迎访问路飞学城官网：https://www.luffycity.com/

本节重点

• 中间件介绍
• 自定义中间件
• 中间件的执行流程
• 中间件版登录验证

1. 引子

我们在前面的课程中通过给视图函数加装饰器来判断是用户是否登录，把没有登录的用户请求跳转到登录页面。但是在有很多视图函数的情况下，需要给每个视图函数都加上装饰器，还是有点繁琐。

学完今天的内容之后，我们就可以用更适宜的方式来实现类似给所有请求都做相同操作的功能了。

2. 中间件介绍

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

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

Django 中间件可以理解为是介于 HttpRequest 与 HttpResponse 处理之间的一道处理过程。浏览器从请求到响应的过程中，Django 需要通过很多中间件来处理，可以看如下图所示：

Django 中间件作用：

• 修改请求，即传送到 view 中的 HttpRequest 对象。
• 修改响应，即 view 返回的 HttpResponse 对象。

中间件组件配置在 settings.py 文件的 MIDDLEWARE 选项列表中。配置中的每个字符串选项都是一个类，也就是一个中间件。

Django 默认的中间件配置：

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

3. 自定义中间件

3.1 中间件的四个方法

中间件可以定义四个方法，分别是（主要的是process_request和process_response）：

• process_request(self,request)
• process_view(self, request, view_func, view_args, view_kwargs)
• process_exception(self, request, exception)
• process_response(self, request, response)

以上方法的返回值可以是None或一个HttpResponse对象，如果是None，则继续按照django定义的规则向后继续执行，如果是HttpResponse对象，则直接将该对象返回给用户。

3.2 自定义中间件步骤

• 在 app 目录下新建一个 py 文件，名字自定义，并在该 py 文件中导入 MiddlewareMixin：

  from django.utils.deprecation import MiddlewareMixin
  

• 自定义的中间件类，要继承父类 MiddlewareMixin:

  class MD1(MiddlewareMixin): 
      pass
  

• 在 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',
     
      'app01.middlewares.MD1',
  

3.3 自定义中间件类的方法

自定义中间件类的方法有：process_request 和 process_response。

• process_request 方法

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

  process_request 方法的返回值可以是 None 也可以是 HttpResponse 对象。

  • 返回值是 None 的话，按正常流程继续走，交给下一个中间件处理。
  • 返回值是 HttpResponse 对象，Django 将不执行后续视图函数之前执行的方法以及视图函数，直接以该中间件为起点，倒序执行中间件，且执行的是视图函数之后执行的方法。

  process_request 方法是在视图函数之前执行的。

  当配置多个中间件时，会按照 MIDDLEWARE中 的注册顺序，也就是列表的索引值，顺序执行。

  不同中间件之间传递的 request 参数都是同一个请求对象。

  实例：

  from django.utils.deprecation import MiddlewareMixin
  
  from django.shortcuts import render, HttpResponse
  
  class MD1(MiddlewareMixin):
      def process_request(self, request):
         print("md1  process_request 方法。", id(request)) #在视图之前执行
  

• process_response

  process_response 方法有两个参数，一个是 request，一个是 response，request 是请求对象，response 是视图函数返回的 HttpResponse 对象，该方法必须要有返回值，且必须是response。

  process_response 方法是在视图函数之后执行的。

  当配置多个中间件时，process_response方法会按照 MIDDLEWARE 中的注册顺序，也就是列表的索引值，倒序执行。也就是说第一个中间件的process_request方法首先执行，而它的process_response方法最后执行，最后一个中间件的process_request方法最后一个执行，它的process_response方法是最先执行。

  实例：

  给上述的M1和M2加上process_response方法：

  class MD1(MiddlewareMixin):
      def process_request(self, request):
          print("md1  process_request 方法。", id(request)) #在视图之前执行
  
  
      def process_response(self,request, response): :#基于请求响应
          print("md1  process_response 方法！", id(request)) #在视图之后
          return response
  

  从下图看，正常的情况下按照绿色的路线进行执行,假设中间件1有返回值，则按照红色的路线走，直接执行该类下的 process_response 方法返回，后面的其他中间件就不会执行。

  

• process_view

  process_view 方法格式如下：

  process_view(request, view_func, view_args, view_kwargs)
  

  process_view 方法有四个参数：

  • request 是 HttpRequest 对象。
  • view_func 是 Django 即将使用的视图函数。
  • view_args 是将传递给视图的位置参数的列表。
  • view_kwargs 是将传递给视图的关键字参数的字典。

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

  process_view 方法是在视图函数之前，process_request 方法之后执行的。

  返回值可以是 None、view_func(request) 或 HttpResponse 对象。

  • 返回值是 None 的话，按正常流程继续走，交给下一个中间件处理。
  • 返回值是 HttpResponse 对象，Django 将不执行后续视图函数之前执行的方法以及视图函数，直接以该中间件为起点，倒序执行中间件，且执行的是视图函数之后执行的方法。
  • c.返回值是 view_func(request)，Django 将不执行后续视图函数之前执行的方法，提前执行视图函数，然后再倒序执行视图函数之后执行的方法。
  • 当最后一个中间件的 process_request 到达路由关系映射之后，返回到第一个中间件 process_view，然后依次往下，到达视图函数。

  实例：

  class MD1(MiddlewareMixin):
      def process_request(self, request):
          print("md1  process_request 方法。", id(request)) #在视图之前执行
  
  
      def process_response(self,request, response): :#基于请求响应
          print("md1  process_response 方法！", id(request)) #在视图之后
          return response
  
  
      def process_view(self,request, view_func, view_args, view_kwargs):
          print("md1  process_view 方法！") #在视图之前执行 顺序执行
          #return view_func(request)
  

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

  

• process_exception

  process_exception 方法如下：

  process_exception(request, exception)
  

  参数说明：

  • request 是 HttpRequest 对象。
  • exception 是视图函数异常产生的 Exception 对象。

  process_exception 方法只有在视图函数中出现异常了才执行，按照 settings 的注册倒序执行。

  在视图函数之后，在 process_response 方法之前执行。

  process_exception 方法的返回值可以是一个 None 也可以是一个 HttpResponse 对象。

  返回值是 None，页面会报 500 状态码错误，视图函数不会执行。

  process_exception 方法倒序执行，然后再倒序执行 process_response 方法。

  返回值是 HttpResponse 对象，页面不会报错，返回状态码为 200。

  视图函数不执行，该中间件后续的 process_exception 方法也不执行，直接从最后一个中间件的 process_response 方法倒序开始执行。

  若是 process_view 方法返回视图函数，提前执行了视图函数，且视图函数报错，则无论 process_exception 方法的返回值是什么，页面都会报错， 且视图函数和 process_exception 方法都不执行。

  直接从最后一个中间件的 process_response 方法开始倒序执行。

  实例：

  class MD1(MiddlewareMixin):
      def process_request(self, request):
          print("md1  process_request 方法。", id(request)) #在视图之前执行
  
      def process_response(self,request, response): :#基于请求响应
          print("md1  process_response 方法！", id(request)) #在视图之后
          return response
  
      def process_view(self,request, view_func, view_args, view_kwargs):
          print("md1  process_view 方法！") #在视图之前执行 顺序执行
          #return view_func(request)
  
  
      def process_exception(self, request, exception):#引发错误 才会触发这个方法
          print("md1  process_exception 方法！")
          # return HttpResponse(exception) #返回错误信息
  

3.4 中间件的执行流程

上一部分，我们了解了中间件中的4个方法，它们的参数、返回值以及什么时候执行，现在总结一下中间件的执行流程。

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

3.5 中间件版登录验证

中间件版的登录验证需要依靠session，所以数据库中要有django_session表。

urls.py:

from django.conf.urls import url
from app01 import views

urlpatterns = [
    url(r'^index/$', views.index),
    url(r'^login/$', views.login, name='login'),
]

views.py

from django.shortcuts import render, HttpResponse, redirect


def index(request):
    return HttpResponse('this is index')


def home(request):
    return HttpResponse('this is home')


def login(request):
    if request.method == "POST":
        user = request.POST.get("user")
        pwd = request.POST.get("pwd")

        if user == "Q1mi" and pwd == "123456":
            # 设置session
            request.session["user"] = user
            # 获取跳到登陆页面之前的URL
            next_url = request.GET.get("next")
            # 如果有，就跳转回登陆之前的URL
            if next_url:
                return redirect(next_url)
            # 否则默认跳转到index页面
            else:
                return redirect("/index/")
    return render(request, "login.html")

login.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="x-ua-compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <title>登录页面</title>
</head>
<body>
<form action="{% url 'login' %}">
    <p>
        <label for="user">用户名：</label>
        <input type="text" name="user" id="user">
    </p>
    <p>
        <label for="pwd">密 码：</label>
        <input type="text" name="pwd" id="pwd">
    </p>
    <input type="submit" value="登录">
</form>
</body>
</html>

middlewares.py

class AuthMD(MiddlewareMixin):
    white_list = ['/login/', ]  # 白名单
    balck_list = ['/black/', ]  # 黑名单

    def process_request(self, request):
        from django.shortcuts import redirect, HttpResponse

        next_url = request.path_info
        print(request.path_info, request.get_full_path())

        if next_url in self.white_list or request.session.get("user"):
            return
        elif next_url in self.balck_list:
            return HttpResponse('This is an illegal URL')
        else:
            return redirect("/login/?next={}".format(next_url))

在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',
    'middlewares.AuthMD',
]

AuthMD中间件注册后，所有的请求都要走AuthMD的process_request方法。

访问的URL在白名单内或者session中有user用户名，则不做阻拦走正常流程；

如果URL在黑名单中，则返回This is an illegal URL的字符串；

正常的URL但是需要登录后访问，让浏览器跳转到登录页面。

注：AuthMD中间件中需要session，所以AuthMD注册的位置要在session中间的下方。

附：Django请求流程图：