7. 请求的生命周期
从请求到达到其响应发出之间,[Django] 要经过若干步骤,应用程序可以在每一步进行干预。我们已经遇到过其中的几个干预点:中间件组件及其 [__call__] 方法(示例 03、12、16、23)、它们的 [process_exception] 方法(示例 08 和 12)和 [process_view] 方法(示例 21),以及路由转换器(示例 12)。本章将它们合并到一个示例中,该示例在每个步骤向控制台显示一条消息,以便观察其顺序:
-
- [request_started] 信号:请求刚刚到达。信号是由 [Django] 在特定时刻发出的通知,应用程序的函数(即接收器)可以接收它。它们不能对请求采取行动:只是被通知而已;
-
- 中间件组件的 [__call__] 方法,在调用 [get_response] 之前:中间件组件按 [MIDDLEWARE] 配置中指定的顺序处理。此时尚未进行路由:中间件组件还不知道由哪个视图处理请求。它也可以自行响应,而不调用链中的其余部分:在这种情况下,后续的中间件组件和视图都不会被调用;
-
- 路由:处理完所有中间件组件之后,[Django] 查找与所请求路径匹配的路由(示例 02);此时会调用路由参数转换器(示例 12)。如果没有路由匹配,则抛出 [Http404] (404)异常;
- 3 和 4. 中间件组件的 [process_view] 方法,按指定顺序:视图已被选定但尚未被调用。此时,中间件组件知道视图及其参数;它可以让流程继续(返回 [None]),代替视图进行响应,或抛出异常;
-
- 视图,以及它生成的模板;
- x. 中间件的 [process_exception] 方法,在视图抛出异常时按与配置相反的顺序调用。第一个提供响应的方法会终止查找。如果没有任何一个提供响应,[Django] 会自行生成错误响应:在调试模式下是其详细页面,否则是应用程序的错误页面,由视图 [handler400]、[handler403]、[handler404]、和 [handler500] 提供(见下文)。在其他地方(在中间件组件的 [__call__] 或 [process_view] 中,或在路由中)抛出的异常不会经过 [process_exception]:[Django] 在退出相应的中间件时将其转换为错误响应;
- 6 和 7. 中间件组件的 [__call__] 方法,在调用 [get_response] 之后,按与配置相反的顺序:响应已准备就绪,每个中间件组件都可以修改它(添加头部、Cookie);
-
- [request_finished] 信号,在响应发送到浏览器之后发出。接收器不能再修改响应:它们用于处理可以延后的任务(例如关闭数据库连接,[Django] 自己就是这样做的),而不会让用户等待。
这相当于 [Java] 的过滤器和 [Spring MVC] 的拦截器、[ASP.NET Core MVC] 的操作过滤器,以及函数 [before_request] / [after_request] 和 [Flask] 函数、[Laravel] 中的中间件,以及 [Symfony] 中的事件监听器。与这些相比,区别在于结构:中间件组件封装了其余的处理过程(它调用 [get_response],因此在同一段代码中既能看到之前的请求,也能看到之后的响应,就像示例 03 中的俄罗斯套娃),而事件监听器则对事件作出反应,要对某个操作采取行动,必须监听两个事件——操作之前一个、之后一个。与此同时,中间件组件的顺序遵循 [MIDDLEWARE] 配置中的列表,而不是数字序列:这样更易于阅读,但你必须熟悉 [Django] 中间件组件的排序约束(例如会话要在身份验证之前;详见 [Django] 文档)。
7.1. 示例 24:处理请求的各个步骤
| 24-lifecycle/
├── calc/
│ ├── __init__.py
│ ├── apps.py
│ ├── converters.py
│ ├── errors.py
│ ├── logger.py
│ ├── middleware.py
│ ├── signals.py
│ ├── timer.py
│ └── views.py
├── config/
│ ├── settings.py
│ ├── urls.py
│ └── ...
├── templates/
│ ├── calc/
│ │ └── result.html
│ ├── error.html
│ └── layout.html
└── manage.py
|
该应用程序只有一个视图,用于计算整数的平方:[/square/7]。根据 URL 的不同,它会成功,或以各种方式失败。消息由一个小函数写入服务器控制台:
| # calc/logger.py:开发服务器控制台中的一条消息
import sys
def log(message):
# stderr:错误输出,由控制台像 Django 的消息一样显示
print(message, file=sys.stderr)
|
默认情况下,[print] 写入标准输出;[file=sys.stderr] 参数将其发送到错误输出,而 [Django] 写入它自己的消息:因此两者将按生成的顺序显示。(真实的应用程序会使用 [logging] 模块,它来自 [Python],[Django] 通过其 [LOGGING] 设置对其进行配置:案例研究就是这样做的。)
7.1.1. 配置:config/settings.py
| # config/settings.py:示例 24 的配置
from pathlib import Path
BASE_DIR = Path(__file__).resolve().parent.parent
DEBUG = True
SECRET_KEY = "django-insecure-1lvp12eazqudzob^%kot4e29)o)jyuph+fvt_dse*lus--6^s^"
# 接受的主机名:只要 DEBUG 为 False 就必不可少
ALLOWED_HOSTS = ["localhost", "127.0.0.1"]
LANGUAGE_CODE = "en"
TIME_ZONE = "Europe/Paris"
ROOT_URLCONF = "config.urls"
WSGI_APPLICATION = "config.wsgi.application"
INSTALLED_APPS = [
"django.contrib.staticfiles",
# calc 应用:它的配置(calc/apps.py)在启动时连接我们的
# 信号接收器
"calc",
]
# 中间件的顺序:每个中间件都包裹其后的中间件
MIDDLEWARE = [
"calc.middleware.Logger",
"calc.middleware.Block",
"calc.middleware.Timer",
"calc.middleware.ErrorPage",
]
TEMPLATES = [
{
"BACKEND": "django.template.backends.django.DjangoTemplates",
"DIRS": [BASE_DIR / "templates"],
},
]
STATIC_URL = "static/"
STATICFILES_DIRS = [
BASE_DIR.parent / "common" / "static",
]
|
- 第 9 行:设置 [ALLOWED_HOSTS] 是为了使示例可以部署到生产环境([DEBUG = False]),并能够查看应用程序的错误页面(见下文);
- 第 23–28 行:四个中间件组件,按请求经过它们的顺序排列。
7.1.2. 在其他一切之前和之后:信号
| # calc/signals.py:两个 Django 信号,在每个请求开始和结束时发出
from django.core.signals import request_finished, request_started
from django.dispatch import receiver
from . import timer
from .logger import log
# @receiver:每次发出 request_started 信号时都会调用该函数,
# 早于所有中间件
@receiver(request_started)
def start(sender, environ, **kwargs):
log(f"--- {environ['REQUEST_METHOD']} {environ['PATH_INFO']}")
log("0. signal request_started")
# request_finished:在最后,响应发送给浏览器之后;我们
# 不能再更改响应
@receiver(request_finished)
def finish(sender, **kwargs):
duration = timer.stop()
# 若没有到达视图,则测量尚未开始
if duration is not None:
log(f"8. signal request_finished (end, {duration} ms)")
|
- 第 3 行:来自 [Django] 的两个信号,它们框定每个请求;
- 第 12–15 行:[@receiver] 装饰器将 [start] 函数挂接到 [request_started] 信号上:每次发出该信号时都会调用它。接收器会收到信号的发出者([sender]),后面是每个信号特有的命名参数;[**kwargs] 收集那些没有被点名的参数,这是 [Django] 文档的要求(信号在未来版本中可能会接收新的参数)。[request_started] 提供 [environ],即该请求的 WSGI 字典(示例 01):[HttpRequest] 对象此时尚不存在。接收器显示方法和路径,后面是 0 号消息;
- 第 20–25 行:8 号消息,在一切结束时输出,并带有由计时器测得的时长(见下文),前提是测量已经开始。
[Django] 还发出其他信号:在保存 ORM 模型之前和之后([pre_save]、[post_save]),在用户登录时([user_logged_in])……应用程序也可以定义自己的信号。接收器必须在应用程序启动时、第一个请求之前注册。为此指定的位置是应用程序配置:
| # calc/apps.py:calc 应用的配置
from django.apps import AppConfig
class CalcConfig(AppConfig):
name = "calc"
# ready:Django 在启动时调用一次,此时所有应用
# 都已加载。信号接收器就是在这里连接的
def ready(self):
from . import signals # noqa: F401(导入本身就足以将它们连接起来)
|
- 第 6–7 行:应用程序的配置是一个继承自 [AppConfig] 的类,按惯例位于应用程序的 [apps.py] 模块中,并由 [Django] 自行定位。[name] 是应用程序包的名称。你也可以在这里为应用程序指定一个便于阅读的名称([verbose_name]);
- 第 11–12 行:[Django] 在启动时、所有应用程序加载完毕后调用一次方法 [ready] 。在那里导入 [signals] 模块就足够了:其 [@receiver] 装饰器在执行时会挂接接收器。导入是在方法内部而不是在文件顶部完成的,因为使用 ORM 模型的模块在应用程序加载完毕之前无法导入。注释 [# noqa: F401] 指示代码检查工具不要将其标记为“未使用”的导入。
7.1.3. 在视图之前和之后:Logger 中间件
| # calc/middleware.py:示例 24 的中间件,按 MIDDLEWARE 设置中的顺序排列
from django.core.exceptions import BadRequest, PermissionDenied
from django.http import Http404
from django.shortcuts import render
from . import timer
from .errors import DomainError
from .logger import log
# 第一个中间件:它先于其他中间件(也先于
# 路由)看到每个请求,并在所有其他中间件之后看到响应
class Logger:
def __init__(self, get_response):
self.get_response = get_response
def __call__(self, request):
log("1. Logger, before (before the routing)")
response = self.get_response(request)
log(f"7. Logger, after (code {response.status_code})")
return response
# process_view:在路由之后:中间件知道所选的路由
class Block:
def __init__(self, get_response):
self.get_response = get_response
def __call__(self, request):
return self.get_response(request)
def process_view(self, request, view_func, view_args, view_kwargs):
# resolver_match:路由的结果(视图、路由的名称等)
log(f"3. Block, process_view (route: {request.resolver_match.url_name})")
if "block" in request.GET:
# 一个异常:其余部分(Timer、视图)不会执行
raise PermissionDenied("access blocked")
return None
# 一个只对带有 @timed 装饰器标记的视图起作用的中间件:
# 在视图之前(process_view)和之后;测量的结束交给
# request_finished 信号处理(见 calc/signals.py)
class Timer:
def __init__(self, get_response):
self.get_response = get_response
def __call__(self, request):
response = self.get_response(request)
if getattr(request, "timed", False):
log(f"6. Timer, after the view (code {response.status_code})")
return response
def process_view(self, request, view_func, view_args, view_kwargs):
# getattr(object, name, default):对象的属性,若不存在则为默认值
if getattr(view_func, "timed", False):
log("4. Timer, process_view (before the view)")
request.timed = True
timer.start()
return None
# process_exception:一个异常从视图中抛出;本中间件用
# 我们的错误页面替换它
class ErrorPage:
CODES = {BadRequest: 400, PermissionDenied: 403, Http404: 404}
def __init__(self, get_response):
self.get_response = get_response
def __call__(self, request):
return self.get_response(request)
def process_exception(self, request, exception):
for cls, code in self.CODES.items():
if isinstance(exception, cls):
log(f"x. ErrorPage, process_exception (HTTP {code})")
break
else:
# for 循环的 else:若循环没有被 break 中断则执行
if not isinstance(exception, DomainError):
return None # 其余情况:Django 的错误页面
log(f"x. ErrorPage, process_exception (DomainError: {exception})")
code = 500
# 响应替换了异常;然后它像普通响应一样,回溯经过各个中间件
# (先是 Timer,然后是 Logger)
return render(request, "error.html", {"code": code}, status=code)
|
- 第 14–22 行:配置中的第一个中间件:它在所有其他中间件之前处理请求(1 号消息),在所有其他中间件之后处理响应(7 号消息),并输出响应的状态码([status_code])。它不知道路由,因为路由尚未进行。它用于适用于所有请求的处理:日志记录、代理处理(案例研究在谈到客户端的 IP 地址时会提到这一点)……
7.1.4. 路由:calc/converters.py
| # calc/converters.py:一个路径转换器(见示例 12):该片段
# 被转换为整数,若不是整数则为 None(此时由
# 视图决定如何处理)
from .logger import log
class IntegerConverter:
# 任意片段,不含斜杠
regex = r"[^/]+"
def to_python(self, value):
log(f'2. IntegerConverter, the routing (received value: "{value}")')
try:
return int(value)
except ValueError:
return None
def to_url(self, value):
return str(value)
|
一个路由转换器(示例 12),它写入 2 号消息。它接受任何路径段(表达式 [[^/]+]:一个或多个不是斜杠的字符),并将其转换为整数,如果不是整数则转换为 [None] :这与 [int] 转换器(示例 02)不同,后者对 [/square/abc] 会返回 404 页面;在这里,将由视图决定结果。文件 [config/urls.py] 将其注册为 [integer]:
| # config/urls.py:主路由表
from django.urls import path, register_converter
from calc import errors, views
from calc.converters import IntegerConverter
# "整数"转换器(见 calc/converters.py)
register_converter(IntegerConverter, "integer")
urlpatterns = [
path("square/<integer:n>", views.square, name="square"),
]
# 应用的错误页面的视图:Django 在发生
# 400、403、404 和 500 错误时使用它们(但在调试模式下,400、404 和 500 除外,Django 会用
# 自己的详细页面替换它们)
handler400 = errors.page_400
handler403 = errors.page_403
handler404 = errors.page_404
handler500 = errors.page_500
|
7.1.5. 路由之后:“Block”中间件
让我们回到 [calc/middleware.py] 文件:
- 第 26–39 行:第二个中间件只在其方法
***[process\_view] 中、即路由之后起作用。[request.resolver_match] 描述路由的结果(示例 16):路由名称([url_name]***)、视图及其参数。3 号消息;
- 第 36–38 行:URL 的参数 [?block] 会导致 403 错误(Forbidden,拒绝访问):异常 [PermissionDenied] 会中断处理;后续的 [process_view]s 以及视图都不会被调用。
7.1.6. 视图之前:Timer 中间件和 @timed 装饰器
我们只想为某些视图计时——那些提出要求的视图。我们只需用自己设计的装饰器标记它们:
| # calc/timer.py:每个执行线程一个秒表,以及 @timed 装饰器
import threading
import time
# threading.local:一个对象,其属性专属于每个执行线程
# (thread);服务器在各自的线程中处理每个请求
_local = threading.local()
def start():
# perf_counter_ns:精确的时钟,以纳秒为单位
_local.start = time.perf_counter_ns()
# 以毫秒为单位的耗时,若秒表尚未启动则为 None
def stop():
start = getattr(_local, "start", None)
_local.start = None
if start is None:
return None
return round((time.perf_counter_ns() - start) / 1e6)
# 一个不改变视图的装饰器:它用一个属性标记视图,
# Timer 中间件可以读取该属性
def timed(view):
view.timed = True
return view
|
- 第 27–29 行:一个不替换视图的装饰器;它添加一个属性 [timed],并返回该视图。在 [Python] 中,函数是可以添加属性的对象。[Django] 自己就是这样标记某些视图的:[@csrf_exempt] (示例 18)添加属性 [csrf_exempt],[CsrfViewMiddleware] 在其方法 [process_view] 中读取该属性;
- 第 8 行:时间戳必须从 [process_view] 传递给信号 [request_finished]。然而,服务器同时处理多个请求:普通的模块变量会被所有请求共享。[threading.local] 对象具有每个线程专属的属性:每个在自己线程中处理的请求都有自己的开始时间;
- 第 11–22 行:启动和停止计时器。[time.perf_counter_ns()] 是一个精确的时钟,以纳秒为单位,专为测量时长而设计。[getattr(object, name, default)] 返回对象的属性,如果该属性不存在则返回默认值:计时器可能尚未在此线程中启动。时长以毫秒为单位返回。
读取该标记的中间件位于文件 [calc/middleware.py]中:
- 第 55–61 行:在 [process_view]中,如果视图带有该标记,就发送消息 #4,并启动计时器。该标记同时保存在请求中,供后续使用。叠加在 [@timed] 之上的装饰器 [@require_GET] (文件 [calc/views.py])不会清除该标记:[functools.wraps] (示例 08)会复制被包装函数的属性;
- 第 49–53 行:在 [__call__]中,视图执行之后,如果该视图被计时,就发送消息 #6,并附上响应状态码。
7.1.7. 视图:calc/views.py
| # calc/views.py:一个计时的视图
from django.core.exceptions import BadRequest
from django.shortcuts import render
from django.views.decorators.http import require_GET
from .errors import DomainError
from .logger import log
from .timer import timed
# n:路由参数,由我们的 IntegerConverter 转换器提供;
# @timed:Timer 中间件测量该视图的耗时
@require_GET
@timed
def square(request, n):
log(f"5. view square({n})")
if n is None:
raise BadRequest("not an integer") # 400 错误:见 ErrorPage
if n == 13:
raise DomainError("13 brings bad luck") # 一个“意外”错误
return render(request, "calc/result.html", {"n": n, "square": n * n})
|
- 第 15 行:视图被我们的装饰器 [@timed]标记;
- 第 16 行:参数 [n] 由我们的转换器提供;
- 第 18–19 行:参数不是整数时,返回错误 400(Bad Request),由异常 [BadRequest] (示例 07)引起;
- 第 20–21 行:数字 13 会引发一个“意外”错误,即应用程序的 [DomainError] 异常;
- 第 22 行:正常情况。[calc/result.html] 模板只是显示结果。
7.1.8. 错误处理:ErrorPage 中间件和错误视图
[calc/middleware.py] 文件中的最后一个中间件,用我们自己的页面取代 [Django] 的错误页面,针对的是从视图中逸出的异常:
- 第 67 行:一个字典,其键是异常类,值是对应的 HTTP 状态码;
- 第 76–79 行:[isinstance] (示例 03)检查异常是否属于这些类之一(或其子类)。如果是,就显示消息 No. x 和状态码,并由 [break] 终止循环;
- 第 80–85 行:[else] 子句附属于 [for] 循环,当循环在没有执行 [break] 的情况下结束时才会执行:即三个类都不匹配。[DomainError] 异常是一个“意外”错误,被转换为状态码 500(Internal Server Error)的“自定义”错误页面。异常消息显示在控制台中,但不显示在页面上:它可能包含与用户无关的内部细节。其他异常交由 [Django] 处理([return None]);
- 第 88 行:响应,它取代了异常。随后它会像普通响应一样,依次经过前面的中间件([Timer],然后是 [Logger])。
该中间件只处理视图抛出的异常。对于其他情况([PermissionDenied] 异常来自 [Block] 中间件,404 错误来自没有匹配路由的 URL 中间件),[Django] 会使用应用程序的错误视图,这些视图由 [config/urls.py] 文件中的变量 [handler400]、[handler403]、[handler404]和 [handler500] (第 18–21 行)声明,并写在文件 [calc/errors.py]中:
| # calc/errors.py:应用的一个异常,以及错误页面的视图
from django.shortcuts import render
from .logger import log
# 应用的一个异常:某种给定类型的"意外"错误
class DomainError(Exception):
pass
# 错误页面的视图(见 config/urls.py):exception 是引发
# 错误的异常
def page_400(request, exception):
return page(request, 400)
def page_403(request, exception):
return page(request, 403)
def page_404(request, exception):
return page(request, 404)
# 500 页面不接收异常
def page_500(request):
return page(request, 500)
def page(request, code):
log(f"x. view of the error page {code}")
return render(request, "error.html", {"code": code}, status=code)
|
- 第 9–10 行:应用程序异常:一个继承自 [Exception] 的类,没有添加任何内容([pass] 是什么也不做的语句:代码块不能为空);
- 第 15–29 行:错误视图接收请求和异常(500 视图除外,它只接收请求);
- 第 32–34 行:所有错误共用同一个错误页面,并显示错误码(消息 #x)。
有一个微妙之处:在调试模式下,[Django] 对错误 400、404 和 500 仍保留其详细页面,只对错误 403 使用这些视图。这是有意为之:在开发期间,详细页面更有用。在调试模式之外,四个视图都会被使用。如果没有这些视图,[Django] 在调试模式之外会使用它自带的简单页面(示例 03),或者使用应用程序中名为 [400.html]、[403.html]、[404.html]和 [500.html] 的模板(如果存在):这是替换错误页面的另一种更简单的方式。应用程序的错误页面:
| {% extends "layout.html" %}
{# 错误页面;其模型:错误代码 #}
{% block content %}
<div class="alert alert-danger">
<h1 class="h4">Error {{ code }}</h1>
<p class="mb-0">
{% if code == 400 %}Bad request.{% elif code == 403 %}Access denied.{% elif code == 404 %}Page not found.{% else %}Internal server error.{% endif %}
</p>
</div>
{% endblock %}
|
- 第 8 行:DTL 不能在模板中定义字典;消息通过一系列 [{% elif %}] 来选择。
7.1.9. 执行
正常情况,[/square/7]:

服务器控制台按顺序显示各个步骤:
| --- GET /square/7
0. signal request_started
1. Logger, before (before the routing)
2. IntegerConverter, the routing (received value: "7")
3. Block, process_view (route: square)
4. Timer, process_view (before the view)
5. view square(7)
6. Timer, after the view (code 200)
7. Logger, after (code 200)
[27/Sep/2026 19:38:41] "GET /square/7 HTTP/1.1" 200 359
8. signal request_finished (end, 5 ms)
|
方括号中的那一行是开发服务器的日志,在响应发送之后、信号 [request_finished] 之前写入。被阻止的访问,[/square/7?block]:

| --- GET /square/7
0. signal request_started
1. Logger, before (before the routing)
2. IntegerConverter, the routing (received value: "7")
3. Block, process_view (route: square)
x. view of the error page 403
Forbidden (Permission denied): /square/7
Traceback (most recent call last):
...
File "/home/claude/django-sept-2026/examples/24-lifecycle/calc/middleware.py", line 38, in process_view
raise PermissionDenied("access blocked")
django.core.exceptions.PermissionDenied: access blocked
7. Logger, after (code 403)
[27/Sep/2026 19:38:42] "GET /square/7?block HTTP/1.1" 403 443
|
[Block] 中间件在 [process_view]中引发了异常:[Timer] 的 [process_view] 和视图都没有被调用。该异常没有经过 [process_exception](它并非源自视图):[Django] 通过视图 [handler403]把它转换为响应,然后连同调用栈一起写入日志([PermissionDenied] 异常属于客户端错误,但 [Django] 仍以“警告”级别这样记录它)。响应经过了 [Logger] 中间件的后半部分。信号 [request_finished] 已发出,但没有显示任何内容,因为测量并未开始。参数不是整数,[/square/abc]:

| --- GET /square/abc
0. signal request_started
1. Logger, before (before the routing)
2. IntegerConverter, the routing (received value: "abc")
3. Block, process_view (route: square)
4. Timer, process_view (before the view)
5. view square(None)
x. ErrorPage, process_exception (HTTP 400)
6. Timer, after the view (code 400)
7. Logger, after (code 400)
Bad Request: /square/abc
[27/Sep/2026 19:38:42] "GET /square/abc HTTP/1.1" 400 441
8. signal request_finished (end, 1 ms)
|
这一次视图被调用了——[None]——并且是它引发了 400 错误;[process_exception] 把它渲染为页面。[Django] 仍然在其日志中记录了 400 响应([Bad Request: /square/abc])。“意外”错误,[/square/13]:

| --- GET /square/13
0. signal request_started
1. Logger, before (before the routing)
2. IntegerConverter, the routing (received value: "13")
3. Block, process_view (route: square)
4. Timer, process_view (before the view)
5. view square(13)
x. ErrorPage, process_exception (DomainError: 13 brings bad luck)
6. Timer, after the view (code 500)
7. Logger, after (code 500)
Internal Server Error: /square/13
[27/Sep/2026 19:38:42] "GET /square/13 HTTP/1.1" 500 451
8. signal request_finished (end, 1 ms)
|
该异常由我们的中间件处理:即使调试模式已启用,用户看到的也是“自定义”错误页面,而不是详细页面。最后,一个不对应任何路由的 URL,[/unknown]:
| --- GET /unknown
0. signal request_started
1. Logger, before (before the routing)
7. Logger, after (code 404)
Not Found: /unknown
[27/Sep/2026 19:38:43] "GET /unknown HTTP/1.1" 404 2282
|
路由失败:没有 [process_view],也没有视图。在调试模式下,404 页面是 [Django] 的详细页面(示例 02)。让我们把该示例切换到生产模式(在 [DEBUG = False] 文件 [config/settings.py] 中);此时必须使用 [python manage.py runserver --insecure] 启动服务器,使其继续提供静态文件(示例 15):
| curl http://localhost:8000/unknown
|
| ...
<body>
<div class="container py-3">
<div class="alert alert-danger">
<h1 class="h4">Error 404</h1>
<p class="mb-0">
Page not found.
</p>
</div>
</div>
</body>
...
|
现在 404 页面是我们自己的页面,由视图 [handler404] 生成(控制台显示 [x. view of the error page 404])。
我们来总结一下要点。中间件是放置许多视图共有检查的合适位置(用户是否已登录?是否有权访问该视图?),而装饰器则用于只适用于少数视图的检查:身份验证将依赖它们,我们将在下一章看到。[process_exception] 和错误视图确保无论出现什么错误,用户都不会看到技术性页面:案例研究会利用这一点。