什么是中间件?

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

但是由于其影响的是全局,所以需要谨慎使用,使用不当会影响性能。

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

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

  1. MIDDLEWARE = [
  2. 'django.middleware.security.SecurityMiddleware',
  3. 'django.contrib.sessions.middleware.SessionMiddleware',
  4. 'django.middleware.common.CommonMiddleware',
  5. 'django.middleware.csrf.CsrfViewMiddleware',
  6. 'django.contrib.auth.middleware.AuthenticationMiddleware',
  7. 'django.contrib.messages.middleware.MessageMiddleware',
  8. 'django.middleware.clickjacking.XFrameOptionsMiddleware',
  9. ]
 

MIDDLEWARE配置项是一个列表,列表中是一个个字符串,这些字符串其实是一个个类,也就是一个个中间件。

我们之前已经接触过一个csrf相关的中间件了?我们一开始让大家把他注释掉,再提交post请求的时候,就不会被forbidden了,后来学会使用csrf_token之后就不再注释这个中间件了。

那接下来就学习中间件中的方法以及这些方法什么时候被执行。

自定义中间件

中间件可以定义五个方法,分别是:(主要的是process_request和process_response)

  • 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)

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

自定义一个中间件示例

 
  1. from django.utils.deprecation import MiddlewareMixin
  2.  
  3. class MD1(MiddlewareMixin):
  4.  
  5. def process_request(self, request):
  6. print("MD1里面的 process_request")
  7.  
  8. def process_response(self, request, response):
  9. print("MD1里面的 process_response")
  10. return response
 

process_request

process_request有一个参数,就是request,这个request和视图函数中的request是一样的。

它的返回值可以是None也可以是HttpResponse对象。返回值是None的话,按正常流程继续走,交给下一个中间件处理,如果是HttpResponse对象,Django将不执行视图函数,而将响应对象返回给浏览器。

我们来看看多个中间件时,Django是如何执行其中的process_request方法的。

 
  1. from django.utils.deprecation import MiddlewareMixin
  2.  
  3. class MD1(MiddlewareMixin):
  4.  
  5. def process_request(self, request):
  6. print("MD1里面的 process_request")
  7.  
  8. class MD2(MiddlewareMixin):
  9. def process_request(self, request):
  10. print("MD2里面的 process_request")
 
  1. MIDDLEWARE = [
  2. 'django.middleware.security.SecurityMiddleware',
  3. 'django.contrib.sessions.middleware.SessionMiddleware',
  4. 'django.middleware.common.CommonMiddleware',
  5. 'django.middleware.csrf.CsrfViewMiddleware',
  6. 'django.contrib.auth.middleware.AuthenticationMiddleware',
  7. 'django.contrib.messages.middleware.MessageMiddleware',
  8. 'django.middleware.clickjacking.XFrameOptionsMiddleware',
  9. 'middlewares.MD1', # 自定义中间件MD1
  10. 'middlewares.MD2' # 自定义中间件MD2
  11. ]
 

此时,我们访问一个视图,会发现终端中打印如下内容:

  1. MD1里面的 process_request
  2. MD2里面的 process_request
    app01 中的 index视图

把MD1和MD2的位置调换一下,再访问一个视图,会发现终端中打印的内容如下:

  1. MD2里面的 process_request
  2. MD1里面的 process_request
    app01 中的 index视图

看结果我们知道:视图函数还是最后执行的,MD2比MD1先执行自己的process_request方法。

在打印一下两个自定义中间件中process_request方法中的request参数,会发现它们是同一个对象。

由此总结一下:

  1. 中间件的process_request方法是在执行视图函数之前执行的。
  2. 当配置多个中间件时,会按照MIDDLEWARE中的注册顺序,也就是列表的索引值,从前到后依次执行的。
  3. 不同中间件之间传递的request都是同一个对象

process_response

它有两个参数,一个是request,一个是response,request就是上述例子中一样的对象,response是视图函数返回的HttpResponse对象。该方法的返回值也必须是HttpResponse对象。

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

 
  1. from django.utils.deprecation import MiddlewareMixin
  2.  
  3. class MD1(MiddlewareMixin):
  4.  
  5. def process_request(self, request):
  6. print("MD1里面的 process_request")
  7.  
  8. def process_response(self, request, response):
  9. print("MD1里面的 process_response")
  10. return response
  11.  
  12. class MD2(MiddlewareMixin):
  13. def process_request(self, request):
  14. print("MD2里面的 process_request")
  15.  
  16. def process_response(self, request, response):
  17. print("MD2里面的 process_response")
  18. return response
 

访问一个视图,看一下终端的输出:

  1. MD2里面的 process_request
  2. MD1里面的 process_request
  3. app01 中的 index视图
  4. MD1里面的 process_response
  5. MD2里面的 process_response

看结果可知:

process_response方法是在视图函数之后执行的,并且顺序是MD1比MD2先执行。(此时settings.py中 MD2比MD1先注册)

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

process_view

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

该方法有四个参数

request是HttpRequest对象。

view_func是Django即将使用的视图函数。 (它是实际的函数对象,而不是函数的名称作为字符串。)

view_args是将传递给视图的位置参数的列表.

view_kwargs是将传递给视图的关键字参数的字典。 view_args和view_kwargs都不包含第一个视图参数(request)。

Django会在调用视图函数之前调用process_view方法。

它应该返回None或一个HttpResponse对象。 如果返回None,Django将继续处理这个请求,执行任何其他中间件的process_view方法,然后在执行相应的视图。 如果它返回一个HttpResponse对象,Django不会调用适当的视图函数。 它将执行中间件的process_response方法并将应用到该HttpResponse并返回结果。

给MD1和MD2添加process_view方法:

 
  1. from django.utils.deprecation import MiddlewareMixin
  2.  
  3. class MD1(MiddlewareMixin):
  4.  
  5. def process_request(self, request):
  6. print("MD1里面的 process_request")
  7.  
  8. def process_response(self, request, response):
  9. print("MD1里面的 process_response")
  10. return response
  11.  
  12. def process_view(self, request, view_func, view_args, view_kwargs):
  13. print("-" * 80)
  14. print("MD1 中的process_view")
  15. print(view_func, view_func.__name__)
  16.  
  17. class MD2(MiddlewareMixin):
  18. def process_request(self, request):
  19. print("MD2里面的 process_request")
  20.  
  21. def process_response(self, request, response):
  22. print("MD2里面的 process_response")
  23. return response
  24.  
  25. def process_view(self, request, view_func, view_args, view_kwargs):
  26. print("-" * 80)
  27. print("MD2 中的process_view")
  28. print(view_func, view_func.__name__)
 

访问index视图函数,看一下输出结果:

 
  1. MD2里面的 process_request
  2. MD1里面的 process_request
  3. --------------------------------------------------------------------------------
  4. MD2 中的process_view
  5. <function index at 0x000001DE68317488> index
  6. --------------------------------------------------------------------------------
  7. MD1 中的process_view
  8. <function index at 0x000001DE68317488> index
  9. app01 中的 index视图
  10. MD1里面的 process_response
  11. MD2里面的 process_response
 

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

process_exception

process_exception(self, request, exception)

该方法两个参数:

一个HttpRequest对象

一个exception是视图函数异常产生的Exception对象。

这个方法只有在视图函数中出现异常了才执行,它返回的值可以是一个None也可以是一个HttpResponse对象。如果是HttpResponse对象,Django将调用模板和中间件中的process_response方法,并返回给浏览器,否则将默认处理异常。如果返回一个None,则交给下一个中间件的process_exception方法来处理异常。它的执行顺序也是按照中间件注册顺序的倒序执行。

给MD1和MD2添加上这个方法:

 
  1. from django.utils.deprecation import MiddlewareMixin
  2.  
  3. class MD1(MiddlewareMixin):
  4.  
  5. def process_request(self, request):
  6. print("MD1里面的 process_request")
  7.  
  8. def process_response(self, request, response):
  9. print("MD1里面的 process_response")
  10. return response
  11.  
  12. def process_view(self, request, view_func, view_args, view_kwargs):
  13. print("-" * 80)
  14. print("MD1 中的process_view")
  15. print(view_func, view_func.__name__)
  16.  
  17. def process_exception(self, request, exception):
  18. print(exception)
  19. print("MD1 中的process_exception")
  20.  
  21. class MD2(MiddlewareMixin):
  22. def process_request(self, request):
  23. print("MD2里面的 process_request")
  24.  
  25. def process_response(self, request, response):
  26. print("MD2里面的 process_response")
  27. return response
  28.  
  29. def process_view(self, request, view_func, view_args, view_kwargs):
  30. print("-" * 80)
  31. print("MD2 中的process_view")
  32. print(view_func, view_func.__name__)
  33.  
  34. def process_exception(self, request, exception):
  35. print(exception)
  36. print("MD2 中的process_exception")

如果视图函数中无异常,process_exception方法不执行。

想办法,在视图函数中抛出一个异常:

  1. def index(request):
  2. print("app01 中的 index视图")
  3. raise ValueError("呵呵")
  4. return HttpResponse("O98K")

在MD1的process_exception中返回一个响应对象:

 
  1. class MD1(MiddlewareMixin):
  2.  
  3. def process_request(self, request):
  4. print("MD1里面的 process_request")
  5.  
  6. def process_response(self, request, response):
  7. print("MD1里面的 process_response")
  8. return response
  9.  
  10. def process_view(self, request, view_func, view_args, view_kwargs):
  11. print("-" * 80)
  12. print("MD1 中的process_view")
  13. print(view_func, view_func.__name__)
  14.  
  15. def process_exception(self, request, exception):
  16. print(exception)
  17. print("MD1 中的process_exception")
  18. return HttpResponse(str(exception)) # 返回一个响应对象
 

看输出结果:

 
  1. MD2里面的 process_request
  2. MD1里面的 process_request
  3. --------------------------------------------------------------------------------
  4. MD2 中的process_view
  5. <function index at 0x0000022C09727488> index
  6. --------------------------------------------------------------------------------
  7. MD1 中的process_view
  8. <function index at 0x0000022C09727488> index
  9. app01 中的 index视图
  10. 呵呵
  11. MD1 中的process_exception
  12. MD1里面的 process_response
  13. MD2里面的 process_response
 

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

process_template_response(用的比较少)

process_template_response(self, request, response)

它的参数,一个HttpRequest对象,response是TemplateResponse对象(由视图函数或者中间件产生)。

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

 
  1. class MD1(MiddlewareMixin):
  2.  
  3. def process_request(self, request):
  4. print("MD1里面的 process_request")
  5.  
  6. def process_response(self, request, response):
  7. print("MD1里面的 process_response")
  8. return response
  9.  
  10. def process_view(self, request, view_func, view_args, view_kwargs):
  11. print("-" * 80)
  12. print("MD1 中的process_view")
  13. print(view_func, view_func.__name__)
  14.  
  15. def process_exception(self, request, exception):
  16. print(exception)
  17. print("MD1 中的process_exception")
  18. return HttpResponse(str(exception))
  19.  
  20. def process_template_response(self, request, response):
  21. print("MD1 中的process_template_response")
  22. return response
  23.  
  24. class MD2(MiddlewareMixin):
  25. def process_request(self, request):
  26. print("MD2里面的 process_request")
  27.  
  28. def process_response(self, request, response):
  29. print("MD2里面的 process_response")
  30. return response
  31.  
  32. def process_view(self, request, view_func, view_args, view_kwargs):
  33. print("-" * 80)
  34. print("MD2 中的process_view")
  35. print(view_func, view_func.__name__)
  36.  
  37. def process_exception(self, request, exception):
  38. print(exception)
  39. print("MD2 中的process_exception")
  40.  
  41. def process_template_response(self, request, response):
  42. print("MD2 中的process_template_response")
  43. return response
 

views.py中:

 
  1. def index(request):
  2. print("app01 中的 index视图")
  3.  
  4. def render():
  5. print("in index/render")
  6. return HttpResponse("O98K")
  7. rep = HttpResponse("OK")
  8. rep.render = render
  9. return rep
 

访问index视图,终端输出的结果:

 
  1. MD2里面的 process_request
  2. MD1里面的 process_request
  3. --------------------------------------------------------------------------------
  4. MD2 中的process_view
  5. <function index at 0x000001C111B97488> index
  6. --------------------------------------------------------------------------------
  7. MD1 中的process_view
  8. <function index at 0x000001C111B97488> index
  9. app01 中的 index视图
  10. MD1 中的process_template_response
  11. MD2 中的process_template_response
  12. in index/render
  13. MD1里面的 process_response
  14. MD2里面的 process_response
 

从结果看出:

视图函数执行完之后,立即执行了中间件的process_template_response方法,顺序是倒序,先执行MD1的,在执行MD2的,接着执行了视图函数返回的HttpResponse对象的render方法,返回了一个新的HttpResponse对象,接着执行中间件的process_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

 
  1. from django.conf.urls import url
  2. from django.contrib import admin
  3. from app01 import views
  4.  
  5. urlpatterns = [
  6. url(r'^admin/', admin.site.urls),
  7. url(r'^login/$', views.login, name='login'),
  8. url(r'^index/$', views.index, name='index'),
  9. url(r'^home/$', views.home, name='home'),
  10. ]
 

views.py

 
  1. from django.shortcuts import render, HttpResponse, redirect
  2.  
  3. def index(request):
  4. return HttpResponse('this is index')
  5.  
  6. def home(request):
  7. return HttpResponse('this is home')
  8.  
  9. def login(request):
  10. if request.method == "POST":
  11. user = request.POST.get("user")
  12. pwd = request.POST.get("pwd")
  13.  
  14. if user == "alex" and pwd == "alex3714":
  15. # 设置session
  16. request.session["user"] = user
  17. # 获取跳到登陆页面之前的URL
  18. next_url = request.GET.get("next")
  19. # 如果有,就跳转回登陆之前的URL
  20. if next_url:
  21. return redirect(next_url)
  22. # 否则默认跳转到index页面
  23. else:
  24. return redirect("/index/")
  25. return render(request, "login.html")
 

login.html

 
  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4. <meta charset="UTF-8">
  5. <meta http-equiv="x-ua-compatible" content="IE=edge">
  6. <meta name="viewport" content="width=device-width, initial-scale=1">
  7. <title>登录页面</title>
  8. </head>
  9. <body>
  10. <form action="{% url 'login' %}" method="post">
  11. {% csrf_token %}
  12. <p>
  13. <label for="user">用户名:</label>
  14. <input type="text" name="user" id="user">
  15. </p>
  16. <p>
  17. <label for="pwd">密 码:</label>
  18. <input type="text" name="pwd" id="pwd">
  19. </p>
  20. <input type="submit" value="登录">
  21. </form>
  22. </body>
  23. </html>
 

middlewares.py

 
  1. from django.utils.deprecation import MiddlewareMixin
  2.  
  3. class AuthMD(MiddlewareMixin):
  4. white_list = ['/login/', ] # 白名单
  5. black_list = ['/black/', ] # 黑名单
  6.  
  7. def process_request(self, request):
  8. from django.shortcuts import redirect, HttpResponse
  9.  
  10. next_url = request.path_info
  11. print(request.path_info, request.get_full_path())
  12. # 黑名单的网址限制访问
  13. if next_url in self.black_list:
  14. return HttpResponse('This is an illegal URL')
  15. # 白名单的网址或者登陆用户不做限制
  16. elif next_url in self.white_list or request.session.get("user"):
  17. return
  18. else:
  19. return redirect("/login/?next={}".format(next_url))
 

在settings.py中注册

 
  1. MIDDLEWARE = [
  2. 'django.middleware.security.SecurityMiddleware',
  3. 'django.contrib.sessions.middleware.SessionMiddleware',
  4. 'django.middleware.common.CommonMiddleware',
  5. 'django.middleware.csrf.CsrfViewMiddleware',
  6. 'django.contrib.auth.middleware.AuthenticationMiddleware',
  7. 'django.contrib.messages.middleware.MessageMiddleware',
  8. 'django.middleware.clickjacking.XFrameOptionsMiddleware',
  9. 'middlewares.AuthMD'
  10. ]
 

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

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

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

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

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

附:Django请求流程图

 

Django的中间件及WSGI的更多相关文章

  1. django框架--中间件系统

    目录 零.参考 一.中间件的基本理解 二.中间件的系统定位 三.中间件的配置 四.中间件的执行流程 五.中间件与装饰器之间的思考 六.中间件的应用场景 七.内置中间件 八.总结 零.参考 https: ...

  2. 自定义Django的中间件

    分析Django的生命周期,我们知道所有的http请求都要经过Django的中间件. 假如现在有一个需求,所有到达服务端的url请求都在系统中记录一条日志,该怎么做呢? Django的中间件的简介 D ...

  3. python/ Django之中间件

    python/ Django之中间件 一.中间件 中间件共分为: (1)process_request(self,request) (2)process_view(self, request, cal ...

  4. Django组件-中间件

    1.中间件的概念 中间件顾名思义,是介于request与response处理之间的一道处理过程,相对比较轻量级,并且在全局上改变django的输入与输出.因为改变的是全局,所以需要谨慎实用,用不好会影 ...

  5. 细说Django的中间件

    分析Django的生命周期,我们知道所有的http请求都要经过Django的中间件. 假如现在有一个需求,所有到达服务端的url请求都在系统中记录一条日志,该怎么做呢? Django的中间件的简介 D ...

  6. csrf 跨站请求伪造相关以及django的中间件

    django为用户实现防止跨站请求伪造的功能,通过中间件 django.middleware.csrf.CsrfViewMiddleware来完成. 1.django中常用的中间件? - proces ...

  7. python 全栈开发,Day87(ajax登录示例,CSRF跨站请求伪造,Django的中间件,自定义分页)

    一.ajax登录示例 新建项目login_ajax 修改urls.py,增加路径 from app01 import views urlpatterns = [ path('admin/', admi ...

  8. django 自定义中间件 middleware

    Django 中间件 Django中的中间件是一个轻量级.底层的插件系统,可以介入Django的请求和响应处理过程,修改Django的输入或输出.中间件的设计为开发者提供了一种无侵入式的开发方式,增强 ...

  9. day 52 Django 的中间件加载顺序

    前情提要: django的中间键的作用是进行加载 可以通过中间键进行辅助操作 1.中间件的概念 中间件顾名思义,是介于request与response处理之间的一道处理过程,相对比较轻量级,并且在全局 ...

随机推荐

  1. ES6字符串操作讲解(详细),字符串编码表,代码单元,码点的详细介绍。

    以前用到字符串的方法时候,并不会深刻的去思考其中的原理,所以在es6新增的这些方法里就有点蒙圈了,于是想要搞清楚为什么会新增这些方法,以及如何使用这些方法. 在博客园上看见一篇大神SamWeb的总结, ...

  2. Integer一类的比较问题

    总体主要分为两个方面 ①比较的是值 一.基本数据类型与引用数据类型进行比较时,引用数据类型会进行拆箱(自动拆装箱需要在jdk1.5以上),然后与基本数据类型进行值的比较 举例: int i = 12; ...

  3. Panoramic Photography

    http://codeforces.com/gym/101149/problem/J 给出n个数字,表示第i条街有a[i]个照片存在过,其中,每个照片可以覆盖一段连续的区间, 就是一张照片可以覆盖[2 ...

  4. 前端之css(宽高)设置小技巧

    一.css宽高自适应: 1.宽度自适应: 元素宽度设为100%(块状元素的默认宽度为100%) 注:应用在通栏效果中 2.高度自适应: height:auto;或者不设置高度 3.最小,最大高度,最小 ...

  5. jquery中each的3种遍历方法

    1.选择器+遍历 $('div').each(function (i){ i就是索引值 this 表示获取遍历每一个dom对象 }); 2.选择器+遍历 $('div').each(function  ...

  6. WebService学习之旅(七)Axis2发布WebService的几种方式

    前面几篇文章中简单的介绍了如何使用Axis2发布WebService及如何使用Axis2实现Web服务的客户端调用,本节將详细介绍Axis2发布WebService的几种方式. 一.使用aar包方式发 ...

  7. DataPicker以及TimePicker显示时间和日期(屏幕上显示)

    public class MainActivity extends Activity { private DatePicker date_picker;private TimePicker time_ ...

  8. jmeter动态参数传值配置

    jmeter动态参数传值配置

  9. Oracle种常用性能监控SQL语句

    --Oracle常用性能监控SQL语句 --1 SELECT * FROM SYS.V_$SQLAREA WHERE DISK_READS > 100; --2 监控事例的等待 SELECT E ...

  10. [文章泛读] The varying faces of a program transformation systems (ACM Inroads, 2012)

    Beevi S. Nadera, D. Chitraprasad, and Vinod S. S. Chandra. 2012. The varying faces of a program tran ...