乔克视界 乔克视界
首页
  • 运维
  • 开发
  • 监控
  • 安全
  • 随笔
  • Docker
  • Golang
  • Python
  • AIOps
  • DevOps
  • 心情杂货
  • 读书笔记
  • 面试
  • 实用技巧
  • 博客搭建
友链
关于
收藏
  • 分类
  • 标签
  • 归档

乔克

云原生爱好者
首页
  • 运维
  • 开发
  • 监控
  • 安全
  • 随笔
  • Docker
  • Golang
  • Python
  • AIOps
  • DevOps
  • 心情杂货
  • 读书笔记
  • 面试
  • 实用技巧
  • 博客搭建
友链
关于
收藏
  • 分类
  • 标签
  • 归档
  • Docker

  • Golang

  • AIOps

  • Python

    • 基础知识

    • Django框架

      • Django之框架
      • Django之ORM详解
      • Django之操作ORM
      • Django之操作ORM例子
      • Django之路由系统
      • Django之跨站请求伪造
      • Django之Cookie和Session
      • Django之CBV和FBV
      • Django之中间件
        • 中间件介绍
        • 自定义中间件
          • 自定义中间件实例
          • process_request
          • process_response
          • process_view
          • process_exception
          • processtemplateresponse
        • 中间件执行流程
        • Django 请求流程
      • Django之用户认证系统
      • Django之Form组件
      • Django之Ajax
      • Django之模板语言
      • Django之URL分发
      • Django中的缓存
      • Models迁移原理
      • 自定义组件Xadmin
      • Markdown 富文本插件
      • 手写一个验证码
    • 其他

  • DevOps

  • 专栏
  • Python
  • Django框架
乔克
2025-07-19
目录

Django之中间件

# 中间件介绍

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

我们一直都在使用中间件,只是没有注意到而已,打开 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',
]
1
2
3
4
5
6
7
8
9

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

# 自定义中间件

中间件可以定义五个方法,分别是:(主要的是 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 对象,则直接将该对象返回给用户。

# 自定义中间件实例

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

1
2
3
4
5
6
7
8
9
10
11
12

# process_request

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

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

我们来看看多个中间件时,Django 是如何执行其中的 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")
        pass

1
2
3
4
5
6
7
8
9
10
11
12
13
14

在 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
]
1
2
3
4
5
6
7
8
9
10
11

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

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

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

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

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

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

由此总结一下:

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

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

# process_response

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

给上述的 M1 和 M2 加上 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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

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

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

看结果可知:

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 方法:

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__)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

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

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
1
2
3
4
5
6
7
8
9
10
11

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 添加上这个方法:

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


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")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

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

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

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

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

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))  ## 返回一个响应对象
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

看输出结果:

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
1
2
3
4
5
6
7
8
9
10
11
12
13

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

# process_template_response

process_template_response(self, request, response)

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

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

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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

views.py 中

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

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

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

从结果看出:

视图函数执行完之后,立即执行了中间件的 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 方法。

![[附件/images/0cb82828cccebf4018c85042937066ec_MD5.png]]

process_request 方法都执行完后,匹配路由,找到要执行的视图函数,先不执行视图函数,先执行中间件中的 process_view 方法,process_view 方法返回 None,继续按顺序执行,所有 process_view 方法执行完后执行视图函数。加入中间件 3 的 process_view 方法返回了 HttpResponse 对象,则 4,5,6 的 process_view 以及视图函数都不执行,直接从最后一个中间件,也就是中间件 6 的 process_response 方法开始倒序执行。

![[附件/images/f72eb81a3bb59dd82d2f4eb0c2875211_MD5.png]]

process_template_response 和 process_exception 两个方法的触发是有条件的,执行顺序也是倒序。总结所有的执行流程如下:

![[附件/images/d81ae7f610c3cd6bea091c6b01103f12_MD5.png]]

![[附件/images/2d2845071083663dd332546783ef08ff_MD5.png]]

# Django 请求流程

![[附件/images/f38d66c65d636b4d49a0a9a7b3a3bc13_MD5.png]]

作者:乔克

本文链接:https://jokerbai.com

版权声明:本博客所有文章除特别声明外,均采用 署名-非商业性-相同方式共享 4.0 国际 (CC-BY-NC-SA-4.0) 许可协议。转载请注明出处!

上次更新: 2025/07/19, 11:33:23
Django之CBV和FBV
Django之用户认证系统

← Django之CBV和FBV Django之用户认证系统→

最近更新
01
使用 Generic Webhook Trigger 触发 Jenkins 多分支流水线自动化构建
07-19
02
使用Zadig从0到1实现持续交付平台
07-19
03
基于Jira的运维发布平台
07-19
更多文章>
Theme by Vdoing | Copyright © 2019-2025 乔克 | MIT License | 渝ICP备20002153号 |
  • 跟随系统
  • 浅色模式
  • 深色模式
  • 阅读模式