Django:中间件

1.MIDDLEWARE中间件

中间件介于request与response处理之间的一道处理过程，中间件是一个轻量，低级别的插件系统，用于在全局范围内改变django的数据和输出，实际作用就是试图函数执行之前与之后做一些额外操作。

中间件定义：

如果你想修改请求，例如被传送到view中的HttpRequest对象。 或者你想修改view返回的HttpResponse对象，这些都可以通过中间件来实现。
	说的直白一点中间件是帮助我们在视图函数执行之前和执行之后都可以做一些额外的操作，它本质上就是一个自定义类，类中定义了几个方法，Django框架会在请求的特定的时间去执行这些方法。

2自定义中间件

中间件可以定义五个方法：
- 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)

这五种方法常用的process_request，process_view，process_response
这五种方法返回值返回值可以是None或一个HttpResponse对象，如果是None,则继续按照django定义的规则继续执行，如果是HttpResponse对象，则直接将该对象返回用户

用户发请求会一次经过所有中间件，此时请求porcess_request,最后到大views的函数中，views函数处理后，再一次穿过中间件，此时为process_response,最后返回给请求者。

1.简单的自定义中间件

在项目创建一个包，名字utils(名字随意起)，再创建一个py文件。这里试验middlewares.py

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
#自定义中间件，不是必须要有下面这两个方法，有request方法说明请求来了要处理，有response方法说明响应出去时需要处理，不是非要写这两个方法，如果你没写process_response方法，那么会一层一层的往上找，哪个中间件有process_response方法就将返回对象给哪个中间件

在settgings.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',
    'utils.middlewares.MD1',
]

2.process_request

process_request
- 执行：
  
  执行顺序执行时间
  
  按照注册顺序执行视图函数之前
- 参数:request
- 返回值：按照注册的顺序顺序执行
  
  返回值效果
  
  None 按正常流程继续走，交给下一个中间件处理
  
  HttpResponse Django将不执行视图函数，而将相应对象返回给浏览器

执行顺序	执行时间
按照注册顺序执行	视图函数之前

返回值	效果
None	按正常流程继续走，交给下一个中间件处理
HttpResponse	Django将不执行视图函数，而将相应对象返回给浏览器

示例：

#middlewares.py  自定义中间件函数
from django.utils.deprecation import MiddlewareMixin
class MD1(MiddlewareMixin):
    def process_request(self,request):#执行MD1  process_request 就会打印
        print("MD1 process_request")

class MD2(MiddlewareMixin):
    def process_request(self,request):#执行MD2  process_request 就会打印
        print("MD2 process_request")
        
#views.py   视图函数
def index(request):
    print("index 视图函数")
    return render(request,"index.html")
#settings.py  注册侧MD1,MD2自定义中间件
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',
    'utils.middlewares.MD1',
    'utils.middlewares.MD2',
]
#结果：
#MD1 process_request
#MD2 process_request
#index 视图函数
#如果MD1和MD2位置交换则结果：
#MD2 process_request
#MD1 process_request
#index 视图函数

由此可以总结：
- 中间件process_request方法是在执行视图函数之前执行
- 当配置多个中间件，会按照MIDDLEWARE中的注册顺序，列表从前到后依次执行
- 不同中间件之间传递的request都是同一个对象，通过id(request)可以验证

3.process_response

process_response
- 执行：
  
  执行顺序执行时间
  
  按照注册的顺序倒叙执行视图函数之后
- 参数：request,response
- 返回值：
  
  返回值效果
  
  return response response是视图函数返回的HttpResponse对象
多个中间件中的process_response方法是按照MIDDLEWARE中的注册顺序倒序执行的，也就是说第一个中间件的process_request方法首先执行，而它的process_response方法最后执行，最后一个中间件的process_request方法最后一个执行，它的process_response方法是最先执行。

执行顺序	执行时间
按照注册的顺序倒叙执行	视图函数之后

返回值	效果
return response	response是视图函数返回的HttpResponse对象

示例

注意：
- 在定义process_response时，必须request和response两个参数必须有。
- 在定义process_response时，必须有返回值，写return response ，否则你上层的中间件就没有拿到httpresponse对象，就会报错：AttributeError: 'NoneType' object has no attribute 'get'
- 使用response.content可以看到响应体里面内容。由于response是个变量，直接点击看源码是看不到的。

from django.utils.deprecation import MiddlewareMixin
class MD1(MiddlewareMixin):
    def process_request(self,request):
        print("MD1 process_request")
        # print(id(request))
    def process_response(self,request,response):
        print(response.content)
        print("MD1 process_response")


class MD2(MiddlewareMixin):
    def process_request(self,request):
        print("MD2 process_request")
        # print(id(request))
    def process_response(self,request,response):
        print("MD1 process_response")

#MD1 process_request
#MD2 process_request
#index 视图函数
#MD2 process_response
#MD1 process_response

当我们把MD1的process_request方法设置一个return HttpResponse("hello")


from django.shortcuts import HttpResponse
from django.utils.deprecation import MiddlewareMixin
class MD1(MiddlewareMixin):
    def process_request(self,request):
        print("MD1 process_request")
        # print(id(request))
        return HttpResponse("hello")
    def process_response(self,request,response):
        print("MD1 process_response")
        print(response.content)
        return response
# MD1 process_request
#MD1 process_response
#b'hello'   响应体输出的内容response.content

#process_request方法里面不写返回值，默认也是返回None，如果你自己写了return None，也是一样的效果，不会中断你的请求，但是如果你return 的一个httpresponse对象，那么就会在这个方法中断你的请求，直接返回给用户，这就成了非正常的流程了。并且，如果你在这里return了httpresponse对象，那么会从你这个中间件类中的process_response方法开始执行返回操作，所以这个类里面只要有process_response方法，肯定会执行

流程图：

练习题：设置路径白名单，只要访问的是login登陆路径，就不做这个cookie认证

from django.urls import reverse
class MD3(MiddlewareMixin):
    def process_request(self,request):
        if request.path not in [reverse('login')]:
            print("中间件MD3")
            is_login = request.COOKies.get("is_login",False)
            if is_login:
                pass
            else:
                return redirect(reverse("login"))
        else:
            return None

    def process_response(self,request,response):
        print("MD3响应")
        return response

4.process_view

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

执行：

执行顺序执行时间

按照注册顺序执行视图函数之前，process_request之后

执行顺序	执行时间
按照注册顺序执行	视图函数之前，process_request之后

参数：

参数	解释
request	是HttpRequest对象
view_func	是Django即将使用的视图函数（它是实际的函数对象，而不是函数的名称作为字符串）
view_args	是将传递给视图的位置参数的列表
view_kwargs	是将传递给视图的关键字参数的字典

返回值：

返回值	效果
None	Django将继续处理这个请求
return response	Django不会调用对应的视图函数,它将执行中间件的process_response方法并将应用到该HttpResponse并返回结果

流程图

给MD1和MD2添加process_view方法：

from django.shortcuts import HttpResponse,redirect,render
from django.utils.deprecation import MiddlewareMixin
class MD1(MiddlewareMixin):
    def process_request(self,request):
        print("MD1 process_request")
        # print(id(request))
    def process_response(self,request,response):
        print("MD1 process_response")
        # print("响应体",response.content)
        return response
    def process_view(self,request,view_func,view_args,view_):
        print("*"*32)
        print("MD1  process_view")
        print(view_func, view_func.__name__)
		ret = view_func(request) #提前执行视图函数.不用上图的试图函数的位置再执行，如果你视图函数有参数的话，可以这么写 view_func(request,view_args,view_kwargs)
        return ret#直接就在MD1中间件这里这个类的process_response给返回了,就不会去找到视图函数里面的这个函数去执行了

class MD2(MiddlewareMixin):
    def process_request(self,request):
        print("MD2 process_request")
        # print(id(request))
    def process_response(self,request,response):
        print("MD2 process_response")
        return response
    def process_view(self,request,view_func,view_args,view_):
        print("*"*32)
        print("MD2  process_view")
        print(view_func, view_func.__name__)#url映射到的那个视图函数，也就是说每个中间件的这个process_view已经提前拿到了要执行的那个视图函数


#MD1 process_request
#MD2 process_request
#********************************
#MD1  process_view
#<function index at 0x0000022D0146E378> index
#********************************
#MD2  process_view
#<function index at 0x0000022D0146E378> index
#index 视图函数
#MD2 process_response
#MD1 process_response

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

5.process_exception

process_exception(self,request,exception)

执行：

执行顺序执行时间

按照注册顺序倒序执行视图层有错才执行（需要触发）
参数：

执行顺序	执行时间
按照注册顺序倒序执行	视图层有错才执行（需要触发）

参数	解释
request	request对象
exception	视图函数异常产生的Exception对象

返回值

返回值	效果
None	交给下一个中间件的process_exception方法来处理异常。它的执行顺序也是按照中间件注册顺序的倒序执行。
return response	是HttpResponse对象，Django将调用模板和中间件中的process_response方法，并返回给浏览器，否则将默认处理异常

流程图：

在MD1，MD2中添加process_exception

from django.shortcuts import HttpResponse,redirect,render
from django.utils.deprecation import MiddlewareMixin
class MD1(MiddlewareMixin):
    def process_request(self,request):
        print("MD1 process_request")
        # print(id(request))
    def process_response(self,request,response):
        print("MD1 process_response")
        # print("响应体",response.content)
        return response
    def process_view(self,request,view_func,view_args,view_):
        print("*"*32)
        print("MD1  process_view")
        print(view_func, view_func.__name__)
    def process_exception(self,request,exception):
        print(exception)
        print("MD1 中的process_exception")

class MD2(MiddlewareMixin):
    def process_request(self,request):
        print("MD2 process_request")
        # print(id(request))
    def process_response(self,request,response):
        print("MD2 process_response")
        return response
    def process_view(self,request,view_func,view_args,view_):
        print("*"*32)
        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("index 视图函数")
    raise ValueError("自己触发异常")
    return render(request,"index.html")

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

class MD1(MiddlewareMixin):
    def process_request(self,request):
        print("MD1 process_request")
        # print(id(request))
    def process_response(self,request,response):
        print("MD1 process_response")
        # print("响应体",response.content)
        return response
    def process_view(self,request,view_func,view_args,view_):
        print("*"*32)
        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))#返回一个字符串
# MD1 process_request
# MD2 process_request
# ********************************
# MD1  process_view
# <function index at 0x000001E9C0C9E378> index
# ********************************
# MD2  process_view
# <function index at 0x000001E9C0C9E378> index
# index 视图函数
# MD2 中的process_exception
# 自己触发异常
# MD1 中的process_exception
# MD2 process_response
# MD1 process_response

代码流程图：

6.process_template_response

process_template_response(self, request, response)

执行：

执行顺序执行时间

按照注册的顺序倒叙执行视图返回的是一个templateResponse对象（触发）
参数：

参数解释

request 一个HttpRequest对象

return response TemplateResponse对象（由视图函数或者中间件产生）

执行顺序	执行时间
按照注册的顺序倒叙执行	视图返回的是一个templateResponse对象（触发）

参数	解释
request	一个HttpRequest对象
return response	TemplateResponse对象（由视图函数或者中间件产生）

返回值：

process_template_response是在视图函数执行完成后立即执行

返回值	效果
一个视图	但是它有一个前提条件，那就是视图函数返回的对象有一个render()方法（或者表明该对象是一个TemplateResponse对象或等价方法）

示例

from django.shortcuts import HttpResponse,redirect,render
from django.utils.deprecation import MiddlewareMixin
class MD1(MiddlewareMixin):
    def process_request(self,request):
        print("MD1 process_request")
        # print(id(request))
    def process_response(self,request,response):
        print("MD1 process_response")
        # print("响应体",response.content)
        return response
    def process_view(self,request,view_func,view_args,view_):
        print("*"*32)
        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")
        # print(id(request))
    def process_response(self,request,response):
        print("MD2 process_response")
        return response
    def process_view(self,request,view_func,view_args,view_):
        print("*"*32)
        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):
        response.template_name = "login.html"#更改页面
        response.context_data["name"] = "haha"#更改传入值
        print("MD2 中process_template_response")
        return response

views.py

from django.template.response import TemplateResponse
def index(request):
    print("index 视图函数")
    return TemplateResponse(request,"index.html",{"name":"xjk"})

视图函数执行完毕后，立即执行了中间件的process_template_response方法，顺序是倒序，先执行MD2的，再执行MD1的。MD2的process_template_response方法，返回一个新的HttpResponse对象，接着执行中间件的process_response方法

3.中间件的执行流程

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

相关阅读:
课堂训练
 测试用例
 学生空间测试
 图书管理系统为例5w1h
风险分析
 关于选择方案的练习作业
 图书管理系统需求报告书
 电梯演说模板
 对于敏捷开发的见解
 课堂练习2
原文地址：https://www.cnblogs.com/xujunkai/p/11848540.html

热门文章
[AMQ]基础与积累
 ant基础
 shell脚本启动java程序
 mongodb分片选择
 mysql优化
 搭建rest服务
 定时框架quartz使用
 nexus + ivy 搭建lib仓库
 学习计划
 团队贡献分