04.7.16.1 架构 MTV 与请求链路
所属:全栈开发面试题库 / 04 后端语言与运行时 / 04.7 Python / 04.7.16 Django 框架
覆盖范围
- MTV 分层与项目/应用边界
settings.py加载与INSTALLED_APPSAppConfig.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、选择响应形式。
原理流程
- Handler 把请求沿中间件、URLconf 送到 View。
- View 调用 Model 完成读写,拿到上下文或响应对象。
- 若返回模板响应,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”(只服务当前业务)。
原理流程
django-admin startproject生成配置骨架。python manage.py startapp生成 app 目录与默认文件。- 把 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、自定义管理器、信号钩子,使用方通过继承扩展而不是改源码。
原理流程
- 发布方把通用能力封装为 app,对外留配置项与扩展点。
- 使用方安装后加入
INSTALLED_APPS,按文档覆写模板、模型或 URL。 - 框架按 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 准备,模板不直接发请求或写库。
原理流程
- 定义 Model 字段、关系、管理器方法与
__str__。 - View 解析请求后调用 Model 查询/写入,组装上下文。
- 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 兼任。
原理流程
- View 接收请求、做参数校验与权限判断,调用 Service。
- Service 在事务内调度 Repository/Model 完成用例,返回领域对象或结果 DTO。
- 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覆盖工具临时替换配置。
原理流程
- 入口脚本设置
DJANGO_SETTINGS_MODULE环境变量。 - 首次访问
settings.DEBUG时,LazySettings导入指定模块,合并默认配置。 - 配置对象供 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子类路径。- 注册顺序有实际意义:模板查找、静态文件收集、部分中间件与标签解析都按顺序进行。
原理流程
django.setup()遍历INSTALLED_APPS,为每项构造或复用AppConfig。- 导入 app 的
models.py(或 models 包),把模型注册到对应 app 的 registry。 - 迁移命令、模板引擎、静态文件命令按已登记 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 包结构调整。
原理流程
- 框架按
INSTALLED_APPS项解析出 app 模块或AppConfig子类。 - 构造实例并读取
name/label等元数据,加入 registry。 - 所有 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 信号模块,避免信号接收器不生效。
原理流程
django.setup()注册全部 app 配置并导入模型模块。- registry 标记填充完成后,按注册顺序调用各
AppConfig.ready()。 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()不启动服务器,只完成框架内部初始化。
原理流程
- 脚本先设置
DJANGO_SETTINGS_MODULE环境变量。 - 调用
django.setup(),框架加载 settings、注册 app 与模型。 - 之后才能导入模型、执行查询、使用
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。
原理流程
base.py定义全部公共配置与默认安全项。- 环境模块继承 base,覆盖
DATABASES、DEBUG、缓存等差异项。 - 部署时通过环境变量选择模块,并注入密钥类配置。
代码或图示
# 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。
原理流程
- 服务器解析请求报文填入
environ,调用 Handler。 WSGIRequest从environ读取 method、path、GET/POST、META 等。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__,与同步中间件由框架桥接适配。
原理流程
- ASGI 服务器(uvicorn/hypercorn)解析协议后把
scope/receive/send交给 Handler。 - Handler 构造异步请求对象,穿过异步化的中间件栈并分发到视图。
- 视图返回响应后,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,协程之间隔离。
原理流程
- Handler 完成路由匹配,拿到视图可调用对象。
- 若是 async 视图,事件循环直接
await调用;若是同步视图,sync_to_async提交线程池。 - 视图返回响应后,异步链路把响应交回 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、消息等都以中间件形式挂在栈上。
原理流程
- Handler 初始化时读取 settings,构造中间件可调用对象链。
- 每个请求进入
get_response:推入上下文 → 跑中间件前半段 → 路由与视图 → 中间件回程。 - 未捕获异常交给处理器映射为 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,协程切换不会串号。
原理流程
- Handler 处理请求前推入应用上下文与请求上下文。
- 中间件、视图、模板通过代理访问栈顶上下文对象。
- 响应返回或异常结束后弹出上下文,单次请求的数据随之销毁。
代码或图示
# 视图内访问代理对象,不直接持有全局单例
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。 - 装配只做一次,运行期每个请求复用同一条链。
原理流程
- Handler 读取
MIDDLEWARE,从后往前包装:最后一项包裹视图入口。 - 每项用自己的
__call__包裹内层可调用对象,形成嵌套链。 - 请求进入最外层,逐层调用
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挂上去;会话不可用时认证无从谈起。 - 响应阶段逆序:安全头、压缩等外层中间件最后补响应,顺序同样要配合。
原理流程
- 先排基础能力:安全、会话、通用处理。
- 再排安全校验:CSRF、认证。
- 最后是业务自定义中间件,确保能拿到完整的请求状态。
代码或图示
请求 → 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提供默认空实现,子类按需覆写。
原理流程
- 装配阶段识别中间件类型,旧式钩子被包装成统一的
__call__形态。 - 请求阶段依次触发各层
process_request与process_view。 - 响应阶段依次触发
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 响应。
原理流程
- 中间件前半段检查请求条件。
- 不满足时直接构造响应返回,不调用
get_response。 - 响应从当前层开始向外层回程,内层链路未被触发。
代码或图示
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 部署下整条链路按同步执行,异步中间件/视图不具备原生并发环境。
原理流程
- ASGIHandler 装配链时标记每层是同步还是异步。
- 跨边界调用由框架桥接:同步层进线程池,异步层直接 await。
- 阻塞调用在错误的执行模型里成为瓶颈,需要按资源类型选择调用方式。
代码或图示
# 异步中间件
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进来的子树。
原理流程
- 从根 URLconf 取出模式列表,逐条尝试匹配剩余路径段。
- 命中
include时,把已匹配前缀剥离,携带命名空间进入子 URLconf。 - 最终匹配到视图可调用对象,组装
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是匹配成功的模式字符串,便于日志与调试输出。
原理流程
resolve()命中最终模式后收集视图与捕获参数。- 沿
include层级累积命名空间信息。 - 构造
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捕获组按位置或命名组映射到视图参数,类型不自动转换。
原理流程
path()为每个转换器生成对应正则片段并拼接完整模式。- 命中后按转换器规则做类型转换,填入
kwargs。 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。
原理流程
- 定义转换器类并实现正则与双向转换方法。
- 在 URLconf 中
register_converter(Converter, "name")。 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层级累积,支持多层嵌套。
原理流程
- 根 URLconf 用
path("orders/", include("orders.urls", namespace="orders"))挂载子树。 - 匹配时剥离前缀,子 URLconf 处理剩余路径并记录命名空间。
- 反向解析按命名空间链 + 路由名找到对应模式并注入参数。
代码或图示
# 根 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 被重定向丢数据。
原理流程
- 路由匹配失败,进入 404 处理流程。
- 若开启
APPEND_SLASH,CommonMiddleware 尝试加斜杠重新解析。 - 加斜杠后命中则重定向;仍未命中则返回 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 通常比堆叠通用视图更清晰。
原理流程
- 简单接口用函数视图:解析请求 → 调用业务 → 返回响应。
- 规整页面继承通用类视图:配置模型/模板/分页,覆写必要钩子。
- 类视图通过
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等属性。
原理流程
- 调用
View.as_view()定义闭包,捕获视图类与初始化参数。 - 请求到达闭包:实例化视图,挂载请求与路由参数。
- 调用
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也应是协程。
原理流程
- 请求进入
dispatch,规范化 method 名称。 - 在白名单内查找同名处理方法;存在则调用并返回响应。
- 不存在则调用
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流程都会复用这些数据准备步骤。
原理流程
- 视图方法(如
get)调用get_object或get_queryset准备数据。 - 数据传入
get_context_data组装上下文字典。 - 上下文交给模板响应渲染;子类覆写钩子时先
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参数的函数式签名要与视图方法兼容。 - 多个装饰器按书写顺序叠加,靠近方法的先执行内层逻辑。
原理流程
- 导入
method_decorator与目标装饰器。 - 在类上用
@method_decorator(..., name="dispatch")标记,或覆写方法时直接装饰。 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),但数据钩子必须调父类。
原理流程
- 子类方法接收请求与参数。
- 需要父类数据时调用
super()对应钩子,拿到基础结果。 - 在结果上追加过滤、上下文或校验后返回。
代码或图示
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。
原理流程
- 请求进入
TemplateView.get,调用get_context_data。 - 读取
template_name/get_template_names定位模板。 - 构造
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。
原理流程
get_queryset解析出基础 QuerySet。paginate_by存在时用Paginator按当前页码切片。- 上下文注入分页器、当前页与对象列表,交给模板渲染。
代码或图示
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自行组装条件。
原理流程
- 读取 URLconf 捕获的
pk或 slug 参数。 - 在基础查询集上构造过滤条件,执行单条查询。
- 命中则挂到
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()是反向生成详情页地址的约定方法。
原理流程
- GET 请求构造空表单或绑定现有对象的表单并渲染。
- POST 请求校验表单:有效则保存对象,调用
success_url跳转;无效则重渲染表单。 - 删除视图 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 覆盖,需要在取对象后校验归属。
原理流程
- 类定义时把鉴权 mixin 放在继承链前部。
- 请求进入
dispatch,mixin 先检查登录态/权限。 - 检查通过才调用父类
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追加的变量与对象列表变量并存。
原理流程
- 基类根据模型元数据推导默认上下文名。
- 若设置
context_object_name,覆盖推导结果。 - 上下文字典随模板响应渲染,模板按变量名取值。
代码或图示
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由认证中间件挂载,未认证时为匿名用户实例。
原理流程
- Handler 从 WSGI/ASGI 环境构造请求对象,填充路径、方法与参数。
- 中间件依次挂载用户、会话、消息等属性。
- 视图通过属性读取输入,构造响应;请求结束后对象不再复用。
代码或图示
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。
原理流程
- 视图选择响应基类,传入内容或目标地址。
- 响应对象设置默认状态码与内容类型,视图可覆盖。
- 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 字符串。
原理流程
- 校验顶层类型与
safe设置。 - 用
json.dumps(含encoder)把数据序列化为字符串。 - 写入响应体并设置 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(除非手动设置),客户端按分块传输读取。
原理流程
- 视图传入生成器函数或迭代器构造流式响应。
- Handler 与服务器按迭代顺序逐块写出。
- 生成器结束即响应结束;中途异常会中断已发送的部分响应。
代码或图示
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 只负责受保护文件的授权下载。
原理流程
- 视图打开受保护文件对象,构造
FileResponse。 - 基类读取文件元数据,填充类型、长度与缓存头。
- 按块流式写出;浏览器按附件或内联方式处理。
代码或图示
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。
原理流程
render组装上下文与模板,生成响应对象。- 视图在响应上追加自定义头、Cookie 或调整状态码。
- 响应沿中间件回程,服务器写出头与体。
代码或图示
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,通常是参数缺失、类型不匹配或路由名写错。
原理流程
- 确定要解析的 URLconf(默认根配置)。
- 按视图名定位 URLPattern,读取其路由模板。
- 注入参数生成路径;绝对地址由请求对象补全 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 多实例间提示当前激活命名空间。
原理流程
- 解析命名空间前缀,定位对应
URLResolver子树。 - 在子树内按
url_name找到具体模式。 - 注入参数生成路径,未找到命名空间或路由名抛
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读取当前路由元信息。
原理流程
- 请求路径进入
resolve,遍历模式匹配并填充参数。 - 需要生成链接时,
reverse沿命名空间定位模式并填参数。 - 两者对同一 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 加载状态约束,运行期路由已注册。
原理流程
- 模板编译时解析
url标签的视图名与参数表达式。 - 渲染节点时从上下文取变量值,调用
reverse生成路径。 - 路径写入输出;
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),节点递归生成字符串片段。
原理流程
- 模板加载器按查找路径读取模板源码。
- 解析器编译为节点树并缓存。
- 请求渲染时节点树结合上下文递归输出 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用于邮件模板、独立渲染脚本等无请求环境。
原理流程
- 视图调用
render或通用视图构造RequestContext,传入请求与基础上下文。 - 框架依次执行配置的上下文处理器,合并其返回字典。
- 节点树渲染时从合并后的上下文取值。
代码或图示
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 操作放处理器代价很高,因为所有页面渲染都会触发。
原理流程
- 在模块中定义
def processor(request): return {...}。 - 登记到
TEMPLATES配置的context_processors列表。 - 每次请求渲染时执行处理器,返回字典并入上下文。
代码或图示
# 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复用的是片段模板,继承复用的是页面骨架;二者可组合使用。- 继承层级过深会增加模板解析与调试成本,通常两层骨架 + 片段复用时最清晰。
原理流程
- 子模板声明
{% extends "base.html" %}并定义各 block 内容。 - 渲染时加载父模板骨架,把子模板覆盖的 block 填入对应位置。
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 %}提供控制流与局部作用域。
原理流程
- 渲染变量节点时按名字链逐级取值。
- 过滤器按书写顺序对值做转换。
- 标签节点执行分支/循环/作用域逻辑,拼接子节点输出。
代码或图示
{{ 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原始用户输入。
原理流程
- 变量输出前检查转义开关与安全标记。
- 未标记安全的内容按 HTML 实体转义。
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 模板互相覆盖。
原理流程
- 模板节点需要加载模板时,按加载器链依次询问。
- 文件系统加载器检查
DIRS路径,app 加载器扫描已登记 app 目录。 - 第一个找到的模板被使用,编译结果进入缓存。
代码或图示
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查看可用标签。- 严重错误会阻止命令继续执行,警告不阻断但需关注。
原理流程
- 命令启动时调用
checks.run_checks,收集已注册检查项。 - 按标签分组执行,收集
CheckMessage(级别:debug/info/warning/error)。 - 存在 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()钩子是框架提供的启动期合法入口,仍不应在其中查库。
原理流程
- 进程入口先设置 settings 模块,再调用
django.setup()。 - registry 导入模型模块、注册模型、解析延迟关系。
- 启动完成后,视图/命令/任务内的查询才执行;顶层查询绕过了这一顺序。
代码或图示
# 错误:模块顶层查库
# 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、配置加载与异常处理。
原理流程
manage.py设置 settings 模块环境变量,进入管理命令入口。- 命令解析器按名称定位
Command类,执行前置 checks。 - 调用
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,错误响应走通用错误页与日志。
原理流程
- 开发:
runserver直接加载项目 Handler,服务静态文件并在代码变更时重载。 - 生产:应用服务器加载 WSGI/ASGI Handler,Nginx 反向代理并处理静态资源、TLS。
- 请求进入后框架内部分发链路与开发环境相同。
代码或图示
# 开发
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)