Skip to content

7. 请求的生命周期

从请求到达到其响应发出之间,[Django] 要经过若干步骤,应用程序可以在每一步进行干预。我们已经遇到过其中的几个干预点:中间件组件及其 [__call__] 方法(示例 03、12、16、23)、它们的 [process_exception] 方法(示例 08 和 12)和 [process_view] 方法(示例 21),以及路由转换器(示例 12)。本章将它们合并到一个示例中,该示例在每个步骤向控制台显示一条消息,以便观察其顺序:

    1. [request_started] 信号:请求刚刚到达。信号是由 [Django] 在特定时刻发出的通知,应用程序的函数(即接收器)可以接收它。它们不能对请求采取行动:只是被通知而已;
    1. 中间件组件的 [__call__] 方法,在调用 [get_response] 之前:中间件组件按 [MIDDLEWARE] 配置中指定的顺序处理。此时尚未进行路由:中间件组件还不知道由哪个视图处理请求。它也可以自行响应,而不调用链中的其余部分:在这种情况下,后续的中间件组件和视图都不会被调用;
    1. 路由:处理完所有中间件组件之后,[Django] 查找与所请求路径匹配的路由(示例 02);此时会调用路由参数转换器(示例 12)。如果没有路由匹配,则抛出 [Http404] (404)异常;
  • 3 和 4. 中间件组件的 [process_view] 方法,按指定顺序:视图已被选定但尚未被调用。此时,中间件组件知道视图及其参数;它可以让流程继续(返回 [None]),代替视图进行响应,或抛出异常;
    1. 视图,以及它生成的模板;
  • x. 中间件的 [process_exception] 方法,在视图抛出异常时按与配置相反的顺序调用。第一个提供响应的方法会终止查找。如果没有任何一个提供响应,[Django] 会自行生成错误响应:在调试模式下是其详细页面,否则是应用程序的错误页面,由视图 [handler400]、[handler403]、[handler404]、和 [handler500] 提供(见下文)。在其他地方(在中间件组件的 [__call__] 或 [process_view] 中,或在路由中)抛出的异常不会经过 [process_exception]:[Django] 在退出相应的中间件时将其转换为错误响应;
  • 6 和 7. 中间件组件的 [__call__] 方法,在调用 [get_response] 之后,按与配置相反的顺序:响应已准备就绪,每个中间件组件都可以修改它(添加头部、Cookie);
    1. [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 的不同,它会成功,或以各种方式失败。消息由一个小函数写入服务器控制台:

1
2
3
4
5
6
7
8
# 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
  • 第 18–21 行:错误页面视图,稍后介绍。

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]:

Image

服务器控制台按顺序显示各个步骤:

--- 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]:

Image

--- 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]:

Image

--- 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]:

Image

--- 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]:

1
2
3
4
5
6
--- 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] 和错误视图确保无论出现什么错误,用户都不会看到技术性页面:案例研究会利用这一点。