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

04.7.17.1 序列化器与视图体系

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

覆盖范围

  • Serializer 与 ModelSerializer 字段映射规则
  • source/read_only/write_only/required/default 等字段参数
  • to_internal_value 与 to_representation 调用链
  • validate_<field> 与对象级 validate 执行顺序
  • 嵌套序列化、depth、many=True 与 ListSerializer
  • SerializerMethodField/HiddenField/CurrentUserDefault 与 context
  • APIView/GenericAPIView 的查询集、序列化器与钩子方法
  • perform_create/perform_update/perform_destroy 与 action
  • ViewSet/GenericViewSet/ModelViewSet 与 mixin 继承链
  • Router、basename、@action 与 URL 反解

04.7.17.1-001 Serializer 和 ModelSerializer 有什么区别?

一句话结论

Serializer 是手写字段的基类,字段、校验、create/update 都要自己声明;ModelSerializer 继承自 Serializer,通过 Meta.model 依据 Django 模型字段自动推导 DRF 字段类型、必填性与默认值,只在需要偏离模型行为时显式覆盖。两者底层都是 BaseSerializer,反序列化校验链完全一致。

概念解释

  • Serializer 面向任意数据源(字典、接口返回值、非模型对象),不绑定 ORM。
  • ModelSerializer 是「模型表单」思路在 API 层的对应物,自动生成字段并提供默认的 create/update 实现。

原理流程

  1. ModelSerializer.build_field_kwargs 读取模型字段的 null/blank/default/choices 推导 DRF 字段参数。
  2. build_standard_field 按模型字段类型选择对应 DRF 字段类,外键、多对多走关系字段分支。
  3. 未被显式声明的字段进入 get_fields() 自动生成;显式声明的同名字段覆盖自动推导结果。

代码或图示

from rest_framework import serializers

# 手写 Serializer:字段与校验全部显式声明
class PlainSerializer(serializers.Serializer):
    name = serializers.CharField(max_length=64)
    age = serializers.IntegerField(min_value=0)

# ModelSerializer:依据模型自动推导字段
class NoteSerializer(serializers.ModelSerializer):
    class Meta:
        model = Note
        fields = ["id", "title", "content", "created_at"]

常见误区

  • ModelSerializer 自动推导的必填性受模型 blank/null 影响:模型字段 null=True 映射出的 DRF 字段通常 allow_null=True,但 blank=True 的 CharField 映射为 allow_blank=True,不等于可缺省。
  • 不要以为 ModelSerializer 自动生成的字段一定符合 API 契约:外键默认映射为主键字段,嵌套表示需要额外声明;模型层的 unique_together 不会自动变成序列化器校验。

追问

  • ModelSerializer 还提供了什么默认行为?答:默认实现了基于模型保存的 create/update,并自动挂模型字段级校验(如 unique)。
  • 什么时候应该退回手写 Serializer?答:数据源不是模型、字段是多个模型聚合、或 API 形态与模型字段差异很大时。

04.7.17.1-002 ModelSerializer 如何自动映射模型字段?

一句话结论

DRF 3.1x 的映射表把 Django 模型字段类型对应到 DRF 字段:AutoField→IntegerField(read_only),CharField→CharField,IntegerField→IntegerField,DateTimeField→DateTimeField,ForeignKey→PrimaryKeyRelatedField,ManyToManyField→PrimaryKeyRelatedField(many=True),BooleanField、DecimalField、EmailField、URLField 等一一对应。映射时同时复制 null、blank、default、max_length、choices、validators。

概念解释

  • 映射逻辑位于 rest_framework.utils.model_meta 与 serializers.ModelSerializer.build_standard_field。
  • 关系字段走 build_relational_field,默认用主键表示;改嵌套表示要在序列化器里显式写嵌套序列化器或 depth。

原理流程

  1. get_fields() 遍历模型的 concrete fields 与反向关系。
  2. build_field_kwargs 从模型字段读取空值、默认值、长度、选项等参数。
  3. 按字段类型查表得到 DRF 字段类,注入 kwargs 后实例化;显式声明字段优先于自动字段。

代码或图示

class ArticleSerializer(serializers.ModelSerializer):
    class Meta:
        model = Article
        fields = ["id", "title", "author", "tags", "score"]
        # author 是 ForeignKey → PrimaryKeyRelatedField(queryset=User.objects.all())
        # tags 是 ManyToManyField → PrimaryKeyRelatedField(many=True, queryset=Tag.objects.all())

常见误区

  • 反向关系(related_name 指向的一对多)默认不出现在自动字段里,需要在 Meta.fields 中显式列出,或手写嵌套序列化器。
  • 模型字段的 db_index、db_column 不会映射到序列化器;default=... 是可调用对象时 DRF 会在输出时调用它,反序列化缺省也会取该默认值。

追问

  • 外键默认序列化成什么?答:默认是 PrimaryKeyRelatedField,输出主键、写入时按主键校验存在性。
  • 想让外键输出嵌套对象怎么办?答:手写嵌套序列化器字段,或设置 depth,两者都需要注意不可写问题。

04.7.17.1-003 source 参数支持哪些取值路径?

一句话结论

source 指定序列化字段从数据源的哪个位置取值:裸属性名(source="author_name")、属性访问链(source="author.username")、字典键、调用无参方法(source="get_full_name"),还可以用 source="*" 把整个对象作为字段值传入嵌套序列化器。反序列化时 source 同时决定 validated_data 写入模型的哪个属性路径。

概念解释

  • 字段名与模型属性不一致时,用 source 做别名,输出键名保持 API 契约不变。
  • 跨关系取值时,source 链路每一级都可能触发数据库查询,需要在视图层优化关联加载。

原理流程

  1. 序列化输出:Field.get_attribute(instance) 按 source 用 getattr/dict 逐级取值。
  2. 反序列化输入:输入数据按字段名进入,校验通过后按 source 路径写回 validated_data 的嵌套字典。
  3. source 指向方法时,序列化阶段调用该方法取返回值。

代码或图示

class ProfileSerializer(serializers.ModelSerializer):
    account_name = serializers.CharField(source="author.username", read_only=True)
    display_name = serializers.CharField(source="get_full_name", read_only=True)

    class Meta:
        model = Profile
        fields = ["account_name", "display_name"]

常见误区

  • source 层级过深时,中间一级为 None 会抛异常或返回空,序列化阶段要处理可空链路;跨关系取值不做预加载会直接造成 N+1。
  • 反序列化字段写 source="author.username" 不能自动拆成级联更新,跨关系写入通常需要在 update 里手动处理。

追问

  • source="*" 是什么意思?答:把当前整个实例作为该字段的输入,常用于嵌套对象整体映射。
  • 字段名和 source 不一致时 validated_data 的键是什么?答:键是 source 指向的路径,字段名只用于输入输出的 JSON 键。

04.7.17.1-004 read_only 与 write_only 分别在什么时候生效?

一句话结论

read_only=True 的字段只参与序列化输出(to_representation),反序列化输入时被忽略,不参与校验与 validated_data;write_only=True 只参与反序列化输入与校验,序列化输出时不返回。两者互斥:一个字段不能同时只读又只写。read_only 常用于服务端生成的 id、created_at、计算字段。

概念解释

  • 只读字段典型来源:自增主键、时间戳、后端计算的聚合值。
  • 只写字段典型来源:密码、验证码、一次性令牌,绝不回显。

原理流程

  1. get_fields() 构造字段时记录 read_only/write_only 标记。
  2. 输出阶段:to_representation 跳过 write_only 字段;输入阶段:to_internal_value 跳过 read_only 字段。
  3. save() 组装 validated_data 时只包含可写字段。

代码或图示

class UserSerializer(serializers.ModelSerializer):
    password = serializers.CharField(write_only=True)
    profile = ProfileSerializer(read_only=True)

    class Meta:
        model = User
        fields = ["id", "username", "password", "profile", "created_at"]
        read_only_fields = ["id", "created_at"]

常见误区

  • Meta.read_only_fields 里写的字段即使传了值也不会被保存,前端传入的只读值会被静默丢弃,不是报错。
  • 嵌套只读对象在输入时整体忽略;若嵌套字段需要写入,必须去掉只读标记并实现嵌套 create/update。

追问

  • 密码字段为什么要 write_only?答:避免响应回显密码哈希,输入校验通过后在 create 里 set_password。
  • read_only 字段还需要出现在请求文档里吗?答:schema 中会标注为只读,POST/PATCH 请求体不需要传。

04.7.17.1-005 required 与 default 如何配合控制必填与默认值?

一句话结论

required=True(默认)表示输入必须提供该字段,缺失即报错;required=False 表示可缺省,缺省时若配置了 default 则用默认值填充 validated_data,未配置 default 则该键不出现在 validated_data 中。default 可以是静态值、可调用对象(如 datetime.now、serializers.CurrentUserDefault)。partial=True 会让所有字段在单次更新中临时变为非必填。

概念解释

  • 必填性与可空性是两件事:required=False 是「可以不传」,allow_null=True 是「传了可以为 null」。
  • default 只在字段缺省时生效,显式传 null 时仍受 allow_null 约束。

原理流程

  1. 输入数据缺该字段:检查 default,有则填入,无则按 required 决定是否报错。
  2. 输入显式传值:进入字段类型校验与 validate_<field>。
  3. partial=True 时校验阶段跳过必填检查,但已传值仍走类型校验。

代码或图示

class OrderSerializer(serializers.ModelSerializer):
    remark = serializers.CharField(required=False, default="")
    source = serializers.CharField(required=False, default="web")
    created_by = serializers.CharField(default=serializers.CurrentUserDefault())

    class Meta:
        model = Order
        fields = ["remark", "source", "created_by"]

常见误区

  • required=False 但没写 default,更新时不传该字段就不会更新它,这正是 PATCH 的预期行为;误以为缺省会清空字段是常见错误。
  • 可调用 default 每次调用都会执行,不要在里面做重 IO;default 与 required 同时显式设置时,缺省优先取默认值。

追问

  • allow_null 和 required=False 有什么区别?答:前者控制「传 null 是否合法」,后者控制「字段能否缺失」。
  • partial=True 在哪里最常用?答:PATCH 更新接口,视图里 self.get_serializer(instance, data=request.data, partial=True)。

04.7.17.1-006 allow_null 与 allow_blank 的区别是什么?

一句话结论

allow_null=True 允许字段值为 Python None(JSON 的 null);allow_blank=True 只对字符串类字段有意义,允许空字符串 ""。模型字段 null=True 映射到 allow_null=True,blank=True 映射到 allow_blank=True,二者来源不同,不能互换。整数、布尔等非字符串字段不支持 allow_blank。

概念解释

  • 数据库层面 null 与空字符串是两种存储语义,API 校验要与之一致。
  • 前端把「未填写」提交成 "" 还是 null,取决于契约,序列化器按契约配置。

原理流程

  1. 字段校验先判空:值为 None 时检查 allow_null;值为 "" 时检查 allow_blank(仅字符串字段)。
  2. 不被允许的空值进入 errors,错误码分别为 null 与 blank。
  3. 空值通过校验后,再走类型转换与后续校验器。

代码或图示

class FeedbackSerializer(serializers.Serializer):
    contact = serializers.EmailField(required=False, allow_null=True, default=None)
    nickname = serializers.CharField(required=False, allow_blank=True, default="")

常见误区

  • 给非字符串字段加 allow_blank 会在 schema 检查或运行时出问题;想表达「可缺省」应使用 required=False 配 default。
  • allow_blank=True 的字符串仍会通过 max_length 等长度校验,但不会被 trim;前后端要统一空白字符串是否算有效输入。

追问

  • 模型 null=True 对应序列化器哪个参数?答:allow_null=True;blank=True 对应 allow_blank=True。
  • 空字符串要拒绝但允许缺省怎么写?答:required=False,不加 allow_blank,并给出业务默认值。

04.7.17.1-007 字段级 validators 与对象级校验如何分工?

一句话结论

字段级 validators 列表作用于单个字段的值,在字段类型转换之后、validate_<field> 之前执行;对象级校验(validate 方法或序列化器级 validators)拿到整份 validated_data,处理跨字段规则(如结束时间晚于开始时间、两次密码一致)。字段级校验失败错误挂在字段名下,对象级失败默认挂在 non_field_errors 下,也可指向具体字段。

概念解释

  • 可复用校验逻辑写成函数 validator,挂在多个字段上。
  • 跨字段一致性必须在对象级校验,字段级拿不到其他字段的值。

原理流程

  1. to_internal_value 逐字段做类型转换与字段 validator。
  2. 依次调用 validate_<field> 钩子。
  3. 汇总后调用 validate(data),抛 ValidationError 携带字段或 non_field_errors。

代码或图示

def even_score(value):
    if value % 2 != 0:
        raise serializers.ValidationError("分数必须为偶数")

class BetSerializer(serializers.Serializer):
    start = serializers.IntegerField()
    end = serializers.IntegerField(validators=[even_score])

    def validate(self, data):
        if data["end"] <= data["start"]:
            raise serializers.ValidationError({"end": "结束值必须大于开始值"})
        return data

常见误区

  • 对象级 validate 抛 ValidationError 传字符串会归入 non_field_errors;要挂到具体字段必须传字典。
  • validator 里不要访问 self.context 做重业务判断,字段级 validator 是纯函数更易复用;需要请求上下文的规则放到 validate 或视图层。

追问

  • 字段级 validator 的执行位置在哪?答:字段类型转换之后、validate_<field> 之前。
  • 跨字段规则放哪一层?答:对象级 validate,因为只有它能拿到完整 validated_data。

04.7.17.1-008 反序列化时 to_internal_value 的调用链是怎样的?

一句话结论

反序列化入口是 is_valid(),内部走 BaseSerializer.run_validation(data) → 序列化器 to_internal_value(data):逐字段调用字段的 run_validation(类型转换、字段级 validator、validate_<field>),收集字段结果与错误;全部通过后再调用对象级 validate(attrs),最终返回 validated_data。任一层抛 ValidationError 都会被捕获并聚合进 self.errors,不会中断到视图层。

概念解释

  • to_internal_value 是「外部输入 → 内部 Python 数据结构」的边界,负责把 JSON 字典转成可保存的 validated_data。
  • 字段内部还有 Field.to_internal_value 做具体类型转换(字符串→整数、字符串→日期等)。

原理流程

  1. run_validation 先处理缺失值(default/required),再调 field.to_internal_value。
  2. 字段层执行 validators 列表与字段钩子;序列化器层遍历 fields 组装 ret。
  3. to_internal_value 返回后调用 self.validate(ret);错误通过 ValidationError.detail 聚合成字段映射。

代码或图示

class ArticleSerializer(serializers.ModelSerializer):
    def to_internal_value(self, data):
        cleaned = super().to_internal_value(data)
        cleaned["title"] = cleaned["title"].strip()
        return cleaned

    class Meta:
        model = Article
        fields = ["title", "body"]

常见误区

  • 重写 to_internal_value 忘记调 super() 会丢掉所有字段自动校验,错误聚合也会失效。
  • 在校验层做数据库写入或副作用是错误分层:to_internal_value/validate 只负责数据校验,持久化放在 create/update 或视图 perform_create。

追问

  • 字段类型转换发生在哪一层?答:Field.run_validation 内的 Field.to_internal_value,先于字段级 validator。
  • 聚合后的错误存在哪里?答:serializer.errors,结构是字段名到错误列表的映射,对象级错误在 non_field_errors。

04.7.17.1-009 序列化输出时 to_representation 的调用链是怎样的?

一句话结论

序列化输出由 Response(serializer.data) 触发,serializer.data 走 BaseSerializer.to_representation(instance):遍历每个可输出字段,调字段的 get_attribute(instance) 取属性值,再经 Field.to_representation 转成 JSON 原生类型(日期→字符串、模型实例→主键或嵌套字典、QuerySet→列表),最终组装成有序字典返回。嵌套序列化器在自己的 to_representation 里递归执行同一套流程。

概念解释

  • 表示层负责「内部模型对象 → 可 JSON 化结构」,不参与校验。
  • 自定义输出格式通常重写 to_representation 或用 SerializerMethodField。

原理流程

  1. serializer.data 属性触发 to_representation(instance)。
  2. 跳过 write_only 字段;每个字段 get_attribute 按 source 取值。
  3. 字段 to_representation 做类型转换,嵌套字段递归调用子序列化器。

代码或图示

class UserOutSerializer(serializers.ModelSerializer):
    class Meta:
        model = User
        fields = ["id", "username", "roles"]

    def to_representation(self, instance):
        data = super().to_representation(instance)
        data["name"] = f"{instance.last_name}{instance.first_name}"
        return data

常见误区

  • 重写 to_representation 里访问未预加载的关联对象会触发 N+1;不要在表示层做数据库查询。
  • 输出 None 的可空关系字段要确认 allow_null 配置,否则可能在类型转换处抛异常;嵌套序列化器输出空集合与空对象的语义要统一。

追问

  • 嵌套对象是如何被序列化的?答:子序列化器的 to_representation 被递归调用,产出嵌套字典或列表。
  • 想给响应统一包一层 data 结构在哪做?答:渲染器或视图层包装,不要改每个序列化器的 to_representation。

04.7.17.1-010 is_valid() 内部依次执行了哪些步骤?

一句话结论

is_valid(raise_exception=False) 调用 run_validation:先做字段缺失/默认值处理与逐字段反序列化,再跑字段级与对象级校验,通过后缓存 validated_data;失败则把 ValidationError.detail 写入 errors。raise_exception=True 时校验失败直接抛 ValidationError,由 DRF 异常处理转成 400 响应。校验结果被缓存,重复调用不会重复执行。

概念解释

  • is_valid() 返回布尔值,validated_data 只有在校验通过后才可访问。
  • 校验分两阶段:字段层(类型、validator、validate_<field>)与对象层(validate)。

原理流程

  1. to_internal_value 逐字段反序列化并收集错误。
  2. validate(attrs) 执行对象级校验。
  3. 成功保存 _validated_data;失败把错误合并进 _errors;raise_exception 按标志抛异常。

代码或图示

serializer = ArticleSerializer(data=request.data)
if serializer.is_valid(raise_exception=True):
    instance = serializer.save()

常见误区

  • 未通过 is_valid() 就访问 serializer.validated_data 会抛断言错误;先判 is_valid() 再取数据。
  • 重复构造相同数据的序列化器才会重新校验;同一实例上重复 is_valid() 走缓存,修改 serializer.initial_data 不会重跑校验。

追问

  • raise_exception=True 失败后返回什么?答:抛 rest_framework.exceptions.ValidationError,最终渲染为 HTTP 400。
  • 校验通过后原始输入还能拿到吗?答:可以通过 serializer.initial_data 访问原始输入字典。

04.7.17.1-011 validate_<field> 和 validate 的执行顺序是什么?

一句话结论

顺序固定为:字段类型转换 → 字段级 validators 列表 → validate_<field> 字段钩子 → 下一字段重复上述流程 → 全部字段完成后调用对象级 validate(attrs)。字段钩子只能访问本字段的值,对象钩子拿到完整 validated_data。字段钩子里抛出的错误挂对应字段名,对象钩子可自由指定错误归属。

概念解释

  • validate_<field> 命名钩子是 DRF 约定:方法名与字段名对应,框架自动发现并调用。
  • 把简单单字段规则放字段钩子,跨字段规则放 validate,职责清晰。

原理流程

  1. 每个字段 run_validation 结束前查找 validate_<字段名> 方法并调用。
  2. 所有字段处理完,to_internal_value 返回 ret。
  3. run_validation 调 self.validate(ret),返回值成为最终 validated_data。

代码或图示

class CouponSerializer(serializers.Serializer):
    code = serializers.CharField()
    amount = serializers.DecimalField(max_digits=10, decimal_places=2)

    def validate_code(self, value):
        if not value.isupper():
            raise serializers.ValidationError("兑换码必须大写")
        return value

    def validate(self, data):
        if data["amount"] <= 0:
            raise serializers.ValidationError("金额必须大于 0")
        return data

常见误区

  • 在 validate_<field> 里读 data["other"] 拿不到其他字段;需要跨字段判断必须放到 validate。
  • 字段钩子的返回值会替换 validated_data 中该字段的值,忘记 return value 会把该字段变成 None。

追问

  • 字段钩子返回值有什么用?答:返回值替换校验后的值,可在钩子内做清洗、格式化或类型归一。
  • 对象级 validate 不返回数据会怎样?答:必须 return data,否则 validated_data 为 None,保存时报错。

04.7.17.1-012 校验失败后的 errors 是什么结构?

一句话结论

serializer.errors 是有序映射:键为字段名,值为错误字符串列表;对象级错误固定在 non_field_errors 键下;嵌套序列化器的错误是同构嵌套字典,many=True 时是「索引 → 字段错误」的列表映射。每条错误 detail 通常包含 message 与 code(DRF 3.1x 中可访问 serializer.errors 的富对象形式)。

概念解释

  • 错误结构与输入结构同构:嵌套哪里出错,错误就挂到哪里,前端按路径定位表单项。
  • 400 响应默认由 JSONRenderer 渲染为该映射。

原理流程

  1. 各层 ValidationError 携带 detail(字符串、列表或字典)。
  2. ValidationError 被 run_validation 捕获,detail 合并进字段映射。
  3. 嵌套子序列化器失败时,父级把其 errors 挂到对应嵌套键。

代码或图示

# 典型 400 响应
{
    "title": ["该字段是必填项。"],
    "author": ["无效的主键 999 — 对象不存在。"],
    "non_field_errors": ["结束时间必须晚于开始时间。"]
}

常见误区

  • 直接把 errors 当字符串使用会丢结构;前端需要按字段键渲染,non_field_errors 是兜底提示位。
  • 自定义 ValidationError 传 code 后,错误对象带错误码,仅取 str(detail) 会丢失码信息;统一错误结构时应同时保留 message 与 code。

追问

  • 嵌套对象的错误挂在哪?答:挂在嵌套键下的子错误字典,结构与请求体同构。
  • 列表批量提交时错误如何定位?答:many=True 下错误列表按索引排列,第 i 项的字段错误在对应位置。

04.7.17.1-013 save() 如何分发到 create 与 update?

一句话结论

serializer.save() 在 validated_data 基础上判断:实例化时传了 instance 则调 update(instance, validated_data),未传则调 create(validated_data);save(**extra_attrs) 传入的额外参数先合并进 validated_data 再分发。ModelSerializer 提供默认实现:create 调 Model.objects.create(**validated_data),update 遍历字段 setattr 后 save()。

概念解释

  • instance 是否存在是创建与更新的唯一判定依据,与 HTTP 方法无关。
  • extra_attrs 用于注入请求级数据,如当前用户,避免进入请求体。

原理流程

  1. save() 先把 **kwargs 合并进 validated_data。
  2. 判断 self.instance:非空走 update,为空走 create。
  3. 返回保存后的模型实例,重新挂回 self.instance。

代码或图示

class NoteSerializer(serializers.ModelSerializer):
    class Meta:
        model = Note
        fields = ["title", "body"]

    def create(self, validated_data):
        validated_data["author"] = self.context["request"].user
        return super().create(validated_data)

常见误区

  • 重复调用 save():已有 instance 时第二次 save() 仍走 update,不会新建;想创建第二条记录要重新实例化序列化器。
  • update 默认实现只更新标量字段,关系字段(多对多)需要手动处理;嵌套对象的保存默认实现不会递归级联写入。

追问

  • 想在保存时注入当前用户放哪?答:save(author=request.user) 或在 create/update 里从 context 取。
  • ModelSerializer.update 默认怎么保存多对多?答:默认不处理,需在 update 里用 set() 同步。

04.7.17.1-014 嵌套序列化器默认为什么不可写?

一句话结论

DRF 的嵌套序列化器默认是「只读友好」的:序列化输出嵌套对象没有歧义,但写入时嵌套数据是新建关联、更新现有关联还是解绑,框架无法推断,因此嵌套字段默认不参与 validated_data 的级联保存,需要开发者在父序列化器的 create/update 里显式处理嵌套数据。可写嵌套要自己实现保存逻辑,或借助第三方嵌套序列化库。

概念解释

  • 不可写的根源是关联语义模糊:一对一、一对多、多对多各有不同的持久化策略。
  • 常见做法:嵌套字段只用于展示,写入用主键字段;确需级联写入再实现嵌套保存。

原理流程

  1. 嵌套字段反序列化得到嵌套 validated_data。
  2. 父级 create/update 收到的 validated_data 包含该嵌套字典或列表。
  3. 默认父级实现不识别嵌套结构,需要手动遍历、查询或新建关联并挂接。

代码或图示

class CommentSerializer(serializers.ModelSerializer):
    class Meta:
        model = Comment
        fields = ["content"]

class PostSerializer(serializers.ModelSerializer):
    comments = CommentSerializer(many=True)

    class Meta:
        model = Post
        fields = ["title", "comments"]

    def create(self, validated_data):
        comments = validated_data.pop("comments")
        post = Post.objects.create(**validated_data)
        Comment.objects.bulk_create([Comment(post=post, **c) for c in comments])
        return post

常见误区

  • 把嵌套字段写成 read_only=True 后又要求接口支持创建子记录,需求与配置矛盾;要么放开嵌套写入并实现保存,要么提供单独的子资源接口。
  • 批量嵌套写入不做事务包裹时,父对象成功、子对象失败会留下脏数据;级联保存应放在 transaction.atomic 内。

追问

  • 可写嵌套一般怎么实现?答:在父级 create/update 中 pop 出嵌套数据,按关联类型新建或更新子对象并挂接。
  • 第三方嵌套序列化库解决什么?答:自动生成嵌套 create/update,处理新建、更新、解绑策略,如 drf-writable-nested(待确认:版本与 DRF 兼容性需按当前项目验证)。

04.7.17.1-015 depth 参数解决什么问题,局限是什么?

一句话结论

Meta.depth = n 让 ModelSerializer 自动把 n 层以内的关系展开为嵌套对象表示,省去手写嵌套序列化器;depth=1 展开直接关联,depth=2 再展开下一层。局限:自动展开的嵌套字段默认只读;无法控制每层输出哪些字段;层级加深后响应体积与查询数膨胀;反向关系与多对多也会被展开,可能带出不需要的数据。

概念解释

  • depth 是表示层快捷方式,只影响序列化输出,不改变可写性。
  • 需要精细控制字段、嵌套写入或不同动作返回不同结构时,应手写嵌套序列化器。

原理流程

  1. ModelSerializer.get_fields() 检测 Meta.depth。
  2. 关系字段在深度范围内被构建为嵌套 ModelSerializer,递归到下一层递减深度。
  3. 超过深度的关系退回主键或不展开。

代码或图示

class CategorySerializer(serializers.ModelSerializer):
    class Meta:
        model = Category
        fields = ["id", "name", "children"]
        depth = 2

常见误区

  • depth 展开的嵌套对象只读,不能用于创建/更新;调大 depth 会静默放大响应体积,并带来深层关联的 N+1 风险。
  • 自动展开沿用子模型全部字段,敏感字段(如密码哈希)可能被带出;对输出字段有安全要求时不要依赖 depth。

追问

  • depth=0 或不写是什么行为?答:关系字段默认按主键表示,不展开嵌套对象。
  • depth 能解决嵌套写入吗?答:不能,只影响输出表示,写入仍需手动实现。

04.7.17.1-016 many=True 与 ListSerializer 是什么关系?

一句话结论

给字段或序列化器传 many=True 时,DRF 不会把原序列化器重复套 N 次,而是用它构造一个 ListSerializer 实例:外层负责遍历输入列表、逐项委派给子序列化器校验、聚合「索引 → 字段错误」,内层负责单项的反序列化与表示。批量创建、批量更新的钩子(create/update 的列表版本)都挂在 ListSerializer 层。

概念解释

  • ListSerializer 是集合级序列化器,many=True 是工厂入口。
  • 列表级校验(如数量上限、去重规则)应放在自定义 ListSerializer。

原理流程

  1. Serializer(many=True) 内部调 ListSerializer(child=...)。
  2. 反序列化:逐项 child.run_validation,错误按索引聚合。
  3. 序列化:逐项 child.to_representation 组装成列表返回。

代码或图示

class BulkTagSerializer(serializers.ListSerializer):
    def validate(self, data):
        if len(data) > 50:
            raise serializers.ValidationError("单次最多提交 50 条")
        return data

class TagSerializer(serializers.Serializer):
    name = serializers.CharField(max_length=32)

    class Meta:
        list_serializer_class = BulkTagSerializer

常见误区

  • 以为 many=True 下子序列化器的 validate 能看到其他条目;单项校验互不可见,跨条目规则必须在 ListSerializer.validate。
  • 批量保存默认实现是逐条 create,没有 bulk_create;大批量写入要在 ListSerializer.create 里自行批量入库。

追问

  • 如何为列表级校验指定类?答:在子序列化器 Meta.list_serializer_class 上声明。
  • 批量提交的错误如何定位到具体项?答:ListSerializer 把错误按列表索引挂在对应位置。

04.7.17.1-017 SerializerMethodField 适合做什么,有什么代价?

一句话结论

SerializerMethodField 是只读字段,值由序列化器上的 get_<字段名> 方法计算得到,适合输出派生值(拼接字段、格式化展示、权限判定结果)。代价:每个列表项都会调用一次方法,方法内访问关联对象极易造成 N+1;它不参与反序列化校验,也不能在方法里做数据库写入。

概念解释

  • 方法签名固定为 def get_<field>(self, obj),obj 是当前模型实例。
  • 派生展示逻辑集中在序列化器,表示层职责内。

原理流程

  1. 输出阶段字段 to_representation 回调绑定的方法。
  2. 方法读取 obj 属性并返回 JSON 原生值。
  3. 返回值再经字段类型包装进入响应字典。

代码或图示

class OrderSerializer(serializers.ModelSerializer):
    total_amount = serializers.SerializerMethodField()
    payable = serializers.SerializerMethodField()

    class Meta:
        model = Order
        fields = ["id", "total_amount", "payable"]

    def get_total_amount(self, obj):
        return sum(item.price for item in obj.items.all())

    def get_payable(self, obj):
        return obj.status == "pending"

常见误区

  • 方法里 obj.relation.all() 或跨关系取值没有预加载,列表接口直接 N+1;这类派生数据应在视图 queryset 上 prefetch_related,或用注解聚合。
  • SerializerMethodField 不能写 write_only 或参与输入校验;需要写入的派生字段应改成普通可写字段。

追问

  • 派生值能不能在方法里查库?答:技术上可以,但会制造 N+1,应预加载或用 SQL 注解。
  • 方法里怎么拿到当前请求?答:通过 self.context["request"],前提是视图用 get_serializer 装配了上下文。

04.7.17.1-018 HiddenField 与 CurrentUserDefault 如何注入隐式值?

一句话结论

HiddenField 是对前端不可见、不出现在输入 schema 里的可写字段,值由 default 或上下文注入;CurrentUserDefault 是一个默认值可调用对象,从 serializer.context["request"].user 取当前用户挂到字段上。两者配合实现「登录用户作为作者/归属人」这类不经过请求体的隐式赋值。

概念解释

  • 与 read_only 不同:HiddenField 可写但不可见,值进入 validated_data 供保存使用。
  • CurrentUserDefault 依赖上下文里有 request,脱离视图独立实例化序列化器时取不到。

原理流程

  1. 字段声明为 HiddenField(default=CurrentUserDefault())。
  2. 反序列化缺省时调用默认值可调用对象。
  3. 可调用对象读取 self.context["request"].user 返回当前用户。

代码或图示

from rest_framework import serializers
from rest_framework.request import Request

class ArticleSerializer(serializers.ModelSerializer):
    author = serializers.HiddenField(
        default=serializers.CurrentUserDefault()
    )

    class Meta:
        model = Article
        fields = ["title", "body", "author"]

常见误区

  • 漏传 context 时 CurrentUserDefault 取不到 request 会抛 KeyError;独立在测试或脚本里构造序列化器必须手动传 context={"request": ...}。
  • HiddenField 不是 read_only:它会写入模型,不要把服务端计算的只读值挂在这里。

追问

  • 除了当前用户还有哪些内置默认值类?答:CreateOnlyDefault、SkipField 等(待确认:具体名称以 DRF 3.1x rest_framework.fields 为准)。
  • 隐式值需要业务校验(如用户状态)放哪?答:在 validate 或视图 perform_create 里判断,不要依赖默认值对象。

04.7.17.1-019 序列化器的 context 从哪里来,如何取出 request?

一句话结论

视图通过 get_serializer() 实例化序列化器,get_serializer_context() 把 request、view、format 打包成字典传入 context;序列化器内用 self.context["request"] 取请求对象,进而取 request.user、request.auth、query_params。脱离视图手动构造序列化器时,context 是空字典,必须显式传入。

概念解释

  • context 是序列化器与请求层之间的通道,避免把请求对象作为字段传参。
  • 子序列化器通过父级 context 共享同一上下文。

原理流程

  1. GenericAPIView.get_serializer_context() 组装默认上下文字典。
  2. get_serializer() 调 serializer_class(*args, **kwargs, context=context)。
  3. 序列化器与嵌套子序列化器都持有该上下文引用。

代码或图示

class CommentSerializer(serializers.ModelSerializer):
    class Meta:
        model = Comment
        fields = ["content"]

    def validate_content(self, value):
        user = self.context["request"].user
        if not user.is_authenticated:
            raise serializers.ValidationError("登录后才能评论")
        return value

常见误区

  • 测试或脚本里 Serializer(data=payload) 不传 context,方法或默认值访问 self.context["request"] 直接 KeyError。
  • 在序列化器里把 request 对象放进 validated_data 再保存是错误分层;上下文只读使用,持久化只取需要的标量值。

追问

  • get_serializer_context 默认带哪些键?答:request、view、format,可在视图里重写补充业务键。
  • 嵌套子序列化器共享上下文吗?答:共享父级传入的同一字典引用。

04.7.17.1-020 实例化序列化器时 data、instance、partial 各起什么作用?

一句话结论

传 instance= 是序列化已有模型实例(输出表示),传 data= 是反序列化外部输入(校验与入库),两者同时传表示基于已有实例做部分更新;partial=True 临时关闭所有字段的必填检查,用于 PATCH。不传 instance 的 save() 走创建,传了 instance 走更新。

概念解释

  • 同一序列化器类承担「读模型 → 输出」与「输入 → 校验 → 写模型」双向职责。
  • partial 只影响必填校验,不改变字段类型与可空规则。

原理流程

  1. 构造函数记录 instance、data、partial、context。
  2. 输出:to_representation(instance);输入:run_validation(data)。
  3. save() 按 instance 是否存在分发 create/update。

代码或图示

# 创建
ser = ArticleSerializer(data=request.data)
# 全量更新(PUT)
ser = ArticleSerializer(instance=article, data=request.data)
# 部分更新(PATCH)
ser = ArticleSerializer(instance=article, data=request.data, partial=True)

常见误区

  • PATCH 接口忘了 partial=True,未提交的必填字段全部报错;反之 PUT 也加 partial=True 会掩盖缺失字段,破坏全量更新语义。
  • 只传 instance 再访问 validated_data 是空的;validated_data 只来自通过校验的 data。

追问

  • partial 能让只读字段变可写吗?答:不能,只读标记在 read_only,partial 只放宽必填。
  • 序列化器可以同时序列化多个实例吗?答:可以,传 many=True,instance 传可迭代对象。

04.7.17.1-021 source='*' 用在什么场景,有什么坑?

一句话结论

source="*" 表示该字段从整个父对象取值,常用于把一个嵌套序列化器挂到父对象整体上,子序列化器可以按自己的字段列表读取父对象属性;也用于把模型实例原样交给一个自定义字段处理。坑:source="*" 的字段反序列化时不能自动把嵌套数据拆回多个模型属性,跨表写入仍需手动处理;取值链路为 None 时容易触发属性异常。

概念解释

  • 普通 source 是属性路径,"*" 是「整对象」语义。
  • 典型用法:拆分超大序列化器为多个职责子序列化器,共享同一模型实例。

原理流程

  1. get_attribute 遇到 source="*" 直接返回当前实例。
  2. 子序列化器在该实例上按自己的 fields 取值。
  3. 反序列化结果按嵌套键进入父级 validated_data。

代码或图示

class ProfileInfoSerializer(serializers.ModelSerializer):
    class Meta:
        model = User
        fields = ["nickname", "avatar"]

class UserSerializer(serializers.ModelSerializer):
    profile = ProfileInfoSerializer(source="*")

    class Meta:
        model = User
        fields = ["id", "username", "profile"]

常见误区

  • 以为 source="*" 的嵌套字段可以级联更新父模型的多个字段;默认 update 只做标量 setattr,嵌套字典需要手动解包。
  • 子序列化器字段与父级 Meta.fields 重复声明时,输出与校验可能出现键冲突,需要核对字段归属。

追问

  • source="*" 输出的是什么结构?答:子序列化器 to_representation 产出的嵌套字典。
  • 什么时候用它比普通嵌套好?答:需要把一个模型按职责拆成多组字段、分组复用序列化器时。

04.7.17.1-022 如何在 Meta 中包含、排除或重命名字段?

一句话结论

ModelSerializer.Meta 用 fields 显式列出允许的字段(或 "__all__"),用 exclude 排除字段;字段重命名不靠 Meta,而是在序列化器体里声明同名模型属性的新字段并配 source。extra_kwargs 可以批量给自动生成的字段追加参数(只读、必填、校验器等),不必逐个手写字段类。

概念解释

  • fields 白名单是安全默认:未列出的模型字段不会进入 API。
  • exclude 与 fields 二选一,敏感字段优先走白名单。

原理流程

  1. get_fields() 先按模型生成自动字段。
  2. 按 fields/exclude 过滤;extra_kwargs 合并参数。
  3. 序列化器体中显式声明的字段覆盖同名单自动字段。

代码或图示

class StaffSerializer(serializers.ModelSerializer):
    login_name = serializers.CharField(source="username", read_only=True)

    class Meta:
        model = Staff
        fields = ["id", "login_name", "display_name", "role"]
        extra_kwargs = {
            "role": {"required": True},
            "display_name": {"allow_blank": True},
        }

常见误区

  • 用 fields = "__all__" 会把密码哈希、内部状态字段一并暴露;对外接口应始终白名单。
  • exclude 排除后又在体里显式声明同名字段,排除失效;字段归属以显式声明为准。

追问

  • extra_kwargs 能覆盖字段类型吗?答:主要追加参数,类型由模型映射决定;改类型需在体里手写字段。
  • 重命名后输入输出键是什么?答:JSON 键是声明的字段名,模型属性走 source。

04.7.17.1-023 如何自定义一个序列化字段类?

一句话结论

继承 serializers.Field(或更具体的子类如 CharField),实现 to_internal_value(data) 做输入校验与转换,实现 to_representation(value) 做输出转换;需要上下文时读 self.context。字段级参数通过构造函数 kwargs 传入,类级别校验错误抛 ValidationError 并带 code。

概念解释

  • 自定义字段是「类型转换 + 校验」单元,可在多个序列化器复用。
  • 复用现成子类(IntegerField、DateTimeField)比直接继承 Field 少写通用逻辑。

原理流程

  1. 反序列化:Field.run_validation 调 to_internal_value,失败抛 ValidationError。
  2. 序列化:字段调 to_representation 把内部值转为 JSON 原生类型。
  3. 字段实例随序列化器 context 共享请求上下文。

代码或图示

class UpperCharField(serializers.CharField):
    def to_internal_value(self, data):
        value = super().to_internal_value(data)
        return value.strip().upper()

    def to_representation(self, value):
        return super().to_representation(value)

常见误区

  • to_internal_value 忘记调 super() 会丢掉父类的空值、长度、编码校验;自定义转换应基于父类结果再加工。
  • 输出转换返回了不可 JSON 序列化的对象(如模型实例、自定义类型),响应渲染阶段才报错;to_representation 必须返回原生类型。

追问

  • 自定义字段怎么接收额外配置?答:在 __init__ 里接收 kwargs 并存为属性,或通过 extra_kwargs 传入。
  • 字段校验错误如何带错误码?答:raise ValidationError("...", code="invalid_format")。

04.7.17.1-024 validated_data 里保存的是什么类型的值?

一句话结论

validated_data 是字典:键为字段名或 source 路径,值为经过类型转换与校验后的 Python 原生/模型对象——字符串、整数、日期、Decimal、关联模型实例(关系字段)、嵌套字典或列表。它不是原始 JSON 输入,也不是待序列化的输出结构;create/update 直接用它构造或更新模型。

概念解释

  • 关系字段 PrimaryKeyRelatedField 校验通过后值是模型实例,不是主键。
  • 嵌套序列化器的值是嵌套 validated_data 字典/列表。

原理流程

  1. 各字段 to_internal_value 输出内部 Python 值。
  2. 汇总进 ret,经对象级 validate 清洗返回。
  3. save() 把字典拆给模型构造函数或 setattr。

代码或图示

ser = ArticleSerializer(data=request.data)
ser.is_valid(raise_exception=True)
# ser.validated_data["author"] 是 User 实例,不是 user_id
author = ser.validated_data["author"]

常见误区

  • 把 validated_data 当主键字典使用,访问 validated_data["author_id"] 取错键;关系字段值是实例,需要主键用 .pk。
  • validated_data 不含 read_only 字段与未传的可选字段;保存时模型默认值自行兜底。

追问

  • 嵌套字段在 validated_data 里是什么?答:子序列化器的 validated_data 字典或列表。
  • validated_data 会被修改吗?答:save() 的 extra_attrs 会合并进去,之后再访问可能与校验时不一致。

04.7.17.1-025 如何按请求场景动态选择序列化器类?

一句话结论

视图层重写 get_serializer_class(),按 self.action、请求方法、用户角色或查询参数返回不同序列化器类;也可在方法内根据 request 条件分支。序列化器类本身保持单一职责,动态选择由视图编排,不在序列化器里硬编码场景判断。

概念解释

  • 读与写分离:输出用精简只读序列化器,输入用带校验的写入序列化器。
  • 动态选择依赖 self.action(ViewSet)或 self.request.method(APIView)。

原理流程

  1. get_serializer() 先调 get_serializer_class() 取类。
  2. 视图方法内按动作/角色分支返回类。
  3. 用该类装配上下文并实例化。

代码或图示

class ArticleViewSet(viewsets.ModelViewSet):
    queryset = Article.objects.all()

    def get_serializer_class(self):
        if self.action in ("list", "retrieve"):
            return ArticleListSerializer
        if self.request.user.is_staff:
            return ArticleAdminSerializer
        return ArticleWriteSerializer

常见误区

  • 在序列化器 Meta 里写条件分支选字段,破坏复用性;场景差异应落到不同序列化器类。
  • 动态类没有重写 get_serializer_context 时上下文仍可用,但若新序列化器依赖额外业务键,需要在视图统一注入。

追问

  • 除了 action 还能按什么选?答:用户角色、请求头、查询参数、资源归属层级。
  • 动态序列化器需要单独配置权限吗?答:权限在视图层控制,序列化器不做授权判定。

04.7.17.1-026 APIView 相比 Django 原生 View 增加了什么?

一句话结论

APIView 保留类视图的 dispatch 骨架,但接入 DRF 全套编排:内容协商、认证、权限、限流、序列化器集成、异常统一处理、Request/Response 包装。它把 Django 原生 HttpRequest 包成 DRF Request(惰性解析 request.data),返回 Response 由渲染器决定最终格式。

概念解释

  • APIView 是 DRF 视图体系的根类,GenericAPIView 与所有 ViewSet 都间接继承它。
  • 原生 Django View 不做认证/权限/限流编排,需要中间件或手写。

原理流程

  1. as_view() 包装后请求进入 dispatch。
  2. dispatch 调 initial() 完成认证、权限、限流。
  3. 分发到 get/post 等方法,返回 Response,经渲染器输出。

代码或图示

from rest_framework.views import APIView
from rest_framework.response import Response

class HealthView(APIView):
    def get(self, request):
        return Response({"status": "ok"})

常见误区

  • 直接返回 Django HttpResponse 绕过了 DRF 渲染与异常处理;DRF 视图应返回 Response。
  • 以为 APIView 自带查询集与序列化器装配;那些能力在 GenericAPIView,APIView 只提供横切编排。

追问

  • request.data 和 request.POST 的区别?答:request.data 惰性解析,支持 JSON、表单、文件等多种解析器;request.POST 只处理表单编码。
  • APIView 支持异步视图吗?答:DRF 3.1x 可在 ASGI 下配合异步方法(待确认:异步支持范围以当前版本文档为准)。

04.7.17.1-027 GenericAPIView 提供哪些核心方法与属性?

一句话结论

GenericAPIView 在 APIView 之上提供数据编排约定:属性 queryset、serializer_class、lookup_field、lookup_url_kwarg、filter_backends、pagination_class;方法 get_queryset()、get_object()、get_serializer_class()、get_serializer()、get_serializer_context()、filter_queryset()、paginate_queryset()、get_paginated_response()。mixin 与 ViewSet 都围绕这些方法协作。

概念解释

  • 这些方法是扩展点:重写 get_queryset 做按用户过滤,重写 get_serializer_class 做动态序列化器。
  • GenericAPIView 本身不实现 list/create 等动作,动作由 mixin 混入。

原理流程

  1. mixin 动作先调 get_queryset() 拿基础查询集。
  2. filter_queryset() 走过滤后端;分页或取对象再加工。
  3. 需要校验时调 get_serializer() 装配上下文实例化序列化器。

代码或图示

class MyGenericView(generics.GenericAPIView):
    serializer_class = NoteSerializer

    def get_queryset(self):
        return Note.objects.filter(author=self.request.user)

常见误区

  • 同时设置 queryset 属性又重写 get_queryset:以重写方法为准,属性不会被使用;二选一保持清晰。
  • 重写 get_object 时忘记调用 filter_queryset,导致对象级绕过列表过滤规则。

追问

  • lookup_field 默认是什么?答:默认 pk,对应模型主键;可改成 slug 等唯一字段。
  • pagination_class 在哪一步生效?答:list 动作里 paginate_queryset 与 get_paginated_response。

04.7.17.1-028 get_serializer 如何装配上下文并实例化序列化器?

一句话结论

get_serializer(*args, **kwargs) 先取 get_serializer_class(),合并默认 context(request/view/format)与传入参数,再实例化序列化器;get_serializer_context() 是上下文扩展点。视图里所有序列化器装配都应走这个方法,保证上下文一致、便于测试替换。

概念解释

  • 直接在视图里 MySerializer(data=...) 会绕过上下文注入,CurrentUserDefault 等失效。
  • kwargs 可传入 instance、data、partial。

原理流程

  1. cls = self.get_serializer_class()。
  2. context = self.get_serializer_context(),并入 kwargs.setdefault("context", context)。
  3. return cls(*args, **kwargs)。

代码或图示

def post(self, request, *args, **kwargs):
    serializer = self.get_serializer(data=request.data)
    serializer.is_valid(raise_exception=True)
    self.perform_create(serializer)
    return Response(serializer.data)

常见误区

  • 重写 get_serializer_class 后忘记其他代码仍直接引用 self.serializer_class,动态选择被绕过。
  • 上下文里塞大型对象或数据库连接,随每个序列化器实例持有引用,增加请求内存。

追问

  • 想给所有序列化器补一个业务上下文键怎么做?答:重写 get_serializer_context(),在返回字典里加键值。
  • get_serializer 返回前会校验数据吗?答:不会,只负责实例化,校验由调用方 is_valid 完成。

04.7.17.1-029 filter_queryset 在过滤链路中处于什么位置?

一句话结论

filter_queryset(queryset) 依次遍历 filter_backends,每个后端对查询集做过滤(DjangoFilterBackend、SearchFilter、OrderingFilter 等),返回过滤后的查询集。它在 get_queryset() 之后、分页或 get_object() 之前调用;ListModelMixin.list 与 get_object 都会经过它,保证列表与单对象访问遵守同一过滤规则。

概念解释

  • 过滤后端是可插拔策略类,视图可覆盖 filter_backends,也可在全局设置默认列表。
  • 自定义过滤逻辑可写后端类,或直接在 get_queryset 里加条件。

原理流程

  1. get_queryset() 返回基础查询集。
  2. filter_queryset 逐个调用后端的 filter_queryset(request, queryset, view)。
  3. 结果交给分页或 get_object 取单条。

代码或图示

from rest_framework.filters import SearchFilter, OrderingFilter

class ArticleViewSet(viewsets.ReadOnlyModelViewSet):
    queryset = Article.objects.all()
    serializer_class = ArticleSerializer
    filter_backends = [SearchFilter, OrderingFilter]
    search_fields = ["title", "body"]
    ordering_fields = ["created_at", "views"]

常见误区

  • 在 get_object 里直接用 self.queryset 而不是过滤后的查询集,造成越权访问未过滤对象;应走 filter_queryset(self.get_queryset())。
  • 过滤条件叠加数据库全表扫描字段又缺索引,列表接口随数据量变慢;过滤/排名字段要核对索引。

追问

  • 全局默认过滤后端在哪配置?答:settings.py 的 DEFAULT_FILTER_BACKENDS。
  • 自定义过滤后端要实现什么?答:实现 filter_queryset(self, request, queryset, view) 方法。

04.7.17.1-030 perform_create/perform_update/perform_destroy 钩子干什么用?

一句话结论

这三个钩子是 mixin 动作里留给业务编排的扩展点:perform_create(serializer) 内部调 serializer.save(),perform_update、perform_destroy 同理;在钩子中可以补充当前用户关联、发信号、写审计日志、做前置业务校验。mixin 把「取序列化器 → 校验 → 保存 → 返回响应」的骨架固定,业务差异落在这些钩子上。

概念解释

  • 钩子在 is_valid 之后、实际持久化时执行,能拿到已校验的序列化器。
  • 与序列化器内 create/update 的分工:通用模型保存放序列化器,请求级编排放钩子。

原理流程

  1. CreateModelMixin 构造序列化器并 is_valid(raise_exception=True)。
  2. 调 perform_create(serializer),默认实现 serializer.save()。
  3. 返回 Response(serializer.data);更新、删除动作同构。

代码或图示

class ArticleViewSet(viewsets.ModelViewSet):
    serializer_class = ArticleSerializer
    queryset = Article.objects.all()

    def perform_create(self, serializer):
        serializer.save(author=self.request.user)

    def perform_destroy(self, instance):
        instance.soft_delete()  # 业务删除:标记而非物理删除

常见误区

  • 在 perform_create 里重复调用 serializer.save() 导致保存两次;默认钩子就是保存一次,覆盖时要么自己保存要么调 super()。
  • 把权限判断塞进钩子绕过了权限体系;授权仍应在权限类/查询集过滤层完成。

追问

  • 删除接口想做软删除改哪里?答:重写 perform_destroy,调用模型的软删除方法而非 delete()。
  • 钩子能拿到响应前的实例吗?答:serializer.instance 即保存后的实例,可用于日志或二次处理。

04.7.17.1-031 get_object 的查找流程与 404 时机?

一句话结论

get_object() 先取 filter_queryset(self.get_queryset()),按 lookup_field 与 URL 中的 lookup_url_kwarg 过滤,用 get() 取单条;找不到抛 Http404 或 ObjectDoesNotExist,被 DRF 异常处理转成 404 响应。对象取出后还会执行对象级权限 check_object_permissions(request, obj),因此列表过滤与对象权限在这一步共同兜底。

概念解释

  • get_object 是 retrieve/update/destroy 三个动作共享的对象获取入口。
  • 覆盖 get_object 可以实现自定义查找(如按 slug、按复合条件),但要保留过滤与权限检查。

原理流程

  1. 取过滤后的查询集。
  2. 解析 URL 关键字参数,拼成查找条件。
  3. get() 取对象;失败抛 404;成功后校验对象级权限并返回。

代码或图示

class ArticleViewSet(viewsets.ModelViewSet):
    queryset = Article.objects.all()
    serializer_class = ArticleSerializer
    lookup_field = "slug"

    def get_object(self):
        obj = super().get_object()
        self.check_object_permissions(self.request, obj)
        return obj

常见误区

  • 重写 get_object 直接 Model.objects.get(pk=...),绕过 filter_queryset 造成水平越权;必须在过滤后的查询集上查找。
  • 对象级权限只在 get_object 中触发,手写 APIView 直接取库对象时不会自动检查,需要显式调用 check_object_permissions。

追问

  • 404 与 403 哪个先判?答:先查到对象(404 兜底不存在),再做对象级权限(403 兜底无权限)。
  • lookup_url_kwarg 什么时候需要?答:URL 中的参数名与 lookup_field 不一致时显式指定。

04.7.17.1-032 五个 CRUD mixin 各自封装了什么动作?

一句话结论

DRF 提供五个 mixin:ListModelMixin(list,返回分页或全量序列化列表)、CreateModelMixin(create,校验后 perform_create)、RetrieveModelMixin(retrieve,取单对象序列化)、UpdateModelMixin(update,含 PUT 全量与 PATCH 部分更新,perform_update)、DestroyModelMixin(destroy,perform_destroy 删除)。每个 mixin 只暴露一个动作方法,与 GenericAPIView 组合即可按需拼装能力。

概念解释

  • mixin 是动作骨架,查询集/序列化器/钩子都来自 GenericAPIView。
  • 可以只混入需要的 mixin,得到裁剪版 ViewSet,避免暴露多余动作。

原理流程

  1. mixin 方法调 get_queryset/filter_queryset 取数据。
  2. 调 get_serializer 装配序列化器并校验。
  3. 调 perform_* 钩子持久化,返回 Response。

代码或图示

from rest_framework import mixins, generics

class CommentViewSet(
    mixins.ListModelMixin,
    mixins.CreateModelMixin,
    generics.GenericAPIView,
):
    queryset = Comment.objects.all()
    serializer_class = CommentSerializer

常见误区

  • 把 mixin 当作独立视图类使用;它必须配合 GenericAPIView 才能拿到 get_queryset 等方法,单独继承会报属性缺失。
  • 混入 UpdateModelMixin 就同时有 PUT 与 PATCH 路由;想只支持 PATCH 需自定义动作或在序列化器/钩子层限制。

追问

  • 想只要列表与详情怎么组合?答:ListModelMixin + RetrieveModelMixin + GenericAPIView。
  • mixin 里的响应状态码是多少?答:create 返回 201,update/destroy 返回 200/204(destroy 默认 204)。

04.7.17.1-033 ViewSet 与 GenericAPIView 的本质差别是什么?

一句话结论

GenericAPIView 把 HTTP 方法绑定到视图方法(get/post),路由直接映射;ViewSet 继承 ViewSetMixin,把动作方法(list/create/retrieve/update/destroy)与 HTTP 方法解耦,通过 as_view({'get': 'list'}) 或 Router 在请求分发时再做「动作 → 方法」映射。GenericViewSet = ViewSetMixin + GenericAPIView,于是既能用动作方法,又有查询集/序列化器编排。

概念解释

  • ViewSetMixin 重写了 as_view,接收动作映射表,请求时按 HTTP 方法查表调用对应动作。
  • 动作方法名成为 Router 生成 URL 与反解的依据。

原理流程

  1. ViewSetMixin.as_view(actions) 保存 {http_method: action_name} 映射。
  2. dispatch 时按请求 HTTP 方法查到动作名。
  3. 把动作名挂到 self.action,调用实例上的同名方法。

代码或图示

# 手动绑定:GET → list,POST → create
path("articles/", ArticleViewSet.as_view({"get": "list", "post": "create"}))
# Router 自动生成同样的映射

常见误区

  • 以为 ViewSet 自带查询集与序列化器;纯 ViewSet 没有,需要 GenericViewSet 或自行实现。
  • 在 ViewSet 里写 def get(self, request) 与动作体系混用,Router 不会识别该方法。

追问

  • ViewSet 继承链上最核心的混入是什么?答:ViewSetMixin,负责动作映射与 self.action。
  • 动作方法与 HTTP 方法是什么关系?答:多对多映射由 Router 或 as_view 表决定,动作方法本身不绑定 HTTP 动词。

04.7.17.1-034 ModelViewSet 的完整继承链是怎样的?

一句话结论

ModelViewSet 依次继承:GenericViewSet(ViewSetMixin + GenericAPIView)→ 五个 CRUD mixin(ListModelMixin、CreateModelMixin、RetrieveModelMixin、UpdateModelMixin、DestroyModelMixin)。MRO 中 mixin 提供动作方法,GenericAPIView 提供查询集/序列化器/分页/过滤基础设施,ViewSetMixin 提供动作路由与 self.action。因此一个 ModelViewSet 同时具备标准七个路由动作:list、create、retrieve、update、partial_update、destroy。

概念解释

  • 继承链拆解是面试高频题,能说清每层职责才算理解 DRF 编排。
  • mixin 之间无状态耦合,方法名与 GenericAPIView 的扩展点对接。

原理流程

  1. 请求进入 ViewSetMixin.as_view 包装的视图。
  2. dispatch 经 APIView.initial 完成认证/权限/限流。
  3. 按动作名调用 mixin 方法,mixin 再用 GenericAPIView 方法取数据与序列化器。

代码或图示

ModelViewSet
├── GenericViewSet
│   ├── ViewSetMixin          # 动作映射、self.action
│   └── GenericAPIView        # queryset/serializer/filter/pagination
├── ListModelMixin            # list
├── CreateModelMixin          # create
├── RetrieveModelMixin        # retrieve
├── UpdateModelMixin          # update / partial_update
└── DestroyModelMixin         # destroy

常见误区

  • 把 ModelViewSet 当成一个黑盒类去改行为;实际上要按层定位:响应格式改 mixin/序列化器,数据范围改 get_queryset,路由改 Router。
  • 继承 ModelViewSet 即暴露全部写动作,公开只读场景应改用 ReadOnlyModelViewSet 或裁剪 mixin。

追问

  • partial_update 来自哪个 mixin?答:UpdateModelMixin,内部以 partial=True 实例化序列化器。
  • 想关掉删除动作怎么做?答:覆盖 destroy 抛 MethodNotAllowed,或不混入 DestroyModelMixin。

04.7.17.1-035 ReadOnlyModelViewSet 暴露了哪些动作?

一句话结论

ReadOnlyModelViewSet = GenericViewSet + ListModelMixin + RetrieveModelMixin,只暴露 list 与 retrieve 两个只读动作,没有创建、更新、删除路由。适合对外提供只读资源、后台数据浏览接口;需要部分写能力时再混入对应写 mixin。

概念解释

  • 只读不是权限层面的只读,而是路由与动作层面不存在写方法。
  • 与 IsAuthenticatedOrReadOnly 这类权限只读配合使用,二者层级不同。

原理流程

  1. 类定义只继承列表与详情两个 mixin。
  2. Router 生成集合路由与单项路由,不生成 POST/PUT/PATCH/DELETE。
  3. 写方法请求到达时无对应动作映射,返回 405。

代码或图示

class PublicArticleViewSet(viewsets.ReadOnlyModelViewSet):
    queryset = Article.objects.filter(published=True)
    serializer_class = ArticleSerializer

常见误区

  • 以为只读 ViewSet 还能通过自定义 @action 写库;自定义动作不受只读约束,需要单独做权限控制。
  • 权限类仍需显式配置:只读 ViewSet 不代表匿名可访问,DEFAULT_PERMISSION_CLASSES 仍会生效。

追问

  • 只读接口也要配序列化器吗?答:要,输出表示仍由序列化器控制字段与嵌套。
  • 只读场景下 N+1 怎么排查?答:在 get_queryset 上 select_related/prefetch_related,只读接口通常并发读多,优化收益明显。

04.7.17.1-036 self.action 是如何被设置和使用的?

一句话结论

self.action 是 ViewSetMixin 在分发时根据 HTTP 方法查到的动作名(list/create/retrieve/update/partial_update/destroy,或自定义 @action 的方法名)。视图与序列化器可据此分支:选序列化器类、切权限、改查询集、决定是否分页。它只在 ViewSet 内可用,APIView 没有该属性。

概念解释

  • action 是动作路由的运行时记录,替代在方法内判断 request.method。
  • 自定义 @action 的 url_name 与动作名是两个概念,self.action 取方法名。

原理流程

  1. as_view(actions) 保存 HTTP 方法到动作名的映射。
  2. dispatch 查表得到动作名,赋给 self.action。
  3. 后续 get_serializer_class、get_permissions 等读取 self.action 分支。

代码或图示

def get_permissions(self):
    if self.action in ("list", "retrieve"):
        return [AllowAny()]
    return [IsAuthenticated()]

常见误区

  • 在 APIView 里读 self.action 会报属性不存在;APIView 用 self.request.method 判断。
  • 同一个动作名映射多个 HTTP 方法时,self.action 只是动作名,区分 PUT/PATCH 还要看 request.method。

追问

  • 自定义动作的 self.action 是什么?答:装饰的方法名本身,例如 @action(detail=True) def publish,self.action == "publish"。
  • action 在序列化器里能拿到吗?答:不能直接拿,需通过 self.context["view"].action 间接读取。

04.7.17.1-037 如何按 action 返回不同的序列化器?

一句话结论

重写 get_serializer_class(),用 self.action 分支:list/retrieve 用只读精简序列化器,create/update 用写入校验序列化器,管理员动作再换管理序列化器。也可在 get_serializer 层补充上下文。保持每个序列化器职责单一,动态选择集中在视图层。

概念解释

  • 读写分离序列化器可以避免「输出字段被校验规则约束」的耦合。
  • 不同动作的字段差异大时,拆类比在一个序列化器里堆条件更易维护。

原理流程

  1. get_serializer() 调 get_serializer_class()。
  2. 方法读 self.action 返回对应类。
  3. 实例化并注入上下文。

代码或图示

class ProductViewSet(viewsets.ModelViewSet):
    queryset = Product.objects.all()

    def get_serializer_class(self):
        if self.action == "list":
            return ProductListSerializer
        if self.action == "retrieve":
            return ProductDetailSerializer
        return ProductWriteSerializer

常见误区

  • 不同序列化器的字段命名不一致,导致同一资源在 list 与 retrieve 间契约漂移;跨动作共享的字段名要对齐。
  • 动态类忘记在 schema 文档中标注,OpenAPI 只识别默认 serializer_class;需要 @extend_schema 补充(drf-spectacular 场景)。

追问

  • 除了 action 还能按用户角色选吗?答:可以,self.request.user 与 action 组合判断。
  • 动态序列化器的上下文怎么补?答:重写 get_serializer_context() 统一注入。

04.7.17.1-038 @action 装饰器的 detail/methods/url_path/url_name 参数?

一句话结论

@action 把 ViewSet 方法注册为额外路由动作:detail=True 表示挂在单项资源下(URL 带 lookup 键),detail=False 挂在集合下;methods 指定允许的 HTTP 方法列表(默认 ["GET"]);url_path 覆盖 URL 路径片段,url_name 提供路由反解名。装饰器还可传 serializer_class、permission_classes、filter_backends 等直接挂在动作上。

概念解释

  • 标准七个动作覆盖常规 CRUD,业务动作(如 publish、vote、export)用 @action 扩展。
  • detail 决定 URL 形态:集合级无主键,单项级带主键。

原理流程

  1. 装饰器给方法打 mapping、url_path、url_name 等标记。
  2. Router 扫描带标记的方法,生成额外路由条目。
  3. 请求命中后按 methods 校验 HTTP 动词,调用方法并设置 self.action。

代码或图示

from rest_framework.decorators import action
from rest_framework.response import Response

class ArticleViewSet(viewsets.ModelViewSet):
    queryset = Article.objects.all()
    serializer_class = ArticleSerializer

    @action(detail=True, methods=["POST"], url_name="publish")
    def publish(self, request, pk=None):
        obj = self.get_object()
        obj.publish()
        return Response({"status": "published"})

    @action(detail=False, methods=["GET"])
    def drafts(self, request):
        return Response(self.get_queryset().filter(status="draft").count())

常见误区

  • detail=True 的动作方法签名必须接收 lookup 键(pk=None 或对应 lookup_field);漏参数导致路由分发报错。
  • 写操作动作忘了把对应 HTTP 方法加进 methods,请求返回 405;@action 默认只允许 GET。

追问

  • url_path 与方法名默认关系?答:默认 URL 片段是方法名,url_path 可改成带连字符的自定义片段。
  • 动作级权限怎么配?答:装饰器参数 permission_classes=[...],或在 get_permissions 里按 self.action 分支。

04.7.17.1-039 SimpleRouter 与 DefaultRouter 生成的路由有何差异?

一句话结论

SimpleRouter 为每个 ViewSet 生成集合路由、单项路由及标准动作映射;DefaultRouter 继承 SimpleRouter,额外生成一个 API 根视图(列出所有注册路由的入口页),并可选在路由末尾附加格式后缀。两者生成的资源路由规则一致,差别只在根视图与附加行为。生产环境通常用 SimpleRouter 或关闭 DefaultRouter 的浏览器浏览入口。

概念解释

  • Router 负责「ViewSet 动作方法 → URL 模式 + 视图绑定表」。
  • DefaultRouter 的根视图配合 BrowsableAPIRenderer 展示可点击导航,生产环境需注意暴露风险。

原理流程

  1. register(prefix, viewset, basename) 记录路由条目。
  2. Router 为集合生成 prefix/,为单项生成 prefix/lookup/。
  3. 绑定表把 GET/POST/PUT/PATCH/DELETE 映射到对应动作方法。

代码或图示

from rest_framework.routers import SimpleRouter, DefaultRouter

router = SimpleRouter()
router.register("articles", ArticleViewSet, basename="article")
# urlpatterns += router.urls

常见误区

  • 以为 Router 会自动把路由挂进 urlpatterns;必须显式 urlpatterns += router.urls 或 include(router.urls)。
  • DefaultRouter 根视图在生产环境暴露全部接口结构,结合 BrowsableAPIRenderer 可能成为信息泄露面,应在生产配置关闭浏览渲染器。

追问

  • 路由格式后缀怎么配?答:Router 的 trailing_slash 与 format 后缀设置,SimpleRouter 可在初始化时传参(待确认:参数名以 DRF 3.1x 源码为准)。
  • 一个前缀能注册两个 ViewSet 吗?答:建议一个前缀对应一个 ViewSet,避免路由冲突。

04.7.17.1-040 basename 什么时候必须显式指定?

一句话结论

basename 是路由反解名的前缀(如 article-detail)。当 ViewSet 没有设置 queryset 属性、或 get_queryset 被重写而无法从模型推导时,Router 无法自动确定 basename,必须在 register(..., basename="article") 显式指定;有 queryset 时默认取模型名小写复数。basename 也是 reverse 反解 URL 的命名空间前缀。

概念解释

  • basename 只影响 URL 名称,不影响路径;同一 Router 内保持唯一。
  • 无 queryset 的纯逻辑 ViewSet 必须给 basename,否则注册时报错。

原理流程

  1. Router 优先用显式 basename。
  2. 未指定时尝试从 viewset.queryset.model 推导。
  3. 推导失败抛配置异常,提示补 basename。

代码或图示

router.register("stats", StatsViewSet, basename="stats")
# 反解:reverse("stats-detail", kwargs={"pk": 1})

常见误区

  • 多个 ViewSet 指向同一模型却省略 basename,自动推导重名导致路由互相覆盖;统一显式命名更稳妥。
  • 改了 basename 后忘记同步更新模板/代码里的 reverse 名称,反解抛 NoReverseMatch。

追问

  • basename 与 Django URL namespace 是什么关系?答:basename 生成 basename-list/basename-detail 这类路由名,再经 include 挂到 namespace 下。
  • 不反解 URL 还需要 basename 吗?答:无 queryset 时仍必须指定,否则 Router 注册阶段就无法推导。

04.7.17.1-041 如何在序列化器或视图里反解 ViewSet 路由 URL?

一句话结论

用 Django 的 reverse(视图内可用 self.reverse_action 或 reverse)按路由名反解:列表名 <basename>-list,详情名 <basename>-detail,自定义动作名是 <basename>-<url_name>。rest_framework.reverse 提供的 reverse 支持请求相对路径与超链接字段(HyperlinkedRelatedField)。URL 反解依赖请求上下文,脱离请求的脚本环境要传 request 或完整域名。

概念解释

  • 超链接序列化器通过反解把对象主键转成 API URL,对外 API 遵循 HATEOAS 风格。
  • 路由名由 basename + 动作后缀组成,改名后要同步反解代码。

原理流程

  1. Router 注册时为每个动作生成带名称的 URL pattern。
  2. reverse(name, kwargs=...) 按名称与参数匹配 pattern。
  3. 序列化器 context["request"] 参与构造绝对/相对 URL。

代码或图示

from rest_framework.reverse import reverse

url = reverse("article-detail", kwargs={"pk": obj.pk}, request=self.context["request"])

常见误区

  • 在序列化器 to_representation 里反解却没传 request 上下文,生成的 URL 缺域名或抛异常;确保视图经 get_serializer 装配上下文。
  • 自定义动作不写 url_name 时反解名取方法名,装饰器参数与 reverse 名称不一致会 NoReverseMatch。

追问

  • HyperlinkedIdentityField 怎么工作?答:按视图名与 lookup 字段在序列化输出中反解对象 URL,无需手写 reverse。
  • 反解生成绝对路径还是相对路径?答:传入 request 时可生成绝对 URL,否则为相对路径。

04.7.17.1-042 不使用 Router 时如何用 as_view 手动绑定动作?

一句话结论

把 ViewSet 当类视图使用时,as_view() 接收一个字典参数,把 HTTP 方法映射到动作方法名:{"get": "list", "post": "create"},单项路由再映射 {"get": "retrieve", "put": "update", "patch": "partial_update", "delete": "destroy"}。手动绑定适合精细控制 URL 形态、兼容旧路由或不引入 Router 的场景。

概念解释

  • ViewSetMixin.as_view(actions) 的 actions 表就是 Router 自动生成的那层映射。
  • 未在表中的 HTTP 方法访问该路径会得到 405。

原理流程

  1. 调用 ViewSet.as_view({"get": "list"}) 得到可调用视图函数。
  2. URLconf 把路径指向该函数。
  3. dispatch 按 HTTP 方法查表调用动作方法。

代码或图示

urlpatterns = [
    path("articles/", ArticleViewSet.as_view({"get": "list", "post": "create"})),
    path("articles/<int:pk>/", ArticleViewSet.as_view({
        "get": "retrieve",
        "put": "update",
        "patch": "partial_update",
        "delete": "destroy",
    })),
]

常见误区

  • 手动绑定漏掉 PATCH 映射,部分更新请求 405;标准动作集合要对照 Router 生成结果检查。
  • 同一 ViewSet 在多条路由绑定不同动作,self.action 以当前请求映射为准,不要假设固定动作名。

追问

  • 手动绑定时还能配 @action 额外路由吗?答:可以,但额外路由也要在 URLconf 里显式映射动作方法。
  • as_view 能传权限等类参数吗?答:可在 as_view(permission_classes=[...]) 覆盖,类属性同样生效。

04.7.17.1-043 视图级如何覆盖 serializer_class、queryset、permission_classes?

一句话结论

这些都是视图类属性,可在类上直接赋值,也可在方法内覆盖:get_serializer_class() 动态返回类,get_queryset() 返回过滤后的查询集,get_permissions() 返回权限实例列表。类属性是默认值,方法重写是动态分支;视图级覆盖优先级高于全局 settings.py 默认配置。

概念解释

  • 全局默认(DEFAULT_PERMISSION_CLASSES 等)兜底,视图级属性/方法覆盖具体接口。
  • get_permissions 返回实例列表,而不是类列表。

原理流程

  1. 视图初始化读取类属性作为默认。
  2. 需要动态分支时重写对应 getter 方法。
  3. mixin/动作方法通过 getter 取值,保证覆盖生效。

代码或图示

class ArticleViewSet(viewsets.ModelViewSet):
    queryset = Article.objects.all()
    serializer_class = ArticleSerializer
    permission_classes = [IsAuthenticated]

    def get_permissions(self):
        if self.action == "list":
            return [AllowAny()]
        return super().get_permissions()

常见误区

  • 在 get_queryset 里直接返回全新查询集却没复用 super(),丢掉基类已有的过滤条件;增量过滤应基于 super().get_queryset()。
  • 覆盖 serializer_class 为类后,动态场景又读 self.serializer_class 绕过 getter;统一走 get_serializer_class。

追问

  • 权限类在全局与视图级同时配置时谁优先?答:视图级覆盖全局默认。
  • queryset 属性与 get_queryset 方法哪个生效?答:重写了方法就以方法为准,属性仅作声明用途。

04.7.17.1-044 lookup_field 与 lookup_url_kwarg 如何定制查询键?

一句话结论

lookup_field 是模型上用于查找单对象的字段(默认 pk),可以改成 slug、uuid 等唯一字段;lookup_url_kwarg 是 URLconf 中对应参数名,默认与 lookup_field 同名。当 URL 参数名与模型字段名不同(如 URL 用 article_slug,模型字段是 slug)时,用 lookup_url_kwarg 建立映射。

概念解释

  • 两个参数配合决定「URL 参数 → 查询条件」的映射。
  • 查找字段必须在数据库有唯一约束,否则 get() 可能抛 MultipleObjectsReturned。

原理流程

  1. get_object 读取 lookup_field 与 lookup_url_kwarg。
  2. 从 self.kwargs 按 lookup_url_kwarg 取值。
  3. 构造 {lookup_field: 值} 条件在过滤查询集上 get()。

代码或图示

class ArticleViewSet(viewsets.ReadOnlyModelViewSet):
    queryset = Article.objects.all()
    serializer_class = ArticleSerializer
    lookup_field = "slug"
    lookup_url_kwarg = "article_slug"

常见误区

  • URL path 参数名与 lookup_url_kwarg 不一致,get_object 取不到值抛 KeyError;两者必须对齐。
  • 用非唯一字段做 lookup_field,多条记录命中时返回 500;查找键应选主键、唯一索引字段。

追问

  • 复合条件查找怎么做?答:重写 get_object,在过滤查询集上按多个条件 get()。
  • 不重写 URLconf 能改查找键吗?答:Router 默认按 pk 生成路径;改 slug 后需配合路由参数名调整。

04.7.17.1-045 分页逻辑在 ListModelMixin 的哪一步执行?

一句话结论

ListModelMixin.list 的流程:get_queryset → filter_queryset 过滤 → paginate_queryset(queryset) 取当前页 → get_serializer 序列化当前页数据 → 若启用分页则 get_paginated_response(serializer.data) 包装分页结构,否则直接返回 Response(serializer.data)。分页是 list 动作内部环节,retrieve/create 等动作不经过分页。

概念解释

  • 分页器类由 pagination_class 提供,全局默认在 DEFAULT_PAGINATION_CLASS 配置。
  • 关闭分页(pagination_class = None)时返回完整列表,大数据量下有内存与响应体积风险。

原理流程

  1. 查询集过滤完成后交给分页器切片。
  2. 序列化只处理当前页对象,避免全量实例化。
  3. 分页响应携带计数、下一页/上一页链接等元数据。

代码或图示

class ArticleViewSet(viewsets.ModelViewSet):
    queryset = Article.objects.all()
    serializer_class = ArticleSerializer
    pagination_class = ArticlePagination

常见误区

  • 在序列化器里对全量 QuerySet 做聚合统计,绕过分页导致 N+1 或全表扫描;统计应走独立注解查询或计数接口。
  • 自定义分页器只实现切片没实现响应包装,get_paginated_response 输出结构缺失;两个方法都要实现。

追问

  • 分页器在哪一步拿到请求参数?答:paginate_queryset 解析 request.query_params 中的页码/偏移量。
  • 不分页的导出接口怎么处理?答:视图级 pagination_class = None,并控制导出量级与流式响应。

04.7.17.1-046 Response 对象与渲染器是如何协作的?

一句话结论

视图返回的 Response 只持有原始数据、状态码与响应头,不决定输出格式;APIView.finalize_response 根据内容协商选出渲染器(renderer_classes),由渲染器把数据转成 JSON、HTML 浏览页或其他格式,并设置 Content-Type。渲染器是可插拔的,全局默认在 DEFAULT_RENDERER_CLASSES 配置,视图级可覆盖。

概念解释

  • Response 类似 Django HttpResponse 的数据载体,渲染延迟到响应阶段。
  • 同一数据经不同渲染器产出不同表示,浏览器访问走 BrowsableAPI,接口调用走 JSON。

原理流程

  1. 视图方法返回 Response(data, status=...)。
  2. finalize_response 做内容协商确定渲染器。
  3. 渲染器 .render(data, media_type, context) 产出响应体与头信息。

代码或图示

from rest_framework.response import Response
from rest_framework.renderers import JSONRenderer

class ArticleView(APIView):
    renderer_classes = [JSONRenderer]

    def get(self, request):
        return Response({"ok": True}, status=200)

常见误区

  • 在视图里手动 json.dumps 再包 HttpResponse,绕过渲染器与内容协商,丢失统一错误结构与编码处理。
  • 生产环境保留 BrowsableAPIRenderer,浏览器直接访问即可看到接口结构与表单,增加信息暴露面;生产只保留 JSON 渲染器。

追问

  • 渲染器选择依据什么?答:请求 Accept 头与内容协商结果,结合视图/全局渲染器列表。
  • 自定义渲染器要实现什么?答:实现 render(self, data, accepted_media_type=None, renderer_context=None)。

04.7.17.1-047 DRF 视图里的 request.user 和 request.auth 从哪来?

一句话结论

DRF Request 包装 Django HttpRequest,在认证阶段由认证类的 authenticate 返回 (user, auth),挂到 request.user 与 request.auth;认证类列表全部返回 None 时,request.user 为 AnonymousUser,request.auth 为 None。后续权限、序列化器上下文都基于这两个值判定。

概念解释

  • request.user 是 Django 用户模型实例或匿名用户;request.auth 是认证凭证对象(Token 实例、JWT 载荷等)。
  • 认证结果在 initial() 阶段确定,动作方法内可直接读取。

原理流程

  1. perform_authentication 遍历认证类列表。
  2. 首个返回 (user, auth) 的认证类写入请求;全部未认证则置匿名。
  3. 权限类与限流类读取 request.user 做判定。

代码或图示

class ArticleViewSet(viewsets.ModelViewSet):
    def perform_create(self, serializer):
        serializer.save(author=self.request.user)

常见误区

  • 把 request.auth 当用户对象使用;它是凭证而非用户,用户信息在 request.user。
  • 自定义认证类返回 (user, None) 后,下游依赖 request.auth 的逻辑拿到空值;返回值语义要与下游约定一致。

追问

  • 匿名请求的 request.user 是什么类型?答:django.contrib.auth.models.AnonymousUser 实例。
  • 认证失败会怎样?答:认证类抛 AuthenticationFailed,由异常处理转 401;返回 None 表示「未识别」,继续尝试下一个认证类。

04.7.17.1-048 同一个 ViewSet 读写不同序列化器怎么实现?

一句话结论

在 get_serializer_class() 里按 self.action 或 request.method 分支:写动作(create/update/partial_update)返回带完整校验的写入序列化器,读动作(list/retrieve)返回精简只读序列化器。也可以为输入与输出分别配置字段,通过两个序列化器类隔离校验规则与表示结构。

概念解释

  • 读写分离避免「输出字段必须满足写入校验」的耦合,也便于按角色裁剪响应。
  • 两个序列化器共享模型与字段命名契约,避免响应结构漂移。

原理流程

  1. 动作方法调 get_serializer()。
  2. get_serializer_class 按动作/方法返回类。
  3. 写入路径走校验与保存,读取路径走表示输出。

代码或图示

class OrderViewSet(viewsets.ModelViewSet):
    queryset = Order.objects.all()

    def get_serializer_class(self):
        if self.request.method in ("POST", "PUT", "PATCH"):
            return OrderWriteSerializer
        return OrderReadSerializer

常见误区

  • 写入序列化器继承读取序列化器后追加可写字段,父类只读标记可能沿继承链干扰;组合优于继承时拆成两个独立类。
  • 读写字段名不一致导致前端同一表单提交后回显结构变化;跨序列化器的共享字段要保持同名同类型。

追问

  • 按角色读写不同怎么扩展?答:在分支条件中叠加 self.request.user 角色判断。
  • 读写分离后 schema 怎么标注?答:用 @extend_schema(request=..., response=...) 分别声明请求与响应序列化器。

04.7.17.1-049 initial() 钩子在视图生命周期中做了什么?

一句话结论

APIView.initial(request, *args, **kwargs) 在动作方法执行前完成横切编排:内容协商、解析器确定、perform_authentication 认证、check_permissions 权限、check_throttles 限流、版本解析。任何一步失败都抛对应异常并短路,不会进入业务动作。它是认证/权限/限流顺序的实际执行点。

概念解释

  • initial 是所有 DRF 视图共享的前置钩子,重写时必须调 super() 保留默认编排。
  • 业务前置校验(如资源状态检查)可放在动作方法内,不混入 initial。

原理流程

  1. 确定版本、内容协商与解析器。
  2. 执行认证装配 request.user/request.auth。
  3. 检查权限与限流,全部通过后才分发到动作方法。

代码或图示

class BaseView(APIView):
    def initial(self, request, *args, **kwargs):
        super().initial(request, *args, **kwargs)
        # 自定义前置逻辑:请求日志、链路 ID 等

常见误区

  • 在 initial 里做业务数据校验并直接返回响应,绕过异常体系;前置授权仍应交由权限类。
  • 重写 initial 漏掉 super().initial(...),认证权限限流全部失效,形成未授权访问漏洞。

追问

  • 认证、权限、限流的先后顺序?答:先认证,再权限,后限流;认证失败不进入权限判定。
  • initial 里能拿到路径参数吗?答:能,args/kwargs 即 URL 捕获参数。

04.7.17.1-050 handle_exception 与异常上抛的关系?

一句话结论

APIView.handle_exception(exc) 调用配置的 exception_handler(默认 rest_framework.views.exception_handler)把 DRF 异常转成 Response;非 DRF 异常(裸 Exception)返回 None,由 Django 兜底走 500 处理。动作方法内抛出的 APIException 及其子类都会被 dispatch 捕获并交给 handle_exception。

概念解释

  • 异常处理链保证 DRF 异常输出统一结构,而不是 Django 默认错误页。
  • 自定义异常处理器可记录日志、补充错误码与请求 ID。

原理流程

  1. dispatch 包裹动作调用,except Exception 捕获。
  2. handle_exception 调 exception_handler 生成响应。
  3. 处理器返回 None 时重新抛出,交给 Django 中间件与 DEBUG 页面。

代码或图示

from rest_framework.views import exception_handler

def custom_exception_handler(exc, context):
    response = exception_handler(exc, context)
    if response is not None:
        response.data["code"] = response.data.get("code", "error")
    return response

常见误区

  • 在动作里 try/except 吞掉异常后返回 200,掩盖错误并破坏统一错误结构;异常应上抛由处理器归一。
  • 自定义处理器对 None 响应(非 DRF 异常)也强行包装,可能把 Django 500 信息泄露给前端;未处理异常应保持上抛。

追问

  • 全局异常处理器在哪配置?答:settings.py 的 EXCEPTION_HANDLER 指向处理器函数路径。
  • ValidationError 走哪条链?答:属于 APIException 子类,经默认处理器转 400 响应。

04.7.17.1-051 序列化器在视图里分别在什么时机实例化?

一句话结论

读取动作(list/retrieve):get_serializer(instance=..., many=...) 做输出表示;写入动作(create/update):get_serializer(data=...) 或 get_serializer(instance, data=..., partial=...) 做反序列化校验。同一视图类在不同动作实例化参数不同,is_valid 只在写入路径调用,读取路径直接取 serializer.data。

概念解释

  • 实例化参数决定序列化器处于「表示模式」还是「校验模式」。
  • 嵌套序列化器随父级实例化时机同步构造。

原理流程

  1. list:查询集分页后 get_serializer(queryset, many=True)。
  2. retrieve:get_serializer(obj)。
  3. create/update:get_serializer(data=request.data[, instance, partial]) 后 is_valid。

代码或图示

# list 路径
serializer = self.get_serializer(queryset, many=True)
return Response(serializer.data)

# create 路径
serializer = self.get_serializer(data=request.data)
serializer.is_valid(raise_exception=True)
self.perform_create(serializer)

常见误区

  • 读取路径也调 is_valid(),对无 data 的序列化器做无意义校验;表示模式不需要校验。
  • 写入路径忘记传 instance,更新接口被当成创建,产生重复记录。

追问

  • many=True 在哪个动作默认加?答:list 动作由 ListModelMixin 传入;单对象动作不传。
  • 序列化器实例能复用吗?答:每个请求/动作独立实例化,不要在类属性上缓存序列化器对象。

04.7.17.1-052 get_serializer_class 动态返回的常见写法有哪些?

一句话结论

常见分支维度:按 self.action(list/retrieve/写动作)、按 self.request.method、按用户角色(is_staff、所属组)、按资源归属或查询参数。写法是在方法内 if/elif 返回类,兜底返回默认 serializer_class;复杂分支可拆成映射字典,避免长串条件。

概念解释

  • 动态选择集中在视图层,序列化器类保持无状态、可复用。
  • 映射字典适合动作到序列化器一一对应的场景。

原理流程

  1. 读取当前动作、方法、用户等上下文。
  2. 条件匹配返回对应序列化器类。
  3. get_serializer 用返回类实例化。

代码或图示

class ArticleViewSet(viewsets.ModelViewSet):
    queryset = Article.objects.all()
    serializer_class = ArticleSerializer

    def get_serializer_class(self):
        mapping = {
            "list": ArticleListSerializer,
            "retrieve": ArticleDetailSerializer,
        }
        if self.request.user.is_staff:
            return ArticleAdminSerializer
        return mapping.get(self.action, self.serializer_class)

常见误区

  • 分支返回的类没有继承共同基类,字段与错误结构不一致;约定共享字段命名与基类。
  • 在 get_serializer_class 里访问数据库做判断,把数据查询塞进类选择阶段;选择逻辑应基于请求上下文,数据范围放 get_queryset。

追问

  • 动态类需要在 serializer_class 上声明默认吗?答:需要,作为兜底与 schema 识别的默认类。
  • 按查询参数选类可行吗?答:可行,读 self.request.query_params,但要注意该参数不进入 schema 时需手工标注。

04.7.17.1-053 嵌套 Router 如何组织父子资源路由?

一句话结论

嵌套路由把子 ViewSet 挂在父资源路径下,例如 /articles/<article_pk>/comments/,子视图的 get_queryset 通过 self.kwargs["article_pk"] 过滤归属。DRF Router 支持嵌套注册(可配合 NestedDefaultRouter 等第三方,待确认:嵌套 Router 实现以项目所选库为准),URL 中的父级主键用于限定子资源范围,防止跨父级访问。

概念解释

  • 父子路由体现资源层级,子资源查询必须绑定父级上下文。
  • 父级主键参数名由嵌套 Router 约定,子视图读取时保持一致。

原理流程

  1. 父 Router 注册父 ViewSet,子 Router 以父前缀为基路径注册子 ViewSet。
  2. URLconf include 嵌套路由生成完整路径。
  3. 子视图 get_queryset 取 kwargs 中的父级键过滤。

代码或图示

class CommentViewSet(viewsets.ModelViewSet):
    serializer_class = CommentSerializer

    def get_queryset(self):
        return Comment.objects.filter(
            article_id=self.kwargs["article_pk"]
        )

常见误区

  • 子视图查询集没按父级键过滤,直接返回全量评论,造成水平越权;父级上下文必须进入查询条件。
  • 嵌套层级过深导致 URL 与 lookup 参数混乱;超过两层的资源关系建议在查询参数中表达。

追问

  • 父级对象不存在时子接口应返回什么?答:应先校验父级归属,父级不存在返回 404,而不是返回空子列表。
  • 嵌套路由的 basename 怎么命名?答:带子资源前缀,如 article-comment-detail,保证反解名唯一。

04.7.17.1-054 视图方法名与 HTTP 方法是如何映射的?

一句话结论

APIView 按方法名直接对应 HTTP 动词:get/post/put/patch/delete/head/options/trace;ViewSet 先由 Router 或 as_view 表把 HTTP 动词映射到动作名(list/create/retrieve/update/partial_update/destroy),再调用实例上的动作方法。partial_update 是动作名,对应 PATCH;update 对应 PUT。

概念解释

  • 两层映射:ViewSet 多了「HTTP 动词 → 动作名」这一层解耦。
  • 未实现对应方法时,请求返回 405 Method Not Allowed。

原理流程

  1. APIView:dispatch 按 request.method.lower() 查找同名方法。
  2. ViewSet:ViewSetMixin 按 actions 表查到动作名,赋 self.action 后调用。
  3. 方法缺失时框架返回 405 并带 Allow 头。

代码或图示

GET  → list / retrieve / get
POST → create / post
PUT  → update / put
PATCH→ partial_update / patch
DELETE→ destroy / delete

常见误区

  • 在 ViewSet 里实现 def get(self, request),Router 不会把它识别为动作;ViewSet 应写动作方法名。
  • 自定义 @action 只声明 methods=["POST"],GET 请求命中同一路径会 405;方法白名单要列全。

追问

  • 405 响应的 Allow 头怎么生成?答:框架根据已实现方法与映射表自动汇总允许的 HTTP 动词。
  • OPTIONS 请求由谁处理?答:默认由视图的 options 方法处理,返回可用动作与 schema 信息。

04.7.17.1-055 format 后缀与内容协商在视图层如何参与?

一句话结论

DRF 内容协商根据请求 Accept 头、URL 格式后缀(如 .json)与渲染器列表确定响应媒体类型;format 是协商结果的标识,随 get_serializer_context 传入序列化器。解析器则按 Content-Type 选择输入解析方式(JSON、表单、文件上传)。格式后缀是可选机制,前后端分离项目通常只靠 Content-Type/Accept 协商。

概念解释

  • 协商分输入解析与输出渲染两侧,分别由 parser_classes 与 renderer_classes 控制。
  • format 后缀在 Router 配置中可开启,用于兼容老式按扩展名区分格式的客户端。

原理流程

  1. perform_content_negotiation 选出解析器与渲染器。
  2. 输入经解析器生成 request.data;输出经渲染器编码响应体。
  3. 协商结果写入请求与上下文,供序列化器/超链接字段使用。

代码或图示

class ArticleView(APIView):
    parser_classes = [JSONParser, MultiPartParser]
    renderer_classes = [JSONRenderer]

常见误区

  • 同时挂多种解析器却未限制 Content-Type,畸形请求可能被错误解析;按接口实际载荷选择解析器集合。
  • 依赖 URL 后缀区分格式,却在反向代理或 CDN 层剥离后缀,导致协商失败;现代接口优先用请求头。

追问

  • 解析器与渲染器全局在哪配?答:DEFAULT_PARSER_CLASSES 与 DEFAULT_RENDERER_CLASSES。
  • 上传文件需要哪个解析器?答:MultiPartParser 处理 multipart/form-data,request.FILES 由此解析。

04.7.17.1-056 queryset 在 Meta.model 与视图之间如何保持一致?

一句话结论

序列化器 Meta.model 声明数据类型,视图 queryset(或 get_queryset)决定可访问的数据范围;两者指向同一模型是前提,视图查询集负责按用户、状态、归属过滤。序列化器不做数据范围授权,只做字段表示与校验;权限与可见性必须在视图查询集或权限类落地,不能依赖序列化器模型声明。

概念解释

  • Meta.model 是类型约束,queryset 是运行时数据边界。
  • 两者模型不一致时,保存与序列化可能抛出实例类型不匹配错误。

原理流程

  1. 序列化器按 Meta.model 推导字段。
  2. 视图 get_queryset 返回该模型的过滤查询集。
  3. 对象在查询集内取出后交给序列化器表示或更新。

代码或图示

class ArticleSerializer(serializers.ModelSerializer):
    class Meta:
        model = Article
        fields = ["id", "title"]

class ArticleViewSet(viewsets.ModelViewSet):
    serializer_class = ArticleSerializer

    def get_queryset(self):
        return Article.objects.filter(author=self.request.user)

常见误区

  • 视图 queryset 与序列化器 Meta.model 指向不同模型,save() 后类型校验失败;改动模型时两处同步检查。
  • 以为序列化器字段白名单天然隐藏未授权数据;列表可见性由查询集控制,敏感字段才由序列化器裁剪。

追问

  • 只设置 Meta.model 不设视图 queryset 可以吗?答:无 queryset 的 ViewSet 必须重写 get_queryset 或提供 basename,否则对象获取无数据源。
  • 跨模型聚合数据用哪个声明?答:手写 Serializer,不绑定 ModelSerializer.Meta.model。

04.7.17.1-057 从 APIView 演进到 ModelViewSet 的取舍是什么?

一句话结论

APIView 灵活、路由与编排完全自控,但 CRUD 样板代码多;GenericAPIView 提供查询集/序列化器约定;mixin 拼装标准动作;ModelViewSet 一步到位生成全套 CRUD 路由,代价是默认暴露写动作、行为受框架骨架约束。演进路径按接口复杂度选择:简单资源用 ViewSet,复杂业务编排或非 CRUD 语义保留 APIView/GenericAPIView。

概念解释

  • 框架抽象越强,约定优于配置,但定制点要通过钩子与重写方法介入。
  • 选型先看资源是否符合标准 CRUD,不符合就不要硬套 ModelViewSet。

原理流程

  1. 评估资源动作是否为标准 list/retrieve/create/update/destroy。
  2. 标准 CRUD 选 ModelViewSet 或裁剪 mixin。
  3. 动作语义特殊(多步骤业务、聚合计算)用 APIView 或 GenericAPIView 手写编排。

代码或图示

APIView            —— 仅认证/权限/限流/渲染编排,无数据约定
  ↓ GenericAPIView —— 加 queryset/serializer/filter/pagination
  ↓ + mixins       —— 按需拼装 CRUD 动作
  ↓ ModelViewSet   —— 全套标准动作

常见误区

  • 业务流程不是资源 CRUD(如审批流、转账)却套 ModelViewSet,动作方法里堆满分支判断;这类场景应手写视图与动作。
  • 直接继承 ModelViewSet 后关闭不需要的动作,不如从 mixin 组合开始,避免暴露面误留。

追问

  • ViewSet 能表达非 CRUD 动作吗?答:能,用 @action 扩展,但标准 CRUD 骨架仍在。
  • 团队约定优先灵活还是优先一致?答:内部标准资源优先 ViewSet 提效,对外复杂接口保留手写视图。

04.7.17.1-058 ListSerializer 层的校验钩子与单字段校验如何配合?

一句话结论

单项校验在子序列化器内完成:字段类型、字段 validator、validate_<field>、子级 validate;列表级校验在 ListSerializer.validate 拿到完整条目列表,做跨条目规则(总数上限、重复键检查、批量业务约束)。错误聚合时单项错误按索引挂在列表对应位置,列表级错误挂 non_field_errors。两层校验顺序是先逐项通过,再做列表级判定。

概念解释

  • 列表级校验依赖所有单项合法,避免在脏数据上做批量规则判断。
  • 跨条目去重、配额、批量权限都属于列表层职责。

原理流程

  1. ListSerializer.to_internal_value 逐项调子序列化器校验并收集错误。
  2. 全部单项通过后调用 self.validate(data)。
  3. 聚合错误:索引映射单项错误,non_field_errors 挂列表级错误。

代码或图示

class UniqueNameListSerializer(serializers.ListSerializer):
    def validate(self, data):
        names = [item["name"] for item in data]
        if len(names) != len(set(names)):
            raise serializers.ValidationError("名称不能重复")
        return data

    class Meta:
        list_serializer_class = UniqueNameListSerializer

常见误区

  • 把批量规则写进子序列化器 validate,每条目互不可见,无法判断重复与配额;跨条目规则必须上移到列表层。
  • 列表级校验抛字段字典错误时,错误归属不符合聚合约定;列表级错误应归 non_field_errors 或明确索引。

追问

  • 批量提交部分失败怎么返回?答:默认按索引聚合错误,前端定位失败条目;全量成功才入库,或在视图层做部分成功策略。
  • ListSerializer 能自定义创建批量入库吗?答:能,重写 create 使用 bulk_create,并注意信号与校验时机。

04.7.17.1-059 标准 ViewSet 动作的 URL 路径分别是什么?

一句话结论

以前缀 articles/、查找键 pk 为例:集合路由 articles/ 对应 list(GET)与 create(POST);单项路由 articles/<pk>/ 对应 retrieve(GET)、update(PUT)、partial_update(PATCH)、destroy(DELETE)。自定义 @action(detail=True) 挂在单项路径下,detail=False 挂在集合路径下,路径片段取 url_path 或方法名。

概念解释

  • Router 按集合/单项两类模板生成路径,动作映射表绑定 HTTP 动词。
  • 尾部斜杠由 Router 配置 trailing_slash 决定。

原理流程

  1. register 记录前缀与 ViewSet。
  2. Router 生成集合 pattern 与单项 pattern(含 lookup 正则)。
  3. 为标准动作填充 HTTP 方法到动作名的映射。

代码或图示

GET    /articles/          → list
POST   /articles/          → create
GET    /articles/<pk>/     → retrieve
PUT    /articles/<pk>/     → update
PATCH  /articles/<pk>/      → partial_update
DELETE /articles/<pk>/      → destroy

常见误区

  • 路径与动作映射记错,把 PUT 当成部分更新;PUT 全量、PATCH 部分更新语义不要混。
  • 自定义动作路径与标准单项路由冲突(同名片段),Router 注册顺序决定匹配优先级,需检查 URLconf。

追问

  • 集合级自定义动作路径长什么样?答:/articles/drafts/,detail=False,不带主键。
  • 查找键不是 pk 时路径怎么变?答:lookup_field 决定查询字段,URL 路径参数名由 lookup_url_kwarg 与 Router 模板决定。

04.7.17.1-060 一次 ModelViewSet list 请求的完整链路是什么?

一句话结论

链路:HTTP 请求进入 ViewSetMixin.as_view 包装的视图 → dispatch 调 initial() 完成版本解析、认证、权限、限流 → 按 GET 映射到 list 动作 → get_queryset 取基础查询集 → filter_queryset 走过滤/搜索/排序后端 → paginate_queryset 切片当前页 → get_serializer(queryset, many=True) 装配上下文并序列化 → get_paginated_response 包装分页结构 → finalize_response 内容协商选渲染器输出 JSON。异常在各环节上抛,由 handle_exception 归一为错误响应。

概念解释

  • 这条链路串起本页所有知识点:认证权限限流在视图前置,过滤分页在数据层,序列化在表示层,渲染在输出层。
  • 每一层都是可重写扩展点,定位问题时按链路分层排查。

原理流程

  1. 前置横切:版本 → 认证 → 权限 → 限流,失败即短路。
  2. 数据编排:查询集 → 过滤 → 分页切片。
  3. 表示输出:序列化当前页 → 分页包装 → 渲染编码响应体。

代码或图示

request → as_view → dispatch → initial(认证/权限/限流)
  → list → get_queryset → filter_queryset → paginate_queryset
  → get_serializer(many=True) → serializer.data
  → get_paginated_response → finalize_response(渲染器) → response

常见误区

  • 性能问题只在序列化器层找;实际 N+1 常出在查询集未预加载,过滤/排序缺索引也在数据层。
  • 越权问题只查序列化器;数据范围由查询集过滤与对象级权限兜底,序列化器不做授权。

追问

  • list 链路里哪一步可能产生 N+1?答:get_queryset 未 select_related/prefetch_related,序列化访问关联对象时逐条查询。
  • 想在 list 返回额外统计数据改哪一步?答:在 list 动作或分页响应包装中附加独立查询,不要对全量未分页数据聚合。

本节高频题

  • 字段映射与 source/只读只写(002、003、004)
  • 反序列化校验链与执行顺序(008、010、011)
  • validated_data 与 create/update 分发(013、024)
  • 嵌套序列化与 depth(014、015)
  • many=True 与 ListSerializer(016、058)
  • SerializerMethodField 与 N+1 代价(017)
  • CurrentUserDefault 与 context(018、019)
  • partial=True 与实例化参数(020)
  • GenericAPIView 核心方法(027、028、029)
  • perform_* 钩子(030)
  • get_object 流程与对象权限(031)
  • mixin 与 ModelViewSet 继承链(032、034、035)
  • self.action 与动态序列化器(036、037、048)
  • @action 装饰器参数(038)
  • Router、basename 与 URL 反解(039、040、041)
  • initial() 横切顺序(049)
  • 标准动作 URL 映射(054、059)
  • list 请求完整链路(060)