django框架中间件原理与用法详解

本文实例讲述了django框架中间件原理与用法。分享给大家供大家参考,具体如下:

中间件:轻量级,介于 request和response之间的一道处理过程,在全局上改变了输入和输出

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

通过我们查看django的源码可以知道,中间件的使用方法有如下几种

process_request(self,request)
process_view(self,request,callback,callback_args,callbackkwargs)
process_template_response(self,request,response)
process_exception(self,request,exception)
process_response(self,request,response)

下面我们来通过自定义中间件来理解它们之间的顺序

1 最基本的一个中间件有两种方法:process_request     process_response

在project下面写一个py文件作为中间件文件

#my_middleware.py
from django.utils.deprecation import MiddlewareMixin
from django.shortcuts import redirect,HttpResponse,render
class Md1(MiddlewareMixin):
  def process_request(self,request):
      print("Md1请求")
  def process_response(self,request,response):
      print("Md1返回")
      return response
class Md2(MiddlewareMixin):
  def process_request(self,request):
      print("Md2请求")
  def process_response(self,request,response):
      print("Md2返回")
      return response

接着我们按照顺序分别加入settings

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',
  'my_middleware.Md1',
  'my_middleware.Md2',
]

定义一个views函数

def index(request):
  print("view视图")
  return HttpResponse("执行了view函数")

执行结果:(并且页面正常显示)

Md1请求
Md2请求
view视图
Md2返回
Md1返回

现在我们在request的后面加上一个 return

class Md1(MiddlewareMixin):
  def process_request(self,request):
      print("Md1请求")
      return Httpresponse("Md1中断")
  def process_response(self,request,response):
      print("Md1返回")
      return response
class Md2(MiddlewareMixin):
  def process_request(self,request):
      print("Md2请求")
       return Httpresponse("Md2中断")
def process_response(self,request,response):
        print("Md2返回")
        return response

结果

Md1请求
Md1返回

#页面显示
Md1中断   ----》也就是没有执行views里面的函数

当两个中间件只有request和response的情况

1 request没有return的情况,按照顺序
  Md1 request  ---->  Md2 request 将view函数返回给用户 --->Md2 response --->Md1 response
2 request有return的情况:
Md1 request  ----> 查看有没有return,有的话返回给用户----->执行 Md1 response
            没有return -------》Md2 request 查看有没有return,有的话返回给用户 ---->执行Md2 response  ---> Md1 response
                                      没有return ,将view函数返回给用户  ---》执行Md2 response  ---> Md1 response

2 两个中间件,有 request  response   view

没有return的情况

from django.utils.deprecation import MiddlewareMixin
from django.shortcuts import redirect,HttpResponse,render
class Md1(MiddlewareMixin):
  def process_request(self,request):
      print("Md1请求")
      # return HttpResponse("Md1中断") #返回到前端
  def process_response(self,request,response):
      print("Md1返回")
      return response #不加return会报错
  def process_view(self,request,callback,callback_args,callback_kwargs):
    print("Md1 process_view",callback,callback_args,callback_kwargs)
class Md2(MiddlewareMixin):
  def process_request(self,request):
      print("Md2请求")
      # return HttpResponse("Md2中断")
  def process_response(self,request,response):
      print("Md2返回")
      return response
  def process_view(self,request,callback,callback_args,callback_kwargs):
    print("Md2 process_view",callback,callback_args,callback_kwargs)

结果:

Md1请求
Md2请求
Md1 process_view <function index at 0x000001B6C0A336A8> () {}
Md2 process_view <function index at 0x000001B6C0A336A8> () {}
view视图
Md2返回
Md1返回

有return的情况

  def process_view(self,request,callback,callback_args,callback_kwargs):
    print("Md1 process_view",callback,callback_args,callback_kwargs)
    ret=callback(request)
    return ret
  def process_view(self,request,callback,callback_args,callback_kwargs):
    print("Md2 process_view",callback,callback_args,callback_kwargs)
    ret=callback(request) #执行views里面的函数  --------------------------》 callback(request) 相当于执行 views里面的函数
    return HttpResponse(ret)

结果:Md2的 process_view没有执行

Md1请求
Md2请求
Md1 process_view <function index at 0x000001F8AA3436A8> () {}
view视图
Md2返回
Md1返回

两个中间件 含有 request  response   view
Md1中process_view有return的话,不执行 Md2的process_view
    没有return和return在Md2的话,依次执行 Md1 process_view  ---> Md2 process_view  ---->view函数
无论有无return 返回给用户的都是views视图里面的函数

3 两个中间件 含有 request  response  view  exception

process_exception是当执行发生错误时,返回给用户一个东西

没有return的情况:

from django.utils.deprecation import MiddlewareMixin
from django.shortcuts import redirect,HttpResponse,render
class Md1(MiddlewareMixin):
  def process_request(self,request):
      print("Md1请求")
  def process_response(self,request,response):
      print("Md1返回")
      return response #不加return会报错
  def process_view(self,request,callback,callback_args,callback_kwargs):
    print("Md1 process_view",callback,callback_args,callback_kwargs)
  def process_exception(self,request,exception):
    print("md1 process_exception")
class Md2(MiddlewareMixin):
  def process_request(self,request):
      print("Md2请求")
  def process_response(self,request,response):
      print("Md2返回")
      return response
  def process_view(self,request,callback,callback_args,callback_kwargs):
    print("Md2 process_view",callback,callback_args,callback_kwargs)
  def process_exception(self,request,exception):
    print("md2 process_exception")

结果:exception的内容没有打印

Md1请求
Md2请求
Md1 process_view <function index at 0x00000292CCBA46A8> () {}
Md2 process_view <function index at 0x00000292CCBA46A8> () {}
view视图
Md2返回
Md1返回

含有return的情况

from django.shortcuts import redirect,HttpResponse,render
class Md1(MiddlewareMixin):
  def process_request(self,request):
      print("Md1请求")
  def process_response(self,request,response):
      print("Md1返回")
      return response #不加return会报错
  def process_view(self,request,callback,callback_args,callback_kwargs):
    print("Md1 process_view",callback,callback_args,callback_kwargs)
  def process_exception(self,request,exception):
    print("md1 process_exception")
    return HttpResponse(exception)
class Md2(MiddlewareMixin):
  def process_request(self,request):
      print("Md2请求")
  def process_response(self,request,response):
      print("Md2返回")
      return response
  def process_view(self,request,callback,callback_args,callback_kwargs):
    print("Md2 process_view",callback,callback_args,callback_kwargs)
  def process_exception(self,request,exception):
    print("md2 process_exception")
    return HttpResponse(exception)

结果和没有return的时候一模一样,也就时exception里面的命令没有执行

我们现在认为的制造一个错误

def index(request):
  print("view视图")
  print(xinxin)  #这里是一个错误
  return HttpResponse("执行view函数")

都有return的情况

Md1请求
Md2请求
Md1 process_view <function index at 0x00000186896336A8> () {}
Md2 process_view <function index at 0x00000186896336A8> () {}
view视图
md2 process_exception  #执行了 Md2的exception,并且页面返回的是 return HttpResponse(exception)
Md2返回
Md1返回

Md2没有return,Md1有return的情况

Md1请求
Md2请求
Md1 process_view <function index at 0x00000276983B36A8> () {}
Md2 process_view <function index at 0x00000276983B36A8> () {}
view视图
md2 process_exception
md1 process_exception
Md2返回
Md1返回

exception总结:

当页面没有发生错误的时候,有无return,有多少个return都不会执行 exception里面的命令
当页面有错误时:倒着从excepton中找return  找到了就返回给用户 【Md2执行excepition,没有return的话,执行 Md1中的exception,有返回给用户,都没有的话,页面报错】
return HttpResponse(exception):中 exception存储了报错内容

最最最最后:

process_request 是顺序执行的
process_view   是顺序执行的
process_exception 是倒着查找的
process_response  是倒着执行的

希望本文所述对大家基于Django框架的Python程序设计有所帮助。

(0)

相关推荐

  • 简介Django中内置的一些中间件

    认证支持中间件 中间件类: django.contrib.auth.middleware.AuthenticationMiddleware . django.contrib.auth.middleware.AuthenticationMiddleware . 这个中间件激活认证支持功能. 它在每个传入的 HttpRequest 对象中添加代表当前登录用户的 request.user 属性. It adds the request.user attribute, representing the

  • Django中间件工作流程及写法实例代码

    熟悉web开发的同学对hook钩子肯定不陌生,通过钩子可以方便的实现一些触发和回调,并且做一些过滤和拦截. django中的中间件(middleware)就是类似钩子的一种存在.下面我们来介绍一下,并且给出一些实例. 1.Middleware的工作流程 我盗了一个图,看网上很多人用这个图,来源已经追不明白了.简单声明一下,这个图不是我的.看着图我们分析一下: 1)django的请求相应流程:HttpRequest -> RequestMiddleware -> view function -&

  • 详解Python的Django框架中的中间件

    什么是中间件 我们从一个简单的例子开始. 高流量的站点通常需要将Django部署在负载平衡proxy之后. 这种方式将带来一些复杂性,其一就是每个request中的远程IP地址(request.META["REMOTE_IP"])将指向该负载平衡proxy,而不是发起这个request的实际IP. 负载平衡proxy处理这个问题的方法在特殊的 X-Forwarded-For 中设置实际发起请求的IP. 因此,需要一个小小的中间件来确保运行在proxy之后的站点也能够在 request.

  • 详解Django中间件的5种自定义方法

    Django中间件 在http请求 到达视图函数之前 和视图函数return之后,django会根据自己的规则在合适的时机执行中间件中相应的方法. 中间件的执行流程 1.执行完所有的request方法 到达视图函数. 2.执行中间件的其他方法 3.经过所有response方法 返回客户端. 注意:如果在其中1个中间件里 request方法里 return了值,就会执行当前中间件的response方法,返回给用户 然后 报错..不会再执行下一个中间件. 自定义中间件 1.在project下随便创建

  • Django框架中间件(Middleware)用法实例分析

    本文实例讲述了Django框架中间件(Middleware)用法.分享给大家供大家参考,具体如下: 1.面向切面编程 切点(钩子) 切点允许我们动态的在原有逻辑中插入一部分代码 在不修改原有代码的情况下,动态注入一部分代码 默认情况,不中断传播,切点会自动愈合(自动执行原有逻辑) 如果我们执行了中断操作(return,raise),没接上,会直接到程序结尾 五个切面:1.请求交给路由处理之前:2.请求交给视图处理之前:3.请求交给视图渲染后:4.渲染结果返回给模板之前:5.出现异常. 2.Dja

  • 详解django自定义中间件处理

    中间件是一个钩子框架,它们可以介入 Django 的请求和响应处理过程. 它是一个轻量级.底层的 插件 系统,用于在 全局修改 Django 的输入或输出 . 每个中间件组件负责完成某个特定的功能 这里介绍的中间件方法适用于 Django1.10 以上 相关文件: django middleware Django基础中间件 django.utils.deprecation.py class MiddlewareMixin(object): def __init__(self, get_respo

  • 从django的中间件直接返回请求的方法

    实例如下所示: #coding=utf-8 import json import gevent from django.http import HttpResponse from sdsom.web.recorder import get_event_type from sdsom.web.recorder import get_request_event_info from sdsom.db.rpcclient import get_db_client class RecordEventMid

  • Django中间件实现拦截器的方法

    1.前言 JavaWeb Struts2的拦截器我们都能很熟悉,在请求交给Action处理之前,先在拦截器中处理,处理完之后再交给Action. 在Django中如何实现相同的效果? 2.Django中间件 这个是我的项目的目录结构. 首先,先在app目录(也就是我项目的web目录)中新建一个文件命名为middleware.py 里面加入以下代码: try: from django.utils.deprecation import MiddlewareMixin # Django 1.10.x

  • Django2.1.3 中间件使用详解

    环境 Win10 Python3.6.6 Django2.1.3 中间件作用 中间件用于全局修改Django的输入或输出. 中间件常见用途 缓存 会话认证 日志记录 异常 中间件执行流程 全局异常捕捉实现 创建django项目&添加app django-admin startproject middleware cd middleware django-admin startapp app 添加app到项目 # middleware/settings.py # INSTALLED_APPS最后添

  • 详解Django中间件执行顺序

    中间件 Django中的中间件是一个轻量级.底层的插件系统,可以介入Django的请求和响应处理过程,修改Django的输入或输出.中间件的设计为开发者提供了一种无侵入式的开发方式,增强了Django框架的健壮性. 我们可以使用中间件,在Django处理视图的不同阶段对输入或输出进行干预. 1 中间件的定义方法 定义一个中间件工厂函数,然后返回一个可以别调用的中间件. 中间件工厂函数需要接收一个可以调用的get_response对象. 返回的中间件也是一个可以被调用的对象,并且像视图一样需要接收

  • Django 登陆验证码和中间件的实现

    验证码 在用户注册.登陆页面为了防止暴力请求,可以加入验证码.如果验证码错误,则不需要继续处理,可以减轻服务器的压力 使用验证码也是一种有效防止 csrf 的方法 def verifycode(request): #引入绘图模块 from PIL import Image, ImageDraw, ImageFont #引入随机函数模块 import random #定义变量,用于画面的背景色.宽.高 bgcolor = (random.randrange(20, 100), random.ran

随机推荐