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

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_lazy
  • Form/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 引用的是可序列化、可重入的函数。
  • 类实例是每请求新建的,因此实例属性不能跨请求保存状态;类属性才是共享配置。

原理流程

  1. URLconf 解析到 View.as_view() 的返回值,这是一个普通函数。
  2. 请求进入闭包,调用 cls(**initkwargs) 构造视图实例。
  3. 实例把 request/args/kwargs 绑定到 self,执行 self.dispatch(request, *args, **kwargs)。
  4. 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 不做二次包装。

原理流程

  1. 闭包把请求与参数绑定到实例,调用 dispatch。
  2. dispatch 检查方法名是否在 http_method_names 中,不在则调用 http_method_not_allowed 返回 405。
  3. 通过 getattr(self, request.method.lower(), self.http_method_not_allowed) 取处理函数。
  4. 执行该函数,返回响应;子类 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 中钩子方法按预期串接。

原理流程

  1. ListView.get 调 get_queryset,分页后经 get_context_data 注入 object_list。
  2. DetailView.get 调 get_object 取对象,注入 object/<model_name>。
  3. CreateView/UpdateView 的 get 渲染空/绑定表单,post 调 form_valid 保存并跳转。
  4. 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。

原理流程

  1. 声明 class PostView(OwnerCheckMixin, ListView),Python 计算 MRO:PostView → OwnerCheckMixin → ListView → ... → object。
  2. 调用 get_context_data 时,沿 MRO 找到第一个实现,其内部 super() 交给链上下一个。
  3. 各 Mixin 在 super() 前加前置逻辑、在返回后加后置修改,形成洋葱式包装。
  4. 链的末端由 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 等保留键。

原理流程

  1. 视图 get 调 get_context_data,沿 MRO 进入自定义实现。
  2. super().get_context_data(**kwargs) 触发基类注入模型对象、分页器等上下文。
  3. 自定义实现向字典追加统计数、标签列表、筛选选项等业务数据。
  4. 字典随 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 参数名不一致时显式映射。

原理流程

  1. DetailView.get 调 get_object(self.get_queryset())。
  2. 优先用 pk_url_kwarg(默认 pk)匹配查询集;没有 pk 再用 slug_field 与 slug_url_kwarg。
  3. 过滤后执行 get(),命中对象返回,未命中抛 Http404。
  4. 结果挂到 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(),覆写后详情视图自动复用,避免两处口径漂移。
  • 权限要求“看不到”与“看到但不可编辑”是两种处理:前者过滤查询集,后者在表单/按钮上控制。

原理流程

  1. 列表视图直接遍历 get_queryset()。
  2. 详情/编辑视图把 get_queryset() 传给 get_object 做过滤范围。
  3. 覆写 get_queryset 按 request.user、站点、软删除状态裁剪全集。
  4. 覆写 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 视图已绑定)。

原理流程

  1. 表单合法或删除提交后,视图调 self.get_success_url()。
  2. ModelFormMixin.get_success_url 默认返回 self.success_url。
  3. 子类覆写时用 reverse_lazy 带 kwargs={"pk": self.object.pk} 反向解析。
  4. 返回的 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})。

原理流程

  1. post 方法构造绑定表单,调用 form.is_valid()。
  2. 合法:form_valid(form),内部保存对象、记录关系、投递钩子、跳转。
  3. 非法:form_invalid(form),把带错误的表单回传模板。
  4. 覆写时保留 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,否则类视图闭包签名会被破坏。

原理流程

  1. 选目标:dispatch 覆盖所有方法,post 只保护写操作。
  2. 用 method_decorator 把函数装饰器转换为方法级包装。
  3. 包装后的方法在 MRO 链中参与分发。
  4. 鉴权类装饰器在未通过时直接返回重定向或 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。

原理流程

  1. 闭包收到 request, *args, **kwargs。
  2. 构造实例后执行 self.request = request; self.args = args; self.kwargs = kwargs。
  3. 调用 self.dispatch(...),此后所有钩子方法可读这些属性。
  4. 请求结束实例丢弃,属性不残留。

代码或图示

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 的方法应能在最小视图类上独立验证。

原理流程

  1. 提炼跨视图重复行为:鉴权、上下文注入、对象归属校验、响应格式。
  2. 实现钩子方法,内部 super() 串接 MRO 链。
  3. 在具体视图类中按“Mixin 在前、基类在后”声明。
  4. 通过 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,而不是渲染错误表单。

原理流程

  1. URLconf 声明 <slug:slug>,请求路径按字符集匹配。
  2. 匹配成功后 kwargs["slug"] 进入视图。
  3. 视图用 slug_field 在查询集过滤,get() 命中返回对象。
  4. 模型保存时由 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 阶段。

原理流程

  1. 模型实现 get_absolute_url,内部 reverse 带 kwargs 反向解析命名路由。
  2. 模板链接、列表跳转、后台“在站点查看”都调用该方法。
  3. 路由改名时只改 URLconf,实例 URL 自动跟随。
  4. 导入期需要 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 命名空间优先,再按绝对命名空间查找。

原理流程

  1. 根 URLconf include("blog.urls", namespace="blog") 挂载子路由。
  2. 子 urls.py 设 app_name = "blog",路由有 name="post-detail"。
  3. reverse("blog:post-detail", kwargs={"slug": ...}) 拼接并反向匹配模式。
  4. 多实例部署(如多租户挂载同一应用)时用实例命名空间区分。

代码或图示

# 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 掩盖鉴权失败。

原理流程

  1. 视图调用 get_object,查询集 get(**filters)。
  2. 未命中抛 Model.DoesNotExist,被捕获后转 Http404。
  3. 异常冒泡到 ExceptionMiddleware,转换为 404 响应。
  4. 模板层查找模板目录下的 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()、错误结构,模板渲染方式一致。

原理流程

  1. 定义字段列表与 widget/label/help_text。
  2. Form 绑定 data 后只做字段与 clean() 校验,取 cleaned_data。
  3. ModelForm 绑定后额外走模型实例校验,save() 写库。
  4. 复杂跨模型编排仍在视图/服务层完成,表单不承担多表事务。

代码或图示

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 不做类型转换与校验,只负责渲染与取值清洗前的输入。

原理流程

  1. 表单类声明字段,绑定默认 widget 与校验器。
  2. 渲染时 widget 生成 <input>/<select> 等标签并带上属性。
  3. 提交后字段的 to_python 把原始字符串转成 Python 类型,再跑校验器。
  4. 校验通过后值进入 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": "..."}) 或在 Meta widgets 中配置。

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 只能拿到此前已通过的字段,顺序依赖不可靠。

原理流程

  1. 绑定表单,is_valid() 触发逐字段清洗。
  2. 字段完成基础类型转换与内置校验。
  3. 调用 clean_<field>,开发者追加业务校验,返回新值。
  4. 最后进入表单级 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() 约束校验。

原理流程

  1. 逐字段清洗与 clean_<field> 全部完成。
  2. 调用表单 clean(),读取多个字段做组合判断。
  3. 违规时 add_error 绑定字段,或抛 ValidationError 进入非字段错误。
  4. 返回(必要时修改后的)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(...)。

原理流程

  1. is_valid() 对绑定表单逐字段清洗,先转换类型再跑内置校验。
  2. 字段自定义校验器执行,随后 clean_<field> 做业务规则。
  3. 所有字段完成后调用表单 clean() 做跨字段一致性。
  4. 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 信号。

原理流程

  1. 表单合法,form.save(commit=False) 构造实例但不执行 INSERT。
  2. 视图补充 author=request.user 等请求相关字段。
  3. instance.save() 入库获得主键。
  4. 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 非法值会校验失败。

原理流程

  1. 表单类元数据读取模型字段,生成对应表单字段与默认校验器。
  2. 绑定数据后走表单校验链。
  3. 实例化模型对象,full_clean() 跑模型字段与模型级校验。
  4. 视图 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 新建空实例;提供则回填现有数据。

原理流程

  1. GET 请求构造未绑定表单,initial 字典注入默认值供 widget 渲染。
  2. 编辑视图从库取出对象,ModelForm(instance=obj) 回填字段。
  3. POST 绑定 data,校验通过后 save() 更新该实例。
  4. 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。

原理流程

  1. formset_factory(ArticleForm, extra=2) 生成 ArticleFormSet 类。
  2. GET 时按 extra 渲染空白表单,initial 列表预填对应行。
  3. POST 时解析 management form 中的数量字段,逐行绑定校验。
  4. 校验通过后遍历 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 用于父表有多个指向子表外键时指定关联字段。

原理流程

  1. 工厂按父子模型与表单类生成内联 formset。
  2. 视图传 instance=parent,已存在的子对象回填成行。
  3. POST 校验通过,formset.save() 把子对象创建/更新/删除到父实例下。
  4. 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。

原理流程

  1. 模板 {{ formset.management_form }} 输出隐藏输入。
  2. 每行字段以 form-<index>-<field> 命名。
  3. POST 到达,formset 读取 management 字段确定行数与初始行。
  4. 逐行构造绑定表单并校验,删除标记在保存阶段生效。

代码或图示

<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,可遍历消息或转字符串。
  • 非字段错误通常是跨字段规则、模型级约束或业务整体校验失败。

原理流程

  1. 校验链各步收集 ValidationError,按归属挂到字段或表单级。
  2. add_error(field, err) 指定字段;不传字段则进 __all__。
  3. 视图取 form.errors 传给模板,按位置渲染。
  4. 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__,便于携带配置参数与反序列化。

原理流程

  1. 定义函数接收 value,规则不满足时抛 ValidationError。
  2. 在字段 validators=[...] 中注册。
  3. 字段清洗到 run_validators 阶段逐个调用。
  4. 多个字段共用时从公共校验模块导入,避免复制粘贴。

代码或图示

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>。

原理流程

  1. 视图构造表单传入模板上下文。
  2. 模板选择整体快捷渲染或逐字段手动渲染。
  3. 字段 widget 按 attrs 生成 HTML,错误列表跟随字段输出。
  4. 提交时字段名与 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 }})。

原理流程

  1. 渲染子模板,模板引擎读取 {% extends %} 定位父模板。
  2. 收集子模板定义的各 block 内容。
  3. 载入父模板骨架,按 block 名用子内容替换对应区域。
  4. 未被覆盖的 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 或继承其他模板。

原理流程

  1. 主模板渲染到 include 标签位置。
  2. 载入被包含模板,按当前上下文(或 with 指定变量)渲染。
  3. 片段输出替换回主模板对应位置。
  4. 主模板继续渲染后续内容。

代码或图示

{% 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 顺序执行,后写的同名键覆盖先写的。

原理流程

  1. 视图 render 构造 RequestContext,先放入视图上下文。
  2. 框架按配置依次调用上下文处理器,合并返回字典。
  3. 模板引擎在完整上下文上解析变量与标签。
  4. 处理器内可访问 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 }};需要参数的方法不能在模板调用。
  • 查找失败静默返回空,调试时要确认变量名与类型。

原理流程

  1. 先解析变量名对应的根对象。
  2. 对点号后的每一段,依次尝试字典取值、属性访问、数字索引。
  3. 命中则继续下一段,未命中置空。
  4. 最终值经过过滤器与自动转义后输出。

代码或图示

{{ 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" }},多个过滤器按从左到右顺序执行。
  • 过滤器不改变原始变量,只影响本次输出。

原理流程

  1. 变量求值得到原始值。
  2. 按 | 顺序逐个套用过滤器,上一个输出是下一个输入。
  3. 最终值进入自动转义与渲染。
  4. 自定义过滤器在 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 侧标记安全,下游不再转义。

原理流程

  1. 模板编译期按 autoescape 默认状态(开启)记录各节点是否转义。
  2. 渲染时变量值经转义函数替换特殊字符为实体。
  3. 带 SafeString 标记的值跳过转义。
  4. {% 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,因此无法伪造配对值。

概念解释

  • 中间件为响应设置 csrftoken Cookie,模板标签把同一 token 写入表单。
  • 免 Cookie 的 API(纯 Token 认证)可对视图 csrf_exempt,但浏览器表单场景不能关闭。

原理流程

  1. 中间件处理 GET 响应,下发 CSRF Cookie。
  2. 模板 {% csrf_token %} 输出隐藏字段 csrfmiddlewaretoken。
  3. POST 到达,中间件从表单或 X-CSRFToken 头取 token,与 Cookie 比对。
  4. 不匹配返回 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 %} 块内别名有效,块外不可见。

原理流程

  1. 模板编译把标签转成节点树。
  2. 渲染时按上下文求值条件或遍历序列。
  3. forloop 计数器随迭代更新,first/last 标识边界。
  4. 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 负责渲染局部模板并返回上下文。

原理流程

  1. 创建 myapp/templatetags/extras.py,导入 template.Library。
  2. 用装饰器注册过滤器或标签函数。
  3. 模板 {% load extras %},按名称调用。
  4. 框架在渲染期执行函数,返回值替换标签位置。

代码或图示

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 查找并编译,编译结果在进程内缓存。
  • 渲染耗时包含字符串拼接、变量查找与过滤器执行,列表页最敏感。

原理流程

  1. 首次请求加载模板源码,编译成节点树并缓存。
  2. 后续请求复用编译树,仅执行渲染。
  3. 渲染期遍历上下文、解析变量、执行标签与过滤器。
  4. 列表规模放大循环内操作(查询、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,但不感知具体路由与视图实现。

原理流程

  1. WSGI/ASGI Handler 收到请求,构造 HttpRequest。
  2. 请求按 MIDDLEWARE 注册顺序进入各中间件的请求段。
  3. 路由匹配到视图,执行业务逻辑生成响应。
  4. 响应按注册逆序穿过中间件回程段,最终由 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 项目统一使用新式写法。

原理流程

  1. 启动期实例化中间件,get_response 注入为下游链。
  2. 请求进入 __call__,执行请求前置逻辑(鉴权、计时、绑定数据)。
  3. 调 get_response(request) 穿过下游拿到响应。
  4. 执行响应后置逻辑(加头、压缩、记录日志),返回响应。

代码或图示

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 等旧式钩子的转发。

原理流程

  1. 旧式中间件类继承 MiddlewareMixin,定义 process_request/process_response。
  2. 框架按新式协议实例化,Mixin 的 __call__ 接管。
  3. __call__ 先调 process_request,有响应则短路;否则调下游。
  4. 回程调用 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 依赖认证数据的依次靠后;顺序错了会出现属性未绑定、防护被绕过或响应头丢失。

概念解释

  • 顺序是洋葱分层:外层中间件包裹内层,请求与响应走两条相反方向。
  • 内置中间件有官方推荐顺序,自定义中间件按依赖关系插入。

原理流程

  1. 启动期按 MIDDLEWARE 列表装配中间件链。
  2. 请求正序穿过:SecurityMiddleware → SessionMiddleware → CommonMiddleware → CsrfViewMiddleware → AuthenticationMiddleware → ...
  3. 视图返回响应,逆序穿过同一批中间件。
  4. 某层短路返回响应时,它内层的中间件请求段未执行,回程只经过其外层。

代码或图示

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 黑白名单都属于典型短路场景。

原理流程

  1. 请求穿过外层中间件进入当前层。
  2. 校验不通过,当前层构造重定向/403/429 响应直接返回。
  3. 下游中间件与视图未被调用。
  4. 响应沿当前层之外的外层中间件逆序回程。

代码或图示

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 上传递,不要挂在中间件实例属性上。

原理流程

  1. 识别需求是否对全站请求一视同仁。
  2. 横切且无业务分支 → 中间件;按路由/模型变化 → 视图或装饰器。
  3. 请求级数据通过 request.xxx 传递,请求结束随对象回收。
  4. 数据库副作用与外部调用评估超时与失败影响,避免拖垮全站。

代码或图示

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 返回非空响应即接管错误处理,否则异常继续冒泡。

原理流程

  1. 路由匹配成功,旧式链依次调用各 process_view。
  2. 任一钩子返回响应即短路,视图不执行。
  3. 视图抛异常,框架沿链调 process_exception 尝试转换响应。
  4. 无人接管则冒泡到异常中间件生成 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(视图级)→ 上下文处理器(模板级)。
  • 同一需求能在更小作用域解决就不下沉到中间件,减少无关请求开销。

原理流程

  1. 判断逻辑是否对每个请求生效:是 → 中间件候选。
  2. 判断是否只保护特定视图:是 → 装饰器/method_decorator/Mixin。
  3. 判断是否为模板展示补数据:是 → 上下文处理器。
  4. 组合使用时明确每层职责,避免重复鉴权或重复注入。

代码或图示

# 视图级装饰器
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 响应不应泄露堆栈与配置,生产环境错误细节只进日志。

原理流程

  1. 外层中间件调用 get_response(request),下游异常向上冒泡。
  2. 捕获已知业务异常,映射为 400/403/404 等语义化响应。
  3. 未知异常记录 logger.exception 后重新抛出。
  4. 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。

原理流程

  1. 安全策略最先执行,协议层重定向与头处理。
  2. 会话加载后,CSRF 校验读取会话/Cookie 数据。
  3. 认证中间件根据会话绑定用户对象。
  4. 视图执行后回程依次写压缩、帧选项、安全头等响应头。

代码或图示

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(),保留惰性由分页器切片。

原理流程

  1. 视图传入完整查询集与每页条数。
  2. Paginator 计算总页数与总数。
  3. get_page 解析页码,切片出当前页对象列表。
  4. 模板遍历 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 时更贵。
  • 偏移分页越深,定位成本越高;键集分页用上一页末尾值作为锚点,每次走索引定位。

原理流程

  1. 默认分页器调用 count() 计算 num_pages 与导航信息。
  2. 大表该计数慢,成为列表接口主要耗时。
  3. 键集分页:WHERE (created_at, id) < (上页末尾值) ORDER BY created_at DESC, id DESC LIMIT 10。
  4. 总数按需缓存或改用“更多”按钮,不展示精确总页数。

代码或图示

# 键集分页示例:按 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 配置,默认内存 + 临时文件两段式。

原理流程

  1. WSGI/ASGI 服务器解析 multipart 请求体,文件部分交给上传处理器。
  2. 未超内存阈值的文件留在内存,超阈值转入系统临时目录。
  3. 表单绑定 request.FILES,is_valid() 校验文件字段。
  4. 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 存用户上传内容。

原理流程

  1. 配置 MEDIA_ROOT(如项目目录下 media/)与 MEDIA_URL="/media/"。
  2. 文件落盘到 MEDIA_ROOT 下按字段 upload_to 组织的子目录。
  3. 模板 {{ attachment.file.url }} 生成 MEDIA_URL 加相对路径的链接。
  4. 开发期 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 两个后端槽位。

原理流程

  1. 模型 FileField 持有存储后端引用。
  2. save() 调用后端 save(name, content),由后端决定落盘位置与命名。
  3. url() 方法向后端取访问地址,本地后端拼 MEDIA_URL,云后端返回 CDN/签名 URL。
  4. 切换后端只改配置,上传与读取路径随之改变。

代码或图示

# 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 限制字段数量,防超大表单攻击。

原理流程

  1. 服务器先按请求体大小拦截超限请求(413)。
  2. 应用解析 multipart,文件按内存阈值分流到内存/临时文件。
  3. 表单校验文件类型、扩展名、图片尺寸。
  4. 模型保存,存储后端落盘。

代码或图示

# 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 部署下异步视图经线程池桥接执行。

原理流程

  1. ASGI 服务器把请求送入异步事件循环。
  2. Django 识别 async def 视图,在循环内 await 执行。
  3. 异步 ORM 查询用 await Post.objects.acount() 等异步接口。
  4. 响应经异步中间件链返回;同步代码通过线程池隔离执行。

代码或图示

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 控制线程复用。
  • 桥接不等于并发优化,阻塞库仍占线程,线程池大小决定并发上限。

原理流程

  1. 异步上下文需要调同步函数,用 sync_to_async(fn) 包装后 await。
  2. 包装器把函数提交到线程池,事件循环继续处理其他协程。
  3. 同步函数返回结果后回传协程。
  4. 反向场景: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,连接来自异步连接池。
  • 模型实例方法、信号处理器若为同步,在异步链路中执行时机需评估。

原理流程

  1. 异步视图构造查询集,调用异步求值接口。
  2. 数据库驱动以非阻塞方式收发 SQL,协程挂起等待结果。
  3. 结果实例化模型对象返回。
  4. 遇到未异步化的操作,包装到线程池或在同步服务层完成。

代码或图示

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。

原理流程

  1. Nginx 终止 TLS、分发静态文件,反向代理到应用服务器。
  2. WSGI:gunicorn 多 worker(可配线程)执行同步视图,阻塞等待下游。
  3. ASGI:uvicorn 单循环跑协程,异步视图 await 时释放循环处理其他连接。
  4. 进程数与连接池按模型配置,数据库总连接数不超过上限。

代码或图示

# 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)