Django 中的中间件

时间  2019-11-24
标签 django 中间件 栏目 Python 繁體版
原文   原文链接

Django 中的中间件

Django 

中间件

中间件介绍

前戏

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

中间件可以实现给全部的请求执行相同的操做。python

什么是中间件

官方介绍：git

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

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

激活中间件

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

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

咱们一直都在使用中间件，只是没有注意到而已，打开 Django 项目的 Settings.py 文件，看到下图的 MIDDLEWARE 配置项。session

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 其实就是一个中间件。app

自定义中间件

中间件能够定义五个方法，分别是：框架

  • 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请求流程图

 

参考：http://www.javashuo.com/article/p-bqlawmrb-s.html

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

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程