罗罗编程学习记录
本页内容 展开查看

04.7.16.1 架构 MTV 与请求链路

所属:全栈开发面试题库 / 04 后端语言与运行时 / 04.7 Python / 04.7.16 Django 框架

覆盖范围

  • MTV 分层与项目/应用边界
  • settings.py 加载与 INSTALLED_APPS
  • AppConfig.ready() 与 django.setup()
  • WSGIHandler / ASGIHandler 请求入口
  • 中间件栈装配与执行顺序
  • URLconf 解析、ResolverMatch、path/re_path 与转换器
  • 函数视图与类视图、as_view() 与 dispatch
  • HttpRequest 与 HttpResponse 系列响应类型
  • reverse/resolve/命名空间/include
  • 模板系统、RequestContext 与上下文处理器
  • 启动期 checks 与 app registry 延迟加载

04.7.16.1-001 Django 的 MTV 分别指什么?与 MVC 如何对应?

一句话结论

Django 自称 MTV:Model 是数据层(模型、字段、关系、管理器),Template 是表现层(模板渲染、上下文注入),View 是业务编排层(接收请求、调用 Model、返回响应)。对照经典 MVC,Model 对应 Model,Template 对应 View,View 对应 Controller;Django 把“控制器分发”这件事交给了框架的路由与 Handler。

概念解释

  • Model 定义数据结构与业务规则,通过 ORM 与数据库交互,不感知 HTTP。
  • Template 只负责把上下文渲染成 HTML 或其他文本,不写业务逻辑。
  • View 是请求与数据之间的胶水:解析请求、校验参数、调度 Model、选择响应形式。

原理流程

  1. Handler 把请求沿中间件、URLconf 送到 View。
  2. View 调用 Model 完成读写,拿到上下文或响应对象。
  3. 若返回模板响应,Template 用上下文渲染;响应沿中间件回程。

代码或图示

HTTP request → Middleware → URLconf → View → Model → DB
                                        ↓
HTTP response ← Middleware ← Template ← View

常见误区

  • 不要把业务逻辑写进 Template:模板里只保留循环、条件与展示格式化;复杂计算放到 View 或 Service。
  • 不要把 SQL/数据访问塞进 View:可复用的查询应下沉到 Model 管理器或 Service,避免多个视图重复实现。
  • MTV 不是严格分层:Django 的 View 同时承担控制器与一部分“视图模型”职责,前后端分离项目里 Template 这一层可能被 JSON 响应取代。

追问

  • MTV 和 MVC 谁控制分发?答:Django 的 URLconf + Handler 承担了 MVC 里 Controller 的路由职责。
  • 前后端分离时 Template 层还存在吗?答:常被 JsonResponse 替代,Model 与 View 编排仍保留。
  • 业务规则应该放 Model 还是 View?答:与数据强相关的规则放 Model,流程编排放 View/Service。

04.7.16.1-002 一个 Django project 和一个 app 的边界是什么?

一句话结论

project 是站点级配置容器:组合多个 app、定义 settings、根 URLconf、中间件与部署入口;app 是可复用的功能模块:包含自己的 models、views、templates、static、tests、migrations。一个 project 可以挂多个 app,同一个 app 也可以被多个 project 复用。

概念解释

  • project 目录通常含 settings/、根 urls.py、wsgi.py/asgi.py,本身一般不放业务模型。
  • app 通过 INSTALLED_APPS 登记进 project;未登记的 app 其模型、模板标签、静态资源不会被框架加载。
  • app 又分“可复用 app”(不绑定具体站点配置)与“项目内 app”(只服务当前业务)。

原理流程

  1. django-admin startproject 生成配置骨架。
  2. python manage.py startapp 生成 app 目录与默认文件。
  3. 把 app 名(或其 AppConfig 路径)加入 INSTALLED_APPS,框架注册模型、信号与检查项。

代码或图示

myproject/
├── manage.py
├── myproject/          # project:settings、urls、wsgi/asgi
├── accounts/          # app:models、views、urls、templates
└── orders/            # app:models、views、urls、templates

常见误区

  • 不要把所有功能堆进一个 app:按领域边界拆分,后续迁移、测试与复用都更清晰。
  • app 之间不应直接导入对方的内部实现细节;跨领域协作走模型接口、信号或 Service,避免循环依赖。
  • 一个 app 的模板默认放在 app/templates/ 下,多 app 同名模板要用 app_name/ 子目录隔离,避免互相覆盖。

追问

  • project 里应该写模型吗?答:一般不写,模型归属于各 app。
  • 没登记到 INSTALLED_APPS 的 app 能用吗?答:模型不会注册到 registry,迁移与管理命令也找不到。
  • 可复用 app 需要绑定 settings 吗?答:应通过配置项或约定路径解耦,避免写死站点配置。

04.7.16.1-003 为什么 Django 把应用设计成可插拔、可复用?

一句话结论

可插拔 app 让认证、评论、购物车这类通用能力以独立模块发布,其他 project 只需安装并登记,再通过配置、继承模板与子类化模型来定制。框架把 app 的注册、发现、模板查找、迁移发现都做成约定机制,复用成本低于从零复制代码。

概念解释

  • 复用的前提是约定优先:模型名、模板路径、URL 命名、配置键都有默认规范,覆盖时才显式声明。
  • app 可暴露抽象基类 mixin、自定义管理器、信号钩子,使用方通过继承扩展而不是改源码。

原理流程

  1. 发布方把通用能力封装为 app,对外留配置项与扩展点。
  2. 使用方安装后加入 INSTALLED_APPS,按文档覆写模板、模型或 URL。
  3. 框架按 app 注册顺序合并模板查找路径、静态文件与迁移依赖。

代码或图示

# 使用方项目里覆写复用 app 的模板:templates/registration/login.html
# 或子类化其模型基类
from reusable.apps.base import ProfileBase

class Profile(ProfileBase):
    level = models.IntegerField(default=0)

常见误区

  • 复用 app 升级时,被覆写的模板与继承模型需要回归测试,否则版本升级容易漏改行为。
  • 把站点专属的业务写进“可复用 app”会污染通用性;通用部分与定制部分应分目录或分 app。
  • app 复用不等于零配置:数据库表名、迁移历史、权限与模板命名空间都需要按规范对齐。

追问

  • 模板覆写的查找顺序是什么?答:按 INSTALLED_APPS 与 DIRS 配置的顺序,先命中先用。
  • 想扩展复用 app 的模型怎么做?答:子类化其抽象基类,或用一对一扩展模型,避免改原表。
  • app 间共享工具放哪里?答:放独立的 utils/core 包或公共 app,不塞进某个业务 app。

04.7.16.1-004 模型、视图、模板之间的依赖方向是怎样的?

一句话结论

依赖方向是单向的:View 依赖 Model 与 Template,Model 不依赖 View 与 Template,Template 只读 View 传入的上下文。模板标签可调用模型方法,但不应反向驱动业务流程;跨模块协作优先通过模型层接口与信号。

概念解释

  • Model 是最底层:只依赖字段、关系、管理器与数据库驱动,不导入 HttpRequest。
  • View 依赖 Model 完成数据访问,依赖 Template 或响应类完成输出。
  • Template 是被动渲染者:上下文由 View 准备,模板不直接发请求或写库。

原理流程

  1. 定义 Model 字段、关系、管理器方法与 __str__。
  2. View 解析请求后调用 Model 查询/写入,组装上下文。
  3. Template 遍历上下文渲染;需要展示时调用模型实例的方法,不执行写操作。

代码或图示

# models.py:不依赖 HTTP
class Article(models.Model):
    title = models.CharField(max_length=120)
    def is_published(self):
        return self.publish_at is not None

# views.py:依赖 Model
def article_detail(request, pk):
    article = get_object_or_404(Article, pk=pk)
    return render(request, "article/detail.html", {"article": article})

常见误区

  • 在模型方法里读取 request 或 session 是坏味道:请求级上下文应在 View 中传入,模型保持可独立测试。
  • 模板里执行复杂查询(如 {% for u in article.author_set.all %})会把数据访问泄漏到表现层,应在 View 预取。
  • 反向依赖(Model 导入 View)会造成循环导入,也是分层混乱的信号,应通过信号或事件解耦。

追问

  • 模型方法需要当前用户信息怎么办?答:由 View 作为参数传入,或在 Service 层组装。
  • 模板可以调用模型方法吗?答:只读展示类方法可以,写操作与复杂查询不应出现在模板里。
  • 跨 app 的 Model 能互相导入吗?答:可以导入模型与管理器,但要避免双向依赖。

04.7.16.1-005 项目里常见的 Service / Repository 分层应该怎么放?

一句话结论

Django 默认不强制 Service 层,但业务复杂时建议在 app 内增加 services/ 或 services.py 放用例编排,repositories.py 放复杂查询封装;Model 保留字段、关系与领域规则,View 只做参数解析与响应转换。分层边界是:View 不拼复杂查询,Service 不碰 HTTP 对象,Repository 不做业务判断。

概念解释

  • Service 组织一个用例涉及的多个模型操作、事务边界与外部调用,可被 View、管理命令、Celery 任务复用。
  • Repository 把 QuerySet 组装、过滤条件封装成命名方法,上层不关心查询细节;简单项目可由 Manager 兼任。

原理流程

  1. View 接收请求、做参数校验与权限判断,调用 Service。
  2. Service 在事务内调度 Repository/Model 完成用例,返回领域对象或结果 DTO。
  3. View 把结果转成模板上下文或 JSON 响应;Service 可在命令行与任务队列中独立复用。

代码或图示

# services.py
def place_order(user, cart):
    with transaction.atomic():
        order = Order.objects.create(user=user, status="pending")
        order.fill_from_cart(cart)
        transaction.on_commit(lambda: notify.delay(order.id))
        return order

# views.py
def checkout(request):
    order = place_order(request.user, request.session["cart"])
    return JsonResponse({"order_id": order.id})

常见误区

  • Service 里直接拿 request 会把用例绑死在 Web 环境;需要用户信息时传入值对象或用户实例。
  • 为分层而分层:简单 CRUD 用通用视图 + Manager 即可,过度拆 Repository 会增加样板代码。
  • 事务边界应放在 Service 用例层,而不是 View;View 之间复用同一段流程时才不会各自重复开事务。

追问

  • Manager 和 Repository 有什么区别?答:Manager 是模型默认查询入口;Repository 面向用例封装跨模型或复杂查询,简单场景可合并。
  • Service 里可以发外部请求吗?答:可以,但外部 IO 应放在事务提交后(on_commit),避免回滚后产生副作用。
  • 异步任务能复用 Service 吗?答:能,这正是抽离 Service 的主要收益之一,前提是不依赖请求上下文。

04.7.16.1-006 Django 启动时如何加载 settings?DJANGO_SETTINGS_MODULE 的作用是什么?

一句话结论

Django 通过环境变量 DJANGO_SETTINGS_MODULE 指定 settings 模块的 Python 路径(如 myproject.settings.prod),django.conf.settings 是一个惰性封装:首次访问属性时才导入模块并把配置挂到全局。manage.py 与 WSGI/ASGI 入口在启动早期设置该环境变量。

概念解释

  • settings 对象本身是 LazySettings,未初始化前访问配置会触发 Settings 实例化并加载模块。
  • 配置分框架默认值(global_settings)与项目覆盖值,后者优先;敏感值从环境变量读取,不写进代码库。
  • 同一进程内通常只加载一套 settings;测试可通过 settings 覆盖工具临时替换配置。

原理流程

  1. 入口脚本设置 DJANGO_SETTINGS_MODULE 环境变量。
  2. 首次访问 settings.DEBUG 时,LazySettings 导入指定模块,合并默认配置。
  3. 配置对象供 app registry、中间件、数据库连接、模板引擎等各子系统读取。

代码或图示

# manage.py
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "myproject.settings.dev")

# 代码中读取
from django.conf import settings
DEBUG = settings.DEBUG
DB_NAME = settings.DATABASES["default"]["NAME"]

常见误区

  • 不要在模块顶层直接 from django.conf import settings 后立即取属性:加载顺序未就绪时可能拿到未初始化封装;函数内访问更安全。
  • DJANGO_SETTINGS_MODULE 指向的模块必须在 Python 路径上,部署时工作目录与 PYTHONPATH 要配置正确。
  • 不要在运行时修改 settings 对象:配置是启动期快照,测试中的临时改值要走 django.test.utils 的覆盖机制。

追问

  • 默认配置从哪里来?答:django.conf.global_settings 提供框架默认值,项目模块覆盖同名项。
  • 两套 settings 能在同一进程共存吗?答:不能直接共存;需要不同进程或显式构造 Settings 实例。
  • 生产敏感配置怎么注入?答:从环境变量或密钥管理服务读取,settings 模块只做解析与默认值。

04.7.16.1-007 在 INSTALLED_APPS 里登记一个 app 后发生了什么?

一句话结论

登记后,app 的模型会被注册进 app registry,其 migrations 目录被迁移系统发现,模板标签、模板过滤器、静态资源目录、 fixtures 与系统检查项随之生效。未登记的 app 代码可以被 import,但框架子系统不会自动发现它的模型与配置。

概念解释

  • INSTALLED_APPS 项可以是 app 名,也可以直接指向 AppConfig 子类路径。
  • 注册顺序有实际意义:模板查找、静态文件收集、部分中间件与标签解析都按顺序进行。

原理流程

  1. django.setup() 遍历 INSTALLED_APPS,为每项构造或复用 AppConfig。
  2. 导入 app 的 models.py(或 models 包),把模型注册到对应 app 的 registry。
  3. 迁移命令、模板引擎、静态文件命令按已登记 app 清单扫描资源。

代码或图示

# settings.py
INSTALLED_APPS = [
    "django.contrib.admin",
    "django.contrib.auth",
    "accounts.apps.AccountsConfig",
    "orders",
]

常见误区

  • 新建模型后忘记登记 app,会出现 no such table 或迁移找不到模型的问题。
  • 两个 app 定义同名模型类不会自动冲突,但表名、模板路径、URL 命名空间需要人工隔离。
  • 把第三方 app 放在自定义 app 之后还是之前,会影响模板覆写与信号接收顺序,排查模板覆盖问题时要先看顺序。

追问

  • 登记 AppConfig 路径有什么好处?答:可定制 name、label、default_auto_field,并在 ready() 里挂信号。
  • 不登记 app 能迁移它的模型吗?答:不能,迁移系统只扫描已登记 app。
  • INSTALLED_APPS 顺序影响什么?答:模板查找、静态收集、信号接收顺序等按列表顺序处理。

04.7.16.1-008 AppConfig 类承担哪些职责?

一句话结论

AppConfig 描述一个 app 的元信息:name(Python 路径)、label(registry 内唯一标识)、verbose_name、path、default_auto_field;框架在注册时实例化它,并提供 ready() 钩子供 app 做启动期初始化。项目通过在 INSTALLED_APPS 写 apps.OrdersConfig 路径来启用自定义配置。

概念解释

  • label 默认取 app 目录名,两个同名 app 共存时必须显式指定不同 label。
  • default_auto_field 控制未显式声明主键字段时使用的自增主键类型(如 BigAutoField)。
  • models_module 指向实际模型模块,便于 app 包结构调整。

原理流程

  1. 框架按 INSTALLED_APPS 项解析出 app 模块或 AppConfig 子类。
  2. 构造实例并读取 name/label 等元数据,加入 registry。
  3. 所有 app 配置完成后,依次调用各 AppConfig.ready()。

代码或图示

# apps.py
from django.apps import AppConfig

class OrdersConfig(AppConfig):
    default_auto_field = "django.db.models.BigAutoField"
    name = "orders"
    verbose_name = "订单"

    def ready(self):
        import orders.signals  # noqa: F401

常见误区

  • AppConfig 子类不要在类属性里写业务逻辑;初始化动作放 ready()。
  • 一个 app 只能有一个生效的 AppConfig;INSTALLED_APPS 里写 app 名时框架会自动加载 apps.py 中的配置。
  • 修改 label 后要同步迁移历史与外键引用,否则已生成的表与模型注册对不上。

追问

  • default_auto_field 在哪里还能统一配置?答:也可在 settings 的 DEFAULT_AUTO_FIELD 全局设置。
  • verbose_name 用在哪里?答:admin、后台展示与部分管理命令的人类可读名称。
  • AppConfig 能决定 app 是否启用吗?答:不能运行时动态摘除;登记与否决定框架是否加载它。

04.7.16.1-009 AppConfig.ready() 在什么时机执行?适合做什么?

一句话结论

ready() 在 app registry 填充完成、所有模型都已导入之后被框架调用,属于进程启动期钩子。它适合注册信号接收器、配置应用级单例、订阅事件或做启动期自检;不适合在这里访问数据库、启动长驻线程或执行依赖请求上下文的逻辑,因为此时连接与上下文尚未为请求准备好。

概念解释

  • 调用时机晚于模型导入:在 ready() 里通过 self.get_model("X") 可以拿到已注册模型。
  • ready() 在每个进程启动时执行一次;开发服务器的 autoreload、多 worker 部署下每个进程各跑一次。
  • 常见写法是在 ready() 内 import 信号模块,避免信号接收器不生效。

原理流程

  1. django.setup() 注册全部 app 配置并导入模型模块。
  2. registry 标记填充完成后,按注册顺序调用各 AppConfig.ready()。
  3. ready() 内完成信号连接、常量装载等初始化;随后进程等待请求。

代码或图示

def ready(self):
    from django.db.models.signals import post_save
    from .signals import notify_on_order_created
    post_save.connect(notify_on_order_created, sender=self.get_model("Order"))

常见误区

  • 在 ready() 里跑 ORM 查询:多进程下重复执行,且迁移未完成时表可能不存在;启动期数据修正应放进数据迁移或管理命令。
  • 在 ready() 里启动后台线程/异步任务:worker 重启、进程回收时生命周期不可控,应交给 Celery/RQ 等独立调度器。
  • 忘记在 ready() 里导入信号模块,导致接收器从未注册,信号触发时静默无响应。

追问

  • ready() 里能安全 get_model 吗?答:可以,模型已在前置阶段导入完毕。
  • 多 worker 下 ready() 执行几次?答:每个 worker 进程一次,不要依赖它做全局唯一初始化。
  • 启动期需要做数据初始化放哪里?答:数据迁移、管理命令或部署脚本,而不是 ready()。

04.7.16.1-010 django.setup() 做了什么?为什么脚本里要调用?

一句话结论

django.setup() 负责初始化 app registry:导入 INSTALLED_APPS 的模型模块、填充模型注册表、运行框架内部就绪逻辑。在 manage.py、WSGI/ASGI 入口之外,独立 Python 脚本、定时任务、REPL 或测试运行器中使用 Django ORM 与配置前,必须先调用 django.setup(),否则模型未注册、配置未加载。

概念解释

  • setup() 幂等:重复调用不会重复注册;内部有 apps.ready 标记。
  • 调用前必须先设置 DJANGO_SETTINGS_MODULE,否则找不到配置模块。
  • setup() 不启动服务器,只完成框架内部初始化。

原理流程

  1. 脚本先设置 DJANGO_SETTINGS_MODULE 环境变量。
  2. 调用 django.setup(),框架加载 settings、注册 app 与模型。
  3. 之后才能导入模型、执行查询、使用 reverse 等框架能力。

代码或图示

import os, django
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "myproject.settings.dev")
django.setup()

from orders.models import Order
print(Order.objects.count())

常见误区

  • 把模型 import 放在 django.setup() 之前:模型类在 registry 未就绪时定义,容易出现关联解析异常。
  • 在已经由 manage.py 或服务器入口初始化过的环境里重复 setup():虽幂等,但排查启动顺序问题时应先确认入口是否已调用。
  • 脚本只设置环境变量却不调用 setup():settings 惰性加载尚可工作,但模型与信号不会完成注册,迁移/查询行为异常。

追问

  • Celery 任务里需要 django.setup() 吗?答:Worker 启动引导通常已初始化;自定义独立脚本则需要。
  • setup() 会运行迁移吗?答:不会,迁移由 migrate 命令单独执行。
  • 为什么 manage.py 里也要设置环境变量?答:入口脚本不假定 settings 模块名,需要显式指定路径。

04.7.16.1-011 settings 如何按环境拆分?为什么敏感值要走环境变量?

一句话结论

常见做法是把 settings 拆成基础模块与环境模块:base.py 放公共配置,dev.py/prod.py 继承 base 并覆盖环境相关项,通过 DJANGO_SETTINGS_MODULE 选择。密钥、数据库口令、外部服务地址等敏感值不写进代码库,从环境变量或密钥管理服务读取,避免随源码泄露。

概念解释

  • 继承方式:from .base import *,子类只覆盖需要改变的项。
  • DEBUG、ALLOWED_HOSTS、数据库配置、缓存后端、日志级别按环境区分。
  • 开发环境可放宽 ALLOWED_HOSTS 与静态文件服务,生产环境必须关闭 DEBUG。

原理流程

  1. base.py 定义全部公共配置与默认安全项。
  2. 环境模块继承 base,覆盖 DATABASES、DEBUG、缓存等差异项。
  3. 部署时通过环境变量选择模块,并注入密钥类配置。

代码或图示

# settings/prod.py
from .base import *
import os

DEBUG = False
ALLOWED_HOSTS = os.environ["ALLOWED_HOSTS"].split(",")
SECRET_KEY = os.environ["DJANGO_SECRET_KEY"]
DATABASES = {"default": {"ENGINE": "django.db.backends.postgresql", "NAME": os.environ["DB_NAME"]}}

常见误区

  • 把生产口令、Token 硬编码进 settings 并提交版本库:泄露后必须轮换密钥,代码历史难以清除。
  • 生产环境保留 DEBUG = True:会暴露堆栈、配置与敏感环境变量,是严重安全事故。
  • 多个环境模块互相覆盖顺序混乱:应保持 base 只放公共项,环境差异集中在子类,不要在 base 里读环境变量做分支判断。

追问

  • django-environ 解决什么问题?答:把环境变量按类型解析成 Python 值,简化密钥与连接串读取。
  • ALLOWED_HOSTS 生产为什么必须显式配置?答:防止 Host 头攻击,未匹配的主机头直接拒绝。
  • 测试用哪套 settings?答:可用独立 test 模块或在测试配置中覆盖数据库与缓存后端。

04.7.16.1-012 WSGIHandler 从 environ 到响应的完整链路是什么?

一句话结论

django.core.handlers.wsgi.WSGIHandler 是同步 WSGI 入口:服务器调用 __call__(environ, start_response),Handler 构造 HttpRequest、推入请求/应用上下文、加载并穿过中间件栈、解析 URLconf 分发到视图,拿到 HttpResponse 后经过中间件回程,最终写入 status 与 headers 并返回可迭代响应体。

概念解释

  • WSGIHandler 继承 BaseHandler,公共的中间件加载、URLconf 解析都在基类完成。
  • 请求上下文在 Handler 内推入栈,响应结束后弹出,保证线程隔离。
  • 同步视图在 WSGI worker 的线程内执行;阻塞 IO 会占用该 worker。

原理流程

  1. 服务器解析请求报文填入 environ,调用 Handler。
  2. WSGIRequest 从 environ 读取 method、path、GET/POST、META 等。
  3. BaseHandler.get_response 跑中间件 → 路由 → 视图,返回响应;Handler 把响应适配成 WSGI 返回格式。

代码或图示

# gunicorn 入口:myproject.wsgi.application
from django.core.wsgi import get_wsgi_application
application = get_wsgi_application()

常见误区

  • 认为 WSGI Handler 自己处理 HTTP 解析:协议解析由 gunicorn/uWSGI 等服务器完成,Handler 只消费 environ。
  • 在 Handler 之外长期持有 HttpRequest 对象:请求结束后上下文已弹出,对象上的缓存与会话状态不应跨请求复用。
  • 同步长查询拖垮 WSGI worker:阻塞期间线程不可用,需要靠多 worker/多线程扩容或改异步方案。

追问

  • get_wsgi_application() 返回什么?答:一个符合 WSGI 协议、可被服务器调用的 Handler 实例。
  • 请求上下文在哪里推入?答:BaseHandler 处理请求时推入,响应完成后弹出。
  • WSGI 下能跑异步视图吗?答:异步视图在 WSGI 入口会被桥接到线程池执行,失去并发收益。

04.7.16.1-013 ASGIHandler 与 WSGIHandler 在请求处理上有什么差异?

一句话结论

django.core.handlers.asgi.ASGIHandler 以 await app(scope, receive, send) 的异步协议处理连接:scope 描述请求与连接类型,receive/send 是消息通道。它原生支持异步视图、WebSocket 与生命周期事件;同步视图会被包裹到线程池执行。WSGIHandler 是一次性请求-响应同步模型,没有消息流概念。

概念解释

  • ASGI 把连接生命周期拆成 HTTP 连接、HTTP 请求、WebSocket 等事件消息,Handler 通过 receive 取消息、通过 send 回消息。
  • ASGIHandler 内部仍复用 BaseHandler 的中间件与路由装配,但响应发送是异步消息流。
  • 异步中间件需写成 async def __call__,与同步中间件由框架桥接适配。

原理流程

  1. ASGI 服务器(uvicorn/hypercorn)解析协议后把 scope/receive/send 交给 Handler。
  2. Handler 构造异步请求对象,穿过异步化的中间件栈并分发到视图。
  3. 视图返回响应后,Handler 依次 send 响应头与响应体消息;WebSocket 场景可持续收发。

代码或图示

# myproject/asgi.py
import os, django
from django.core.asgi import get_asgi_application
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "myproject.settings.prod")
application = get_asgi_application()

常见误区

  • 把 ASGI 理解成“自动变快”:异步只在 IO 等待密集场景提升并发;视图里调用阻塞同步库仍会卡住事件循环,需要走线程池。
  • 同步中间件与异步视图混用:框架可桥接,但每一次同步/异步切换都有开销,链路内应尽量统一。
  • 用 WSGI 服务器(gunicorn 同步 worker)跑 ASGI 应用:需要 gunicorn -k uvicorn.workers.UvicornWorker 等异步 worker。

追问

  • ASGI 的 scope 里有什么?答:协议类型、路径、方法、头、查询串、客户端/服务器地址、路由元信息等。
  • Django 异步视图能直接操作 ORM 吗?答:Django 4.2 起支持异步 ORM 查询;同步 ORM 调用会在线程池执行。
  • WebSocket 在 Django 里怎么落地?答:ASGI 入口 + Channels 等扩展,原生 Django 只覆盖 HTTP。

04.7.16.1-014 Django 5.x 的异步视图如何被调度?同步视图会退化到哪里?

一句话结论

ASGIHandler 检测视图是否为协程函数:异步视图直接在事件循环中 await;同步视图经 asgiref.sync.sync_to_async 包裹进入线程池执行,避免阻塞事件循环。Django 5.x 的 ORM 提供异步查询接口(aget/afilter/aiterator 等),但混用同步 ORM 于异步视图同样走线程池,且不应在同一请求内并发混用同步与异步连接。

概念解释

  • 判定依据是视图/方法是否为协程函数;类视图的 dispatch 若为 async def,则整条分发链路按异步处理。
  • 线程池大小由 asgiref 默认配置控制,阻塞调用堆积会反映为线程池等待。
  • 异步请求上下文同样基于 contextvars,协程之间隔离。

原理流程

  1. Handler 完成路由匹配,拿到视图可调用对象。
  2. 若是 async 视图,事件循环直接 await 调用;若是同步视图,sync_to_async 提交线程池。
  3. 视图返回响应后,异步链路把响应交回 Handler 发送。

代码或图示

# async view
async def order_detail(request, pk):
    order = await Order.objects.aget(pk=pk)
    return JsonResponse({"id": order.id})

# sync view:ASGI 下被包裹到线程池
def order_detail(request, pk):
    order = Order.objects.get(pk=pk)
    return JsonResponse({"id": order.id})

常见误区

  • 在异步视图里直接调用耗时同步库(同步 DB 驱动、requests):阻塞事件循环,应改用异步客户端或 sync_to_async 在线程池跑。
  • 异步视图里叠加 @sync_to_async 装饰同步 ORM:可行但失去异步收益;新代码优先用异步 ORM 接口。
  • 以为 ASGI 部署后所有视图自动并发:只有非阻塞的异步链路才能承载高并发连接,阻塞代码仍占用线程。

追问

  • 异步 ORM 方法名有规律吗?答:查询集提供 aget/afirst/acount/aiterator/aupdate 等 a 前缀接口。
  • 线程池打满怎么排查?答:看阻塞调用占比、线程等待指标,把重阻塞操作迁出事件循环。
  • 异步视图能用 Session 同步读写吗?答:同步 Session 访问会走桥接;异步链路优先使用异步兼容的存储后端(待确认:具体后端异步支持矩阵以 Django 5.x 文档为准)。

04.7.16.1-015 BaseHandler 在公共流程里组装了哪些部件?

一句话结论

BaseHandler 封装 WSGI/ASGI 共用的启动与请求逻辑:加载 MIDDLEWARE 装配中间件栈、按 ROOT_URLCONF 准备 URLconf、提供 load_middleware 与 get_response 分发骨架、管理上下文推入与异常转响应。WSGIHandler/ASGIHandler 只负责协议适配与请求/响应对象构造。

概念解释

  • 中间件在 Handler 初始化时加载一次,而不是每个请求重新实例化。
  • get_response 是内部分发函数:依次穿过中间件、解析路由、调用视图,异常在此被转成错误响应。
  • 框架内置的认证、会话、CSRF、消息等都以中间件形式挂在栈上。

原理流程

  1. Handler 初始化时读取 settings,构造中间件可调用对象链。
  2. 每个请求进入 get_response:推入上下文 → 跑中间件前半段 → 路由与视图 → 中间件回程。
  3. 未捕获异常交给处理器映射为 500/400 等响应,再沿回程返回。

代码或图示

BaseHandler
├── load_middleware()      # 按 MIDDLEWARE 列表装配洋葱栈
├── load_urlconf()         # 解析 ROOT_URLCONF
├── get_response(request)  # 上下文 + 中间件 + 路由 + 视图
└── _handle_legacy_exception / 错误响应转换

常见误区

  • 以为中间件每个请求新建实例:实例在初始化时创建,__call__ 内处理请求,实例状态应保持无请求相关数据。
  • 把协议相关逻辑写进 BaseHandler:协议差异属于 WSGI/ASGI 子类,公共部分只做框架内部分发。
  • 自定义 Handler 时绕过 get_response:会丢失上下文管理、异常转换与中间件回程,行为不一致。

追问

  • URLconf 何时加载?答:Handler 初始化或首次路由解析时按 ROOT_URLCONF 加载,开发模式下可随文件变更重新加载。
  • 中间件实例能保存状态吗?答:可以保存进程级配置,但不能保存单请求数据,并发下会串请求。
  • 异常在哪里被转成响应?答:get_response 内的异常处理环节,再经错误处理器映射状态码与模板。

04.7.16.1-016 应用上下文与请求上下文在 Handler 里何时推入、何时弹出?

一句话结论

Django 的 AppContext 绑定当前应用配置与 settings,RequestContext 相关的请求上下文绑定 request、session、user 等。Handler 在处理请求时把两者推入基于 LocalStack/contextvars 的上下文栈,视图与模板通过 django.http.request、django.conf 等代理访问;响应完成后按相反顺序弹出,确保线程/协程间隔离。

概念解释

  • 应用上下文在多 app 场景区分“当前配置”;请求上下文携带单次请求的数据。
  • 上下文代理(request、current_app 风格的全局引用)实际指向栈顶对象,不保存具体状态。
  • 异步环境下上下文基于 contextvars,协程切换不会串号。

原理流程

  1. Handler 处理请求前推入应用上下文与请求上下文。
  2. 中间件、视图、模板通过代理访问栈顶上下文对象。
  3. 响应返回或异常结束后弹出上下文,单次请求的数据随之销毁。

代码或图示

# 视图内访问代理对象,不直接持有全局单例
from django.http import HttpRequest

def view(request: HttpRequest):
    user = request.user          # 请求上下文栈顶
    session = request.session
    ...

常见误区

  • 在请求结束后保留 request 引用并继续访问:上下文已弹出,延迟任务里取不到会话与用户,应先取所需值再异步化。
  • 把请求级数据存进模块级全局变量:多线程/多协程并发下互相覆盖,应放 request 或上下文局部存储。
  • 在后台线程里直接访问请求代理:上下文不会自动跨线程传递,需要显式传递对象或复制上下文变量。

追问

  • 上下文栈与线程本地存储是什么关系?答:Django 早期基于线程本地,现代版本结合 contextvars,同步线程与异步协程都隔离。
  • request.user 是何时挂载的?答:认证中间件在中间件链中把用户对象挂到请求上。
  • 后台任务需要当前用户怎么办?答:在提交任务前把用户 ID 等值序列化传过去,不在任务里引用 request。

04.7.16.1-017 MIDDLEWARE 列表如何被装配成中间件栈?

一句话结论

Handler 初始化时遍历 settings.MIDDLEWARE:每项可以是中间件类或可调用工厂,框架依次实例化,把内层中间件作为 get_response 参数传入外层,最终形成“洋葱”可调用链。请求时从列表第一项进入,响应时按相反顺序回程;每个中间件的前半段在调用 self.get_response(request) 之前,后半段在其后。

概念解释

  • 列表第一项是最外层中间件,最先看到请求、最后看到响应。
  • 中间件工厂接收 get_response 并返回 __call__ 可调用对象;新式写法在 __init__ 保存 get_response。
  • 装配只做一次,运行期每个请求复用同一条链。

原理流程

  1. Handler 读取 MIDDLEWARE,从后往前包装:最后一项包裹视图入口。
  2. 每项用自己的 __call__ 包裹内层可调用对象,形成嵌套链。
  3. 请求进入最外层,逐层调用 get_response;响应沿嵌套栈退回最外层。

代码或图示

# settings.py
MIDDLEWARE = [
    "django.middleware.security.SecurityMiddleware",
    "django.contrib.sessions.middleware.SessionMiddleware",
    "django.middleware.common.CommonMiddleware",
    "django.middleware.csrf.CsrfViewMiddleware",
    "django.contrib.auth.middleware.AuthenticationMiddleware",
]

常见误区

  • 把中间件列表当成“平行过滤器”:实际是嵌套洋葱,外层短路后内层完全不执行。
  • 在 __call__ 里忘记调用 self.get_response(request):视图不会被执行,响应链断裂。
  • 中间件实例保存请求级状态:实例被所有请求共享,并发下状态串号。

追问

  • 中间件在哪一层实例化?答:Handler 初始化时装配一次,运行期复用。
  • 怎么看请求实际经过了哪些中间件?答:在各层加耗时日志,或用 debug toolbar 的请求跟踪视图。
  • 中间件链可以运行时动态增减吗?答:常规做法不行,需改 settings 后重启;动态逻辑应放在单个中间件内部判断。

04.7.16.1-018 中间件顺序为什么影响认证、会话、CSRF 的生效范围?

一句话结论

顺序决定“谁先看到请求”:Session 中间件必须在 Authentication 之前,因为认证要从会话取用户;CSRF 中间件保护的视图位于其内层;通用中间件(路径归一化、URL 前缀处理)应尽量靠前。顺序颠倒会出现用户未挂载、CSRF 未校验、会话不可用等问题,且问题表现为内层中间件拿到的请求缺少前置处理。

概念解释

  • 依赖方向:被依赖的中间件放外层(列表靠前),依赖它的放内层。
  • 认证中间件读取 session 与请求头,把 request.user 挂上去;会话不可用时认证无从谈起。
  • 响应阶段逆序:安全头、压缩等外层中间件最后补响应,顺序同样要配合。

原理流程

  1. 先排基础能力:安全、会话、通用处理。
  2. 再排安全校验:CSRF、认证。
  3. 最后是业务自定义中间件,确保能拿到完整的请求状态。

代码或图示

请求 → Security → Session → Common → CSRF → Authentication → 视图
响应 ← Security ← Session ← Common ← CSRF ← Authentication ← 视图

常见误区

  • 把 Authentication 放到 Session 之前:request.session 尚未初始化,用户加载失败。
  • 自定义日志/计时中间件放在最内层:它只能看到视图抛错后的结果,拿不到外层短路或认证失败的请求。
  • 认为 CSRF 中间件顺序无关:被它包裹的才是受保护视图,置于其后的视图绕过了 CSRF 校验。

追问

  • 会话中间件依赖什么存储?答:SESSION_ENGINE 配置的缓存/数据库/文件等后端。
  • 认证中间件如何识别用户?答:从 session、Authorization 头或其他认证后端解析用户并挂载。
  • 想对所有响应统一加安全头放哪层?答:最外层中间件,保证内层短路响应也能带上头。

04.7.16.1-019 旧式 process_request/process_view/process_response 与新式 __call__ 写法如何共存?

一句话结论

Django 同时支持两种中间件写法:旧式基于 MiddlewareMixin 提供 process_request、process_view、process_response、process_exception 钩子;新式写成 def __call__(self, request),在 get_response 前后包裹逻辑。框架在装配时把旧式钩子适配成新式可调用链,二者可以混排在 MIDDLEWARE 列表中。

概念解释

  • 旧式钩子按请求阶段分别触发:process_request 在路由前,process_view 在视图调用前,process_response 在响应回程。
  • 新式 __call__ 把前后两段写在同一个方法里,便于共享局部变量(如计时起点)。
  • MiddlewareMixin 提供默认空实现,子类按需覆写。

原理流程

  1. 装配阶段识别中间件类型,旧式钩子被包装成统一的 __call__ 形态。
  2. 请求阶段依次触发各层 process_request 与 process_view。
  3. 响应阶段依次触发 process_response;异常时触发 process_exception。

代码或图示

# 新式
class TimingMiddleware:
    def __init__(self, get_response):
        self.get_response = get_response
    def __call__(self, request):
        start = time.perf_counter()
        response = self.get_response(request)
        response["X-Cost"] = f"{time.perf_counter() - start:.3f}"
        return response

# 旧式(兼容写法)
from django.utils.deprecation import MiddlewareMixin
class OldMiddleware(MiddlewareMixin):
    def process_request(self, request):
        request.old_flag = True

常见误区

  • 新代码仍默认写旧式钩子:新式 __call__ 更直观,且能在前后段共享变量;旧式主要用于维护存量代码。
  • 旧式 process_view 返回非 None 会短路视图:与新式中间件提前返回响应效果相同,后续视图不再执行。
  • 在 process_exception 里返回响应:异常被吞掉,不再向上传播,其他错误处理器也看不到。

追问

  • process_view 能拿到匹配到的视图吗?答:能,参数包含视图函数、参数与关键字参数。
  • 两种写法性能有差异吗?答:适配层开销很小,主要差异在表达能力与共享局部变量。
  • 异步中间件用哪种写法?答:新式 async def __call__;旧式钩子不支持异步语义。

04.7.16.1-020 中间件里如何短路返回响应?对后续中间件有什么影响?

一句话结论

中间件在调用 self.get_response(request) 之前直接返回一个 HttpResponse,即构成短路:内层中间件与视图完全不执行,响应沿当前外层链回程。典型用途是认证失败、限流拒绝、维护页拦截。短路响应同样会经过更外层中间件的回程处理。

概念解释

  • 短路点决定保护范围:越靠外层短路,被跳过的内层越多。
  • 短路响应要设置正确状态码与响应头,避免被后续中间件误改。
  • 认证、限流类中间件常返回 401/403/429 响应。

原理流程

  1. 中间件前半段检查请求条件。
  2. 不满足时直接构造响应返回,不调用 get_response。
  3. 响应从当前层开始向外层回程,内层链路未被触发。

代码或图示

class BlockMiddleware:
    def __init__(self, get_response):
        self.get_response = get_response
    def __call__(self, request):
        if request.path.startswith("/internal/") and not request.user.is_staff:
            return HttpResponseForbidden("forbidden")
        return self.get_response(request)

常见误区

  • 短路后忘记记录日志/指标:被拦截请求在视图层不可见,必须在中间件内埋点。
  • 在短路响应里重复执行内层逻辑:既已拦截就不要调用 get_response,否则保护失效。
  • 把业务校验放进最外层中间件:业务规则应在视图/Service 层,中间件只做横切的通用拦截。

追问

  • 短路响应会经过 CSRF 校验吗?答:取决于短路层与 CSRF 层的相对位置,外层短路则内层 CSRF 不执行。
  • 怎么返回 JSON 短路响应?答:返回 JsonResponse 并设置对应状态码。
  • 短路后 process_view 还会触发吗?答:不会,视图分发根本没有发生。

04.7.16.1-021 异步中间件与同步中间件混用有什么限制?

一句话结论

Django 在 ASGI 下自动桥接:同步中间件被包进线程池,异步中间件直接在事件循环执行。混用本身可行,但每经过一次同步/异步边界都有调度开销;同步中间件内做阻塞操作会占住线程池,异步链路里调用阻塞库会卡住事件循环。复杂链路建议统一为异步或统一为同步,减少反复切换。

概念解释

  • 框架通过协程检测判断中间件是否为 async 可调用,决定走 await 还是线程池桥接。
  • 异步中间件内不能直接访问阻塞式同步资源;需要时用 sync_to_async 提交。
  • WSGI 部署下整条链路按同步执行,异步中间件/视图不具备原生并发环境。

原理流程

  1. ASGIHandler 装配链时标记每层是同步还是异步。
  2. 跨边界调用由框架桥接:同步层进线程池,异步层直接 await。
  3. 阻塞调用在错误的执行模型里成为瓶颈,需要按资源类型选择调用方式。

代码或图示

# 异步中间件
class AsyncLoggingMiddleware:
    def __init__(self, get_response):
        self.get_response = get_response
    async def __call__(self, request):
        await self.before(request)
        response = await self.get_response(request)
        await self.after(request, response)
        return response

常见误区

  • 在异步中间件里直接调用同步数据库查询:阻塞事件循环,应使用异步 ORM 或线程池包裹。
  • 以为桥接零成本:频繁切换会带来上下文切换与线程池排队,压测时要单独看中间件耗时。
  • 同步视图链中混入 async def 中间件却部署在 WSGI:异步语义无法生效,需 ASGI 服务器承载。

追问

  • 怎么判断一个中间件是同步还是异步?答:看 __call__ 是否为 async def,框架据此选择执行模型。
  • 线程池大小能配置吗?答:由 asgiref/Django 配置控制,阻塞场景需结合监控调整(待确认:具体配置项以 Django 5.x 文档为准)。
  • WebSocket 请求经过中间件吗?答:经过 ASGI 中间件层,但 HTTP 专用中间件(CSRF 等)按协议类型判断是否适用。

04.7.16.1-022 Django 如何从请求路径匹配到视图?resolve() 内部流程是什么?

一句话结论

django.urls.resolve(path, urlconf=None) 从根 URLconf 开始按顺序遍历模式:对每条 URLPattern 用对应匹配方式(转换器正则或 re_path 正则)校验路径,命中后把捕获参数存入,再沿 include 进入子 URLconf 继续匹配;全部命中后返回 ResolverMatch,记录视图、参数、命名空间与路由模板。未命中抛 Resolver404。

概念解释

  • 根 URLconf 由 ROOT_URLCONF 指定,也可在请求上临时覆盖 request.urlconf。
  • 匹配是顺序敏感的:靠前的模式先命中,模式重叠时要把更具体的放前面。
  • URLPattern 对应单个视图,URLResolver 对应 include 进来的子树。

原理流程

  1. 从根 URLconf 取出模式列表,逐条尝试匹配剩余路径段。
  2. 命中 include 时,把已匹配前缀剥离,携带命名空间进入子 URLconf。
  3. 最终匹配到视图可调用对象,组装 ResolverMatch;遍历完仍未命中则 404。

代码或图示

# urls.py
from django.urls import path, include
urlpatterns = [
    path("orders/", include("orders.urls")),
    path("articles/<int:pk>/", article_detail, name="article-detail"),
]

常见误区

  • 模式顺序颠倒导致宽泛规则拦截具体规则:如 "<str:slug>" 写在 "<int:pk>" 之前会先吞掉数字段。
  • 认为 include 会改变完整路径:只剥离已匹配前缀,子 URLconf 处理剩余部分。
  • 在 URLconf 里写复杂业务判断:路由只负责定位视图,参数校验与业务逻辑留在视图层。

追问

  • resolve() 在代码里有什么用途?答:测试、中间件判断当前视图、反查请求对应路由等。
  • 404 在哪一层产生?答:URLconf 遍历完未命中,Handler 转成 404 响应。
  • 如何临时切换 URLconf?答:设置 request.urlconf,视图处理期间使用指定配置。

04.7.16.1-023 ResolverMatch 对象包含哪些信息?

一句话结论

ResolverMatch 携带本次路由匹配的结果:func(视图可调用对象或类视图实例)、args(位置参数)、kwargs(关键字参数)、app_name 与 namespaces(命名空间链)、route(命中的路由模板字符串)、url_name 等。视图与中间件可通过 request.resolver_match 读取它做分支判断。

概念解释

  • func 对类视图是 as_view() 返回的闭包;可通过 func.cls 拿到视图类(待确认:Django 5.x 上该属性暴露形式以源码为准)。
  • namespaces 是嵌套 include 形成的命名空间栈,app_name 是当前子树应用名。
  • route 是匹配成功的模式字符串,便于日志与调试输出。

原理流程

  1. resolve() 命中最终模式后收集视图与捕获参数。
  2. 沿 include 层级累积命名空间信息。
  3. 构造 ResolverMatch 挂到请求对象上,供后续环节读取。

代码或图示

def debug_view(request):
    m = request.resolver_match
    print(m.route, m.kwargs, m.namespaces, m.url_name)
    return JsonResponse({"route": m.route})

常见误区

  • 在未经过路由分发的早期中间件里访问 resolver_match:此时尚未匹配,属性可能为 None。
  • 把 ResolverMatch 当请求参数集合:它只含路由捕获参数,GET/POST 参数仍在 request.GET/POST。
  • 依赖 func 的内部属性做框架级判断:跨版本可能变化,优先用 url_name/命名空间做稳定标识。

追问

  • app_name 和 namespace 有什么区别?答:app_name 是子 URLconf 声明的应用名;实例命名空间是 include(..., namespace=...) 给同一 app 的多个实例起的别名。
  • url_name 来自哪里?答:path(..., name="...") 声明的路由名。
  • 如何从 ResolverMatch 反查视图类?答:可通过视图闭包上的类引用,或按 url_name 在 URLconf 中定位。

04.7.16.1-024 path() 与 re_path() 的区别是什么?内置路径转换器有哪些?

一句话结论

path() 使用声明式转换器匹配路径段,语法直观、可读性好;re_path() 使用完整正则表达式匹配,适合转换器无法表达的复杂模式。内置转换器包括 str(默认,不含斜杠)、int、slug(字母数字连字符下划线)、uuid、path(含斜杠的整段剩余路径)。

概念解释

  • str 匹配除 / 外的任意非空字符串;path 转换器允许捕获跨斜杠的剩余路径。
  • 转换器把捕获字符串转成目标类型(如 int 转整数),视图拿到的已是类型化参数。
  • re_path 捕获组按位置或命名组映射到视图参数,类型不自动转换。

原理流程

  1. path() 为每个转换器生成对应正则片段并拼接完整模式。
  2. 命中后按转换器规则做类型转换,填入 kwargs。
  3. re_path() 直接用正则匹配,命名组成为关键字参数,位置组成为位置参数。

代码或图示

path("articles/<int:pk>/", detail, name="detail"),
path("files/<path:rel>/", serve, name="serve"),
re_path(r"^archive/(?P<year>[0-9]{4})/$", archive, name="archive"),

常见误区

  • 用 re_path 替代 path 处理简单参数:正则可读性差、类型需手动转换,能用转换器就优先转换器。
  • 正则未加锚点(^/$)导致部分匹配误命中;path() 模式由框架自动拼接边界。
  • str 转换器吞不下带斜杠的路径:需要跨目录匹配时改用 path 转换器。

追问

  • uuid 转换器匹配什么格式?答:标准 UUID 字符串(带连字符的十六进制形式)。
  • slug 允许中文吗?答:不允许,仅匹配 ASCII 字母、数字、-、_;中文标识需自定义转换器。
  • 正则捕获组怎么传给视图?答:命名组按关键字传,未命名组按位置顺序传。

04.7.16.1-025 自定义路径转换器怎么写?

一句话结论

继承 django.urls.converters.StringConverter(或直接实现转换器协议),定义 regex 属性(匹配正则片段)与 to_python/to_url 两个方法:to_python 把路径字符串转成视图参数类型,to_url 把反向生成时的值转回 URL 片段。转换器在 path() 中按 <转换器名:变量名> 引用,并通过 register_converter 注册。

概念解释

  • 转换器协议只有三个成员:regex、to_python、to_url;框架据此生成匹配正则与反查逻辑。
  • to_url 用于 reverse() 生成 URL,必须保证输出能被 regex 再次匹配。
  • 常见场景:复合编号、枚举标识、需要校验格式的业务 ID。

原理流程

  1. 定义转换器类并实现正则与双向转换方法。
  2. 在 URLconf 中 register_converter(Converter, "name")。
  3. path() 使用自定义转换器;匹配后 to_python 转换参数,反查时 to_url 生成片段。

代码或图示

from django.urls import register_converter, path

class OrderNoConverter:
    regex = r"ORD-[0-9]{6}"
    def to_python(self, value):
        return value
    def to_url(self, value):
        return value

register_converter(OrderNoConverter, "ordno")
urlpatterns = [path("orders/<ordno:no>/", order_detail, name="order-detail")]

常见误区

  • to_url 输出与 regex 不兼容:reverse() 生成的 URL 再次访问时匹配失败。
  • 在 to_python 里抛业务异常:路由阶段异常会变成 500,格式不匹配应返回不命中或在视图层处理。
  • 把复杂校验塞进转换器:转换器只做格式与类型转换,业务合法性判断留给视图/模型。

追问

  • 转换器和 re_path 怎么选?答:可复用、需要双向转换的模式用转换器;一次性复杂正则用 re_path。
  • to_python 能做类型转换吗?答:能,int 转换器就是把字符串转成整数。
  • 转换器注册在哪生效?答:在使用它的 URLconf 模块内注册,框架加载该 URLconf 时可见。

04.7.16.1-026 include() 如何拆分 URLconf?应用命名空间与实例命名空间有什么区别?

一句话结论

include("app.urls") 把前缀路径交给子 URLconf 继续匹配,实现按 app 拆分路由;include((module, app_name), namespace=...) 可同时声明应用命名空间与实例命名空间。应用命名空间(app_name)标识这是哪一类 app,实例命名空间(namespace)区分同一 app 的多个挂载实例;reverse 时用 namespace:app_name:url_name 定位。

概念解释

  • 子 URLconf 内可声明 app_name,与父级传入的实例命名空间配合。
  • 同一 app 挂载两次(如前台与后台各一套),靠不同实例命名空间区分反向解析目标。
  • 命名空间链沿 include 层级累积,支持多层嵌套。

原理流程

  1. 根 URLconf 用 path("orders/", include("orders.urls", namespace="orders")) 挂载子树。
  2. 匹配时剥离前缀,子 URLconf 处理剩余路径并记录命名空间。
  3. 反向解析按命名空间链 + 路由名找到对应模式并注入参数。

代码或图示

# 根 urls.py
path("store/", include(("shop.urls", "shop"), namespace="store")),
path("admin-shop/", include(("shop.urls", "shop"), namespace="admin-shop")),

# 反向解析
reverse("store:product-detail", args=[pk])
reverse("admin-shop:product-detail", args=[pk])

常见误区

  • 只写 app_name 不写实例命名空间,或反之:reverse 命名解析时报找不到命名空间,二者配合关系要按 Django 文档写法对齐。
  • 子 URLconf 路由名与其他 app 重名却不加命名空间:反查时命中错误模式。
  • 在 include 里重复传模块路径与元组导致配置冲突:按 include(module, namespace) 或 include((module, app_name), namespace) 的规范形式书写。

追问

  • 命名空间在模板 {% url %} 里怎么写?答:同样用 namespace:url_name,多层用冒号分隔。
  • 同一 app 多实例共享模型吗?答:共享代码与模型,路由与模板上下文按实例区分。
  • include 能挂视图函数列表吗?答:可传入模式列表或元组,不限于模块路径。

04.7.16.1-027 路由匹配失败、模式冲突、尾部斜杠与 APPEND_SLASH 如何处理?

一句话结论

遍历所有模式仍未命中时抛 Resolver404,Handler 渲染 404 页面;模式重叠时按列表顺序先命中为准,必须把更具体的模式前置。APPEND_SLASH=True(默认)时,无斜杠路径未命中且加斜杠后能命中,框架会返回 301/302 重定向到带斜杠版本;该重定向只对 GET/HEAD 等安全方法生效,POST 不会自动补斜杠。

概念解释

  • CommonMiddleware 负责斜杠补全与 URL 归一化行为。
  • 模式冲突常见于宽泛转换器(<str:slug>)覆盖具体数字编号路由。
  • 生产环境 APPEND_SLASH 行为要与前端路由约定一致,避免 POST 被重定向丢数据。

原理流程

  1. 路由匹配失败,进入 404 处理流程。
  2. 若开启 APPEND_SLASH,CommonMiddleware 尝试加斜杠重新解析。
  3. 加斜杠后命中则重定向;仍未命中则返回 404。

代码或图示

# settings.py
APPEND_SLASH = True

# urls.py:具体模式前置
urlpatterns = [
    path("articles/<int:pk>/", article_detail),
    path("articles/<str:slug>/", article_by_slug),
]

常见误区

  • 依赖斜杠重定向保护 POST 表单:POST 到无斜杠地址不会自动补斜杠,请求数据会丢失或 404。
  • 把宽泛路由放前面:后续具体规则永远命中不到,表现为参数类型异常或对象不存在。
  • 关闭 APPEND_SLASH 后遗留无斜杠链接:旧书签与硬编码地址出现 404,需要前端与链接生成统一。

追问

  • 404 页面如何自定义?答:配置 handler404 视图,或在模板层提供 404 模板。
  • 重定向状态码是 301 还是 302?答:斜杠补全使用永久重定向语义(具体状态码以 Django 5.x 行为为准,待确认:验证点为 CommonMiddleware 源码)。
  • request.path_info 和 request.path 区别?答:前者是解码后的路径信息,后者为原始路径字符串。

04.7.16.1-028 函数视图与类视图各自的适用场景是什么?

一句话结论

函数视图写法直接、控制流清晰,适合逻辑独立、定制化强的用例;类视图把通用 CRUD 抽象为可继承的基类(View、TemplateView、ListView 等),通过类属性与钩子方法定制,适合结构规整的列表/详情/增删改页面。两者都能挂装饰器,可按用例复杂度选择,不要求项目内统一。

概念解释

  • 函数视图是接收 request 返回响应的纯函数;类视图经 as_view() 包装成等价闭包。
  • 类视图的复用靠继承与 mixin:覆写 get_queryset、get_context_data 等钩子即可改行为。
  • 复杂编排跨模型、事务与外部调用时,函数视图 + Service 通常比堆叠通用视图更清晰。

原理流程

  1. 简单接口用函数视图:解析请求 → 调用业务 → 返回响应。
  2. 规整页面继承通用类视图:配置模型/模板/分页,覆写必要钩子。
  3. 类视图通过 as_view() 暴露为 URLconf 可调用对象。

代码或图示

# 函数视图
def health(request):
    return JsonResponse({"ok": True})

# 类视图
from django.views.generic import ListView
from orders.models import Order

class OrderListView(ListView):
    model = Order
    paginate_by = 20

常见误区

  • 为了“面向对象”把简单函数视图改成多层继承类视图:钩子链条长、调试跳转多,反而降低可读性。
  • 在类视图里覆写 dispatch 塞入大量业务逻辑:破坏了通用视图的分层,应下沉到 Service。
  • 认为类视图不能用装饰器:可以用 method_decorator 或在 as_view 上包裹。

追问

  • 类视图实例每次请求新建吗?答:as_view() 内部每次请求实例化视图类,实例状态不跨请求共享。
  • 函数视图能复用通用逻辑吗?答:能,通过装饰器、mixin 对应的辅助函数或 Service 复用。
  • 异步场景用哪种?答:两者都支持 async def,类视图覆写异步钩子时整条链路按异步处理。

04.7.16.1-029 View.as_view() 返回的是什么?闭包如何绑定实例?

一句话结论

as_view() 是类方法,返回一个名为 view 的闭包函数;URLconf 调用该闭包时,闭包内部实例化视图类、把请求与参数存到实例上,再调用实例的 dispatch(request, *args, **kwargs)。闭包还保留视图类引用,便于反射获取类与属性。每个请求独立实例化,类属性作为默认配置共享,实例属性不跨请求。

概念解释

  • as_view() 在类定义期只生成闭包,不在此时创建实例。
  • 闭包内 self = cls(**initkwargs),initkwargs 来自 as_view(**initkwargs) 传入的类属性覆盖。
  • 返回的 view 可挂载装饰器、设置 csrf_exempt 等属性。

原理流程

  1. 调用 View.as_view() 定义闭包,捕获视图类与初始化参数。
  2. 请求到达闭包:实例化视图,挂载请求与路由参数。
  3. 调用 self.dispatch(...) 进入 HTTP 方法分发流程。

代码或图示

class MyView(View):
    greeting = "hello"

    def get(self, request):
        return HttpResponse(self.greeting)

# URLconf 中
path("greet/", MyView.as_view(greeting="hi"), name="greet")

常见误区

  • 在类属性里放可变对象并在方法中修改:类属性被所有实例共享,多请求下互相污染;请求级状态放局部变量。
  • 以为 as_view() 执行时就把视图实例化:实例化发生在每次请求的闭包内部。
  • 在闭包返回后修改视图类属性:后续请求受影响,但运行期改配置不属于常规做法。

追问

  • initkwargs 怎么传?答:as_view(attr=value) 传入,实例化时作为类属性初始化。
  • 闭包上能读视图类吗?答:view.cls 指向视图类(待确认:Django 5.x 属性名以源码为准)。
  • 两个 URL 用同一个类视图会共享实例吗?答:不共享,各自请求都新建实例。

04.7.16.1-030 dispatch() 如何按 HTTP 方法分发?http_method_not_allowed 何时触发?

一句话结论

View.dispatch 先执行前置钩子(如 http_method_not_allowed 判断),再按 request.method.lower() 查找实例上对应的 get/post/put/patch/delete 方法;找到则调用,找不到则返回 http_method_not_allowed,状态码 405,并在 Allow 头列出允许的方法。options 由基类默认实现返回允许方法列表。

概念解释

  • 方法映射通过 http_method_names 白名单控制;不在白名单内的方法视为不允许。
  • dispatch 是子类插入横切逻辑(鉴权、计时、参数预处理)的主要钩子。
  • 异步视图覆写 async def dispatch,对应的 get/post 也应是协程。

原理流程

  1. 请求进入 dispatch,规范化 method 名称。
  2. 在白名单内查找同名处理方法;存在则调用并返回响应。
  3. 不存在则调用 http_method_not_allowed,生成 405 响应与 Allow 头。

代码或图示

class ProfileView(View):
    def get(self, request):
        return JsonResponse({"name": request.user.username})
    def post(self, request):
        return HttpResponse(status=405)

# 框架内部等价逻辑
def dispatch(self, request, *args, **kwargs):
    handler = getattr(self, request.method.lower(), self.http_method_not_allowed)
    return handler(request, *args, **kwargs)

常见误区

  • 只实现 get 却允许前端 POST:会得到 405,需明确实现 post 或在前端限制方法。
  • 覆写 dispatch 后忘记 super().dispatch(...):方法分发被跳过,视图逻辑不执行。
  • 在 dispatch 里捕获所有异常吞掉:错误处理与 405/500 语义被破坏,应只做横切包装。

追问

  • 405 响应的 Allow 头怎么生成?答:基类从已实现的处理方法集合中提取允许方法。
  • HEAD 请求如何处理?答:基类默认按 get 处理并去掉响应体。
  • 如何限制只允许特定方法?答:实现对应方法,或覆写 http_method_names 白名单。

04.7.16.1-031 类视图的 get_context_data/get_object 等钩子如何被调用?

一句话结论

通用视图在标准流程中按顺序调用一系列可覆写钩子:get_queryset 取列表查询集,get_object 按参数取单条对象,get_context_data 组装上下文,get_template_names 决定模板。钩子之间通过 super() 串联,子类在调用父类后追加或覆盖上下文,这是定制通用视图的主要入口。

概念解释

  • get_object 默认按 pk/slug 在 get_queryset() 内过滤,找不到抛 404。
  • get_context_data 先调用父类实现拿到基础上下文,再合并子类新增项。
  • 钩子命名与 HTTP 方法解耦:get/post 流程都会复用这些数据准备步骤。

原理流程

  1. 视图方法(如 get)调用 get_object 或 get_queryset 准备数据。
  2. 数据传入 get_context_data 组装上下文字典。
  3. 上下文交给模板响应渲染;子类覆写钩子时先 super() 再补充。

代码或图示

class ArticleDetail(DetailView):
    model = Article

    def get_object(self, queryset=None):
        obj = super().get_object(queryset)
        if not obj.is_visible_to(self.request.user):
            raise Http404("不可见")
        return obj

    def get_context_data(self, **kwargs):
        ctx = super().get_context_data(**kwargs)
        ctx["related"] = Article.objects.related_to(self.object)
        return ctx

常见误区

  • 覆写 get_context_data 忘记调用 super():父类注入的 object/object_list 等上下文丢失,模板渲染报错。
  • 在 get_object 里直接查库绕过 get_queryset:权限与过滤规则不一致,应基于父类查询集补充条件。
  • 钩子方法签名与父类不一致:路由调用时参数不匹配,运行期报错。

追问

  • get_queryset 和 model 属性关系?答:未覆写时基类按 model 生成默认查询集;覆写后以自定义查询集为准。
  • 上下文对象名如何确定?答:context_object_name 未设置时按模型名生成(详情为 object,列表为 object_list)。
  • 钩子里能访问 self.request 吗?答:能,请求在 dispatch 阶段已挂载到实例。

04.7.16.1-032 装饰器如何作用于类视图?

一句话结论

类视图不能直接套函数装饰器在类定义上,需用 method_decorator 把装饰器转换为方法装饰器,作用于 dispatch 或具体 HTTP 方法;也可在 as_view() 返回的闭包上包裹。常用装饰器如 @login_required、@permission_required、@csrf_exempt 都通过 method_decorator 应用。

概念解释

  • method_decorator(decorator, name="dispatch") 把装饰器挂到指定方法;挂 dispatch 覆盖所有 HTTP 方法。
  • 装饰器接收 request 参数的函数式签名要与视图方法兼容。
  • 多个装饰器按书写顺序叠加,靠近方法的先执行内层逻辑。

原理流程

  1. 导入 method_decorator 与目标装饰器。
  2. 在类上用 @method_decorator(..., name="dispatch") 标记,或覆写方法时直接装饰。
  3. as_view() 生成闭包时,被装饰方法按包装后的版本参与分发。

代码或图示

from django.contrib.auth.decorators import login_required
from django.utils.decorators import method_decorator

@method_decorator(login_required, name="dispatch")
class ProfileView(TemplateView):
    template_name = "profile.html"

# 或作用于单个方法
class EditableView(View):
    @method_decorator(login_required)
    def post(self, request):
        ...

常见误区

  • 把 @login_required 直接放在类定义上方:装饰器签名不匹配类,不会按预期工作。
  • 只装饰 get 忘记 post:未受保护的写操作仍可匿名访问,写接口也要加鉴权装饰器。
  • 装饰器顺序混乱导致权限判断在认证之前:先认证后授权,装饰器层级要按依赖排列。

追问

  • csrf_exempt 能用于类视图吗?答:能,用 method_decorator(csrf_exempt, name="dispatch")。
  • mixin 里能统一加装饰器吗?答:可在 mixin 的 dispatch 上装饰,被继承类自动获得。
  • 装饰器能在 as_view() 外层包吗?答:能,path("x/", login_required(MyView.as_view())) 形式同样有效。

04.7.16.1-033 类视图继承链上方法重写时如何调用父类?

一句话结论

子类覆写钩子方法时,先通过 super().方法名(...) 执行父类标准流程,再在返回值基础上补充或调整;上下文类钩子要把父类返回的字典作为基础合并。继承链上每个 mixin/基类的钩子按 MRO 顺序执行,漏调 super() 会跳过父类的数据准备与上下文注入。

概念解释

  • Python MRO 决定多继承方法解析顺序;Django 通用视图与 mixin 按此协作。
  • super() 返回代理对象,调用链沿 MRO 向上传递,最终到达基类实现。
  • 重写 get/post 等入口方法时,通常不需要 super()(基类默认实现为空或分发逻辑在 dispatch),但数据钩子必须调父类。

原理流程

  1. 子类方法接收请求与参数。
  2. 需要父类数据时调用 super() 对应钩子,拿到基础结果。
  3. 在结果上追加过滤、上下文或校验后返回。

代码或图示

class PublishedArticleListView(ListView):
    model = Article

    def get_queryset(self):
        qs = super().get_queryset()
        return qs.filter(status="published").select_related("author")

    def get_context_data(self, **kwargs):
        ctx = super().get_context_data(**kwargs)
        ctx["today"] = timezone.localdate()
        return ctx

常见误区

  • 覆写 get_context_data 直接返回新字典:父类注入的 object_list、分页上下文全部丢失。
  • 多 mixin 继承顺序不当:super() 沿错误 MRO 调用到非预期实现,应把功能 mixin 放在基类之前。
  • 在子类钩子里重复实现父类已完成的过滤:行为分叉后两处规则不一致,优先在父类查询集上追加条件。

追问

  • 怎么查看类的 MRO?答:cls.__mro__ 或 inspect.getmro(cls)。
  • 父类钩子返回 QuerySet 还是列表?答:通用视图默认返回 QuerySet,覆写时保持类型一致便于分页与过滤复用。
  • 子类需要完全替换父类逻辑怎么办?答:可以不调 super(),但要自行补齐上下文与数据准备,通常不推荐。

04.7.16.1-034 TemplateView 的数据流是什么?

一句话结论

TemplateView 是最基础的通用视图:从 template_name(或 get_template_names)确定模板,get_context_data 组装上下文,render_to_response 用 RequestContext 渲染模板并返回 TemplateResponse。它不绑定模型,适合纯展示页面、静态信息页与自定义上下文的组合页。

概念解释

  • TemplateResponse 延迟渲染:响应对象先持有模板与上下文,响应阶段才真正渲染。
  • 上下文处理器在 RequestContext 构造时执行,注入 user、messages、csrf_token 等通用变量。
  • get 方法调用 render_to_response(context),post 默认走 http_method_not_allowed。

原理流程

  1. 请求进入 TemplateView.get,调用 get_context_data。
  2. 读取 template_name/get_template_names 定位模板。
  3. 构造 TemplateResponse,渲染后沿中间件链返回。

代码或图示

from django.views.generic import TemplateView

class AboutView(TemplateView):
    template_name = "about.html"

    def get_context_data(self, **kwargs):
        ctx = super().get_context_data(**kwargs)
        ctx["site_name"] = "Ann-Interview"
        return ctx

常见误区

  • 在 template_name 里写死环境相关路径:模板查找应按 app 模板目录约定组织。
  • 以为 TemplateView 自带模型查询:没有默认查询集,数据需在上下文钩子里自行准备。
  • 把复杂业务判断写进模板:页面组装逻辑放 get_context_data,模板只做展示。

追问

  • TemplateResponse 何时渲染?答:响应返回阶段才渲染,中间件可在渲染前修改上下文或模板。
  • 不传 template_name 会怎样?答:基类抛模板缺失错误,必须显式指定或覆写 get_template_names。
  • TemplateView 能处理 POST 吗?答:默认不能,需覆写 post 方法。

04.7.16.1-035 ListView 如何取 queryset/model/paginate_by?

一句话结论

ListView 的数据来源优先级是:get_queryset() 返回值 > 类属性 queryset > 由 model 生成的默认管理器查询集;分页通过 paginate_by(每页条数)、paginate_orphans(尾页孤儿条数)与 page_kwarg(页码参数名)配置。分页上下文包含 page_obj、paginator、object_list 与是否分页标记。

概念解释

  • 覆写 get_queryset 是定制列表过滤、排序、预取的标准入口。
  • queryset 类属性若直接写查询集表达式,会被所有实例共享;需要按请求变化时用方法覆写。
  • 分页对象来自 Paginator,页码从查询参数读取,非法页码由分页器处理为空页或 404。

原理流程

  1. get_queryset 解析出基础 QuerySet。
  2. paginate_by 存在时用 Paginator 按当前页码切片。
  3. 上下文注入分页器、当前页与对象列表,交给模板渲染。

代码或图示

class OrderListView(ListView):
    model = Order
    paginate_by = 20
    paginate_orphans = 5
    ordering = "-created_at"

    def get_queryset(self):
        return super().get_queryset().filter(user=self.request.user)

常见误区

  • 把过滤条件写在 queryset 属性里却引用 self.request:类属性定义期无请求对象,应在 get_queryset 中读取。
  • 大表深分页仍用默认 Paginator:OFFSET 随页码变深而变慢,需考虑键集分页。
  • 列表视图忘记预取关联:模板遍历外键触发 N+1,应在 get_queryset 中 select_related/prefetch_related。

追问

  • context_object_name 未设置时列表变量叫什么?答:object_list,也可按模型名生成小写复数形式。
  • 每页条数能从请求参数动态取吗?答:可覆写 get_paginate_by 按请求解析,但要限制上下界。
  • 分页器对空查询集如何表现?答:返回空页对象,模板按 object_list 为空渲染。

04.7.16.1-036 DetailView 如何按 pk/slug 取对象?get_object 内部逻辑是什么?

一句话结论

DetailView.get_object 在 get_queryset() 结果内按 URL 参数过滤:优先用 pk_url_kwarg(默认 pk)匹配主键,否则用 slug_field 与 slug_url_kwarg 匹配 slug;找到对象返回,找不到抛 Http404。对象挂到 self.object,上下文默认以 object 与模型名注入。

概念解释

  • 过滤范围必须来自 get_queryset,这样权限、软删除、可见性过滤才会作用于详情页。
  • slug_field 默认与 URL 关键字同名(slug),字段名不同需显式配置。
  • 联合唯一标识(多字段定位)可覆写 get_object 自行组装条件。

原理流程

  1. 读取 URLconf 捕获的 pk 或 slug 参数。
  2. 在基础查询集上构造过滤条件,执行单条查询。
  3. 命中则挂到 self.object;未命中抛 404,由错误处理器渲染。

代码或图示

class ArticleDetail(DetailView):
    model = Article
    slug_field = "slug"
    slug_url_kwarg = "slug"

    def get_queryset(self):
        return super().get_queryset().filter(status="published")

常见误区

  • 直接用 Article.objects.get(pk=...) 绕过 get_queryset:软删除/权限过滤失效,已删除对象仍可访问。
  • slug 字段含中文或特殊字符却未配置转换器/编码:URL 匹配与反查对不上。
  • 详情视图不做可见性判断:应在查询集过滤或 get_object 中校验当前用户权限。

追问

  • 404 与 403 怎么区分?答:对象不存在抛 404;存在但无权访问应在视图层返回 403,不要用 404 掩盖越权(公开场景可统一 404)。
  • pk 能换成其他参数名吗?答:配置 pk_url_kwarg 指向自定义 URL 关键字。
  • 详情页需要预取关联怎么做?答:在 get_queryset 中预取,避免模板再触发 N+1。

04.7.16.1-037 CreateView/UpdateView/DeleteView 的表单与成功跳转机制是什么?

一句话结论

三个编辑视图都基于表单流程:CreateView/UpdateView 用 ModelForm(由 fields/form_class 生成)校验并保存对象,DeleteView 用确认页表单执行删除;提交成功后按 get_success_url() 跳转,默认从模型的 get_absolute_url() 取地址。表单无效时重新渲染表单页并携带错误信息。

概念解释

  • UpdateView 通过 URL 参数加载现有对象,CreateView 新建空实例;二者共享 form_valid/form_invalid 钩子。
  • success_url 类属性或 get_success_url 决定跳转目标;删除视图通常要求 POST 确认。
  • 模型 get_absolute_url() 是反向生成详情页地址的约定方法。

原理流程

  1. GET 请求构造空表单或绑定现有对象的表单并渲染。
  2. POST 请求校验表单:有效则保存对象,调用 success_url 跳转;无效则重渲染表单。
  3. 删除视图 GET 展示确认页,POST 执行删除后跳转。

代码或图示

class ArticleUpdate(UpdateView):
    model = Article
    fields = ["title", "body"]
    success_url = "/articles/"

    def form_valid(self, form):
        form.instance.author = self.request.user
        return super().form_valid(form)

常见误区

  • 未在 form_valid 里绑定当前用户:外键作者为空或被表单字段暴露,存在越权改他人内容风险。
  • 直接配置 success_url 硬编码路径:应优先 reverse_lazy 或模型 get_absolute_url,避免路由改名后失效。
  • 删除视图未做权限校验:任何人 POST 即可删除,需配合权限 mixin 或对象级判断。

追问

  • 为什么跳转地址常用 reverse_lazy?答:类属性求值早于 URLconf 加载,reverse_lazy 延迟解析,避免导入期反查失败。
  • 表单字段能按用户裁剪吗?答:覆写 get_form/get_form_class,或在 form_valid 中限制可写字段。
  • DeleteView 的确认模板叫什么?答:默认 <app>/<model>_confirm_delete.html。

04.7.16.1-038 通用视图如何限制访问(LoginRequiredMixin、权限 mixin)?

一句话结论

通过 mixin 在 dispatch 层加鉴权:LoginRequiredMixin 要求登录,未登录重定向到登录页;PermissionRequiredMixin 校验指定模型权限;对象级权限需在 get_object/dispatch 中自行判断。mixin 应放在通用视图基类之前,保证鉴权先于数据准备执行。

概念解释

  • mixin 本质是在 dispatch 前后插入检查逻辑,未通过则返回重定向或 403。
  • 权限字符串格式为 app_label.codename,可配置 raise_exception 直接抛 403 而非跳登录页。
  • 对象级权限(只能改自己的文章)无法靠模型级权限 mixin 覆盖,需要在取对象后校验归属。

原理流程

  1. 类定义时把鉴权 mixin 放在继承链前部。
  2. 请求进入 dispatch,mixin 先检查登录态/权限。
  3. 检查通过才调用父类 dispatch 进入数据准备与视图方法。

代码或图示

from django.contrib.auth.mixins import LoginRequiredMixin, PermissionRequiredMixin

class ArticleEdit(LoginRequiredMixin, PermissionRequiredMixin, UpdateView):
    model = Article
    fields = ["title", "body"]
    permission_required = "articles.change_article"

    def get_object(self):
        obj = super().get_object()
        if obj.author != self.request.user:
            raise PermissionDenied
        return obj

常见误区

  • 只加 LoginRequiredMixin 不校验对象归属:登录用户可遍历 ID 修改他人内容。
  • mixin 继承顺序写反:数据准备先于鉴权执行,既浪费查询又可能泄露对象信息。
  • 权限字符串写错 app_label 或 codename:校验永远不通过或错误放行,需对照 auth_permission 表核对。

追问

  • 未登录访问返回什么?答:默认重定向 LOGIN_URL;配置 raise_exception=True 抛 403。
  • 对象级权限有现成 mixin 吗?答:Django 内置不直接提供,常用 UserPassesTestMixin 写测试函数判断归属。
  • API 接口也用这些 mixin 吗?答:DRF 有自己的权限类体系,混用 Django 视图 mixin 仅限 Django 视图。

04.7.16.1-039 通用视图的上下文变量名是怎么定的?context_object_name 起什么作用?

一句话结论

未显式配置时,详情视图注入 object 与模型小写名(如 article),列表视图注入 object_list 与模型小写复数名;context_object_name 可覆盖这个变量名,模板按约定引用。多个视图共用模板或上下文名容易冲突时,显式命名最稳妥。

概念解释

  • 变量名由 get_context_object_name 生成,基于模型 meta.model_name。
  • 列表视图与详情视图的默认名不同,迁移模板时要对照上下文实际注入项。
  • extra_context 或 get_context_data 追加的变量与对象列表变量并存。

原理流程

  1. 基类根据模型元数据推导默认上下文名。
  2. 若设置 context_object_name,覆盖推导结果。
  3. 上下文字典随模板响应渲染,模板按变量名取值。

代码或图示

class MyOrders(ListView):
    model = Order
    context_object_name = "order_list"

# 模板
{% for order in order_list %}{{ order.no }}{% endfor %}

常见误区

  • 模板写 article 而视图默认注入 object:变量取不到,页面渲染为空且不易察觉。
  • 两个嵌套列表用相同默认名:内层覆盖外层上下文,应分别设置 context_object_name。
  • 依赖模型名复数规则(如特殊复数形式):规则不符合预期时显式命名更可靠。

追问

  • object 变量在列表视图里存在吗?答:不存在,列表用 object_list。
  • 如何一次性给多个变量起名?答:在 get_context_data 字典中显式设置键名。
  • context_object_name 影响 get_absolute_url 吗?答:不影响,它只控制模板上下文键名。

04.7.16.1-040 HttpRequest 上常用的属性与方法有哪些?

一句话结论

HttpRequest 携带单次请求的全部输入:method、path/path_info、GET/POST(QueryDict)、body(原始字节)、META(HTTP 头与环境信息)、user、session、COOKIES、FILES、headers;常用方法包括 get_full_path()、build_absolute_uri()、is_ajax()(旧版,待确认:Django 5.x 状态)、accepts() 等。请求对象在视图与中间件间传递,不跨请求保存。

概念解释

  • GET/POST 是 QueryDict,支持多值取列表(getlist);body 是未经表单解析的原始字节体。
  • META 中 HTTP 头以 HTTP_ 前缀大写形式存放;headers 属性提供更友好的大小写不敏感访问。
  • user 由认证中间件挂载,未认证时为匿名用户实例。

原理流程

  1. Handler 从 WSGI/ASGI 环境构造请求对象,填充路径、方法与参数。
  2. 中间件依次挂载用户、会话、消息等属性。
  3. 视图通过属性读取输入,构造响应;请求结束后对象不再复用。

代码或图示

def view(request):
    q = request.GET.get("q")
    raw = request.body
    host = request.headers.get("Host")
    full = request.build_absolute_uri()
    if request.method == "POST":
        data = request.POST.get("field")

常见误区

  • 用 request.POST 读 JSON 请求体:JSON 不在表单解析结果里,应读 request.body 后 json.loads。
  • 直接索引 request.GET["q"] 触发 MultiValueDictKeyError:用 get() 并处理缺失。
  • 把请求对象存进缓存或模块级变量:并发下串请求,且上下文结束后属性不可靠。

追问

  • QueryDict.getlist 解决什么问题?答:同名多值参数返回完整列表,get 只取最后一个。
  • request.META 里怎么取自定义头?答:如 X-Trace-Id 对应 HTTP_X_TRACE_ID,优先用 request.headers。
  • 文件上传在哪个属性?答:request.FILES,配合表单 FileField 处理。

04.7.16.1-041 HttpResponse 与重定向、JSON 响应类是什么关系?

一句话结论

HttpResponse 是所有响应的基类:持有状态码、响应头、Content-Type 与可迭代响应体;HttpResponseRedirect/HttpResponsePermanentRedirect 设置 Location 头与 302/301 状态码;JsonResponse 继承 HttpResponse,把字典/列表序列化为 JSON 并设置 application/json 头。流式与文件响应另有独立基类,不继承 HttpResponse 的内存缓冲模型。

概念解释

  • 构造 HttpResponse(content) 时内容可为字节、字符串或迭代器;字符串按编码写入。
  • 重定向类只负责 Location 与状态码,不写入响应体。
  • 响应类可在视图中实例化后追加头、Cookie,再返回给 Handler。

原理流程

  1. 视图选择响应基类,传入内容或目标地址。
  2. 响应对象设置默认状态码与内容类型,视图可覆盖。
  3. Handler 把响应沿中间件链回程,由服务器写出状态、头与体。

代码或图示

from django.http import HttpResponse, HttpResponseRedirect, JsonResponse

HttpResponse("ok", status=200)
HttpResponseRedirect("/login/")
JsonResponse({"id": 1, "name": "ann"})

常见误区

  • 重定向地址用 reverse 生成却写成硬编码路径:路由改名后链接失效,应优先反查。
  • 把字符串直接当 JSON 返回:未设 Content-Type: application/json,前端按文本解析。
  • 响应体传生成器给普通 HttpResponse:基类按缓冲模型处理,大内容应改用流式响应类。

追问

  • 301 和 302 怎么选?答:资源永久移动用 301,临时跳转/表单后跳转用 302;浏览器会缓存 301。
  • render() 返回的是什么响应?答:TemplateResponse,继承 SimpleTemplateResponse,最终也是可写回的响应对象。
  • 响应编码在哪里设置?答:HttpResponse 默认按 DEFAULT_CHARSET(UTF-8)编码,可在构造时覆盖。

04.7.16.1-042 JsonResponse 的 safe 参数与序列化边界是什么?

一句话结论

JsonResponse(data, safe=True) 默认只接受字典(dict),传列表等顶层非字典对象需显式 safe=False;序列化走 json.dumps,默认 json.dumps 无法序列化的类型(日期、Decimal、模型实例、UUID 等)会抛 TypeError,需先转成原生类型或提供 encoder。JsonResponse 自动设置 Content-Type: application/json; charset=utf-8。

概念解释

  • safe=True 是历史安全约定:防止顶层 JSON 数组在旧浏览器/某些解析场景下被误用;现代前端可安全关闭。
  • encoder 可传入自定义 JSONEncoder 子类处理日期、Decimal 等类型。
  • 响应构造时即完成序列化,大对象在内存中生成完整 JSON 字符串。

原理流程

  1. 校验顶层类型与 safe 设置。
  2. 用 json.dumps(含 encoder)把数据序列化为字符串。
  3. 写入响应体并设置 JSON 内容类型与编码头。

代码或图示

from django.http import JsonResponse
from django.core.serializers.json import DjangoJSONEncoder

JsonResponse({"count": 1, "tags": ["a", "b"]})
JsonResponse([1, 2, 3], safe=False)
JsonResponse({"created": timezone.now()}, encoder=DjangoJSONEncoder)

常见误区

  • 直接把 QuerySet 或模型实例塞进 JsonResponse:不可序列化,应先 values()/values_list() 或手工组装字典。
  • 关闭 safe 后仍传嵌套不可序列化对象:顶层校验通过,内层类型错误照样抛异常。
  • 依赖默认编码器处理 Decimal/UUID:需 DjangoJSONEncoder 或提前转换,否则序列化失败。

追问

  • DjangoJSONEncoder 能处理哪些类型?答:日期时间、Decimal、UUID、迭代器等 Django 常用类型(完整清单以 5.x 文档为准)。
  • 大列表用 JsonResponse 有什么问题?答:一次性内存序列化,超大数据集应考虑流式分片或分页接口。
  • 怎么返回 201 创建成功?答:构造 JsonResponse(..., status=201)。

04.7.16.1-043 StreamingHttpResponse 适用场景与缓冲限制是什么?

一句话结论

StreamingHttpResponse 不把响应体读入内存缓冲,而是迭代给定的生成器/迭代器,边产生边写出;适合大文件导出、CSV 流式下载、分批查询拼接等响应体远大于内存的场景。限制:它不支持 write() 增量写入接口,中间件对响应体的后处理(如压缩、内容长度计算)可能强制缓冲,且状态码/响应头在流开始前必须确定。

概念解释

  • 响应体是可迭代对象,服务器按迭代节奏分块发送。
  • 视图内生成器应按需取数,避免一次性把结果集加载进内存。
  • 流式响应不提供 Content-Length(除非手动设置),客户端按分块传输读取。

原理流程

  1. 视图传入生成器函数或迭代器构造流式响应。
  2. Handler 与服务器按迭代顺序逐块写出。
  3. 生成器结束即响应结束;中途异常会中断已发送的部分响应。

代码或图示

import csv, io
from django.http import StreamingHttpResponse

def row_stream():
    yield ["id", "name"]
    for order in Order.objects.iterator():
        yield [order.id, order.no]

def export_csv(request):
    resp = StreamingHttpResponse(row_stream(), content_type="text/csv")
    resp["Content-Disposition"] = "attachment; filename=orders.csv"
    return resp

常见误区

  • 在生成器里包裹数据库事务:流开始后事务长时间持有连接与锁,应先在事务内取完所需数据再流式输出。
  • 指望中间件自动压缩流式响应:压缩需要完整内容或缓冲块,行为取决于服务器与中间件配置。
  • 生成器内抛异常仍想返回错误页:响应头可能已发出,无法再切换为 500 页面,前置校验要在流开始前完成。

追问

  • 流式响应能写 Cookie 吗?答:能,Cookie 属于响应头,必须在响应体开始写出前设置。
  • iterator() 与流式响应怎么配合?答:ORM 用 iterator() 分批取数,生成器逐行产出,避免大结果集占内存。
  • 流式下载中断会重试吗?答:取决于客户端与服务器,服务端不保证断点续传,需单独实现 Range 支持。

04.7.16.1-044 FileResponse 与 StreamingHttpResponse 在静态文件发送上有什么差异?

一句话结论

FileResponse 是面向文件对象的流式响应子类:自动处理文件块读取、Content-Type 猜测、Content-Length、Last-Modified 与条件请求(If-Modified-Since),支持 as_attachment 触发下载并设置文件名。StreamingHttpResponse 是通用迭代器流,文件相关元数据需自行处理;发送磁盘文件优先用 FileResponse,它还能借助服务器的高效文件发送机制。

概念解释

  • FileResponse 接收文件类对象(open(..., "rb") 或 Storage 文件),按 block_size 分块读取。
  • 文件名与下载名通过 filename/as_attachment 配置,响应头自动生成。
  • 静态文件在生产环境通常由 Web 服务器/CDN 直接发送,Django 只负责受保护文件的授权下载。

原理流程

  1. 视图打开受保护文件对象,构造 FileResponse。
  2. 基类读取文件元数据,填充类型、长度与缓存头。
  3. 按块流式写出;浏览器按附件或内联方式处理。

代码或图示

from django.http import FileResponse

def download(request, pk):
    doc = get_object_or_404(Document, pk=pk)
    if not doc.can_access(request.user):
        raise PermissionDenied
    fh = doc.file.open("rb")
    return FileResponse(fh, as_attachment=True, filename=doc.filename)

常见误区

  • 把大文件先读进内存再包 HttpResponse:内存占用随文件大小增长,应传文件对象给 FileResponse。
  • 忘记关闭文件句柄:FileResponse 会在响应结束后关闭传入文件对象,但显式管理生命周期更稳妥。
  • 用 Django 直接对外服务静态媒体:高并发下占用应用进程,生产应由 Web 服务器/对象存储/CDN 承载。

追问

  • FileResponse 支持 Range 断点续传吗?答:基础能力以 Django 5.x 实现为准(待确认:验证点为 FileResponse 源码对 Range 头的处理)。
  • 文件存储在对象存储怎么发?答:返回预签名 URL 重定向,或后端代理流读取。
  • 怎么判断文件类型?答:基类按扩展名猜测,必要时显式传 content_type。

04.7.16.1-045 响应头、Cookie、状态码与 render() 是如何组合的?

一句话结论

render(request, template_name, context, status=None, content_type=None) 是快捷函数:构造 RequestContext(执行上下文处理器)、渲染模板生成 TemplateResponse,可在返回前设置状态码与内容类型;响应头与 Cookie 通过响应对象的 headers/set_cookie() 方法附加。视图先拿到响应对象,再补头与 Cookie,最后返回给 Handler。

概念解释

  • render 内部等价于 TemplateResponse + 上下文处理器,比手工 Context 多了请求级上下文注入。
  • Cookie 通过 set_cookie 写入 Set-Cookie 头,支持过期路径、域、Secure、HttpOnly、SameSite。
  • 状态码在构造响应时指定,后续可改 response.status_code。

原理流程

  1. render 组装上下文与模板,生成响应对象。
  2. 视图在响应上追加自定义头、Cookie 或调整状态码。
  3. 响应沿中间件回程,服务器写出头与体。

代码或图示

def view(request):
    resp = render(request, "page.html", {"x": 1}, status=200)
    resp["X-Request-Id"] = request.META.get("HTTP_X_REQUEST_ID", "")
    resp.set_cookie("theme", "dark", max_age=3600, httponly=True, samesite="Lax")
    return resp

常见误区

  • 在 render 之后才追加 Cookie 却提前返回:响应对象未带回视图,Cookie 丢失。
  • 设置敏感 Cookie 漏 httponly/secure:XSS 可读取或明文传输,安全属性要按场景配齐。
  • 用 HttpResponse 手工拼模板字符串:绕过上下文处理器与自动转义约定,易出安全问题。

追问

  • set_cookie 的 samesite 取值?答:Strict/Lax/None,None 需配合 secure=True。
  • 怎么删除 Cookie?答:set_cookie(..., max_age=0) 或 delete_cookie,路径与域要与写入时一致。
  • render 与 TemplateView 关系?答:TemplateView 内部同样构造 TemplateResponse,render 是函数视图的等价快捷方式。

04.7.16.1-046 reverse() 如何按视图名反查 URL?参数如何注入?

一句话结论

reverse(viewname, urlconf=None, args=None, kwargs=None, current_app=None) 在指定 URLconf 中按路由名查找匹配模式,把位置参数填入 args、命名参数填入 kwargs,拼出完整 URL 路径;需要绝对地址时用 request.build_absolute_uri(reverse(...))。路由名冲突时配合命名空间限定。

概念解释

  • viewname 可以是路由 name、视图函数引用或带命名空间的字符串。
  • args 按位置顺序填充正则/转换器捕获组;kwargs 按命名填充,二者不要混用在同一路由上。
  • 反查失败抛 NoReverseMatch,通常是参数缺失、类型不匹配或路由名写错。

原理流程

  1. 确定要解析的 URLconf(默认根配置)。
  2. 按视图名定位 URLPattern,读取其路由模板。
  3. 注入参数生成路径;绝对地址由请求对象补全 scheme 与 host。

代码或图示

from django.urls import reverse

reverse("article-detail", kwargs={"pk": 42})
reverse("article-detail", args=[42])
request.build_absolute_uri(reverse("article-detail", kwargs={"pk": 42}))

常见误区

  • args 与 kwargs 同时传:框架按路由捕获形式取其一,混用导致参数错位。
  • 传整数给 slug 转换器或反之:类型不匹配触发 NoReverseMatch。
  • 在模块顶层调用 reverse:URLconf 可能尚未加载,应在函数内调用,类属性场景用 reverse_lazy。

追问

  • reverse_lazy 用在哪里?答:类视图 success_url、类属性等导入期求值场景,延迟解析路由。
  • 查询串怎么拼进反查 URL?答:reverse(...) + "?q=" + quote(value),框架不自动处理查询参数。
  • 反查能拿到完整域名吗?答:reverse 只给路径,绝对地址需 build_absolute_uri 配合。

04.7.16.1-047 URL 命名空间在 reverse 中怎么写?

一句话结论

带命名空间的反查格式为 namespace:app_name:url_name,多层 include 用冒号逐层连接;实例命名空间区分同一 app 的多份挂载,应用名对应子 URLconf 内 app_name。reverse("store:product-detail", kwargs={"pk": 1}) 会先定位实例命名空间,再在对应子树内找路由名。

概念解释

  • 若子 URLconf 只声明 app_name 且挂载时给了实例命名空间,反查写 instance_namespace:app_name:url_name。
  • 单实例挂载时可简化为 app_name:url_name(待确认:Django 5.x 对简写形式的解析规则以文档为准)。
  • current_app 参数用于在同一 app 多实例间提示当前激活命名空间。

原理流程

  1. 解析命名空间前缀,定位对应 URLResolver 子树。
  2. 在子树内按 url_name 找到具体模式。
  3. 注入参数生成路径,未找到命名空间或路由名抛 NoReverseMatch。

代码或图示

reverse("store:shop:product-detail", kwargs={"pk": 7})
# 模板中
{% url "store:shop:product-detail" pk=7 %}

常见误区

  • 只写路由名不写命名空间:多 app 重名时反查到错误子树。
  • 命名空间层级写反或漏层:NoReverseMatch,对照 include 挂载层级逐一核对。
  • 改了 include 的实例命名空间却遗漏模板与代码中的反查字符串:部分链接解析失败。

追问

  • app_name 在哪里声明?答:子 URLconf 模块内 app_name = "shop"。
  • 同一 app 挂两处怎么反查?答:用不同实例命名空间前缀区分目标挂载。
  • 模板 {% url %} 支持命名空间吗?答:支持,语法与 reverse 字符串一致。

04.7.16.1-048 resolve() 与 reverse() 的对称关系是什么?

一句话结论

二者互为逆操作:resolve(path) 把 URL 路径解析成 ResolverMatch(视图、参数、命名空间、路由名);reverse(viewname, ...) 把视图名与参数反推成路径。一个用于“当前请求落到了哪个视图”的判断,一个用于“按视图生成链接”的构造;共享同一套 URLconf 模式与转换器规则。

概念解释

  • resolve 输入路径输出匹配结果,失败抛 Resolver404;reverse 输入视图标识与参数输出路径,失败抛 NoReverseMatch。
  • 转换器的 to_python 用于 resolve 阶段类型转换,to_url 用于 reverse 阶段生成片段。
  • 中间件、测试与调试工具常用 resolve 读取当前路由元信息。

原理流程

  1. 请求路径进入 resolve,遍历模式匹配并填充参数。
  2. 需要生成链接时,reverse 沿命名空间定位模式并填参数。
  3. 两者对同一 URLconf 保持一致:能 resolve 的模式应可被对应参数 reverse 出来。

代码或图示

from django.urls import resolve, reverse

match = resolve("/articles/42/")
print(match.url_name, match.kwargs)      # article-detail {'pk': 42}
path = reverse("article-detail", kwargs={"pk": 42})

常见误区

  • 以为 resolve 拿到的参数是原始字符串:int 等转换器已在 to_python 中转换类型。
  • 用 resolve 做权限判断却忽略命名空间:同名不同子树的视图会被误判。
  • 修改转换器后只测了正向访问:反查路径可能因 to_url 不兼容而失效,需要双向回归。

追问

  • resolve 能在视图外调用吗?答:能,传入路径与可选 URLconf 即可,常用于测试与脚本。
  • 两个模式 resolve 到同一视图怎么办?答:按列表顺序先命中为准,url_name 用于区分链接来源。
  • reverse 失败常见原因有哪些?答:路由名不存在、参数缺失/类型不符、命名空间未挂载。

04.7.16.1-049 模板里 {% url %} 标签如何调用 reverse?

一句话结论

{% url "view-name" arg1 kwarg=value %} 在模板编译期生成节点,渲染时内部调用 reverse() 完成反查并输出路径;支持命名空间前缀与关键字参数。模板标签拿到的参数是上下文变量或字面量,反查失败在渲染期抛 NoReverseMatch,与代码中 reverse 的失败行为一致。

概念解释

  • 位置参数按顺序填入路由捕获组,关键字参数按命名填入;语法与 reverse(kwargs=...) 对应。
  • 标签可加 as varname 把反查结果存入上下文变量而不直接输出。
  • 模板内反查同样受 URLconf 加载状态约束,运行期路由已注册。

原理流程

  1. 模板编译时解析 url 标签的视图名与参数表达式。
  2. 渲染节点时从上下文取变量值,调用 reverse 生成路径。
  3. 路径写入输出;as 形式则存入指定变量。

代码或图示

{% url "article-detail" article.pk %}
{% url "store:product-detail" pk=product.id as product_url %}
<a href="{{ product_url }}">查看</a>

常见误区

  • 模板参数传了未定义变量:反查拿到空值,触发 NoReverseMatch 或拼出错误路径。
  • 在模板里硬编码 URL 路径:路由改名后模板链接失效,应统一用 {% url %} 反查。
  • 命名空间层级在模板标签里写错:与代码层一样报反查失败,需对照 include 层级核对。

追问

  • {% url %} 能生成绝对地址吗?答:默认输出路径;需要完整域名时在视图/上下文里用 build_absolute_uri 处理。
  • 反查失败模板会怎样?答:渲染期抛 NoReverseMatch,调试模式下可见堆栈。
  • 模板标签参数能调用方法吗?答:支持上下文属性与方法取值,复杂表达式应在视图组装好再传入。

04.7.16.1-050 Django 模板引擎的渲染流程是什么?

一句话结论

模板文件先被解析器切分成 token,编译成节点树(文本节点、变量节点、标签节点、过滤器节点);渲染时从根节点递归调用 render,变量从上下文按名字查找,标签执行控制逻辑并拼接输出。模板可被编译缓存,重复渲染复用节点树;TemplateResponse 在响应阶段才触发实际渲染。

概念解释

  • 解析阶段:模板语言标签 {% %}、变量 {{ }}、文本分别归类为 token。
  • 编译阶段:token 转换为 Node 列表,每个节点知道如何渲染自己。
  • 渲染阶段:传入上下文(Context/RequestContext),节点递归生成字符串片段。

原理流程

  1. 模板加载器按查找路径读取模板源码。
  2. 解析器编译为节点树并缓存。
  3. 请求渲染时节点树结合上下文递归输出 HTML,自动转义在变量输出节点生效。

代码或图示

模板源码 → 分词 token → 编译节点树 → 上下文渲染 → 输出字符串
                └── 编译结果可缓存复用 ──┘

常见误区

  • 把模板引擎当纯字符串替换:标签有控制流与作用域(with/for),变量查找也经过属性/键名解析规则。
  • 在模板里做重型计算:渲染遍历节点树,复杂逻辑拖慢响应,应在视图层预处理。
  • 重复读取模板文件:框架有模板缓存,生产环境开启模板缓存避免每次编译。

追问

  • 模板缓存由哪个配置控制?答:TEMPLATES 中的 OPTIONS.loaders 与调试模式;DEBUG=False 下默认缓存编译结果(待确认:具体缓存行为以 5.x 配置为准)。
  • 自定义标签在哪一层参与?答:编译期解析为自定义节点,渲染期执行节点逻辑。
  • 模板报错定位到哪一级?答:错误信息含模板名、行号与节点类型,便于定位标签/变量问题。

04.7.16.1-051 RequestContext 与普通 Context 的区别是什么?

一句话结论

Context 是纯字典式上下文容器,只保存手工传入的变量;RequestContext 继承 Context,额外绑定当前 request,并在构造时按 TEMPLATES 配置执行上下文处理器,注入 user、csrf_token、messages、perms 等请求级变量。render() 与通用视图默认使用 RequestContext,手工 Template 渲染若只传 Context 就拿不到这些变量。

概念解释

  • 上下文处理器接收 request,返回并入上下文的字典。
  • RequestContext 还携带当前应用路径信息,支持模板按 app 解析名称。
  • 普通 Context 用于邮件模板、独立渲染脚本等无请求环境。

原理流程

  1. 视图调用 render 或通用视图构造 RequestContext,传入请求与基础上下文。
  2. 框架依次执行配置的上下文处理器,合并其返回字典。
  3. 节点树渲染时从合并后的上下文取值。

代码或图示

from django.template import RequestContext, Template, Context

# 请求环境:RequestContext 执行处理器
ctx = RequestContext(request, {"name": "ann"})

# 无请求环境:普通 Context
tpl = Template("Hello {{ name }}")
html = tpl.render(Context({"name": "ann"}))

常见误区

  • 手工构造 TemplateResponse 时传了普通 Context:user、csrf_token 等变量缺失,表单与登录态展示异常。
  • 上下文处理器依赖 request 却在离线渲染中使用:处理器拿不到请求对象,需改用普通上下文并显式传值。
  • 在处理器里做重查询:每个渲染请求都执行,拖慢全站页面,应加缓存或移到视图层。

追问

  • csrf_token 变量由哪个处理器提供?答:django.template.context_processors.csrf。
  • perms 变量是什么?答:当前用户的权限集合,供模板按权限渲染按钮与菜单。
  • 能在视图中追加上下文变量吗?答:能,作为 render 的 context 字典传入,与处理器结果合并。

04.7.16.1-052 上下文处理器里能放什么?内置处理器有哪些?

一句话结论

上下文处理器是接收 request 返回字典的可调用对象,适合放全站页面共享的展示数据:当前用户、权限、消息、站点配置、导航项、购物车摘要等。内置常用处理器包括 auth(user/perms)、messages(消息列表)、csrf(csrf_token)、request(把 request 放入上下文)、debug、media/static 路径。自定义处理器在 TEMPLATES.OPTIONS.context_processors 中登记。

概念解释

  • 处理器返回的键会合并进每次渲染的上下文,命名要避免与视图变量冲突。
  • 处理器在 RequestContext 构造时按配置顺序执行,后合并的键可覆盖同名前置键。
  • 重计算或 IO 操作放处理器代价很高,因为所有页面渲染都会触发。

原理流程

  1. 在模块中定义 def processor(request): return {...}。
  2. 登记到 TEMPLATES 配置的 context_processors 列表。
  3. 每次请求渲染时执行处理器,返回字典并入上下文。

代码或图示

# context_processors.py
def site_nav(request):
    return {"nav_categories": Category.objects.filter(visible=True)}

# settings.py
TEMPLATES = [{
    "OPTIONS": {
        "context_processors": [
            "django.template.context_processors.auth",
            "django.template.context_processors.messages",
            "django.template.context_processors.csrf",
            "myapp.context_processors.site_nav",
        ],
    },
}]

常见误区

  • 处理器内直接查库且无缓存:全站页面 QPS 都叠加这份查询,列表页与详情页同时变慢。
  • 处理器返回可变全局对象:多请求间共享引用,修改后串号;每次返回新字典或副本。
  • 把业务鉴权逻辑塞进处理器:鉴权属于视图/中间件职责,处理器只提供展示数据。

追问

  • 处理器执行顺序重要吗?答:重要,同名键后者覆盖前者,共享数据应约定命名前缀。
  • 离线渲染能用处理器吗?答:需要构造模拟 request 或拆分出纯函数供两处复用。
  • static/media 处理器提供什么?答:静态与媒体文件的基础路径变量。

04.7.16.1-053 模板继承、block 与 include 标签的渲染机制是什么?

一句话结论

模板继承通过 {% extends %} 指向父模板,子模板覆盖同名 block;渲染时框架先解析子模板的 block 定义,再用父模板骨架占位填充,子模板未覆盖的 block 保留父模板内容。{% include %} 把另一个模板片段嵌入当前上下文渲染,适合复用局部片段,不形成继承关系。

概念解释

  • block 是父子模板之间的挂载点,支持 {{ block.super }} 引用父块内容。
  • include 复用的是片段模板,继承复用的是页面骨架;二者可组合使用。
  • 继承层级过深会增加模板解析与调试成本,通常两层骨架 + 片段复用时最清晰。

原理流程

  1. 子模板声明 {% extends "base.html" %} 并定义各 block 内容。
  2. 渲染时加载父模板骨架,把子模板覆盖的 block 填入对应位置。
  3. include 标签在当前位置加载片段模板,用现有上下文渲染后插入输出。

代码或图示

{# base.html #}
<html><body>{% block content %}{% endblock %}</body></html>

{# page.html #}
{% extends "base.html" %}
{% block content %}
  <h1>标题</h1>
  {% include "partial/meta.html" %}
{% endblock %}

常见误区

  • 子模板在 extends 之外写大量裸文本:不在任何 block 内的内容不会进入父骨架,渲染丢失。
  • include 片段依赖未传入的上下文变量:片段不会自动查询,所需变量由当前上下文提供。
  • 重复 {% block %} 同名:后定义覆盖先定义,父块内容丢失,命名要唯一。

追问

  • {{ block.super }} 什么时候用?答:子块需要在父块内容基础上追加,而不是整体替换时。
  • include 能传额外变量吗?答:{% include "x.html" with foo=bar %} 可追加局部变量。
  • 模板继承影响缓存吗?答:编译缓存按模板文件粒度管理,继承链在渲染时解析。

04.7.16.1-054 模板变量查找与过滤器、标签的执行边界是什么?

一句话结论

变量查找按“字典键 → 属性 → 列表索引”顺序解析名字链;过滤器是纯函数式转换,左侧值作为第一个参数,可链式串联;标签执行控制逻辑并可能改变作用域。模板内不能写 Python 表达式与赋值语句(除特定标签),复杂运算必须在视图/模型层完成后传入。

概念解释

  • 变量 a.b.c 逐级解析,任一级缺失返回空值或字符串,不抛属性异常(默认行为)。
  • 过滤器如 {{ value|default:"无" }}、{{ value|date:"Y-m-d" }},参数用冒号分隔。
  • 标签如 {% for %}、{% if %}、{% with %} 提供控制流与局部作用域。

原理流程

  1. 渲染变量节点时按名字链逐级取值。
  2. 过滤器按书写顺序对值做转换。
  3. 标签节点执行分支/循环/作用域逻辑,拼接子节点输出。

代码或图示

{{ article.title|truncatechars:30 }}
{% with full_name=user.first_name|add:" "|add:user.last_name %}
  {{ full_name }}
{% endwith %}
{% for tag in tags %}<span>{{ tag.name }}</span>{% endfor %}

常见误区

  • 在模板里写乘法、复杂条件判断:模板语言不支持完整表达式,应在视图计算后传入。
  • 假设变量缺失会抛异常:默认静默返回空,关键变量要在视图保证存在。
  • 过滤器顺序理解反了:从左到右依次作用,前一个输出是后一个输入。

追问

  • 自定义过滤器怎么注册?答:写装饰函数后在 register.filter 登记,或放在 templatetags 包并加载。
  • 模板内能不能给变量赋值?答:只能通过 {% with %} 建立局部别名,不能做通用赋值。
  • 变量查找失败显示什么?答:默认空字符串,调试配置下可见未解析变量提示。

04.7.16.1-055 模板自动转义与 {% autoescape %}/|safe 的风险是什么?

一句话结论

Django 模板默认对变量输出做 HTML 转义(<、>、&、引号等转为实体),防止 XSS;|safe 标记内容为可信 HTML 不再转义,{% autoescape off %} 关闭块内转义。风险在于:把用户可控内容标记为 safe 会直接输出脚本标签与事件属性,构成 XSS 注入面;关闭转义后所有嵌套变量也失去保护。

概念解释

  • 转义发生在变量输出节点,过滤器与标签生成的文本按其自身安全约定处理。
  • mark_safe 与 |safe 等价地把字符串标记为安全,下游不再转义。
  • 富文本场景应先用白名单清洗(如 Bleach)再标记安全,不能直接 safe 原始用户输入。

原理流程

  1. 变量输出前检查转义开关与安全标记。
  2. 未标记安全的内容按 HTML 实体转义。
  3. safe/autoescape off 跳过转义,原样写入输出。

代码或图示

{{ comment.body }}                 {# 自动转义 #}
{{ comment.body|safe }}            {# 风险:原样输出 #}
{% autoescape off %}
  {{ raw_html }}
{% endautoescape %}

常见误区

  • 把含用户提交内容的字段整体 safe:攻击者注入 <script> 或 onerror 属性即触发 XSS。
  • 以为 safe 只影响当前标签:被标记安全的字符串参与拼接后,后续片段也可能被视为安全。
  • 在 autoescape off 块内混入可信与不可信变量:不可信变量一并失去转义保护。

追问

  • 富文本怎么安全展示?答:服务端白名单清洗标签与属性,再输出安全片段。
  • mark_safe 在 Python 代码里用还是模板里用?答:模型方法/过滤器中可返回 mark_safe 字符串,模板用 |safe 效果相同,风险相同。
  • 转义能防哪些 XSS?答:防 HTML 上下文注入;URL/JS 上下文还需按对应规则编码,CSP 作为兜底。

04.7.16.1-056 模板加载器与查找路径是如何组织的?

一句话结论

TEMPLATES 配置的 DIRS 列出项目级模板目录,各已登记 app 的 templates/ 目录由 app 模板加载器自动加入;加载器按配置顺序查找,先命中先使用。{% extends %}/{% include %}/通用视图模板名都按这套路径解析,多 app 同名模板通过 app_name/ 子目录隔离。

概念解释

  • filesystem 加载器查 DIRS,app_directories 加载器扫各 app 的 templates/。
  • 查找顺序决定模板覆写关系:项目级 DIRS 在前可覆盖 app 默认模板。
  • 模板命名建议带 app 前缀目录,避免不同 app 模板互相覆盖。

原理流程

  1. 模板节点需要加载模板时,按加载器链依次询问。
  2. 文件系统加载器检查 DIRS 路径,app 加载器扫描已登记 app 目录。
  3. 第一个找到的模板被使用,编译结果进入缓存。

代码或图示

TEMPLATES = [{
    "DIRS": [BASE_DIR / "templates"],
    "APP_DIRS": True,
    "OPTIONS": {"context_processors": [...]},
}]

常见误区

  • 两个 app 都有 detail.html 且未放子目录:先加载的 app 模板覆盖另一个,页面表现错乱。
  • 新增模板目录后未重启/未更新加载器配置:开发模式下有时缓存旧查找结果。
  • 在 app 模板里引用项目级相对路径:模板名按查找路径解析,应写完整相对模板名而非文件系统相对路径。

追问

  • 怎么确认实际加载了哪个模板?答:调试模板标签或 debug toolbar 查看模板来源路径。
  • DIRS 与 app 模板谁优先?答:由加载器配置顺序决定,filesystem 通常先于 app 目录加载。
  • 第三方 app 模板如何覆写?答:在 DIRS 或同名 app 模板目录放置同名模板,查找顺序命中覆盖。

04.7.16.1-057 Django 启动期 checks 都检查什么?如何自定义检查?

一句话结论

checks 是框架内置的静态自检体系:在 runserver、migrate 等命令启动前运行,检查模型字段、关系引用、配置项、路由命名、中间件依赖、静态文件设置等是否存在明显问题,按 tags(models、compatibility、security、templates、urls 等)分类输出告警与错误。自定义检查实现 check(app_configs, **kwargs) 函数返回 CheckMessage 列表,通过 register 装饰器登记。

概念解释

  • 检查不连数据库做数据校验,主要检查代码与配置的一致性。
  • python manage.py check 可单独运行;--tag 过滤分类,--list-tags 查看可用标签。
  • 严重错误会阻止命令继续执行,警告不阻断但需关注。

原理流程

  1. 命令启动时调用 checks.run_checks,收集已注册检查项。
  2. 按标签分组执行,收集 CheckMessage(级别:debug/info/warning/error)。
  3. 存在 error 级别问题时中止启动;自定义检查把项目约定纳入同一体系。

代码或图示

from django.core.checks import register, CheckMessage, Tags, Error

@register(Tags.models)
def check_business_rule(app_configs, **kwargs):
    errors = []
    # 检查模型约定、必填配置等
    if not errors:
        errors.append(Error("缺少必填配置", id="myapp.E001"))
    return errors

常见误区

  • 把运行时数据校验写进 checks:检查在无请求、可能无库环境下运行,数据级校验应放在视图/迁移。
  • 自定义检查返回普通字符串而非 CheckMessage:级别与标识缺失,无法被框架正确归类。
  • 忽略启动告警:配置类警告(如安全设置、缺索引提示)常演变为生产问题,应在上线前清理。

追问

  • check 会连接数据库吗?答:默认不做数据查询,仅静态检查模型定义与配置。
  • 怎么只跑某一类检查?答:manage.py check --tag models。
  • 检查项 id 有什么规范?答:app_label.E001 形式,便于在文档与告警中定位。

04.7.16.1-058 模型与 app registry 的延迟加载机制是什么?为什么不能在模块顶层直接查库?

一句话结论

Django 的 app registry 在 django.setup() 阶段才导入各 app 的模型模块并注册模型类;模型之间的关系解析、管理器挂载都依赖注册表完成。在模型模块或 app 包的顶层直接执行 ORM 查询,会在注册表尚未填充、数据库连接未就绪时触发,导致模型未注册、关系未解析或连接异常。查询应放在函数/方法内,由请求或命令在启动完成后调用。

概念解释

  • 模型类定义时只声明字段与关系,外键目标可先写字符串,注册表就绪后再解析。
  • 顶层代码在 import 阶段执行,早于 setup() 完成;此时 settings、模型、迁移环境都可能未就绪。
  • 信号接收器、ready() 钩子是框架提供的启动期合法入口,仍不应在其中查库。

原理流程

  1. 进程入口先设置 settings 模块,再调用 django.setup()。
  2. registry 导入模型模块、注册模型、解析延迟关系。
  3. 启动完成后,视图/命令/任务内的查询才执行;顶层查询绕过了这一顺序。

代码或图示

# 错误:模块顶层查库
# from .models import Order
# total = Order.objects.count()

# 正确:封装为函数,启动完成后调用
def pending_count():
    return Order.objects.filter(status="pending").count()

常见误区

  • 在 models.py 顶层用模型类做类属性计算:关系与管理器可能尚未绑定。
  • 把缓存预热、初始化数据放进模型模块顶层:迁移命令、测试收集阶段会反复触发,行为不可控。
  • 跨 app 顶层互相 import 模型:容易形成循环导入,应在函数内延迟导入。

追问

  • 外键写字符串 "app.Model" 有什么好处?答:避免循环导入,注册表就绪后按名解析。
  • 什么时候可以安全查库?答:django.setup() 完成之后,在视图、管理命令、Celery 任务等运行期入口内。
  • 测试收集阶段为什么也会触发顶层代码?答:测试运行器先 import 模块再初始化 Django,顶层执行早于 registry 就绪。

04.7.16.1-059 manage.py 与 django-admin 的启动流程有什么差异?

一句话结论

django-admin 是 Django 自带的通用命令行工具,不绑定具体项目;manage.py 是项目生成的薄封装,内部设置 DJANGO_SETTINGS_MODULE 后调用 django-admin 同款命令体系。二者命令集一致,manage.py 免去每次指定 settings 模块;项目自定义命令放在 app 的 management/commands/ 下,两边都能发现。

概念解释

  • manage.py 主要做环境变量引导,真正的命令分发在 django.core.management。
  • 自定义命令类继承 BaseCommand,实现 handle 方法,文件名即命令名。
  • 命令可声明 add_arguments 定义参数,execute 流程含 checks、配置加载与异常处理。

原理流程

  1. manage.py 设置 settings 模块环境变量,进入管理命令入口。
  2. 命令解析器按名称定位 Command 类,执行前置 checks。
  3. 调用 handle 执行业务,输出结果或错误。

代码或图示

# management/commands/recalc_stats.py
from django.core.management.base import BaseCommand

class Command(BaseCommand):
    help = "重算统计数据"
    def handle(self, *args, **options):
        self.stdout.write("done")

常见误区

  • 自定义命令忘记继承 BaseCommand 或文件名不符:命令不被发现,manage.py 列表里找不到。
  • 在命令 handle 里假设请求上下文存在:命令环境无 request,需要用户/上下文时显式传入。
  • 把一次性运维脚本写成视图接口:应落为管理命令,便于部署执行与日志留存。

追问

  • 命令怎么接收参数?答:add_arguments 中添加 --option 或位置参数,options 字典读取。
  • django-admin 怎么指定项目配置?答:--settings 参数或环境变量 DJANGO_SETTINGS_MODULE。
  • 命令能调用其他命令吗?答:可通过 call_command("migrate", ...) 内部调用。

04.7.16.1-060 开发服务器(runserver)与生产 WSGI/ASGI 部署在请求链路上有什么差异?

一句话结论

runserver 是面向开发的单进程/多线程服务器,自带静态文件服务、自动重载与宽松错误页,性能与并发模型不面向生产;生产用 gunicorn/uWSGI(WSGI)或 uvicorn/hypercorn(ASGI)承载 Handler,配合 Nginx 做静态文件、TLS 与反向代理。链路主干(Handler → 中间件 → 路由 → 视图)一致,差异在进程模型、静态资源处理、并发能力与错误暴露方式。

概念解释

  • runserver 默认不开多进程,改动代码触发重载;生产服务器按 worker 进程/事件循环模型承载并发。
  • 静态与媒体文件在生产由 Web 服务器/对象存储处理,Django 不直接对外服务。
  • 调试页面暴露堆栈与配置,生产必须关闭 DEBUG,错误响应走通用错误页与日志。

原理流程

  1. 开发:runserver 直接加载项目 Handler,服务静态文件并在代码变更时重载。
  2. 生产:应用服务器加载 WSGI/ASGI Handler,Nginx 反向代理并处理静态资源、TLS。
  3. 请求进入后框架内部分发链路与开发环境相同。

代码或图示

# 开发
python manage.py runserver 16899

# 生产示例(WSGI)
gunicorn myproject.wsgi:application -w 4 -k gthread --threads 4

# 生产示例(ASGI)
uvicorn myproject.asgi:application --workers 4

常见误区

  • 用 runserver 直接对外提供服务:并发、静态文件、安全头与错误暴露都不达标。
  • 生产让 Django 服务上传媒体文件:占用应用进程带宽与内存,应由 Nginx/对象存储承载。
  • 认为换了服务器就自动获得异步能力:同步视图在 ASGI 下仍走线程池,并发收益取决于视图与 IO 模型。

追问

  • 生产静态文件怎么收集?答:collectstatic 汇总到静态目录,由 Web 服务器直接服务。
  • 多 worker 下本地内存缓存/会话有效吗?答:不共享,需用缓存后端/数据库会话等共享存储。
  • 怎么对比开发与生产行为差异?答:检查 DEBUG、静态处理、数据库连接、中间件配置与错误处理器是否一致。

本节高频题

  • MTV 分层与项目/app 边界(001、002)
  • settings 加载与 INSTALLED_APPS(006、007)
  • AppConfig.ready() 与 django.setup()(009、010)
  • WSGIHandler/ASGIHandler 请求链路(012、013)
  • 异步视图调度与线程池桥接(014)
  • 中间件栈装配与顺序(017、018)
  • 路由解析与 ResolverMatch(022、023)
  • path/re_path 与转换器(024、025)
  • include 与命名空间(026、047)
  • 类视图 as_view() 与 dispatch(029、030)
  • 通用视图钩子与上下文命名(031、035、039)
  • 访问限制 mixin(038)
  • JsonResponse 与流式/文件响应(042、043、044)
  • reverse/resolve 对称关系(046、048)
  • RequestContext 与上下文处理器(051、052)
  • 模板继承与自动转义(053、055)
  • 启动期 checks 与 registry 延迟加载(057、058)
  • 开发服务器与生产部署差异(060)