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与contextAPIView/GenericAPIView的查询集、序列化器与钩子方法perform_create/perform_update/perform_destroy与actionViewSet/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实现。
原理流程
ModelSerializer.build_field_kwargs读取模型字段的null/blank/default/choices推导 DRF 字段参数。build_standard_field按模型字段类型选择对应 DRF 字段类,外键、多对多走关系字段分支。- 未被显式声明的字段进入
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。
原理流程
get_fields()遍历模型的 concrete fields 与反向关系。build_field_kwargs从模型字段读取空值、默认值、长度、选项等参数。- 按字段类型查表得到 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链路每一级都可能触发数据库查询,需要在视图层优化关联加载。
原理流程
- 序列化输出:
Field.get_attribute(instance)按source用getattr/dict逐级取值。 - 反序列化输入:输入数据按字段名进入,校验通过后按
source路径写回validated_data的嵌套字典。 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、计算字段。
概念解释
- 只读字段典型来源:自增主键、时间戳、后端计算的聚合值。
- 只写字段典型来源:密码、验证码、一次性令牌,绝不回显。
原理流程
get_fields()构造字段时记录read_only/write_only标记。- 输出阶段:
to_representation跳过write_only字段;输入阶段:to_internal_value跳过read_only字段。 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约束。
原理流程
- 输入数据缺该字段:检查
default,有则填入,无则按required决定是否报错。 - 输入显式传值:进入字段类型校验与
validate_<field>。 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,取决于契约,序列化器按契约配置。
原理流程
- 字段校验先判空:值为
None时检查allow_null;值为""时检查allow_blank(仅字符串字段)。 - 不被允许的空值进入
errors,错误码分别为null与blank。 - 空值通过校验后,再走类型转换与后续校验器。
代码或图示
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,挂在多个字段上。
- 跨字段一致性必须在对象级校验,字段级拿不到其他字段的值。
原理流程
to_internal_value逐字段做类型转换与字段 validator。- 依次调用
validate_<field>钩子。 - 汇总后调用
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做具体类型转换(字符串→整数、字符串→日期等)。
原理流程
run_validation先处理缺失值(default/required),再调field.to_internal_value。- 字段层执行
validators列表与字段钩子;序列化器层遍历fields组装ret。 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。
原理流程
serializer.data属性触发to_representation(instance)。- 跳过
write_only字段;每个字段get_attribute按source取值。 - 字段
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)。
原理流程
to_internal_value逐字段反序列化并收集错误。validate(attrs)执行对象级校验。- 成功保存
_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,职责清晰。
原理流程
- 每个字段
run_validation结束前查找validate_<字段名>方法并调用。 - 所有字段处理完,
to_internal_value返回ret。 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渲染为该映射。
原理流程
- 各层
ValidationError携带detail(字符串、列表或字典)。 ValidationError被run_validation捕获,detail合并进字段映射。- 嵌套子序列化器失败时,父级把其
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用于注入请求级数据,如当前用户,避免进入请求体。
原理流程
save()先把**kwargs合并进validated_data。- 判断
self.instance:非空走update,为空走create。 - 返回保存后的模型实例,重新挂回
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 里显式处理嵌套数据。可写嵌套要自己实现保存逻辑,或借助第三方嵌套序列化库。
概念解释
- 不可写的根源是关联语义模糊:一对一、一对多、多对多各有不同的持久化策略。
- 常见做法:嵌套字段只用于展示,写入用主键字段;确需级联写入再实现嵌套保存。
原理流程
- 嵌套字段反序列化得到嵌套
validated_data。 - 父级
create/update收到的validated_data包含该嵌套字典或列表。 - 默认父级实现不识别嵌套结构,需要手动遍历、查询或新建关联并挂接。
代码或图示
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是表示层快捷方式,只影响序列化输出,不改变可写性。- 需要精细控制字段、嵌套写入或不同动作返回不同结构时,应手写嵌套序列化器。
原理流程
ModelSerializer.get_fields()检测Meta.depth。- 关系字段在深度范围内被构建为嵌套
ModelSerializer,递归到下一层递减深度。 - 超过深度的关系退回主键或不展开。
代码或图示
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。
原理流程
Serializer(many=True)内部调ListSerializer(child=...)。- 反序列化:逐项
child.run_validation,错误按索引聚合。 - 序列化:逐项
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是当前模型实例。 - 派生展示逻辑集中在序列化器,表示层职责内。
原理流程
- 输出阶段字段
to_representation回调绑定的方法。 - 方法读取
obj属性并返回 JSON 原生值。 - 返回值再经字段类型包装进入响应字典。
代码或图示
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,脱离视图独立实例化序列化器时取不到。
原理流程
- 字段声明为
HiddenField(default=CurrentUserDefault())。 - 反序列化缺省时调用默认值可调用对象。
- 可调用对象读取
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.1xrest_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共享同一上下文。
原理流程
GenericAPIView.get_serializer_context()组装默认上下文字典。get_serializer()调serializer_class(*args, **kwargs, context=context)。- 序列化器与嵌套子序列化器都持有该上下文引用。
代码或图示
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只影响必填校验,不改变字段类型与可空规则。
原理流程
- 构造函数记录
instance、data、partial、context。 - 输出:
to_representation(instance);输入:run_validation(data)。 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是属性路径,"*"是「整对象」语义。 - 典型用法:拆分超大序列化器为多个职责子序列化器,共享同一模型实例。
原理流程
get_attribute遇到source="*"直接返回当前实例。- 子序列化器在该实例上按自己的
fields取值。 - 反序列化结果按嵌套键进入父级
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二选一,敏感字段优先走白名单。
原理流程
get_fields()先按模型生成自动字段。- 按
fields/exclude过滤;extra_kwargs合并参数。 - 序列化器体中显式声明的字段覆盖同名单自动字段。
代码或图示
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少写通用逻辑。
原理流程
- 反序列化:
Field.run_validation调to_internal_value,失败抛ValidationError。 - 序列化:字段调
to_representation把内部值转为 JSON 原生类型。 - 字段实例随序列化器
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字典/列表。
原理流程
- 各字段
to_internal_value输出内部 Python 值。 - 汇总进
ret,经对象级validate清洗返回。 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)。
原理流程
get_serializer()先调get_serializer_class()取类。- 视图方法内按动作/角色分支返回类。
- 用该类装配上下文并实例化。
代码或图示
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不做认证/权限/限流编排,需要中间件或手写。
原理流程
as_view()包装后请求进入dispatch。dispatch调initial()完成认证、权限、限流。- 分发到
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 混入。
原理流程
- mixin 动作先调
get_queryset()拿基础查询集。 filter_queryset()走过滤后端;分页或取对象再加工。- 需要校验时调
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。
原理流程
cls = self.get_serializer_class()。context = self.get_serializer_context(),并入kwargs.setdefault("context", context)。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里加条件。
原理流程
get_queryset()返回基础查询集。filter_queryset逐个调用后端的filter_queryset(request, queryset, view)。- 结果交给分页或
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的分工:通用模型保存放序列化器,请求级编排放钩子。
原理流程
- CreateModelMixin 构造序列化器并
is_valid(raise_exception=True)。 - 调
perform_create(serializer),默认实现serializer.save()。 - 返回
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、按复合条件),但要保留过滤与权限检查。
原理流程
- 取过滤后的查询集。
- 解析 URL 关键字参数,拼成查找条件。
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,避免暴露多余动作。
原理流程
- mixin 方法调
get_queryset/filter_queryset取数据。 - 调
get_serializer装配序列化器并校验。 - 调
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 与反解的依据。
原理流程
ViewSetMixin.as_view(actions)保存{http_method: action_name}映射。dispatch时按请求 HTTP 方法查到动作名。- 把动作名挂到
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的扩展点对接。
原理流程
- 请求进入
ViewSetMixin.as_view包装的视图。 dispatch经APIView.initial完成认证/权限/限流。- 按动作名调用 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这类权限只读配合使用,二者层级不同。
原理流程
- 类定义只继承列表与详情两个 mixin。
- Router 生成集合路由与单项路由,不生成 POST/PUT/PATCH/DELETE。
- 写方法请求到达时无对应动作映射,返回 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取方法名。
原理流程
as_view(actions)保存 HTTP 方法到动作名的映射。dispatch查表得到动作名,赋给self.action。- 后续
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 层补充上下文。保持每个序列化器职责单一,动态选择集中在视图层。
概念解释
- 读写分离序列化器可以避免「输出字段被校验规则约束」的耦合。
- 不同动作的字段差异大时,拆类比在一个序列化器里堆条件更易维护。
原理流程
get_serializer()调get_serializer_class()。- 方法读
self.action返回对应类。 - 实例化并注入上下文。
代码或图示
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 形态:集合级无主键,单项级带主键。
原理流程
- 装饰器给方法打
mapping、url_path、url_name等标记。 - Router 扫描带标记的方法,生成额外路由条目。
- 请求命中后按
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 展示可点击导航,生产环境需注意暴露风险。
原理流程
register(prefix, viewset, basename)记录路由条目。- Router 为集合生成
prefix/,为单项生成prefix/lookup/。 - 绑定表把 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,否则注册时报错。
原理流程
- Router 优先用显式
basename。 - 未指定时尝试从
viewset.queryset.model推导。 - 推导失败抛配置异常,提示补 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 + 动作后缀组成,改名后要同步反解代码。
原理流程
- Router 注册时为每个动作生成带名称的 URL pattern。
reverse(name, kwargs=...)按名称与参数匹配 pattern。- 序列化器
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。
原理流程
- 调用
ViewSet.as_view({"get": "list"})得到可调用视图函数。 - URLconf 把路径指向该函数。
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返回实例列表,而不是类列表。
原理流程
- 视图初始化读取类属性作为默认。
- 需要动态分支时重写对应 getter 方法。
- 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。
原理流程
get_object读取lookup_field与lookup_url_kwarg。- 从
self.kwargs按lookup_url_kwarg取值。 - 构造
{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)时返回完整列表,大数据量下有内存与响应体积风险。
原理流程
- 查询集过滤完成后交给分页器切片。
- 序列化只处理当前页对象,避免全量实例化。
- 分页响应携带计数、下一页/上一页链接等元数据。
代码或图示
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类似 DjangoHttpResponse的数据载体,渲染延迟到响应阶段。- 同一数据经不同渲染器产出不同表示,浏览器访问走 BrowsableAPI,接口调用走 JSON。
原理流程
- 视图方法返回
Response(data, status=...)。 finalize_response做内容协商确定渲染器。- 渲染器
.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()阶段确定,动作方法内可直接读取。
原理流程
perform_authentication遍历认证类列表。- 首个返回
(user, auth)的认证类写入请求;全部未认证则置匿名。 - 权限类与限流类读取
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)返回精简只读序列化器。也可以为输入与输出分别配置字段,通过两个序列化器类隔离校验规则与表示结构。
概念解释
- 读写分离避免「输出字段必须满足写入校验」的耦合,也便于按角色裁剪响应。
- 两个序列化器共享模型与字段命名契约,避免响应结构漂移。
原理流程
- 动作方法调
get_serializer()。 get_serializer_class按动作/方法返回类。- 写入路径走校验与保存,读取路径走表示输出。
代码或图示
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。
原理流程
- 确定版本、内容协商与解析器。
- 执行认证装配
request.user/request.auth。 - 检查权限与限流,全部通过后才分发到动作方法。
代码或图示
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。
原理流程
dispatch包裹动作调用,except Exception捕获。handle_exception调exception_handler生成响应。- 处理器返回
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。
概念解释
- 实例化参数决定序列化器处于「表示模式」还是「校验模式」。
- 嵌套序列化器随父级实例化时机同步构造。
原理流程
- list:查询集分页后
get_serializer(queryset, many=True)。 - retrieve:
get_serializer(obj)。 - 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;复杂分支可拆成映射字典,避免长串条件。
概念解释
- 动态选择集中在视图层,序列化器类保持无状态、可复用。
- 映射字典适合动作到序列化器一一对应的场景。
原理流程
- 读取当前动作、方法、用户等上下文。
- 条件匹配返回对应序列化器类。
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 约定,子视图读取时保持一致。
原理流程
- 父 Router 注册父 ViewSet,子 Router 以父前缀为基路径注册子 ViewSet。
- URLconf
include嵌套路由生成完整路径。 - 子视图
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。
原理流程
- APIView:
dispatch按request.method.lower()查找同名方法。 - ViewSet:
ViewSetMixin按 actions 表查到动作名,赋self.action后调用。 - 方法缺失时框架返回 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 配置中可开启,用于兼容老式按扩展名区分格式的客户端。
原理流程
perform_content_negotiation选出解析器与渲染器。- 输入经解析器生成
request.data;输出经渲染器编码响应体。 - 协商结果写入请求与上下文,供序列化器/超链接字段使用。
代码或图示
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是运行时数据边界。- 两者模型不一致时,保存与序列化可能抛出实例类型不匹配错误。
原理流程
- 序列化器按
Meta.model推导字段。 - 视图
get_queryset返回该模型的过滤查询集。 - 对象在查询集内取出后交给序列化器表示或更新。
代码或图示
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。
原理流程
- 评估资源动作是否为标准 list/retrieve/create/update/destroy。
- 标准 CRUD 选 ModelViewSet 或裁剪 mixin。
- 动作语义特殊(多步骤业务、聚合计算)用 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。两层校验顺序是先逐项通过,再做列表级判定。
概念解释
- 列表级校验依赖所有单项合法,避免在脏数据上做批量规则判断。
- 跨条目去重、配额、批量权限都属于列表层职责。
原理流程
ListSerializer.to_internal_value逐项调子序列化器校验并收集错误。- 全部单项通过后调用
self.validate(data)。 - 聚合错误:索引映射单项错误,
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决定。
原理流程
register记录前缀与 ViewSet。- Router 生成集合 pattern 与单项 pattern(含 lookup 正则)。
- 为标准动作填充 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 归一为错误响应。
概念解释
- 这条链路串起本页所有知识点:认证权限限流在视图前置,过滤分页在数据层,序列化在表示层,渲染在输出层。
- 每一层都是可重写扩展点,定位问题时按链路分层排查。
原理流程
- 前置横切:版本 → 认证 → 权限 → 限流,失败即短路。
- 数据编排:查询集 → 过滤 → 分页切片。
- 表示输出:序列化当前页 → 分页包装 → 渲染编码响应体。
代码或图示
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)