04.7.16.3 视图、模板、表单与中间件
所属:全栈开发面试题库 / 04 后端语言与运行时 / 04.7 Python / 04.7.16 Django 框架
覆盖范围
- 类视图与 Mixin 组合、
get_context_data/get_object/get_queryset覆写 slug路由、get_absolute_url与reverse_lazyForm/ModelForm的clean/clean_<field>与校验顺序formset与inlineformset、management form- 模板继承、
{% block %}/{% include %}、过滤器与自动转义 {% csrf_token %}、中间件新式写法与执行顺序、短路回程Paginator分页、文件上传与MEDIA_ROOT/Storage- 异步视图(Django 4.2+/5.x)、
sync_to_async与 ASGI 部署差异
04.7.16.3-001 函数视图与类视图有什么区别?as_view() 做了什么?
一句话结论
函数视图是一个直接接收 request 并返回响应的函数;类视图把“按 HTTP 方法分发”抽成类,通过 View.as_view() 返回一个闭包 view,请求进来时实例化类、绑定 self.request/args/kwargs,再调用 dispatch。类视图的价值是把通用行为(上下文、对象查找、表单处理)沉淀到 Mixin 与基类里复用,而不是让代码“更面向对象”。
概念解释
as_view()是类方法,返回的view闭包在模块级定义,保证 URLconf 引用的是可序列化、可重入的函数。- 类实例是每请求新建的,因此实例属性不能跨请求保存状态;类属性才是共享配置。
原理流程
- URLconf 解析到
View.as_view()的返回值,这是一个普通函数。 - 请求进入闭包,调用
cls(**initkwargs)构造视图实例。 - 实例把
request/args/kwargs绑定到self,执行self.dispatch(request, *args, **kwargs)。 dispatch根据request.method映射到get/post/put/delete等方法并返回响应。
代码或图示
from django.views.generic import View
from django.http import HttpResponse
class HelloView(View):
def get(self, request, *args, **kwargs):
return HttpResponse("hello")
# 等价于 URLconf 里的 path("hello/", HelloView.as_view())
常见误区
- 以为类视图实例是单例:实际上每个请求都
cls()新建一次,在__init__里读请求属性是拿不到的。 - 以为
as_view()实例化了类:它只返回闭包,实例化发生在请求到达时;as_view(xxx=1)传入的关键字参数会进入initkwargs。 - 把函数视图强行改写成类视图:逻辑只做一件事、没有复用诉求时,函数视图更直接。
追问
- 类视图实例属性能跨请求吗?答:不能,每请求新建实例,跨请求状态要放缓存、Session 或数据库。
initkwargs什么时候有用?答:as_view(template_name="x.html")传入的配置会挂到实例属性上。- 类视图能加装饰器吗?答:能,用
method_decorator包裹dispatch或具体方法。
04.7.16.3-002 View.dispatch 的执行流程是什么?
一句话结论
dispatch 是类视图的分发入口:先做 http_method_not_allowed 检查,再按 request.method.lower() 查找同名处理方法;找不到就返回 405。它是 Mixin 组合链上承上启下的一环,覆写 dispatch 等于在所有方法外层包一层逻辑。
概念解释
http_method_names列出允许的方法,options由基类自动处理。dispatch返回的必须是HttpResponseBase子类,Django 不做二次包装。
原理流程
- 闭包把请求与参数绑定到实例,调用
dispatch。 dispatch检查方法名是否在http_method_names中,不在则调用http_method_not_allowed返回 405。- 通过
getattr(self, request.method.lower(), self.http_method_not_allowed)取处理函数。 - 执行该函数,返回响应;子类 Mixin 常通过
super().dispatch()串起前后置逻辑。
代码或图示
from django.views.generic import View
import time
class TimedView(View):
def dispatch(self, request, *args, **kwargs):
start = time.perf_counter()
response = super().dispatch(request, *args, **kwargs)
response["X-Elapsed-Ms"] = str(int((time.perf_counter() - start) * 1000))
return response
常见误区
- 覆写
dispatch时忘记return super().dispatch(...),导致响应丢失返回None。 - 在
dispatch里直接读self.request之前还没绑定:绑定发生在as_view闭包里,进入dispatch时已就绪。 - 405 与 404 混淆:方法不支持是 405,对象不存在才是 404。
追问
- 如何给整个类视图加日志/鉴权?答:覆写
dispatch前后置,或用method_decorator装饰dispatch。 - 405 响应里带什么?答:
Allow头列出允许的 HTTP 方法。 options方法谁处理?答:View.dispatch默认提供options实现,返回允许的方法列表。
04.7.16.3-003 六大通用类视图各自负责什么?
一句话结论
TemplateView 渲染模板;ListView 列出查询集;DetailView 取单个对象;CreateView 处理新建表单;UpdateView 处理编辑表单;DeleteView 处理删除确认与提交。它们分别把“取上下文、取对象、跑表单”这些重复链路固化成可覆写的钩子方法。
概念解释
- 列表/详情视图基于
SingleObjectMixin/MultipleObjectMixin,CRUD 视图基于FormMixin/ModelFormMixin。 - 基类组合遵循“Mixin 在前、Django 基类在后”的顺序,保证 MRO 中钩子方法按预期串接。
原理流程
ListView.get调get_queryset,分页后经get_context_data注入object_list。DetailView.get调get_object取对象,注入object/<model_name>。CreateView/UpdateView的get渲染空/绑定表单,post调form_valid保存并跳转。DeleteView的get渲染确认页,post删除对象后跳success_url。
代码或图示
from django.views.generic import ListView, DetailView, CreateView
from .models import Article
class ArticleListView(ListView):
model = Article
paginate_by = 10
class ArticleDetailView(DetailView):
model = Article
class ArticleCreateView(CreateView):
model = Article
fields = ["title", "body"]
常见误区
CreateView写了model又写fields之外还自定义form_class:二者选一个口径,避免字段来源不一致。- 以为
ListView默认带分页:需要显式设paginate_by或在视图里配置paginate_kwargs。 DeleteView必须提供success_url,否则 POST 后反向解析失败。
追问
ListView上下文里对象叫什么?答:object_list,同时带模型小写名(如article_list)。DetailView找不到对象返回什么?答:抛出Http404,模板渲染为 404 页面。- CRUD 视图的表单类如何替换?答:覆写
form_class,并保持fields与模型字段一致。
04.7.16.3-004 类视图 Mixin 的组合顺序由什么决定?super() 链怎么走?
一句话结论
组合顺序由类声明的从左到右顺序与 Python MRO(C3 线性化)决定,Django 惯例是 Mixin 写在左、基类写在右;每个钩子方法内部调用 super().xxx(),调用链沿 MRO 向上推进。顺序错了会导致 get_context_data 覆盖、对象被重复查找或属性取错。
概念解释
- MRO 保证“每个类只出现一次、子类在前”,可用
View.__mro__检查。 - Mixin 只提供可插拔行为,不单独承担完整视图职责,通常不直接继承
View。
原理流程
- 声明
class PostView(OwnerCheckMixin, ListView),Python 计算 MRO:PostView → OwnerCheckMixin → ListView → ... → object。 - 调用
get_context_data时,沿 MRO 找到第一个实现,其内部super()交给链上下一个。 - 各 Mixin 在
super()前加前置逻辑、在返回后加后置修改,形成洋葱式包装。 - 链的末端由 Django 基类提供默认实现,例如
ListView.get_context_data注入分页上下文。
代码或图示
class OwnerCheckMixin:
def get_object(self, queryset=None):
obj = super().get_object(queryset)
if obj.author != self.request.user:
raise PermissionDenied
return obj
class PostDetailView(OwnerCheckMixin, DetailView):
model = Post
常见误区
- Mixin 顺序写反:把基类放左、Mixin 放右,
super()链直接跳过 Mixin 的覆写。 - Mixin 之间假设对方一定存在:跨 Mixin 调用属性时要标注依赖,否则复用时报
AttributeError。 - 多个 Mixin 各自
super()调用不一致:有的忘了调,链就断掉,基类上下文注入丢失。
追问
- 怎么检查 MRO 顺序?答:
PostView.mro()或inspect.getmro(PostView)打印线性化结果。 - Mixin 应该继承
View吗?答:一般不继承,只提供方法注入,避免菱形继承与重复初始化。 - 钩子方法签名不一致会怎样?答:
super()传参对不上会抛TypeError,覆写时要保留原签名。
04.7.16.3-005 get_context_data 如何追加上下文?为什么必须先调 super()?
一句话结论
get_context_data 返回传给模板的上下文字典;自定义追加字段时先 context = super().get_context_data(**kwargs) 拿到基类注入的 object_list、paginator 等,再往 context 里塞自定义键。跳过 super() 会丢失基类上下文,模板里 object_list、object 全部不可用。
概念解释
- 上下文是普通 dict,Django 渲染模板时再叠加上下文处理器与请求信息。
- 同名键覆盖是显式行为:后写入的值覆盖先写入的值,命名要避开
object/object_list等保留键。
原理流程
- 视图
get调get_context_data,沿 MRO 进入自定义实现。 super().get_context_data(**kwargs)触发基类注入模型对象、分页器等上下文。- 自定义实现向字典追加统计数、标签列表、筛选选项等业务数据。
- 字典随
render_to_response交给模板引擎。
代码或图示
class PostListView(ListView):
model = Post
def get_context_data(self, **kwargs):
context = super().get_context_data(**kwargs)
context["tag_list"] = Tag.objects.all()
context["total_count"] = Post.objects.count()
return context
常见误区
- 直接
return {"tag_list": ...}而不经过super(),导致object_list丢失。 - 在上下文里放未求值的大 QuerySet:模板遍历时才查库,容易产生 N+1,应在视图层算好。
- 键名与基类冲突:例如覆盖
object导致详情模板取值异常。
追问
- 上下文里能放
request吗?答:模板可通过{{ request }}访问,前提是RequestContext与request上下文处理器开启。 - 自定义上下文应该放视图还是上下文处理器?答:单视图数据放视图;跨页面复用的用户/站点信息放上下文处理器。
- 上下文里的 QuerySet 何时执行 SQL?答:惰性求值,模板遍历或切片时才执行。
04.7.16.3-006 get_object 的查找流程是什么?如何按 slug 取对象?
一句话结论
get_object 先取 get_queryset() 作为限定范围,再按 URLconf 捕获的 pk 或 slug 在查询集里过滤;找不到抛 Http404。按 slug 路由时,URLconf 用 slug: 转换器并在视图设 slug_field,Django 自动把 kwargs["slug"] 映射到该字段。
概念解释
get_object接受可选queryset参数,便于 Mixin 限定可访问范围。pk_url_kwarg/slug_url_kwarg决定从 kwargs 里取哪个键,字段名与 URL 参数名不一致时显式映射。
原理流程
DetailView.get调get_object(self.get_queryset())。- 优先用
pk_url_kwarg(默认pk)匹配查询集;没有pk再用slug_field与slug_url_kwarg。 - 过滤后执行
get(),命中对象返回,未命中抛Http404。 - 结果挂到
self.object,供get_context_data与后续方法使用。
代码或图示
# urls.py
from django.urls import path
from .views import PostDetailView
urlpatterns = [
path("post/<slug:slug>/", PostDetailView.as_view(), name="post-detail"),
]
# views.py
class PostDetailView(DetailView):
model = Post
slug_field = "slug"
slug_url_kwarg = "slug"
常见误区
- 查询集没有先按当前用户过滤:任何知道 slug 的人都能取到别人的对象,对象级鉴权要在
get_queryset或get_object里补。 slug_field写成模型上不存在的字段:过滤条件报错或匹配为空。- 以为
get_object会处理软删除:需要在get_queryset里排除已删除记录,否则已删对象仍可访问。
追问
slug与pk同时出现在 URL 怎么办?答:pk_url_kwarg优先,需要自定义get_object覆盖优先级。- 找不到对象一定是 404 吗?答:
get()抛DoesNotExist,get_object捕获后转成Http404;鉴权失败应抛PermissionDenied。 - 复合唯一键怎么查?答:覆写
get_object,从self.kwargs取多个字段自行过滤。
04.7.16.3-007 get_queryset 与 get_object 是什么关系?权限过滤放哪一层?
一句话结论
get_queryset 定义“当前用户可见的全集”,get_object 在这个全集里取单个对象;列表与详情共用同一套可见范围,是最干净的鉴权分层。行级/对象级过滤放 get_queryset,单对象的额外校验放 get_object 或 Mixin。
概念解释
get_queryset默认返回self.model._default_manager.all(),覆写后详情视图自动复用,避免两处口径漂移。- 权限要求“看不到”与“看到但不可编辑”是两种处理:前者过滤查询集,后者在表单/按钮上控制。
原理流程
- 列表视图直接遍历
get_queryset()。 - 详情/编辑视图把
get_queryset()传给get_object做过滤范围。 - 覆写
get_queryset按request.user、站点、软删除状态裁剪全集。 - 覆写
get_object做对象归属、状态、锁定等二次校验。
代码或图示
class OwnedPostMixin:
def get_queryset(self):
return super().get_queryset().filter(author=self.request.user)
def get_object(self, queryset=None):
obj = super().get_object(queryset)
if obj.is_locked:
raise PermissionDenied("locked")
return obj
常见误区
- 只在
DetailView里判归属、ListView不过滤:列表泄露标题与摘要,接口泄露对象。 - 把权限判断写进模板:模板只能隐藏按钮,直接访问 URL 仍可绕过。
get_queryset里访问未登录用户导致匿名报错:先判断request.user.is_authenticated。
追问
- 列表里也需要“锁定不可编辑”标识怎么办?答:查询集里取状态字段,模板按状态渲染按钮,对象级拒绝仍在后端校验。
- 管理员看全集、普通用户看自己的怎么写?答:
get_queryset里按is_staff分支返回不同查询集。 - 多租户隔离放哪一层?答:
get_queryset按租户过滤,配合中间件解析当前租户。
04.7.16.3-008 get_success_url 与 success_url 的优先级是什么?
一句话结论
form_valid/delete 成功后调用 get_success_url() 生成跳转地址;get_success_url 默认返回 self.success_url,因此覆写 get_success_url 优先于类属性 success_url。需要按对象动态拼 URL(如跳转回详情页)时覆写 get_success_url。
概念解释
success_url可以是reverse_lazy结果或硬编码路径;类属性在 URLconf 未加载完时也安全。get_success_url里可访问self.object(Create/Update/Delete 视图已绑定)。
原理流程
- 表单合法或删除提交后,视图调
self.get_success_url()。 ModelFormMixin.get_success_url默认返回self.success_url。- 子类覆写时用
reverse_lazy带kwargs={"pk": self.object.pk}反向解析。 - 返回的 URL 经
HttpResponseRedirect跳走。
代码或图示
from django.urls import reverse_lazy
from django.views.generic import UpdateView
class PostUpdateView(UpdateView):
model = Post
fields = ["title", "body"]
def get_success_url(self):
return reverse_lazy("post-detail", kwargs={"slug": self.object.slug})
常见误区
- 在模块导入阶段调用
reverse():URLconf 尚未加载会报错,延迟场景用reverse_lazy。 get_success_url里访问self.object但该属性在删除视图已置空:删除后跳转依赖查询参数或列表页。- 同时设
success_url又覆写get_success_url:覆写生效,类属性被忽略,口径要统一。
追问
reverse与reverse_lazy区别?答:reverse立即解析,reverse_lazy返回惰性对象,适合类属性与导入期赋值。- 保存后想返回来源页怎么办?答:从
request.POST.get("next")或HTTP_REFERER取值并校验白名单。 - 删除成功跳哪里?答:
DeleteView同样走get_success_url,通常跳列表页。
04.7.16.3-009 form_valid/form_invalid 在编辑类视图里处于什么位置?
一句话结论
CreateView/UpdateView 的 POST 流程:表单绑定数据 → is_valid() 通过则进 form_valid(默认保存对象并跳转),不通过进 form_invalid(默认重渲染带错误的表单)。覆写 form_valid 是“保存前后挂业务逻辑”的标准扩展点,不要在覆写里绕开 form.save()。
概念解释
form_valid默认调form.save(),再redirect(self.get_success_url())。form_invalid默认render(self.request, self.get_template_name(), {"form": form})。
原理流程
post方法构造绑定表单,调用form.is_valid()。- 合法:
form_valid(form),内部保存对象、记录关系、投递钩子、跳转。 - 非法:
form_invalid(form),把带错误的表单回传模板。 - 覆写时保留
super().form_valid(form)可复用保存与跳转,或自行实现完整分支。
代码或图示
class PostCreateView(CreateView):
model = Post
fields = ["title", "body"]
def form_valid(self, form):
form.instance.author = self.request.user
response = super().form_valid(form)
# 保存后可做:发通知、写审计、投递异步任务
return response
常见误区
- 覆写
form_valid只设置字段却不调form.save():对象未入库,跳转后详情页 404。 - 在
form_valid里访问未提交的关联对象:commit=False场景要先save()再挂 m2m。 - 覆写
form_invalid后丢失模板上下文:直接render时记得把form传入。
追问
- 保存前后要发通知放哪?答:
form_valid里对象保存后;涉及外部副作用优先transaction.on_commit再投递任务。 form.save(commit=False)后还要做什么?答:补字段、保存实例、form.save_m2m()再返回。- 表单不通过时想返回 JSON 怎么办?答:覆写
form_invalid返回JsonResponse(form.errors, status=400)。
04.7.16.3-010 装饰器如何作用到类视图?method_decorator 的边界是什么?
一句话结论
函数视图装饰器默认只接收函数,类视图需要用 method_decorator 把装饰器包成“方法装饰器”,通常装饰 dispatch 以覆盖全部 HTTP 方法,或装饰具体的 get/post。csrf_exempt、login_required、permission_required 都通过这条路挂到类视图上。
概念解释
method_decorator(decorator, name="dispatch")也可作为类装饰器声明。- 装饰器必须能正确转发
*args, **kwargs,否则类视图闭包签名会被破坏。
原理流程
- 选目标:
dispatch覆盖所有方法,post只保护写操作。 - 用
method_decorator把函数装饰器转换为方法级包装。 - 包装后的方法在 MRO 链中参与分发。
- 鉴权类装饰器在未通过时直接返回重定向或 403,不再进入视图逻辑。
代码或图示
from django.utils.decorators import method_decorator
from django.contrib.auth.decorators import login_required
from django.views.generic import CreateView
@method_decorator(login_required, name="dispatch")
class PostCreateView(CreateView):
model = Post
fields = ["title", "body"]
常见误区
- 直接把
@login_required堆在类上:装饰器收到的是类而不是函数,行为不符合预期。 - 只装饰
get不装饰post:GET 被保护、POST 仍可匿名提交。 - 装饰器内部用了函数视图特有的闭包假设:与类视图
self绑定方式冲突时需要检查装饰器实现。
追问
- 多个装饰器顺序怎么排?答:按洋葱顺序,靠近
dispatch的先执行请求、后执行回程,鉴权一般放最外层。 csrf_exempt装饰类视图怎么做?答:method_decorator(csrf_exempt, name="dispatch"),仅 API 等豁免场景使用。- 权限检查能写成 Mixin 替代装饰器吗?答:能,Mixin 在
dispatch/get_object里抛PermissionDenied,复用性更好。
04.7.16.3-011 类视图里什么时候能访问 self.request、self.args、self.kwargs?
一句话结论
这些属性由 as_view() 返回的闭包在实例化之后、调用 dispatch 之前绑定,因此 dispatch 及其下游的 get/post/get_object/get_context_data 都能安全访问;__init__、类属性定义阶段访问不到。URL 捕获参数在 self.kwargs,位置参数在 self.args。
概念解释
self.request是HttpRequest实例,self.args/kwargs来自 URLconf 匹配结果。- 类属性在导入期求值,此时没有请求上下文,不能写
self.request.user。
原理流程
- 闭包收到
request, *args, **kwargs。 - 构造实例后执行
self.request = request; self.args = args; self.kwargs = kwargs。 - 调用
self.dispatch(...),此后所有钩子方法可读这些属性。 - 请求结束实例丢弃,属性不残留。
代码或图示
class MyView(View):
def get(self, request, *args, **kwargs):
user = self.request.user
slug = self.kwargs["slug"]
return HttpResponse(f"{user} {slug}")
常见误区
- 在
__init__里读self.request:此时属性尚未绑定,抛AttributeError。 - 把请求相关值写进类属性缓存:多请求共享,串号泄露。
- 混淆
args与kwargs:re_path捕获组按位置进args,命名捕获进kwargs。
追问
- 上下文处理器注入的
request与self.request是同一个吗?答:是同一个请求对象。 - 异步视图里
self.request有区别吗?答:属性绑定方式一致,只是方法为async def,访问用户等同步属性需注意异步 ORM 边界。 - 如何在 Mixin 里取 URL 参数?答:直接读
self.kwargs,Mixin 方法同样在绑定之后执行。
04.7.16.3-012 写一个可复用 Mixin 有哪些注意事项?
一句话结论
好的 Mixin 只注入单一职责的方法与属性,不继承 View,保留 super() 调用链,方法签名与被混入的基类一致,并在文档里写明依赖。Mixin 之间避免状态冲突,共享数据通过约定的属性名传递,而不是互相假设对方实现。
概念解释
- Mixin 是“行为片段”,生命周期由最终视图类决定;它不应该单独被 URLconf 引用。
- 可测试性:Mixin 的方法应能在最小视图类上独立验证。
原理流程
- 提炼跨视图重复行为:鉴权、上下文注入、对象归属校验、响应格式。
- 实现钩子方法,内部
super()串接 MRO 链。 - 在具体视图类中按“Mixin 在前、基类在后”声明。
- 通过
mro()检查顺序,补充属性默认值与类型说明。
代码或图示
class StaffRequiredMixin:
def dispatch(self, request, *args, **kwargs):
if not request.user.is_staff:
raise PermissionDenied
return super().dispatch(request, *args, **kwargs)
常见误区
- Mixin 里写
self.object = ...又被另一个 Mixin 覆盖:状态归属不清,排查困难。 - 多个 Mixin 同名方法不调
super():链中断,后基类逻辑丢失。 - 把大段业务流程塞进 Mixin:复用面变窄,不如拆成服务层函数。
追问
- Mixin 与装饰器怎么选?答:横切、无状态包装用装饰器;需要覆写多个钩子、持有视图状态用 Mixin。
- Mixin 能读模型字段吗?答:可通过
self.object/self.get_queryset()间接读,避免硬编码具体模型。 - Mixin 失败如何定位?答:打印
View.mro(),沿链检查每个方法是否调了super()。
04.7.16.3-013 slug 路由转换器与模型 SlugField 有什么约束?
一句话结论
URLconf 的 slug: 转换器只匹配 ASCII 字母、数字、连字符与下划线;模型 SlugField 默认同样限制 ASCII,allow_unicode=True 才允许中文等字符。slug 应在模型层保证唯一、稳定,路由转换器只做格式拦截,不负责唯一性。
概念解释
- slug 是面向 URL 的可读标识,替代自增主键暴露在地址栏。
- 转换器不匹配时进入 404,而不是渲染错误表单。
原理流程
- URLconf 声明
<slug:slug>,请求路径按字符集匹配。 - 匹配成功后
kwargs["slug"]进入视图。 - 视图用
slug_field在查询集过滤,get()命中返回对象。 - 模型保存时由
pre_save或slugify生成 slug,unique=True保证不重复。
代码或图示
from django.db import models
from django.utils.text import slugify
class Article(models.Model):
title = models.CharField(max_length=120)
slug = models.SlugField(max_length=140, unique=True, allow_unicode=True)
def save(self, *args, **kwargs):
if not self.slug:
self.slug = slugify(self.title, allow_unicode=True)
super().save(*args, **kwargs)
常见误区
- 标题改动后 slug 不更新:老链接失效,常见做法是 slug 一次生成后冻结,或保留历史 slug 重定向。
allow_unicode与转换器不匹配:中文 slug 在slug:转换器下 404,需自定义转换器或改用path。- 长标题截断后 slug 重复:生成时追加短随机串或查询冲突后递增序号。
追问
- 如何为 slug 保证全局唯一?答:
unique=True,生成时检测冲突并追加序号或随机后缀。 - 想在 URL 里用中文怎么办?答:
SlugField(allow_unicode=True)并自定义路径转换器,注意编码与历史兼容。 - slug 能当主键吗?答:技术上可以用
primary_key=True,但 slug 变更成本高,一般仍用自增 id 做主键。
04.7.16.3-014 get_absolute_url 解决什么问题?为什么常配 reverse_lazy?
一句话结论
get_absolute_url 在模型实例上返回其详情页 URL,模板与视图直接调 {{ object.get_absolute_url }},避免各处硬编码路径。类属性或导入期赋值用 reverse_lazy 惰性解析,避免 URLconf 尚未加载时调用 reverse() 报错。
概念解释
- 模型只负责“自己的 URL 是什么”,路由规则集中在 URLconf,改路由不用改模板。
reverse_lazy返回惰性对象,真正取值时才解析,适合类属性与AppConfig阶段。
原理流程
- 模型实现
get_absolute_url,内部reverse带kwargs反向解析命名路由。 - 模板链接、列表跳转、后台“在站点查看”都调用该方法。
- 路由改名时只改 URLconf,实例 URL 自动跟随。
- 导入期需要 URL 的场景(如
success_url类属性)使用reverse_lazy。
代码或图示
from django.urls import reverse
from django.db import models
class Article(models.Model):
slug = models.SlugField(unique=True)
def get_absolute_url(self):
return reverse("article-detail", kwargs={"slug": self.slug})
常见误区
- 在模块顶层
reverse("xxx"):URLconf 未加载完成时抛NoReverseMatch。 get_absolute_url里访问不存在的字段:实例化任何对象都报错。- 把业务跳转(编辑页、删除页)也塞进
get_absolute_url:该方法语义是“详情页”,其他跳转单独写方法。
追问
reverse什么时候可以直接用?答:请求处理期、视图函数内 URLconf 已加载完成。- 站点后台的“在站点上查看”链接来自哪里?答:Admin 调用模型的
get_absolute_url。 - 模型跨应用反向解析要注意什么?答:使用带命名空间的路由名,如
blog:article-detail。
04.7.16.3-015 URL 命名空间与 reverse 解析有哪些规则?
一句话结论
include() 可带 namespace,路由名格式为 namespace:viewname,子应用还可分实例命名空间与应用命名空间。reverse("blog:post-detail", kwargs={...}) 按命名空间定位 URLconf;同名视图在不同应用下靠命名空间区分,避免冲突。
概念解释
app_name定义应用命名空间,include((urlpatterns, app_name), namespace=...)定义实例命名空间。- 解析顺序:当前请求的
ResolverMatch命名空间优先,再按绝对命名空间查找。
原理流程
- 根 URLconf
include("blog.urls", namespace="blog")挂载子路由。 - 子
urls.py设app_name = "blog",路由有name="post-detail"。 reverse("blog:post-detail", kwargs={"slug": ...})拼接并反向匹配模式。- 多实例部署(如多租户挂载同一应用)时用实例命名空间区分。
代码或图示
# blog/urls.py
from django.urls import path
from .views import PostDetailView
app_name = "blog"
urlpatterns = [
path("post/<slug:slug>/", PostDetailView.as_view(), name="post-detail"),
]
# 项目 urls.py
path("blog/", include("blog.urls", namespace="blog"))
常见误区
- 漏写
app_name导致命名空间解析警告或冲突。 - 模板
{% url %}里只写视图名不写命名空间:多应用重名时解析到错误分支。 - 嵌套
include后命名空间层级写错:outer:inner:view,层级与挂载路径不一致会NoReverseMatch。
追问
{% url %}标签与reverse是同一套解析吗?答:是,模板标签内部调用反向解析。- 实例命名空间与应用命名空间区别?答:应用命名空间标识代码包,实例命名空间标识一次挂载,多实例用实例名区分。
NoReverseMatch怎么排查?答:打印request.resolver_match,核对路由名、命名空间与 kwargs 是否齐全。
04.7.16.3-016 详情视图找不到对象时 Http404 如何流转到 404 页面?
一句话结论
get_object 在查询集过滤后 get() 未命中,捕获 DoesNotExist 抛出 Http404;Django 的异常中间件把 Http404 转成 404 响应并渲染 404.html。DEBUG=True 时展示调试页面与异常栈,DEBUG=False 时才走正式 404 模板。
概念解释
Http404是 Django 定义的异常,不是 HTTP 状态码本身;状态码由异常处理器写入响应。- 权限不足抛
PermissionDenied,对应 403,不要用 404 掩盖鉴权失败。
原理流程
- 视图调用
get_object,查询集get(**filters)。 - 未命中抛
Model.DoesNotExist,被捕获后转Http404。 - 异常冒泡到
ExceptionMiddleware,转换为 404 响应。 - 模板层查找模板目录下的
404.html,未配置则用默认错误页。
代码或图示
from django.http import Http404
from django.shortcuts import get_object_or_404
def post_detail(request, slug):
post = get_object_or_404(Post, slug=slug)
return render(request, "post_detail.html", {"post": post})
常见误区
- 鉴权失败也抛
Http404:语义错误,403 与 404 的监控、缓存策略不同。 - 在
DEBUG=True下测完直接上线:本地看到的是调试栈,线上 404 模板未准备好。 - 捕获
Http404后返回 200:破坏状态码语义,监控与 CDN 缓存会误判。
追问
get_object_or_404与get_object内部一致吗?答:都是get()失败转Http404,前者是函数视图快捷方式。- 自定义 404 模板放哪?答:模板根目录
404.html,需DEBUG=False且ALLOWED_HOSTS配置正确。 - 404 响应能带 JSON 吗?答:API 视图可捕获
Http404返回JsonResponse(..., status=404)。
04.7.16.3-017 Form 与 ModelForm 怎么选型?
一句话结论
Form 是纯字段与校验容器,不绑定模型,适合搜索框、登录、联系人留言等不直接落库的场景;ModelForm 关联模型,自动生成字段、校验模型约束并提供 save()。表单数据需要直接持久化到模型时用 ModelForm,否则用 Form。
概念解释
ModelForm本质是在Form之上套一层模型元数据:字段类型、必填、unique校验都从模型推导。- 二者共用
is_valid()、clean()、错误结构,模板渲染方式一致。
原理流程
- 定义字段列表与
widget/label/help_text。 Form绑定data后只做字段与clean()校验,取cleaned_data。ModelForm绑定后额外走模型实例校验,save()写库。- 复杂跨模型编排仍在视图/服务层完成,表单不承担多表事务。
代码或图示
from django import forms
from .models import Post
class SearchForm(forms.Form):
q = forms.CharField(max_length=80, required=False)
class PostForm(forms.ModelForm):
class Meta:
model = Post
fields = ["title", "body", "tags"]
常见误区
- 用
ModelForm承载纯查询条件:模型约束(必填、唯一)被带进搜索表单,体验错误。 - 在
ModelForm.Meta.fields写"__all__":后续模型新增敏感字段会自动暴露,应显式列字段。 - 把业务权限判断写进表单:表单不知道当前用户,归属与可见范围在视图层注入。
追问
ModelForm能改模型字段行为吗?答:能,显式声明同名字段覆盖widget、label、validators。- 一个表单写多个模型怎么办?答:用组合的
Form/ModelForm,视图里分别保存并包事务。 Form的cleaned_data一定有所有字段吗?答:is_valid()为真时才有,未通过校验时字段可能缺失。
04.7.16.3-018 表单字段类型与 widget 如何映射?
一句话结论
字段类型(CharField、IntegerField、ChoiceField 等)决定校验规则与 cleaned_data 类型;widget 决定渲染成什么 HTML 控件(TextInput、Select、CheckboxInput、FileInput)。二者正交:同一个字段可换 widget,同一个 widget 可配不同校验字段。
概念解释
- 字段默认带一个 widget,可在表单类里用
widgets字典覆盖。 - widget 不做类型转换与校验,只负责渲染与取值清洗前的输入。
原理流程
- 表单类声明字段,绑定默认 widget 与校验器。
- 渲染时 widget 生成
<input>/<select>等标签并带上属性。 - 提交后字段的
to_python把原始字符串转成 Python 类型,再跑校验器。 - 校验通过后值进入
cleaned_data。
代码或图示
from django import forms
class CommentForm(forms.Form):
nickname = forms.CharField(max_length=30, widget=forms.TextInput(attrs={"class": "input"}))
content = forms.CharField(widget=forms.Textarea(attrs={"rows": 4}))
agree = forms.BooleanField(label="同意条款")
常见误区
- 把 HTML 属性写进字段类型:
attrs必须挂在 widget 上。 - 用
CharField收数字却不转int:cleaned_data仍是字符串,比较与存储出错。 - 多选关系用
ModelMultipleChoiceField却配错 queryset:选项为空或泄露无权对象。
追问
ChoiceField与ModelChoiceField区别?答:前者选项是静态元组,后者从 queryset 动态生成并返回模型实例。- 日期字段默认 widget 是什么?答:
DateInput,可换成SelectDateWidget或第三方日期控件。 - 如何给 widget 加 CSS 类?答:
widget=forms.TextInput(attrs={"class": "..."})或在 Metawidgets中配置。
04.7.16.3-019 clean_<field> 的执行时机与返回值要求是什么?
一句话结论
字段级 clean_<fieldname> 在该字段的 to_python、validate、run_validators 之后、表单 clean() 之前执行;返回清洗后的值,校验失败抛 forms.ValidationError。它负责单字段的业务规则(格式、存在性、与已有数据比对),返回值会替换 cleaned_data 中的对应项。
概念解释
- 字段名与方法名必须严格对应:
email字段对应clean_email。 - 方法里访问
self.cleaned_data只能拿到此前已通过的字段,顺序依赖不可靠。
原理流程
- 绑定表单,
is_valid()触发逐字段清洗。 - 字段完成基础类型转换与内置校验。
- 调用
clean_<field>,开发者追加业务校验,返回新值。 - 最后进入表单级
clean()做跨字段判断。
代码或图示
class ResetPasswordForm(forms.Form):
email = forms.EmailField()
def clean_email(self):
email = self.cleaned_data["email"]
if not User.objects.filter(email=email, is_active=True).exists():
raise forms.ValidationError("该邮箱未注册或已停用")
return email
常见误区
- 抛错后忘记返回值:
cleaned_data中该字段缺失,后续clean()取值报KeyError。 - 在
clean_<field>里读其他尚未清洗的字段:值可能不在cleaned_data,跨字段判断放clean()。 - 做数据库查询却没处理异常:多租户/软删除场景容易查到无权数据。
追问
ValidationError的消息能带参数吗?答:能,用%(key)s)插值与params=做国际化翻译替换。- 字段级错误显示在哪里?答:模板
{{ form.email.errors }},绑定到字段标签下方。 - 多个校验规则如何复用?答:抽成可复用
Validator,挂到字段validators列表。
04.7.16.3-020 表单级 clean() 与字段级校验有什么区别?
一句话结论
clean() 在所有字段通过 clean_<field> 之后执行,适合跨字段规则(两次密码一致、起止时间先后、组合条件必填);它返回完整 cleaned_data,字段级错误通过 add_error(field, ...) 挂到具体字段,其余进 non_field_errors。跨字段一致性不要拆到各个 clean_<field> 里互相读取。
概念解释
clean()可访问完整cleaned_data,但仍要做dict.get防护,因为前置字段可能已报错。ModelForm的clean()之后还有模型实例自身的full_clean()约束校验。
原理流程
- 逐字段清洗与
clean_<field>全部完成。 - 调用表单
clean(),读取多个字段做组合判断。 - 违规时
add_error绑定字段,或抛ValidationError进入非字段错误。 - 返回(必要时修改后的)
cleaned_data,进入ModelForm实例校验或视图。
代码或图示
class RangeForm(forms.Form):
start = forms.DateField()
end = forms.DateField()
def clean(self):
cleaned = super().clean()
start = cleaned.get("start")
end = cleaned.get("end")
if start and end and end < start:
raise forms.ValidationError("结束日期不能早于开始日期")
return cleaned
常见误区
- 覆写
clean()不调super().clean():基类已做的字段汇总逻辑丢失。 - 直接从
self.data取原始字符串比较:绕过清洗后的类型,时区/格式错误导致误判。 - 跨字段错误只挂非字段错误:用户不知道改哪一项,能用
add_error定位字段就定位。
追问
non_field_errors在哪里渲染?答:模板{{ form.non_field_errors }},通常放表单顶部。ModelForm.clean()与模型clean()什么关系?答:表单clean()先跑,模型clean()在实例full_clean()阶段跑,二者都可覆写。- 组合必填(填了 A 必填 B)怎么写?答:
clean()里if cleaned.get("a") and not cleaned.get("b")抛错并add_error("b", ...)。
04.7.16.3-021 Django 表单的完整校验顺序是怎样的?
一句话结论
顺序为:字段 to_python 类型转换 → 字段 validate 内置规则 → run_validators 自定义校验器 → 表单 clean_<field> → 表单级 clean();ModelForm 在表单校验通过后还会对模型实例跑 full_clean(),检查模型字段约束、unique 与模型 clean()。理解这条链才能判断某个错误该在哪一层拦截。
概念解释
- 每一步收集的错误独立存放:字段错误可定位到具体控件,表单错误进
non_field_errors。 - 前面字段失败后,后续跨字段判断要防御性取
cleaned_data.get(...)。
原理流程
is_valid()对绑定表单逐字段清洗,先转换类型再跑内置校验。- 字段自定义校验器执行,随后
clean_<field>做业务规则。 - 所有字段完成后调用表单
clean()做跨字段一致性。 ModelForm把数据灌入实例,执行模型full_clean(),再由视图决定save()。
代码或图示
to_python → validate → run_validators → clean_<field> → clean()
→ (ModelForm) instance.full_clean() → model.clean() → save()
常见误区
- 把模型层
unique校验期待在字段级拦截:它在实例full_clean()阶段才跑,错误可能挂到字段或表单级。 - 以为
clean_<field>失败后clean()还能读到该字段:失败字段不在cleaned_data。 - 视图里重复跑校验:
is_valid()已走完整条链,手动再调full_clean()会产生重复错误。
追问
- 模型
unique_together错误挂在哪?答:实例校验阶段,通常作为模型字段错误或表单非字段错误返回。 - 校验器抛错后值还进
cleaned_data吗?答:不进,该字段以错误形式存在。 - 想跳过某条内置校验怎么做?答:字段层关闭对应
required/validators,模型约束不能在表单层关闭。
04.7.16.3-022 ModelForm.save(commit=False) 之后还要做什么?
一句话结论
commit=False 返回未入库的模型实例,便于先补当前用户、计算派生字段、挂多对多关系;补完后调 instance.save(),再调 form.save_m2m() 保存 m2m。直接返回 commit=False 的实例就跳转,关联关系会丢失。
概念解释
- 单对多外键在实例保存时写入;多对多必须等实例有主键后才能建关系表记录。
commit=False不触发数据库写入,也不发pre_save/post_save信号。
原理流程
- 表单合法,
form.save(commit=False)构造实例但不执行 INSERT。 - 视图补充
author=request.user等请求相关字段。 instance.save()入库获得主键。form.save_m2m()把表单中的 m2m 选择写入关系表。
代码或图示
def post_create(request):
form = PostForm(request.POST)
if form.is_valid():
post = form.save(commit=False)
post.author = request.user
post.save()
form.save_m2m()
return redirect(post.get_absolute_url())
return render(request, "post_form.html", {"form": form})
常见误区
- 漏调
save_m2m():标签、分类等 m2m 关系保存不上。 - 在
commit=False后直接读对象主键:尚未保存,主键为None。 - 新建与编辑混用:编辑场景实例已存在,
save_m2m()同样需要调用以刷新关系。
追问
save_m2m()什么时候必须调?答:只要表单含 m2m 字段且用了commit=False,实例保存后就要调。- 想在保存前后做事务包裹怎么做?答:视图层
with transaction.atomic():包住save()与save_m2m()。 commit=False的实例能传给模板吗?答:能渲染,但未持久化,刷新后数据丢失。
04.7.16.3-023 ModelForm 如何校验模型字段约束?
一句话结论
ModelForm 从模型元数据推导字段的必填、max_length、unique、外键存在性等规则;表单校验通过后,实例 full_clean() 再核对模型层约束(含 unique_together、unique_for_date、模型 clean())。数据库唯一索引是最后兜底,表单层报错信息更友好。
概念解释
- 模型
blank=True对应表单非必填,null=True不直接决定表单必填(CharField 仍按blank判断)。 - 外键字段用
ModelChoiceField,queryset 非法值会校验失败。
原理流程
- 表单类元数据读取模型字段,生成对应表单字段与默认校验器。
- 绑定数据后走表单校验链。
- 实例化模型对象,
full_clean()跑模型字段与模型级校验。 - 视图
save()时数据库约束作为最后防线,违反会抛IntegrityError。
代码或图示
class Article(models.Model):
title = models.CharField(max_length=100, unique=True)
slug = models.SlugField(max_length=120, unique_for_date="published_at")
class ArticleForm(forms.ModelForm):
class Meta:
model = Article
fields = ["title", "slug", "published_at"]
常见误区
- 以为
null=True表单就非必填:字符串字段按blank判断,null只影响数据库存储。 - 数据库唯一索引与表单校验不一致:并发下仍可能撞索引,视图要捕获
IntegrityError兜底。 - 模型
clean()里抛错但表单不显示:确认full_clean()被调用,Admin 与 ModelForm 默认会走。
追问
unique校验需要查库吗?答:需要,表单校验时按现有记录比对;编辑场景排除当前实例。- 外键不存在时表单报什么错?答:
ModelChoiceField校验失败,提示选择的选项无效。 - 模型级校验失败如何转成表单错误?答:
full_clean()抛出的ValidationError会被 ModelForm 收集进错误字典。
04.7.16.3-024 表单的 initial 与 instance 分别用在什么场景?
一句话结论
initial 是未绑定表单时的初始展示值,只影响 GET 渲染,不参与校验;instance 是 ModelForm 绑定的已有模型对象,用于编辑回填,POST 合法时在该实例上更新。新建用 initial 填默认值,编辑传 instance=obj。
概念解释
- 绑定表单(传
data)后initial不再覆盖提交值,只作为字段缺省。 instance未提供时 ModelForm 新建空实例;提供则回填现有数据。
原理流程
- GET 请求构造未绑定表单,
initial字典注入默认值供 widget 渲染。 - 编辑视图从库取出对象,
ModelForm(instance=obj)回填字段。 - POST 绑定
data,校验通过后save()更新该实例。 initial值不会自动入库,需要在form_valid或cleaned_data中显式处理。
代码或图示
# 新建:initial 给默认展示值
form = PostForm(initial={"channel": "general"})
# 编辑:instance 回填已有对象
form = PostForm(request.POST or None, instance=post)
常见误区
- 把请求用户塞进
initial期待自动保存:initial只渲染,入库要在视图层赋值。 - 编辑表单忘记传
instance:提交后变成新建重复记录。 initial与instance同名字段冲突:绑定数据优先,其次instance,initial仅在无值时展示。
追问
- 类视图里怎么传
initial?答:覆写get_initial()返回字典,或设initial类属性。 instance能是未保存的实例吗?答:可以,用于预填部分字段的新建场景,save()时再入库。- 初始值需要按用户动态计算放哪?答:
get_initial()或视图构造表单时读取request.user。
04.7.16.3-025 formset_factory 是什么?extra/initial 如何控制表单数量?
一句话结论
formset_factory(Form, extra=N) 生成一组同类型表单的集合,用于一次提交多行数据;extra 是额外空白表单数量,initial 提供预填数据列表,can_delete 控制是否显示删除勾选。formset 自身有校验、数量上限与 management form 跟踪。
概念解释
- formset 是“表单的表单”:外层管理数量与一致性,内层是一个个独立
Form。 - 与模型无关的普通行数据用普通 formset,关联模型用 inline formset。
原理流程
formset_factory(ArticleForm, extra=2)生成ArticleFormSet类。- GET 时按
extra渲染空白表单,initial列表预填对应行。 - POST 时解析 management form 中的数量字段,逐行绑定校验。
- 校验通过后遍历
formset.save()或cleaned_data处理每行。
代码或图示
from django.forms import formset_factory
ItemFormSet = formset_factory(ItemForm, extra=3, can_delete=True)
def add_items(request):
formset = ItemFormSet(request.POST or None)
if formset.is_valid():
for form in formset:
if form.cleaned_data and not form.cleaned_data.get("DELETE"):
form.save()
return redirect("item-list")
return render(request, "items.html", {"formset": formset})
常见误区
- 模板漏渲染 management form:提交后
TOTAL_FORMS缺失,formset 解析失败。 - 空行未排除:
extra空白行被当成无效数据,应判断form.cleaned_data且未被标记删除。 max_num与前端可增删行数不一致:超过上限的行被丢弃或校验失败。
追问
min_num/max_num控制什么?答:允许提交的最少/最多表单数量,超出触发 formset 级错误。- formset 的错误在哪取?答:
formset.non_form_errors()是集合级错误,各行错误在form.errors。 - 动态增删行前端怎么配合?答:JS 复制表单块并更新 management form 的
TOTAL_FORMS。
04.7.16.3-026 inlineformset_factory 如何处理外键关联表单?
一句话结论
inlineformset_factory(ParentModel, ChildModel, form=ChildForm, extra=N) 生成绑定父子外键的表单集合,编辑父对象时一次维护其全部子对象;保存时子对象自动挂到当前父实例,无需手动填外键。典型场景:一篇文章下的多个段落、一个订单下的多个明细行。
概念解释
- 父对象必须先保存有主键,内联表单才能挂外键;新建父对象的同时提交子对象需在视图层包事务。
fk_name用于父表有多个指向子表外键时指定关联字段。
原理流程
- 工厂按父子模型与表单类生成内联 formset。
- 视图传
instance=parent,已存在的子对象回填成行。 - POST 校验通过,
formset.save()把子对象创建/更新/删除到父实例下。 can_delete勾选的子对象在保存时删除。
代码或图示
from django.forms import inlineformset_factory
from django.shortcuts import get_object_or_404
LineInlineFormSet = inlineformset_factory(
Order, OrderLine, form=OrderLineForm, extra=2, can_delete=True
)
def order_edit(request, pk):
order = get_object_or_404(Order, pk=pk)
formset = LineInlineFormSet(request.POST or None, instance=order)
if formset.is_valid():
formset.save()
return redirect("order-detail", pk=order.pk)
return render(request, "order_edit.html", {"formset": formset})
常见误区
- 父对象未保存就提交内联行:外键为空,子对象无法挂载,先保存父实例再处理 formset。
- 漏包事务:父对象保存成功、子对象失败导致半成品数据。
- 父子模型外键关系写反:工厂参数顺序是父、子,反了取不到回填数据。
追问
- 一对多与多对多内联有区别吗?答:
inlineformset_factory面向外键一对多;m2m 用普通模型表单多选或专门内联。 - 子对象的权限校验放哪?答:formset 自定义
clean()或视图遍历行时按当前用户判断。 - Admin 里的 TabularInline 背后是什么?答:同样基于内联 formset 机制封装。
04.7.16.3-027 formset 的 management form 包含哪些关键字段?
一句话结论
management form 用隐藏字段跟踪表单数量:TOTAL_FORMS(当前总行数)、INITIAL_FORMS(已存在行数)、MIN_NUM_FORMS、MAX_NUM_FORMS,可选 DELETE 标记。前端动态增删行后必须同步更新 TOTAL_FORMS,否则服务端按错误数量解析表单。
概念解释
- 这些字段由
formset.management_form在模板中渲染,不需要开发者手写。 - 服务端按
TOTAL_FORMS切片request.POST中的字段前缀,前缀形如form-0-title。
原理流程
- 模板
{{ formset.management_form }}输出隐藏输入。 - 每行字段以
form-<index>-<field>命名。 - POST 到达,formset 读取 management 字段确定行数与初始行。
- 逐行构造绑定表单并校验,删除标记在保存阶段生效。
代码或图示
<form method="post">
{% csrf_token %}
{{ formset.management_form }}
{% for form in formset %}
<div class="line">
{{ form.as_p }}
</div>
{% endfor %}
<button type="submit">保存</button>
</form>
常见误区
- JS 复制行后只加 DOM 不更新
TOTAL_FORMS:服务端只解析第一行,其余丢失。 - 手写隐藏字段漏掉
INITIAL_FORMS:删除既有行时计数错误。 - 字段前缀与 index 不连续:跳过 index 会导致切片错位,行号必须连续。
追问
- management form 能禁用吗?答:不能,它是 formset 解析的协议基础。
- 行号前缀如何自定义?答:formset 可设
prefix,字段前缀随之改变。 - 提交空 formset 合法吗?答:取决于
min_num,允许零行时空 formset 可通过校验。
04.7.16.3-028 表单错误结构如何区分字段错误与非字段错误?
一句话结论
form.errors 是字典:字段名键对应字段错误列表,__all__ 键存放非字段错误;模板可用 form.<field>.errors 定位控件下方,用 form.non_field_errors 渲染全局错误。ModelForm 的模型级错误同样汇入这套结构。
概念解释
field.errors是ErrorList,可遍历消息或转字符串。- 非字段错误通常是跨字段规则、模型级约束或业务整体校验失败。
原理流程
- 校验链各步收集
ValidationError,按归属挂到字段或表单级。 add_error(field, err)指定字段;不传字段则进__all__。- 视图取
form.errors传给模板,按位置渲染。 - API 场景可把错误字典序列化为 JSON 返回。
代码或图示
if not form.is_valid():
return JsonResponse(
{"errors": form.get_context_data().get("form", form).errors},
status=400,
)
常见误区
- 模板只渲染
{{ form.errors }}:非字段错误显示了,字段级错误被忽略。 - 把字段错误拼成一句话:丢失定位信息,用户不知道改哪个输入框。
- 错误消息直接暴露内部异常:应转成友好提示,原始栈记录到日志。
追问
form.errors与form.non_field_errors()区别?答:前者是完整字典含__all__,后者只返回非字段错误列表。- 如何拿到单字段错误消息列表?答:
form.errors["email"]或form.email.errors。 - 国际化错误消息怎么做?答:
ValidationError消息走翻译标记,配合LocaleMiddleware与翻译文件。
04.7.16.3-029 如何写可复用的自定义校验器?
一句话结论
校验器是接收值、违规抛 ValidationError 的函数,可挂到多个字段复用;带参数的校验器用闭包或类封装。校验器只做单值规则,跨字段规则仍放表单 clean()。可复用校验器应在参数化后保持错误消息一致、可翻译。
概念解释
- 字段
validators列表在run_validators阶段依次执行。 - 类校验器实现
__call__,便于携带配置参数与反序列化。
原理流程
- 定义函数接收
value,规则不满足时抛ValidationError。 - 在字段
validators=[...]中注册。 - 字段清洗到
run_validators阶段逐个调用。 - 多个字段共用时从公共校验模块导入,避免复制粘贴。
代码或图示
from django.core.exceptions import ValidationError
import re
def validate_phone(value):
if not re.fullmatch(r"1[3-9]\d{9}", str(value)):
raise ValidationError("手机号格式不正确")
class MinLength:
def __init__(self, length):
self.length = length
def __call__(self, value):
if len(str(value)) < self.length:
raise ValidationError(f"至少 {self.length} 个字符")
常见误区
- 校验器里查库并修改数据:校验应是纯规则,副作用放服务层。
- 正则未做全匹配:局部匹配导致非法值通过。
- 错误消息写死业务术语:复用到其他表单时口径不一致,应参数化消息。
追问
- 校验器与
clean_<field>怎么分工?答:纯单值规则抽校验器复用;需要访问其他字段或上下文的逻辑放表单方法。 - 模型字段能挂校验器吗?答:能,
models.CharField(validators=[...]),保存前full_clean()触发。 - 校验器报错后如何带参数?答:
ValidationError(message, params={"min": n}),消息用参数插值替换。
04.7.16.3-030 表单模板渲染有哪些方式?手动渲染要注意什么?
一句话结论
快捷渲染 as_p/as_table/as_ul 自动按段落/表格/列表输出全部字段;手动渲染可逐字段控制标签、控件、错误与帮助文本。生产页面通常手动布局:{{ form.field.label_tag }}、{{ form.field }}、{{ form.field.errors }}、{{ form.field.help_text }},并记得渲染 CSRF 与 management form。
概念解释
- 快捷方式适合内部工具与快速原型,样式可控性差。
- 每个字段控件自带初始值与错误状态,手动渲染不要绕过 widget 自己写
<input name>。
原理流程
- 视图构造表单传入模板上下文。
- 模板选择整体快捷渲染或逐字段手动渲染。
- 字段 widget 按
attrs生成 HTML,错误列表跟随字段输出。 - 提交时字段名与
cleaned_data键由表单类保证对应。
代码或图示
<form method="post" novalidate>
{% csrf_token %}
<div>
{{ form.title.label_tag }}
{{ form.title }}
{{ form.title.errors }}
</div>
<div>
{{ form.body.label_tag }}
{{ form.body }}
<p class="help">{{ form.body.help_text }}</p>
</div>
<button type="submit">提交</button>
</form>
常见误区
- 自己写
<input name="title">而不用{{ form.title }}:widget 属性、初始值与错误状态脱节。 - 漏掉
{% csrf_token %}:POST 被 CSRF 中间件拒绝。 novalidate关掉浏览器校验后后端错误未渲染:必须在模板输出字段错误。
追问
- 如何批量渲染字段但保留自定义样式?答:遍历
{{ form.visible_fields }},按字段类型加 CSS 类。 - 隐藏字段怎么输出?答:
{{ form.hidden_fields }}统一渲染,避免遗漏。 - 字段标签文案在哪改?答:模型/表单字段的
label,或模板label_tag后自定义文本。
04.7.16.3-031 模板继承如何通过 {% block %} 工作?
一句话结论
父模板用 {% block 名称 %} 预留可替换区域,子模板 {% extends "父模板" %} 后用同名 {% block %} 覆盖;未覆盖的区域保留父模板内容。继承是单链覆盖:子模板先解析自身 block,再回填到父模板骨架,公共头尾只写一次。
概念解释
{% extends %}必须是子模板第一个标签,否则继承不生效。- block 可嵌套,子级覆盖时要决定是否保留父级内容(
{{ block.super }})。
原理流程
- 渲染子模板,模板引擎读取
{% extends %}定位父模板。 - 收集子模板定义的各 block 内容。
- 载入父模板骨架,按 block 名用子内容替换对应区域。
- 未被覆盖的 block 保留父模板默认内容,最终输出完整 HTML。
代码或图示
{# base.html #}
<html>
<head><title>{% block title %}站点{% endblock %}</title></head>
<body>
{% block content %}{% endblock %}
</body>
</html>
{# child.html #}
{% extends "base.html" %}
{% block title %}文章列表{% endblock %}
{% block content %}<h1>列表</h1>{% endblock %}
常见误区
- 子模板在
{% extends %}之前写了普通 HTML:这些内容不会进入父骨架,被丢弃。 - 覆盖 block 时想保留父内容却不用
{{ block.super }}:父级导航/样式被整段抹掉。 - 多层继承中 block 名冲突:同名 block 沿继承链逐层覆盖,层级混乱时应改名区分。
追问
{{ block.super }}用在哪?答:子 block 需要在父内容前后追加内容时,先输出父级再补自己的部分。- 一个子模板能继承多个父模板吗?答:不能,模板继承是单链;公共片段用
{% include %}。 - block 里能写 Python 逻辑吗?答:只能用模板标签与过滤器,复杂计算放视图或自定义标签。
04.7.16.3-032 {% include %} 与模板继承有什么区别?
一句话结论
{% include "片段.html" %} 在当前位置嵌入另一个模板的渲染结果,是横向复用公共片段(导航、卡片、分页条);继承是纵向骨架覆盖,决定页面整体结构。include 每次渲染都重新解析片段,可通过 with 传入局部变量,不影响父模板上下文之外的数据。
概念解释
- include 片段默认继承当前上下文,
only关键字限制只传显式变量,避免上下文泄漏。 - 片段自身也可以再 include 或继承其他模板。
原理流程
- 主模板渲染到 include 标签位置。
- 载入被包含模板,按当前上下文(或
with指定变量)渲染。 - 片段输出替换回主模板对应位置。
- 主模板继续渲染后续内容。
代码或图示
{% include "partials/pagination.html" with page=page only %}
{% include "partials/card.html" with post=item %}
常见误区
- 用 include 拼页面大结构:纵向布局应交给继承,否则头尾重复、改一处漏多处。
- 片段依赖未在视图提供的上下文变量:渲染为空或报错,
only模式下尤其要显式传参。 - 在循环里 include 重片段:每次渲染都解析模板,列表页应评估性能,必要时内联。
追问
{% include %}能传模型实例吗?答:能,变量可以是对象,片段内访问其字段与方法。- include 与
{% extends %}性能差异?答:继承在编译期确定骨架;include 是运行期嵌入,高频列表需关注模板解析开销。 - 片段里想复用父模板 block 怎么办?答:block 只在继承链内有效,include 片段不能引用父级 block。
04.7.16.3-033 模板上下文与上下文处理器是什么关系?
一句话结论
上下文是模板渲染时的变量字典,由视图传入部分、上下文处理器统一补充全局变量(当前用户、请求、站点信息、消息)。上下文处理器在每个请求上执行,往 RequestContext 注入公共键,避免每个视图重复 render 相同数据。
概念解释
- 处理器签名
def processor(request): return dict,返回的键合并进上下文。 - 处理器按
TEMPLATE_CONTEXT_PROCESSORS顺序执行,后写的同名键覆盖先写的。
原理流程
- 视图
render构造RequestContext,先放入视图上下文。 - 框架按配置依次调用上下文处理器,合并返回字典。
- 模板引擎在完整上下文上解析变量与标签。
- 处理器内可访问
request.user、session 等请求级信息。
代码或图示
# context_processors.py
def site_info(request):
return {"site_name": "Ann-Interview", "is_authed": request.user.is_authenticated}
# settings.py
TEMPLATES = [{"OPTIONS": {"context_processors": [
"django.template.context_processors.request",
"django.contrib.auth.context_processors.auth",
"myapp.context_processors.site_info",
]}}]
常见误区
- 在处理器里做重查询:每个页面都执行,列表与详情页被拖慢,全局数据应走缓存。
- 处理器返回与视图同名的键:覆盖顺序依赖配置,排查困难。
- 以为函数视图
render不传context也有全局变量:依赖处理器注入,RequestContext才会跑处理器。
追问
request处理器注入了什么?答:把request对象本身放进上下文,模板可读{{ request.user }}。- 处理器能读写 session 吗?答:能,
request.session可用,但不要在处理器里写副作用。 - 自定义处理器放哪个应用?答:公共应用下的
context_processors.py,在配置中按完整路径注册。
04.7.16.3-034 模板变量的点号查找顺序是怎样的?
一句话结论
{{ post.title }} 按顺序尝试:字典键 post["title"] → 属性 post.title → 列表索引 post["title"](数字时);找不到返回空字符串,不抛异常。点号语法同时兼容 dict、对象属性与序列下标,模板层不写 Python 表达式。
概念解释
- 方法调用在模板中不带括号,无参方法可直接
{{ post.is_active }};需要参数的方法不能在模板调用。 - 查找失败静默返回空,调试时要确认变量名与类型。
原理流程
- 先解析变量名对应的根对象。
- 对点号后的每一段,依次尝试字典取值、属性访问、数字索引。
- 命中则继续下一段,未命中置空。
- 最终值经过过滤器与自动转义后输出。
代码或图示
{{ article.title }}
{{ article.author.name }}
{{ items.0 }}
{{ article.tags.all }}
常见误区
- 模板里调用带参方法:如
{{ article.get_url "/x" }}不是合法模板语法,参数计算放视图。 - 把布尔方法当属性写括号:
{{ article.is_active() }}在模板中不会执行调用。 - 字典键与属性同名时优先级误解:先字典后属性,命名避免冲突。
追问
- 变量不存在会报错吗?答:默认静默输出空字符串,
string_if_invalid可配置调试默认值。 - 模板能做算术吗?答:不能直接写表达式,可用
with、过滤器或自定义标签。 - QuerySet 在模板里遍历会查库吗?答:惰性求值,遍历时执行 SQL,注意 N+1。
04.7.16.3-035 常用模板过滤器有哪些?分别解决什么问题?
一句话结论
过滤器用 | 链式处理变量:default 给缺省值,date 格式化日期,length 取长度,join 拼接列表,yesno 转布尔文案,truncatechars 截断文本,linebreaks 转段落,urlencode 转义 URL 参数。过滤器只做值变换,复杂逻辑应上移到视图或自定义过滤器。
概念解释
- 过滤器可带参数:
{{ value|date:"Y-m-d" }},多个过滤器按从左到右顺序执行。 - 过滤器不改变原始变量,只影响本次输出。
原理流程
- 变量求值得到原始值。
- 按
|顺序逐个套用过滤器,上一个输出是下一个输入。 - 最终值进入自动转义与渲染。
- 自定义过滤器在
templatetags模块注册后{% load %}使用。
代码或图示
{{ created_at|date:"Y-m-d H:i" }}
{{ summary|truncatechars:80 }}
{{ tags|join:", " }}
{{ flag|yesno:"是,否" }}
{{ avatar_url|default:"/static/img/default.png" }}
常见误区
- 过滤器链条顺序写反:先截断再转义与先转义再截断结果不同,需按输出预期排列。
- 对
None调依赖类型的过滤器:先default兜底再格式化。 - 在模板里堆业务格式化规则:同一格式多处不一致,应抽自定义过滤器复用。
追问
default与default_if_none区别?答:default对空值(空串、0、False 等)生效,default_if_none只对None生效。- 如何注册自定义过滤器?答:
@register.filter装饰函数,放入应用templatetags目录并{% load %}。 - 过滤器能改变上下文吗?答:不能,纯函数式值变换。
04.7.16.3-036 自动转义机制是什么?|safe、|escape 与 {% autoescape %} 怎么用?
一句话结论
Django 模板默认开启自动转义:< > & " ' 输出为 HTML 实体,防止 XSS;|safe 标记一段内容已可信、不再转义,|escape 显式转义,{% autoescape off/on %} 按块开关。只有来源完全可信(如后台配置的富文本白名单过滤后)才能用 |safe。
概念解释
- 转义发生在输出阶段,变量内部存储不受影响。
mark_safe与|safe等价:在 Python 侧标记安全,下游不再转义。
原理流程
- 模板编译期按
autoescape默认状态(开启)记录各节点是否转义。 - 渲染时变量值经转义函数替换特殊字符为实体。
- 带
SafeString标记的值跳过转义。 {% autoescape off %}块内内容按关闭状态输出。
代码或图示
{{ comment.content }} {# 自动转义 #}
{{ rich_text|safe }} {# 仅可信富文本使用 #}
{% autoescape off %}
{{ raw_html }}
{% endautoescape %}
常见误区
- 对用户输入直接
|safe:存储型 XSS 的主要入口,富文本必须先经白名单过滤。 - 整个模板
autoescape off:块内所有变量都失去防护,应只对可信片段关闭。 - 以为
|safe会清洗 HTML:它只跳过转义,不做任何标签过滤。
追问
- 富文本入库前怎么处理?答:后端用 HTML 白名单库剥离脚本/事件属性,存储清洗结果,输出时再决定是否
safe。 escape过滤器与默认转义重复吗?答:显式调用在关闭自动转义的块里仍可单独转义某变量。- Python 侧如何标记安全?答:
from django.utils.safestring import mark_safe,返回SafeString。
04.7.16.3-037 {% csrf_token %} 渲染什么?背后如何校验?
一句话结论
{% csrf_token %} 渲染一个隐藏输入,值与 Cookie 中的 CSRF token 配对;POST 提交时 CSRF 中间件比对表单/头中的 token 与 Cookie token,一致才放行。token 基于 SECRET_KEY 与会话/随机值生成,跨站页面读不到用户 Cookie,因此无法伪造配对值。
概念解释
- 中间件为响应设置
csrftokenCookie,模板标签把同一 token 写入表单。 - 免 Cookie 的 API(纯 Token 认证)可对视图
csrf_exempt,但浏览器表单场景不能关闭。
原理流程
- 中间件处理 GET 响应,下发 CSRF Cookie。
- 模板
{% csrf_token %}输出隐藏字段csrfmiddlewaretoken。 - POST 到达,中间件从表单或
X-CSRFToken头取 token,与 Cookie 比对。 - 不匹配返回 403;校验通过后进入视图。
代码或图示
<form method="post">
{% csrf_token %}
{{ form.as_p }}
<button type="submit">提交</button>
</form>
常见误区
- AJAX 只带 Cookie 不带 CSRF 头:同源 POST 仍被拒,需从 Cookie 读 token 放
X-CSRFToken。 - 表单漏写标签:隐藏字段不渲染,提交 403。
- 全站
csrf_exempt:失去跨站请求防护,豁免只能用于明确的 webhook/纯 API。
追问
- token 存 Cookie 还是 Session?答:默认存 Cookie 并随表单回传,不依赖 Session 记录。
- 跨子域提交怎么办?答:配置
CSRF_COOKIE_DOMAIN与CSRF_TRUSTED_ORIGINS,保证 Cookie 可写、来源可信。 - 如何测试 CSRF 校验?答:测试客户端默认启用;手动构造不带 token 的 POST 应收到 403。
04.7.16.3-038 {% for %}、{% if %}、{% url %}、{% with %} 各有什么用法要点?
一句话结论
{% for %} 遍历序列并提供 forloop 变量(counter/first/last/parentloop);{% if %} 做条件判断,支持 and/or/not 与 in;{% url %} 按命名路由反向生成 URL;{% with %} 给复杂表达式起局部别名,避免重复查找。模板标签只做展示层控制,不承载业务计算。
概念解释
{% empty %}在序列为空时渲染分支。{% with x=expr %}块内别名有效,块外不可见。
原理流程
- 模板编译把标签转成节点树。
- 渲染时按上下文求值条件或遍历序列。
forloop计数器随迭代更新,first/last标识边界。url标签反向解析路由并插入路径。
代码或图示
{% for post in posts %}
{% if forloop.first %}<ul>{% endif %}
<li><a href="{% url 'post-detail' slug=post.slug %}">{{ post.title }}</a></li>
{% if forloop.last %}</ul>{% endif %}
{% empty %}
<p>暂无文章</p>
{% endfor %}
{% with total=posts|length %}共 {{ total }} 篇{% endwith %}
常见误区
{% if %}里写复杂表达式:模板不支持函数调用与嵌套算术,复杂判断移到视图。- 循环内重复访问关联对象:触发 N+1,应在视图层预取。
url标签 kwargs 与路由参数名不一致:反向解析失败,模板报错或留空。
追问
forloop.counter与counter0区别?答:counter从 1 开始,counter0从 0 开始。- 嵌套循环怎么取外层计数?答:
forloop.parentloop.counter。 {% with %}为什么需要?答:缓存重复的属性查找/过滤器结果,提升模板渲染效率。
04.7.16.3-039 如何写自定义模板标签与过滤器?
一句话结论
在应用的 templatetags 目录建模块,用 @register.filter 注册过滤器(值变换),用 @register.simple_tag 注册简单标签(返回任意字符串),@register.inclusion_tag 注册含子模板的标签;模板内 {% load 模块名 %} 后使用。标签函数可接收上下文参数,但应保持无副作用。
概念解释
templatetags目录需为 Python 包(含__init__.py),应用必须在INSTALLED_APPS。simple_tag包装视图函数,可处理复杂参数;inclusion_tag负责渲染局部模板并返回上下文。
原理流程
- 创建
myapp/templatetags/extras.py,导入template.Library。 - 用装饰器注册过滤器或标签函数。
- 模板
{% load extras %},按名称调用。 - 框架在渲染期执行函数,返回值替换标签位置。
代码或图示
from django import template
from django.utils.html import format_html
register = template.Library()
@register.filter
def discount(price, rate):
return round(price * (1 - rate), 2)
@register.simple_tag
def greeting(name):
return f"你好,{name}"
@register.inclusion_tag("partials/star.html")
def star_rating(score):
return {"score": score}
常见误区
- 漏把应用加入
INSTALLED_APPS:模板加载标签模块失败。 - 标签函数里访问数据库或写缓存:渲染期副作用,请求并发下行为不可控。
- 过滤器参数类型未校验:传入
None或字符串时抛异常,影响整页渲染。
追问
assignment_tag还需要用吗?答:Django 现代版本由simple_tag配合as 变量替代,旧写法已废弃。- 标签能读取当前上下文吗?答:
takes_context=True后函数首参接收context,可取request等。 - 自定义标签需要测试吗?答:需要,按纯函数方式单测返回值与上下文。
04.7.16.3-040 模板渲染性能受哪些因素影响?
一句话结论
主要因素:模板继承层级过深、循环内 include 重片段、上下文携带大对象、未编译缓存的重复解析、模板内触发懒加载查询。优化方向:扁平继承结构、高频片段内联或编译缓存、视图层预取、上下文只传需要的数据。Django 默认对模板做加载缓存,生产环境不应开启模板调试重载。
概念解释
- 模板引擎按
TEMPLATES的loaders查找并编译,编译结果在进程内缓存。 - 渲染耗时包含字符串拼接、变量查找与过滤器执行,列表页最敏感。
原理流程
- 首次请求加载模板源码,编译成节点树并缓存。
- 后续请求复用编译树,仅执行渲染。
- 渲染期遍历上下文、解析变量、执行标签与过滤器。
- 列表规模放大循环内操作(查询、include、格式化)的开销。
代码或图示
# settings.py:生产环境使用缓存模板加载器
TEMPLATES = [{
"OPTIONS": {
"loaders": [
("django.template.loaders.cached.Loader", [
"django.template.loaders.filesystem.Loader",
"django.template.loaders.app_directories.Loader",
]),
],
},
}]
常见误区
- 开发期
DEBUG=True的模板行为直接套生产:源码重载关闭后改动需重启进程生效。 - 循环里
{% include %}卡片:每次迭代重复解析片段,高频列表改内联。 - 上下文塞入整个请求/大查询集:变量查找成本上升,还可能泄露无关字段。
追问
- 模板编译缓存在哪一层?答:进程内,
cached.Loader按模板路径缓存编译结果,多进程各自缓存一份。 - 怎么定位慢模板?答:开启 SQL 查询计数与渲染耗时日志,先查循环内 N+1,再查片段复用。
- 模板能被 CDN 缓存吗?答:页面级输出可由 Nginx/CDN 按规则缓存,动态用户内容需分层处理。
04.7.16.3-041 中间件在请求链路中处于什么位置?
一句话结论
中间件包裹在 URLconf 与视图之外:请求从 Handler 进入后依次穿过 MIDDLEWARE 列表,到达路由与视图;响应沿反向顺序穿过同一批中间件回到服务器。它是横切关注点(认证、会话、CSRF、压缩、日志)的挂载点,介于协议入口与业务视图之间。
概念解释
- 每个中间件既可以处理请求前逻辑,也可以处理响应后逻辑,形成洋葱模型。
- 中间件能访问
request与response,但不感知具体路由与视图实现。
原理流程
- WSGI/ASGI Handler 收到请求,构造
HttpRequest。 - 请求按
MIDDLEWARE注册顺序进入各中间件的请求段。 - 路由匹配到视图,执行业务逻辑生成响应。
- 响应按注册逆序穿过中间件回程段,最终由 Handler 写回客户端。
代码或图示
request → M1 → M2 → M3 → router → view → response
response ← M1 ← M2 ← M3 ←─────────────────────
常见误区
- 把中间件当成路由层:中间件拿不到
ResolverMatch时还未路由,需要路由信息应在视图层或旧式process_view。 - 在中间件里做业务编排:职责越界,复用性与可测试性下降。
- 以为中间件只在请求前执行:回程段同样重要,响应头、压缩、日志都在这里处理。
追问
- 中间件能读取匹配到的视图函数吗?答:新式写法在请求段读不到,需用
process_view钩子或在视图内处理。 - 中间件抛出异常谁兜底?答:异常冒泡到异常中间件,转换为 500 或对应错误响应。
- 全局日志拦截放哪一层?答:外层中间件最合适,可覆盖全部请求与响应。
04.7.16.3-042 新式中间件的 __call__ 写法与旧式中间件有什么区别?
一句话结论
Django 1.10 起的新式中间件是可调用类:__init__(self, get_response) 保存下游调用,def __call__(self, request): 内先写请求前逻辑,response = get_response(request) 执行下游,再写响应后逻辑。旧式按 process_request/process_response 拆分两个方法,由框架分别调用;新式把前后逻辑收进一个 __call__,顺序更直观。
概念解释
get_response是下游链路(后续中间件或视图)的可调用对象,不是视图本身。- 新式中间件同时兼容同步与异步链路框架判定,Django 5.x 项目统一使用新式写法。
原理流程
- 启动期实例化中间件,
get_response注入为下游链。 - 请求进入
__call__,执行请求前置逻辑(鉴权、计时、绑定数据)。 - 调
get_response(request)穿过下游拿到响应。 - 执行响应后置逻辑(加头、压缩、记录日志),返回响应。
代码或图示
class TimerMiddleware:
def __init__(self, get_response):
self.get_response = get_response
def __call__(self, request):
import time
start = time.perf_counter()
response = self.get_response(request)
response["X-Elapsed-Ms"] = str(int((time.perf_counter() - start) * 1000))
return response
常见误区
- 忘记保存
get_response或没调用它:下游不执行,请求挂起或返回空响应。 - 请求前与响应后逻辑写反:计时开始放请求前,结束放
get_response之后。 - 在
__init__里做请求级工作:__init__启动期只执行一次,不能访问request。
追问
- 新式中间件能只处理请求或只处理响应吗?答:能,只写一侧逻辑即可,另一侧透传。
- 旧式项目迁移成本?答:
MiddlewareMixin提供兼容,新代码直接写__call__。 - 异步项目中间件要写
async def __call__吗?答:全异步链路可写异步中间件;同步中间件由框架通过线程池桥接。
04.7.16.3-043 MiddlewareMixin 解决什么兼容问题?
一句话结论
django.utils.deprecation.MiddlewareMixin 是旧式 process_request/process_response 到新式 __call__ 的适配层:它实现 __call__,内部按顺序调用 process_request 与 process_response,让老中间件在新式栈里继续工作。新写中间件不需要继承它,直接写 __call__ 即可。
概念解释
- Mixin 在实例化时保存
get_response,把旧式两个钩子织入新式调用链。 - 它同时提供对
process_view、process_exception等旧式钩子的转发。
原理流程
- 旧式中间件类继承
MiddlewareMixin,定义process_request/process_response。 - 框架按新式协议实例化,Mixin 的
__call__接管。 __call__先调process_request,有响应则短路;否则调下游。- 回程调用
process_response加工响应后返回。
代码或图示
from django.utils.deprecation import MiddlewareMixin
class OldStyleMiddleware(MiddlewareMixin):
def process_request(self, request):
request.extra = "bound"
return None
def process_response(self, request, response):
response["X-Old"] = "1"
return response
常见误区
- 新代码不必要地继承
MiddlewareMixin:增加间接层,直接__call__更清晰。 - 以为
MiddlewareMixin是异步兼容层:它只做新旧协议适配,不处理协程调度。 - 覆写
__call__又保留process_request:两套逻辑冲突,执行顺序难判断。
追问
- Django 5.x 还推荐旧式钩子吗?答:不推荐,仅为兼容存量代码保留。
process_view在新式写法里对应什么?答:新式中间件没有直接等价物,视图级拦截用装饰器/Mixin,或保留旧式钩子经 Mixin 转发。- Mixin 实例化时机?答:启动期一次,中间件实例是进程级单例。
04.7.16.3-044 MIDDLEWARE 注册顺序如何决定执行链?
一句话结论
列表靠前的中间件先处理请求,靠后的先处理响应:请求顺序按列表正序,响应顺序按列表逆序。因此认证、安全头这类“最外层防护”要放前面,会话、CSRF 依赖认证数据的依次靠后;顺序错了会出现属性未绑定、防护被绕过或响应头丢失。
概念解释
- 顺序是洋葱分层:外层中间件包裹内层,请求与响应走两条相反方向。
- 内置中间件有官方推荐顺序,自定义中间件按依赖关系插入。
原理流程
- 启动期按
MIDDLEWARE列表装配中间件链。 - 请求正序穿过:
SecurityMiddleware→SessionMiddleware→CommonMiddleware→CsrfViewMiddleware→AuthenticationMiddleware→ ... - 视图返回响应,逆序穿过同一批中间件。
- 某层短路返回响应时,它内层的中间件请求段未执行,回程只经过其外层。
代码或图示
MIDDLEWARE = [
"django.middleware.security.SecurityMiddleware",
"django.contrib.sessions.middleware.SessionMiddleware",
"django.middleware.common.CommonMiddleware",
"django.middleware.csrf.CsrfViewMiddleware",
"django.contrib.auth.middleware.AuthenticationMiddleware",
"django.contrib.messages.middleware.MessageMiddleware",
]
常见误区
- 把 CSRF 放在 Session 之前:认证数据未加载,部分校验场景异常。
- 自定义日志中间件放最内层:短路的内层请求根本到不了它,覆盖率不全。
- 调整顺序后没回归测试:响应头、重定向、会话行为可能悄悄变化。
追问
- 为什么
SecurityMiddleware放最前?答:它处理 HSTS、SSL 重定向等最外层安全策略,应在其他逻辑之前生效。 - 响应头由谁最后写?答:逆序回程中列表靠后的先写,靠前的后写,覆盖关系与请求相反。
- 如何检查中间件实际顺序?答:打印
settings.MIDDLEWARE,结合请求/响应日志验证每层进入时机。
04.7.16.3-045 中间件“短路”是什么?回程如何走?
一句话结论
中间件在请求段直接返回 HttpResponse(如未登录重定向、限流拒绝)即短路:下游中间件与视图不再执行;回程只从当前层向外经过它的外层中间件,内层未进入的中间件响应段也不会执行。短路响应必须自己处理好状态码、响应头与会话写入。
概念解释
- 短路是中间件实现前置拦截的主要手段,避免请求进入业务层。
- 认证、限流、IP 黑白名单都属于典型短路场景。
原理流程
- 请求穿过外层中间件进入当前层。
- 校验不通过,当前层构造重定向/403/429 响应直接返回。
- 下游中间件与视图未被调用。
- 响应沿当前层之外的外层中间件逆序回程。
代码或图示
class BlocklistMiddleware:
def __init__(self, get_response):
self.get_response = get_response
def __call__(self, request):
if request.META.get("REMOTE_ADDR") in BLOCKED_IPS:
return HttpResponse("拒绝访问", status=403)
return self.get_response(request)
常见误区
- 短路时忘记写必要响应头:缓存策略、
WWW-Authenticate等缺失导致客户端行为异常。 - 在短路响应里依赖下游中间件写入的会话/消息:下游未执行,数据不存在。
- 把可恢复错误也做成硬短路:应区分 302 登录跳转与 403 永久拒绝。
追问
- 短路响应还会经过 CSRF 校验吗?答:取决于短路层在 CSRF 中间件的外层还是内层,外层短路先于 CSRF,内层短路则 CSRF 已通过。
- 如何统计被短路的请求?答:在短路分支单独打点计数,区别于正常 2xx/4xx。
- 中间件能在响应段再拦截一次吗?答:能,回程可改响应状态或头,但不能重新执行视图。
04.7.16.3-046 中间件里适合做什么?不适合做什么?
一句话结论
适合:跨全部请求的横切逻辑——鉴权前置、会话/用户绑定、请求计时、访问日志、限流、统一响应头、异常兜底。不适合:业务规则编排、具体模型查询写入、模板渲染、需要路由参数的逻辑;这些放视图、服务层或 Mixin。中间件实例是进程级单例,不能保存请求级可变状态。
概念解释
- 中间件面向“所有请求”,业务差异大的逻辑放视图才能按路由控制。
- 请求级数据挂在
request上传递,不要挂在中间件实例属性上。
原理流程
- 识别需求是否对全站请求一视同仁。
- 横切且无业务分支 → 中间件;按路由/模型变化 → 视图或装饰器。
- 请求级数据通过
request.xxx传递,请求结束随对象回收。 - 数据库副作用与外部调用评估超时与失败影响,避免拖垮全站。
代码或图示
class RequestTraceMiddleware:
def __init__(self, get_response):
self.get_response = get_response
def __call__(self, request):
request.trace_id = generate_trace_id() # 请求级绑定到 request
response = self.get_response(request)
response["X-Trace-Id"] = request.trace_id
return response
常见误区
- 中间件实例属性缓存当前用户:多请求并发共享,串号泄露。
- 在中间件里查业务表:未登录、静态文件、健康检查等无关请求也被拖累。
- 把复杂分支写进
__call__:中间件膨胀,应拆成可测试的服务函数。
追问
- 静态文件请求会经过中间件吗?答:开发期经 Django 服务时会;生产由 Nginx 直发,不进入 Django 进程。
- 中间件里能读 URL 参数吗?答:请求段未路由,拿不到
kwargs;需要参数时在视图层处理。 - 中间件里发异步任务合适吗?答:可以,但注意事务边界,应在提交后投递,避免任务读到未提交数据。
04.7.16.3-047 旧式 process_view/process_exception 在新式栈里如何对应?
一句话结论
process_view(request, view_func, view_args, view_kwargs) 在路由匹配后、视图执行前触发,可短路或注入;process_exception(request, exception) 在视图抛未捕获异常时触发。新式 __call__ 没有同名钩子,需要视图级拦截用装饰器/Mixin;异常兜底可用外层中间件捕获下游异常,或保留旧式钩子经 MiddlewareMixin 转发。
概念解释
process_view能拿到视图函数与参数,是做细粒度鉴权、参数预处理的位置。process_exception返回非空响应即接管错误处理,否则异常继续冒泡。
原理流程
- 路由匹配成功,旧式链依次调用各
process_view。 - 任一钩子返回响应即短路,视图不执行。
- 视图抛异常,框架沿链调
process_exception尝试转换响应。 - 无人接管则冒泡到异常中间件生成 500 页面。
代码或图示
from django.utils.deprecation import MiddlewareMixin
class ViewHookMiddleware(MiddlewareMixin):
def process_view(self, request, view_func, view_args, view_kwargs):
request.view_name = view_func.__name__
return None
常见误区
- 在新式
__call__里找view_func:请求段尚未路由,拿不到。 process_exception里吞掉异常不记录日志:错误现场丢失,线上无法排查。- 用
process_view做业务权限:可替代但分散在中间件,视图/Mixin 内聚性更好。
追问
- 装饰器能完全替代
process_view吗?答:按路由挂载的鉴权/限流装饰器可以;需要遍历全站视图的横切场景仍用中间件。 - 异常中间件与
process_exception区别?答:前者兜底全局错误转换,后者逐中间件尝试接管。 - 异步视图抛异常谁捕获?答:ASGI Handler 与异常中间件按异步链路处理,同步桥接处注意异常传播。
04.7.16.3-048 请求钩子该选中间件、装饰器还是上下文处理器?
一句话结论
按作用域选:全站所有请求的前置/回程逻辑用中间件;指定视图或路由的鉴权、限流、参数加工用装饰器或类视图 Mixin;向所有模板注入全局变量用上下文处理器。三者不要混用职责:中间件不碰模板变量,上下文处理器不做请求拦截。
概念解释
- 作用域从大到小:中间件(全站)→ 装饰器/Mixin(视图级)→ 上下文处理器(模板级)。
- 同一需求能在更小作用域解决就不下沉到中间件,减少无关请求开销。
原理流程
- 判断逻辑是否对每个请求生效:是 → 中间件候选。
- 判断是否只保护特定视图:是 → 装饰器/
method_decorator/Mixin。 - 判断是否为模板展示补数据:是 → 上下文处理器。
- 组合使用时明确每层职责,避免重复鉴权或重复注入。
代码或图示
# 视图级装饰器
from django.contrib.auth.decorators import login_required
@login_required
def profile(request):
...
# 中间件处理全站计时
# 上下文处理器注入站点名
常见误区
- 全站中间件里判断“只对某路由生效”:应用路由判断后中间件退化为装饰器,不如直接挂视图。
- 上下文处理器里做鉴权拦截:它只返回字典,不能短路请求。
- 装饰器链顺序与中间件依赖冲突:鉴权所需会话/用户必须由更外层中间件先加载。
追问
- 类视图的装饰器等价物是什么?答:
method_decorator包裹dispatch或方法,也可写成鉴权 Mixin。 - 限流放哪一层?答:全站粗粒度限流用中间件;按用户/接口的细粒度限流放视图装饰器或服务层。
- 全局模板变量与视图上下文冲突谁优先?答:视图上下文后合并,同名键覆盖处理器注入值。
04.7.16.3-049 中间件如何处理异常并转换为 500 响应?
一句话结论
下游抛出的异常在中间件回程段可被外层捕获;ExceptionMiddleware 把未处理异常转为 500 响应(DEBUG=True 显示调试栈,False 渲染 500 模板)。自定义中间件应捕获可预期异常并转换友好响应,未捕获的记录日志后重新抛出,不能静默吞掉。
概念解释
- 中间件
__call__包get_response即为 try/except 的天然位置。 - 500 响应不应泄露堆栈与配置,生产环境错误细节只进日志。
原理流程
- 外层中间件调用
get_response(request),下游异常向上冒泡。 - 捕获已知业务异常,映射为 400/403/404 等语义化响应。
- 未知异常记录
logger.exception后重新抛出。 ExceptionMiddleware兜底生成 500 页面或 JSON。
代码或图示
import logging
logger = logging.getLogger(__name__)
class ErrorWrapMiddleware:
def __init__(self, get_response):
self.get_response = get_response
def __call__(self, request):
try:
return self.get_response(request)
except PermissionDenied:
return HttpResponse("无权限", status=403)
except Exception:
logger.exception("unhandled error on %s", request.path)
raise
常见误区
except Exception后返回 200:错误被掩盖,监控看不到失败。- 捕获后不记堆栈:线上只剩一条错误消息,无法定位。
- 在中间件里做业务异常映射:业务异常类型应由服务层定义,中间件只做转换。
追问
- 404 异常需要中间件捕获吗?答:
Http404由ExceptionMiddleware统一转换,自定义中间件一般不重复处理。 - API 服务如何返回 JSON 500?答:捕获异常后返回
JsonResponse({"detail": "内部错误"}, status=500),同时记录日志。 - 调试页面何时出现?答:仅
DEBUG=True且异常未被自定义响应接管时。
04.7.16.3-050 Django 内置中间件各自承担什么职责?
一句话结论
SecurityMiddleware 处理安全头与 SSL 重定向;SessionMiddleware 加载/保存会话;CommonMiddleware 处理尾斜杠、APPEND_SLASH 与默认响应头;CsrfViewMiddleware 校验跨站请求;AuthenticationMiddleware 绑定 request.user;MessageMiddleware 加载消息;XFrameOptionsMiddleware 下发点击劫持防护;GZipMiddleware 压缩响应。理解职责才能排查“用户未绑定”“重定向循环”等问题。
概念解释
- 内置中间件按依赖排序装配,自定义中间件插入对应层。
- 未加入
MIDDLEWARE的内置能力不会生效,如消息框架无对应中间件则取不到messages。
原理流程
- 安全策略最先执行,协议层重定向与头处理。
- 会话加载后,CSRF 校验读取会话/Cookie 数据。
- 认证中间件根据会话绑定用户对象。
- 视图执行后回程依次写压缩、帧选项、安全头等响应头。
代码或图示
MIDDLEWARE = [
"django.middleware.security.SecurityMiddleware",
"django.contrib.sessions.middleware.SessionMiddleware",
"django.middleware.common.CommonMiddleware",
"django.middleware.csrf.CsrfViewMiddleware",
"django.contrib.auth.middleware.AuthenticationMiddleware",
"django.contrib.messages.middleware.MessageMiddleware",
"django.middleware.clickjacking.XFrameOptionsMiddleware",
]
常见误区
- 漏装
AuthenticationMiddleware:request.user始终是匿名用户,登录态判断全部失效。 - 漏装
SessionMiddleware:CSRF、消息、登录会话都无法持久化。 - 重复启用压缩与上游 Nginx 压缩:双重压缩浪费 CPU,应只在一层做。
追问
CommonMiddleware的APPEND_SLASH做什么?答:路径无匹配且加尾斜杠可匹配时 301 重定向,循环重定向需检查路由与中间件顺序。- 哪个中间件设置
X-Frame-Options?答:XFrameOptionsMiddleware,取值由X_FRAME_OPTIONS配置。 - 消息框架依赖哪些中间件?答:
SessionMiddleware提供存储,MessageMiddleware加载当前消息。
04.7.16.3-051 Paginator 与 Page 的核心 API 怎么用?
一句话结论
Paginator(object_list, per_page) 包装查询集,get_page(number) 返回 Page 对象;Page 提供 object_list、number、paginator、has_next()/has_previous()、next_page_number()/previous_page_number()。视图把 paginator 与 page_obj 传入模板,模板按这些方法渲染分页条。
概念解释
get_page对非法页码(非数字、越界)做容错:返回首页或末页;page(number)越界直接抛PageNotAnInteger/EmptyPage。- 查询集在构造
Paginator时不应提前list(),保留惰性由分页器切片。
原理流程
- 视图传入完整查询集与每页条数。
Paginator计算总页数与总数。get_page解析页码,切片出当前页对象列表。- 模板遍历
page_obj.object_list,用导航方法渲染上一页/下一页。
代码或图示
from django.core.paginator import Paginator
def post_list(request):
posts = Post.objects.all().order_by("-created_at")
paginator = Paginator(posts, 10)
page_obj = paginator.get_page(request.GET.get("page"))
return render(request, "post_list.html", {"page_obj": page_obj})
{% if page_obj.has_previous %}
<a href="?page={{ page_obj.previous_page_number }}">上一页</a>
{% endif %}
第 {{ page_obj.number }} / {{ page_obj.paginator.num_pages }} 页
{% if page_obj.has_next %}
<a href="?page={{ page_obj.next_page_number }}">下一页</a>
{% endif %}
常见误区
- 页码参数名与模板链接不一致:翻页丢失筛选条件,链接应保留原有 query string。
- 对大列表
len()后再分页:强制全量求值,失去切片优化。 - 未做排序就分页:无序结果在翻页间重复或遗漏记录。
追问
Paginator.count什么时候求值?答:取总数时对查询集执行COUNT(*),大表开销需评估。- 每页条数在视图还是模板定?答:视图设置
per_page,模板只展示,便于配置化与压测调整。 - 类视图分页怎么配?答:
ListView.paginate_by = 10,自动注入page_obj与paginator上下文。
04.7.16.3-052 大表分页的 count() 有什么性能问题?如何优化?
一句话结论
默认分页器为渲染页码导航执行 COUNT(*),百万级大表在无索引条件下扫描代价很高;优化方向:深分页改游标/键集分页(按排序字段 + id 过滤)、减少总数依赖(只显示上下页)、对可估算总数做缓存或近似值。深度翻页(LIMIT 100000, 10)本身也会让数据库跳过大量行,键集分页优于偏移分页。
概念解释
COUNT(*)在 InnoDB 上需扫描索引/表估算行数,带复杂 WHERE 时更贵。- 偏移分页越深,定位成本越高;键集分页用上一页末尾值作为锚点,每次走索引定位。
原理流程
- 默认分页器调用
count()计算num_pages与导航信息。 - 大表该计数慢,成为列表接口主要耗时。
- 键集分页:
WHERE (created_at, id) < (上页末尾值) ORDER BY created_at DESC, id DESC LIMIT 10。 - 总数按需缓存或改用“更多”按钮,不展示精确总页数。
代码或图示
# 键集分页示例:按 created_at + id 倒序
last_ts = request.GET.get("ts")
last_id = request.GET.get("id")
qs = Post.objects.order_by("-created_at", "-id")
if last_ts and last_id:
qs = qs.filter(created_at__lt=last_ts).exclude(id=last_id)
page = qs[:11] # 多取一条判断是否还有下一页
常见误区
- 列表页必须显示“共 N 条”:为精确总数付全表计数代价,很多场景上下页足够。
- 对非唯一排序字段做键集分页:值重复导致记录跳过或重复,必须加唯一字段(id)作次级排序。
- 缓存
count()但数据实时性要求高:缓存窗口内数字不准,需按业务容忍度设置过期。
追问
- 深分页
LIMIT offset, n为什么慢?答:数据库先扫描并丢弃 offset 行,再取 n 行,offset 越大跳过成本越高。 - 搜索引擎类列表怎么分页?答:外部索引(如全文检索引擎)自带翻页能力,不直接走数据库深分页。
- 如何关闭总数计算?答:自定义分页器或视图只取切片,不访问
paginator.count。
04.7.16.3-053 文件上传在 Django 内部如何流转?
一句话结论
上传文件经服务器解析进 request.FILES,每个文件是 UploadedFile 实例:小文件存内存(InMemoryUploadedFile),超过内存阈值落临时磁盘(TemporaryFileUploadedFile);表单字段校验后,模型 FileField/ImageField 调用存储后端写入 MEDIA_ROOT 并保存路径到数据库。上传过程可自定义处理器改变临时存储行为。
概念解释
request.FILES是 dict,键与表单文件字段名对应。- 上传处理由
FILE_UPLOAD_HANDLERS配置,默认内存 + 临时文件两段式。
原理流程
- WSGI/ASGI 服务器解析 multipart 请求体,文件部分交给上传处理器。
- 未超内存阈值的文件留在内存,超阈值转入系统临时目录。
- 表单绑定
request.FILES,is_valid()校验文件字段。 form.save()时FileField调storage.save()落盘,数据库只存相对路径。
代码或图示
from django import forms
from .models import Attachment
class AttachmentForm(forms.ModelForm):
class Meta:
model = Attachment
fields = ["file", "remark"]
def upload(request):
if request.method == "POST":
form = AttachmentForm(request.POST, request.FILES)
if form.is_valid():
form.save()
return redirect("attachment-list")
return render(request, "upload.html", {"form": form})
常见误区
- 表单只传
request.POST漏request.FILES:文件字段始终为空,校验失败。 - 表单
enctype不是multipart/form-data:浏览器不上传文件体。 - 直接把
UploadedFile当最终文件路径:它是临时对象,需经模型字段落盘后才持久化。
追问
- 如何读取上传文件内容?答:
uploaded_file.read(),大文件用chunks()分块迭代避免占满内存。 - 上传文件名会被覆盖吗?答:存储后端默认重名追加随机后缀,避免覆盖已有文件。
- 图片校验由谁做?答:
ImageField用 Pillow 校验图片头与尺寸,非图片拒绝保存。
04.7.16.3-054 MEDIA_ROOT/MEDIA_URL 如何配合?开发期怎么访问上传文件?
一句话结论
MEDIA_ROOT 是上传文件在服务器磁盘的存放目录,MEDIA_URL 是浏览器访问这些文件的 URL 前缀;模型 FileField 存相对路径,拼接 MEDIA_URL 得到访问地址。开发期可在 URLconf 用 static() 服务 media 文件;生产环境由 Nginx/对象存储/CDN 直发,Django 不负责输出 media。
概念解释
MEDIA_ROOT是文件系统路径,MEDIA_URL是 web 路径,二者通过存储后端关联。- 与静态文件分离:
STATIC_ROOT存打包的 CSS/JS,MEDIA_ROOT存用户上传内容。
原理流程
- 配置
MEDIA_ROOT(如项目目录下media/)与MEDIA_URL="/media/"。 - 文件落盘到
MEDIA_ROOT下按字段upload_to组织的子目录。 - 模板
{{ attachment.file.url }}生成MEDIA_URL加相对路径的链接。 - 开发期 URLconf
static(settings.MEDIA_URL, document_root=settings.MEDIA_ROOT)提供访问。
代码或图示
# settings.py
MEDIA_ROOT = BASE_DIR / "media"
MEDIA_URL = "/media/"
# urls.py(仅 DEBUG 开发期)
from django.conf import settings
from django.conf.urls.static import static
urlpatterns = [
# ...
] + static(settings.MEDIA_URL, document_root=settings.MEDIA_ROOT)
常见误区
- 生产仍依赖 Django 服务 media:大文件占满应用 worker,应交给 Nginx/对象存储。
MEDIA_ROOT与STATIC_ROOT混目录:collectstatic可能覆盖用户上传文件。- 跨域访问 media 未配 CORS/域名:浏览器加载图片下载链接被拦截。
追问
upload_to支持按日期分目录吗?答:支持,可传 callable 返回路径,或用path/strftime模式。- media 文件要纳入版本管理吗?答:不纳入,上传产物放磁盘/对象存储,仓库只保留代码。
- 模板里如何拿文件 URL?答:
field.url属性;文件删除后该路径不再有效。
04.7.16.3-055 Storage 抽象层如何工作?如何接云存储?
一句话结论
Django 文件操作通过 Storage 接口解耦:FileSystemStorage 本地磁盘实现,默认后端由 DEFAULT_FILE_STORAGE(Django 5.0 起为 STORAGES 配置)指定;接入 S3/OSS/七牛等云存储只需实现或选用对应 Storage 后端,模型代码不变。存储接口覆盖 save/delete/exists/url/open/list 等方法。
概念解释
- 业务代码面向
default_storage或模型字段,不直接拼文件系统路径。 - 5.0 之前用
DEFAULT_FILE_STORAGE单配置;5.0 起STORAGES分default与staticfiles两个后端槽位。
原理流程
- 模型
FileField持有存储后端引用。 save()调用后端save(name, content),由后端决定落盘位置与命名。url()方法向后端取访问地址,本地后端拼MEDIA_URL,云后端返回 CDN/签名 URL。- 切换后端只改配置,上传与读取路径随之改变。
代码或图示
# settings.py(Django 5.x)
STORAGES = {
"default": {
"BACKEND": "django.core.files.storage.FileSystemStorage",
},
"staticfiles": {
"BACKEND": "django.contrib.staticfiles.storage.StaticFilesStorage",
},
}
# 业务代码不关心后端
from django.core.files.storage import default_storage
path = default_storage.save("avatars/a.png", content)
url = default_storage.url(path)
常见误区
- 代码里硬编码
MEDIA_ROOT拼接路径:切换云存储后路径语义失效,应走 Storage API。 - 云存储后端未配置签名/公共读:
url()返回的地址无法访问。 - 本地与云存储混用目录:迁移期历史文件路径映射不清,需统一前缀规则。
追问
- 如何为某个字段单独指定存储?答:
FileField(storage=CustomStorage(...)),覆盖默认后端。 - Storage 的
exists在云存储上成本如何?答:远端 HEAD/GET 请求,高频判断会产生额外调用,避免在循环里逐条检查。 - 文件删除是逻辑删除还是物理删除?答:
delete()默认物理删除,云存储需确认后端实现与权限。
04.7.16.3-056 上传大小与数量有哪些限制配置?
一句话结论
内存阈值由 FILE_UPLOAD_MAX_MEMORY_SIZE(默认 2.5 MB)控制,超过则转临时磁盘;请求体总大小由 DATA_UPLOAD_MAX_MEMORY_SIZE(默认 2.5 MB,不含文件)与服务器层(Nginx client_max_body_size)共同限制;文件字段在表单/模型层可限制扩展名、MIME 与尺寸。多层限制要对齐,否则前端允许、后端拒绝或服务器直接 413。
概念解释
- 内存阈值决定“内存还是临时磁盘”,不是上传上限;上限由服务器与应用校验共同决定。
DATA_UPLOAD_MAX_NUMBER_FIELDS/FILE_UPLOAD_MAX_NUMBER_FIELDS限制字段数量,防超大表单攻击。
原理流程
- 服务器先按请求体大小拦截超限请求(413)。
- 应用解析 multipart,文件按内存阈值分流到内存/临时文件。
- 表单校验文件类型、扩展名、图片尺寸。
- 模型保存,存储后端落盘。
代码或图示
# settings.py
FILE_UPLOAD_MAX_MEMORY_SIZE = 2 * 1024 * 1024 # 2MB 内存阈值
DATA_UPLOAD_MAX_MEMORY_SIZE = 2 * 1024 * 1024
# 表单层限制
from django import forms
class AvatarForm(forms.Form):
avatar = forms.ImageField()
def clean_avatar(self):
f = self.cleaned_data["avatar"]
if f.size > 2 * 1024 * 1024:
raise forms.ValidationError("图片不超过 2MB")
return f
常见误区
- 只在前端校验大小:抓包可绕过,后端必须复核。
- Nginx 未调
client_max_body_size:应用允许的大文件在网关层先被拒。 - 信任浏览器 MIME 类型:
content-type可伪造,应校验文件头与扩展名白名单。
追问
- 大文件上传怎么做?答:分片上传 + 断点续传,由对象存储或自定义接口合并,不走单次 multipart。
- 内存阈值调大有什么代价?答:并发上传时内存占用线性上升,worker 易 OOM,阈值宜小。
- 字段数量限制防什么攻击?答:防止构造海量表单字段耗尽解析与校验资源。
04.7.16.3-057 Django 异步视图支持到什么程度?
一句话结论
Django 3.1 引入异步视图,4.2 起异步 ORM 与更多组件成熟,5.x 支持 async def 视图、异步类视图与异步中间件;异步链路下同步 ORM 调用会被拒绝或需显式包装。异步视图适合 IO 密集(等待下游 API、消息、长查询)场景,CPU 密集或存量同步代码迁收益有限,混合栈需通过 sync_to_async 桥接。
概念解释
- 异步视图运行在事件循环线程内,阻塞调用会卡住整个循环。
- 框架按视图签名自动判定异步/同步链路,WSGI 部署下异步视图经线程池桥接执行。
原理流程
- ASGI 服务器把请求送入异步事件循环。
- Django 识别
async def视图,在循环内await执行。 - 异步 ORM 查询用
await Post.objects.acount()等异步接口。 - 响应经异步中间件链返回;同步代码通过线程池隔离执行。
代码或图示
from django.http import JsonResponse
from django.views import View
from .models import Post
async def async_post_list(request):
posts = [
{"id": p.id, "title": p.title}
async for p in Post.objects.all().order_by("-created_at")[:20]
]
return JsonResponse({"posts": posts})
class AsyncPostView(View):
async def get(self, request, *args, **kwargs):
return JsonResponse({"ok": True})
常见误区
- 在异步视图里直接跑同步 ORM:阻塞事件循环,新版 Django 对同步模型操作有明确限制提示。
- 以为异步一定提升吞吐:CPU 密集场景单循环被占满,不如多进程同步 worker。
- 同步/异步代码双向随意调用:嵌套桥接会导致线程池耗尽,需明确边界。
追问
- 异步类视图怎么写?答:
async def get/post,dispatch也可异步覆写。 - 异步中间件与同步中间件能混排吗?答:能,框架自动桥接,但混用会损失异步收益,应评估链路一致性。
- 哪些组件暂不支持异步?答:部分第三方后端与老组件仍为同步,需在其边界包装并验证。
04.7.16.3-058 sync_to_async/async_to_sync 如何做同步异步桥接?
一句话结论
asgiref.sync.sync_to_async 把同步函数放到线程池执行,供异步代码 await;async_to_sync 反向把协程包装成同步函数,在线程中跑事件循环。桥接边界要清晰:异步视图里调用遗留同步服务用 sync_to_async;同步代码调用异步任务用 async_to_sync。反复嵌套桥接会消耗线程池并引入死锁风险。
概念解释
sync_to_async默认通过线程池执行同步阻塞代码,可设thread_sensitive控制线程复用。- 桥接不等于并发优化,阻塞库仍占线程,线程池大小决定并发上限。
原理流程
- 异步上下文需要调同步函数,用
sync_to_async(fn)包装后await。 - 包装器把函数提交到线程池,事件循环继续处理其他协程。
- 同步函数返回结果后回传协程。
- 反向场景:
async_to_sync在调用线程内启动临时事件循环执行协程。
代码或图示
from asgiref.sync import sync_to_async, async_to_sync
# 异步视图中调用遗留同步函数
@sync_to_async
def legacy_report(pk):
return Report.objects.get(pk=pk).render()
async def report_view(request, pk):
html = await legacy_report(pk)
return HttpResponse(html)
# 同步代码中调用异步函数
result = async_to_sync(fetch_remote)(url)
常见误区
- 在
sync_to_async包装内再调async_to_sync:双向嵌套,线程池与事件循环互相等待,易死锁。 - 对纯 CPU 函数也走线程池:不释放 GIL 的计算型函数线程内串行,收益为负。
- 忽略线程敏感语义:带线程本地状态的代码应保持
thread_sensitive=True,避免状态串扰。
追问
sync_to_async线程池默认多大?答:受asgiref线程池配置约束,阻塞调用多时需调大并监控队列。- 桥接后异常如何传播?答:包装器保留原始异常,在异步侧
await时重新抛出。 - ORM 同步操作必须包
sync_to_async吗?答:异步视图中应优先用异步 ORM 接口;遗留同步查询需包装到线程池执行。
04.7.16.3-059 异步 ORM 有哪些限制与注意事项?
一句话结论
异步 ORM 提供 aget/acount/aexists/ain_bulk 与异步 async for 迭代查询集;仍有部分管理方法、聚合与第三方后端未完全异步化。异步视图中禁止直接执行同步模型查询(会在事件循环线程阻塞),混用必须经 sync_to_async 隔离;事务、迁移、Admin 等链路主要仍是同步模型。
概念解释
- 异步查询集走数据库驱动的非阻塞 IO,连接来自异步连接池。
- 模型实例方法、信号处理器若为同步,在异步链路中执行时机需评估。
原理流程
- 异步视图构造查询集,调用异步求值接口。
- 数据库驱动以非阻塞方式收发 SQL,协程挂起等待结果。
- 结果实例化模型对象返回。
- 遇到未异步化的操作,包装到线程池或在同步服务层完成。
代码或图示
from .models import Post
async def detail(request, pk):
post = await Post.objects.aget(pk=pk)
count = await Post.objects.acount()
recent = [p async for p in Post.objects.order_by("-created_at")[:10]]
return JsonResponse({"title": post.title, "count": count})
常见误区
- 异步视图里
Post.objects.get(pk=pk):同步调用阻塞循环,框架给出同步操作警告。 - 把异步查询集传给同步模板渲染:求值方式不匹配,应在视图内取出数据再传上下文。
- 期待所有第三方字段/后端原生异步:需查阅驱动支持度,缺口部分用线程池兜底。
追问
- 异步事务怎么写?答:
async with transaction.atomic():,配合异步 ORM 使用。 - 信号接收函数要写成异步吗?答:信号触发链路有同步/异步区分,默认按同步调用;异步 receiver 需确认框架版本支持。
- 连接池在异步下如何配置?答:按数据库驱动的异步连接参数设置,池大小与异步并发匹配。
04.7.16.3-060 ASGI 与 WSGI 部署在 Django 上有什么差异?
一句话结论
WSGI 部署用 gunicorn(同步/线程 worker)承载同步 Django,每请求占一个线程/进程;ASGI 部署用 uvicorn/hypercorn 跑事件循环,承载异步视图、WebSocket 与长连接,单进程靠协程承载高并发 IO。存量同步栈可在 ASGI 服务器下经桥接运行,但要获得异步收益需链路与组件逐步异步化;两者前面都有 Nginx 做静态、TLS 与连接管理。
概念解释
- WSGI 是请求-响应阻塞模型,ASGI 是事件流模型,支持 WebSocket 与生命周期事件。
- 部署选型:以同步视图/Admin/存量 ORM 为主用 WSGI;需要异步 IO、WebSocket、SSE 用 ASGI。
原理流程
- Nginx 终止 TLS、分发静态文件,反向代理到应用服务器。
- WSGI:gunicorn 多 worker(可配线程)执行同步视图,阻塞等待下游。
- ASGI:uvicorn 单循环跑协程,异步视图
await时释放循环处理其他连接。 - 进程数与连接池按模型配置,数据库总连接数不超过上限。
代码或图示
# WSGI
gunicorn AnnInterview.wsgi:application -w 4 --threads 4 -k gthread
# ASGI
uvicorn AnnInterview.asgi:application --workers 4 --host 0.0.0.0 --port 8000
常见误区
- 同步 Django 直接上 ASGI 就期待高并发:同步代码被桥接到线程池,并发上限仍受线程数约束。
- ASGI worker 开过多:单循环 CPU 饱和,上下文切换增加,worker 数按核数与压测定。
- 漏掉生命周期事件处理:ASGI 启动/关闭钩子(如连接池初始化)需在
asgi.py生命周期内正确挂接。
追问
- 一个项目能同时暴露 WSGI 与 ASGI 入口吗?答:代码可分别提供
wsgi.py/asgi.py,按部署拓扑选其一运行。 - WebSocket 必须用 ASGI 吗?答:是,WSGI 协议不支持双向长连接。
- 异步部署下静态文件谁服务?答:生产由 Nginx/CDN 直发,应用服务器不处理静态资源。
本节高频题
- 类视图 Mixin 组合与 MRO(004)
get_context_data与super()链(005)get_object/get_queryset权限分层(006、007)- 表单校验顺序(021)
commit=False与save_m2m(022)- inline formset 父子表单(026)
- 模板继承与 block 覆盖(031)
- 自动转义与
|safe风险(036) - CSRF token 配对校验(037)
- 新式中间件
__call__写法(042) - 中间件注册顺序与洋葱回程(044)
- 中间件短路与职责边界(045、046)
- 分页器 API 与大表 count 优化(051、052)
- 文件上传链路与 Storage 抽象(053、055)
- 异步视图与
sync_to_async桥接(057、058) - ASGI 与 WSGI 部署差异(060)