Django 中的中间件

Django 中的中间件

Django 

中间件

中间件介绍

前戏

之前在判断登录的时候使用的是装饰器的功能，通过给视图函数加装饰器来增加判断是否登录的功能。但此方法的缺点是必须给每个需要判断登录的视图函数都加上装饰器。

中间件能够实现给所有的请求执行相同的操作。

什么是中间件

官方介绍：

中间件是 Django 请求/响应处理的钩子框架。它是一个轻量级的、低级的“插件”系统，用于全局改变 Django 的输入或输出。每个中间件组件负责做一些特定的功能。

说的直白一点中间件是帮助我们在视图函数执行之前和执行之后都可以做一些额外的操作，它本质上就是一个自定义类，类中定义了几个方法，Django 框架会在请求的特定的时间去执行这些方法。

激活中间件

若要激活中间件组件，请将其添加到 Django 设置中的 MIDDLEWARE 列表中。

在 MIDDLEWARE 中，每个中间件组件由字符串表示：指向中间件工厂的类或函数名的完整 Python 路径。

我们一直都在使用中间件，只是没有注意到而已，打开 Django 项目的 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',
]

例如之前学到的 csrf 其实就是一个中间件。

自定义中间件

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

• process_request
• process_response
• process_view
• process_exception
• process_template_response

process_request

示例：

from django.utils.deprecation import MiddlewareMixin

class MD1(MiddlewareMixin):

    def process_request(self, request):
        print("MD1里面的 process_request")

class MD2(MiddlewareMixin):
    def process_request(self, request):
        print("MD2里面的 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',
    'middlewares.MD1',  # 自定义中间件MD1
    'middlewares.MD2'  # 自定义中间件MD2
]

打印结果：

MD1里面的 process_request
MD2里面的 process_request
app01 中的 index视图

• 参数:
  • self：类实例化后的自身
  • request： 请求对象
• 执行顺序:
  按照注册的顺序（在 settings.py 里面设置中 从上到下的顺序）
• 何时执行:
  请求从 wsgi 拿到之后，在执行视图函数之前执行
• 返回值:
  • 返回 None：继续执行后续的中间件的 process_request 方法
  • 返回 response： 不执行后续的中间件的 process_request 方法，Django 将不执行视图函数，而将响应对象返回给浏览器。

process_response

示例：

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

class MD2(MiddlewareMixin):
    def process_request(self, request):
        print("MD2里面的 process_request")
        pass

    def process_response(self, request, response):
        print("MD2里面的 process_response")
        return response

输出：

MD2里面的 process_request
MD1里面的 process_request
app01 中的 index视图
MD1里面的 process_response
MD2里面的 process_response

• 参数：
  • self：类实例化后的自身
  • request： 请求对象
  • response：响应对象
• 执行顺序：
  按照注册顺序的倒序（在 settings.py 里面设置中 从下到上的顺序）
• 何时执行：
  在执行视图函数执行之后，请求获得响应之后
• 返回值：
  • 返回值必须是一个 response 对象：将响应对象返回给浏览器。

process_view

示例：

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

    def process_view(self, request, view_func, view_args, view_kwargs):
        print("-" * 80)
        print("MD1 中的process_view")
        print(view_func, view_func.__name__)

class MD2(MiddlewareMixin):
    def process_request(self, request):
        print("MD2里面的 process_request")
        pass

    def process_response(self, request, response):
        print("MD2里面的 process_response")
        return response

    def process_view(self, request, view_func, view_args, view_kwargs):
        print("-" * 80)
        print("MD2 中的process_view")
        print(view_func, view_func.__name__)

输出：

MD2里面的 process_request
MD1里面的 process_request
--------------------------------------------------------------------------------
MD2 中的process_view
<function index at 0x000001DE68317488> index
--------------------------------------------------------------------------------
MD1 中的process_view
<function index at 0x000001DE68317488> index
app01 中的 index视图
MD1里面的 process_response
MD2里面的 process_response

• 参数：
  • self：类实例化后的自身
  • request： 请求对象
  • view_func: Django 即将使用的视图函数。 （它是实际的函数对象，而不是函数的名称作为字符串。）
  • view_args: 将传递给视图的位置参数的列表.
  • view_kwargs: 将传递给视图的关键字参数的字典。 view_args 和 view_kwargs 都不包含第一个视图参数（ request ）。
• 执行顺序：
  按照注册的顺序（在 settings.py 里面设置中 从上到下的顺序）
• 何时执行：
  在 urls.py 中找到对应关系之后 在执行真正的视图函数之前
• 返回值：
  • 返回None: 继续执行后续的中间件的 process_view 方法
  • 返回response: 不执行后续的中间件的 process_view 方法，Django 将不执行视图函数，而将响应对象返回给浏览器。

process_exception

示例：

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

    def process_view(self, request, view_func, view_args, view_kwargs):
        print("-" * 80)
        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))  # 返回一个响应对象

class MD2(MiddlewareMixin):
    def process_request(self, request):
        print("MD2里面的 process_request")
        pass

    def process_response(self, request, response):
        print("MD2里面的 process_response")
        return response

    def process_view(self, request, view_func, view_args, view_kwargs):
        print("-" * 80)
        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("app01 中的 index视图")
    raise ValueError("呵呵")
    return HttpResponse("O98K")

输出：

MD2里面的 process_request
MD1里面的 process_request
--------------------------------------------------------------------------------
MD2 中的process_view
<function index at 0x0000022C09727488> index
--------------------------------------------------------------------------------
MD1 中的process_view
<function index at 0x0000022C09727488> index
app01 中的 index视图
呵呵
MD1 中的process_exception
MD1里面的 process_response
MD2里面的 process_response

注意: 这里并没有执行 MD2 的 process_exception 方法，因为 MD1 中的 process_exception 方法直接返回了一个响应对象。

• 参数：
  • self：类实例化后的自身
  • request：请求对象
  • exception:视图函数异常产生的 Exception 对象
• 执行顺序：
  按照注册顺序的倒序（在 settings.py 里面设置中 从下到上的顺序）
• 何时执行：
  视图函数中抛出异常的时候才执行
• 返回值：
  • 返回None: 继续执行后续的中间件的 process_exception 方法
  • 返回response: 不执行后续的中间件的 process_exception 方法，而将响应对象返回给浏览器。

process_template_response

示例：

class MD1(MiddlewareMixin):

    def process_request(self, request):
        print("MD1里面的 process_request")

    def process_response(self, request, response):
        print("MD1里面的 process_response")
        return response

    def process_view(self, request, view_func, view_args, view_kwargs):
        print("-" * 80)
        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")
        pass

    def process_response(self, request, response):
        print("MD2里面的 process_response")
        return response

    def process_view(self, request, view_func, view_args, view_kwargs):
        print("-" * 80)
        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):
        print("MD2 中的process_template_response")
        return response

视图函数中：

def index(request):
    print("app01 中的 index视图")

    def render():
        print("in index/render")
        return HttpResponse("O98K")
    rep = HttpResponse("OK")
    rep.render = render
    return rep

输出：

MD2里面的 process_request
MD1里面的 process_request
--------------------------------------------------------------------------------
MD2 中的process_view
<function index at 0x000001C111B97488> index
--------------------------------------------------------------------------------
MD1 中的process_view
<function index at 0x000001C111B97488> index
app01 中的 index视图
MD1 中的process_template_response
MD2 中的process_template_response
in index/render
MD1里面的 process_response
MD2里面的 process_response

• 参数：

  • self：类实例化后的自身
  • request：请求对象
  • response:响应对象（由视图函数或者中间件产生）。

• 执行顺序：
  按照注册顺序的倒序（在 settings.py 里面设置中 从下到上的顺序）

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

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

• 返回值：

  • 返回None: 继续执行后续的中间件的 process_template_response 方法
  • 返回response: 不执行后续的中间件的 process_template_response 方法，而将响应对象返回给浏览器。

中间件的执行流程

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

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

 

 

中间件版登录验证

中间件版的登录验证需要依靠 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请求流程图

Django请求流程图

参考：https://www.cnblogs.com/liwenzhou/p/8761803.html

GitHub地址：https://github.com/protea-ban/oldboy/tree/master/s9day74/MD_demo