04.7.17.2 认证、权限、限流与分页过滤
所属:全栈开发面试题库 / 04 后端语言与运行时 / 04.7 Python / 04.7.17 Django REST Framework
覆盖范围
BaseAuthentication契约与authenticate/authenticate_header- Token/Session/JWT(simplejwt)认证差异与刷新机制
BasePermission、对象级has_object_permission与全局/视图级配置AnonRateThrottle/UserRateThrottle/ScopedRateThrottle与缓存后端- 单机与分布式限流实现、429 与
Retry-After - 三种分页方式与
page_size_query_param/max_page_size DjangoFilterBackend/SearchFilter/OrderingFilter/自定义FilterSet- 内容协商、
BrowsableAPIRenderer生产风险 - 认证、权限、限流在
initial()中的执行顺序与匿名用户处理
04.7.17.2-001 DRF 认证整体流程中 request.user/request.auth 如何装配?
一句话结论
请求进入 APIView.initial() 后调用 perform_authentication(),按 authentication_classes 顺序逐个执行认证类的 authenticate(request):返回二元组 (user, auth) 即认证成功,挂到 request.user 与 request.auth 并短路;全部返回 None 则置匿名用户。认证只负责「识别身份」,是否放行由后续权限类判定。
概念解释
- DRF
Request是对 DjangoHttpRequest的惰性包装,认证结果缓存在请求对象上。 - 认证与授权分离:回答「你是谁」与「你能不能做」是两套独立机制。
原理流程
initial()先完成内容协商与版本解析。perform_authentication遍历认证类列表调用authenticate。- 首个成功认证写入
user/auth;未识别则继续,最终匿名兜底。
代码或图示
# 视图内读取认证结果
def get(self, request):
user = request.user
auth = request.auth # Token 实例、JWT 载荷或 None
return Response({"user": user.username})
常见误区
- 以为认证成功就代表有权限;认证只识别身份,匿名或已认证用户都要再过权限类。
- 多个认证类混用,前一个返回部分身份后短路,后续认证源不再尝试;顺序设计要明确主认证源。
追问
- 认证结果缓存在哪里?答:
request._user/request._auth与 DRFRequest对象属性,单次请求内有效。 - 不配置任何认证类默认是什么?答:由全局
DEFAULT_AUTHENTICATION_CLASSES决定,未配置时 DRF 默认含 Session 与 Basic(待确认:当前版本默认清单以 DRF 3.1x 设置文档为准)。
04.7.17.2-002 BaseAuthentication 的契约方法有哪些?
一句话结论
自定义认证类继承 BaseAuthentication,实现 authenticate(request):返回 (user, auth) 表示成功,返回 None 表示本类不识别该凭证(继续下一个认证类),抛 AuthenticationFailed 表示凭证无效(直接 401)。可选实现 authenticate_header(request),返回 WWW-Authenticate 头值,决定 401 响应头与浏览器弹窗行为。
概念解释
authenticate是核心契约,authenticate_header只影响未认证响应的头信息。- 认证类不抛 403;禁止访问属于权限层职责。
原理流程
- 框架调用
authenticate(request)传入 DRF 请求对象。 - 解析凭证(Header/Cookie/参数),校验有效性后构造用户对象。
- 失败按语义选择返回
None或抛AuthenticationFailed。
代码或图示
from rest_framework import authentication
from rest_framework.exceptions import AuthenticationFailed
class XApiKeyAuthentication(authentication.BaseAuthentication):
def authenticate(self, request):
key = request.headers.get("X-Api-Key")
if not key:
return None
if key != settings.API_KEY:
raise AuthenticationFailed("无效的 API Key")
return (None, key)
def authenticate_header(self, request):
return 'ApiKey realm="api"'
常见误区
- 凭证缺失时抛
AuthenticationFailed,导致不携带凭证的请求直接 401,而不是进入匿名兜底;缺失应返回None,无效才抛异常。 - 在认证类里查库做权限判定,越权到授权层;认证只识别身份,规则放权限类。
追问
authenticate_header返回None会怎样?答:401 响应不带WWW-Authenticate头,浏览器不弹原生登录框。- 认证类返回的 user 必须是 Django User 实例吗?答:建议是,权限与
is_authenticated依赖该接口协议;自定义用户对象需实现相同属性。
04.7.17.2-003 SessionAuthentication 的原理与 CSRF 处理?
一句话结论
SessionAuthentication 直接复用 Django 会话框架:从会话中取出 request.user,已登录即认证成功。它对 POST/PUT/PATCH/DELETE 启用 Django CSRF 校验(CsrfViewMiddleware 或 enforce_csrf),适合服务端渲染或同域前后端;跨域 AJAX 携带 Cookie 时需要同时配置 CSRF 头与 CORS。
概念解释
- 会话凭证存在服务端,浏览器靠 Cookie 携带 sessionid。
- DRF 的 Session 认证与 Django 中间件认证共享同一份会话数据。
原理流程
- 请求带 Cookie,Django 会话中间件加载会话。
SessionAuthentication.authenticate读取会话用户。- 写操作经 CSRF 校验通过后放行。
代码或图示
from rest_framework.authentication import SessionAuthentication
class ArticleViewSet(viewsets.ModelViewSet):
authentication_classes = [SessionAuthentication]
permission_classes = [IsAuthenticated]
常见误区
- 前后端分离跨域调用只配 CORS 漏掉 CSRF,写操作被 403 拒绝;同域 Cookie 会话必须带 CSRF Token 头。
- 以为 Session 认证天然防跨站请求;CSRF 防护依赖中间件与 Token,不是认证类自身完成。
追问
- Session 认证适合纯 API 移动端吗?答:不适合,移动端无 Cookie 容器,应选 Token 或 JWT。
- 登出时 Session 认证如何失效?答:调 Django
logout清空会话,服务端会话记录随即失效。
04.7.17.2-004 TokenAuthentication 的原理、表结构与多设备问题?
一句话结论
TokenAuthentication 使用 DRF 内置 authtoken 应用:用户登录后为其生成随机 Token 存数据库(Token 表含 key、user、created),请求头 Authorization: Token <key> 携带,认证类按 key 查库匹配用户。局限:一个用户默认一个 Token,多设备登出需要轮换;Token 长期有效、无内置过期与吊销机制,适合内部小系统,生产推荐 JWT 或接入 Token 轮换方案。
概念解释
- Token 是数据库凭证,每次认证都查库;与 JWT 的无状态签名不同。
authtoken需要加入INSTALLED_APPS并执行迁移。
原理流程
- 登录接口校验账号密码后
Token.objects.get_or_create(user=...)。 - 客户端后续请求在 Header 携带 Token。
- 认证类按
key查询,命中则返回(user, token)。
代码或图示
from rest_framework.authtoken.models import Token
def login(request):
user = authenticate(username=request.data["username"],
password=request.data["password"])
token, _ = Token.objects.get_or_create(user=user)
return Response({"token": token.key})
常见误区
- 把 Token 当 JWT 使用,指望它携带用户信息与过期时间;内置 Token 只是不透明随机串,信息全在数据库。
- 一个 Token 全员复用或写死在代码里,无法按用户吊销;每个用户独立生成并提供登出删除接口。
追问
- 内置 Token 支持多设备多 Token 吗?答:默认一对一,多设备需扩展模型或改用其他认证方案。
- Token 泄露如何失效?答:删除或轮换数据库中对应 Token 记录。
04.7.17.2-005 JWT 结构与 simplejwt 如何接入?
一句话结论
JWT 是自包含签名令牌:三段 Base64URL 拼接(Header、Payload、Signature),Payload 携带用户标识与过期时间,服务端用密钥验签,不查库。djangorestframework-simplejwt 5.x 提供 TokenObtainPairView 签发 access/refresh 对,配置 REST_FRAMEWORK.DEFAULT_AUTHENTICATION_CLASSES 加入 JWTAuthentication,请求头 Authorization: Bearer <access> 完成认证。
概念解释
- JWT 验签依赖密钥与算法(默认 HS256),Payload 只是 Base64 编码不是加密,不能放敏感信息。
- access 短期有效,refresh 长期用于换新 access,降低泄露窗口。
原理流程
- 登录接口校验凭证,simplejwt 生成 pair:access(短时)+ refresh(较长)。
- 客户端存 access,后续请求 Bearer 携带。
JWTAuthentication解析并验签,提取user_id取用户实例挂到请求。
代码或图示
# settings.py
REST_FRAMEWORK = {
"DEFAULT_AUTHENTICATION_CLASSES": [
"rest_framework_simplejwt.authentication.JWTAuthentication",
],
}
# urls.py
from rest_framework_simplejwt.views import TokenObtainPairView, TokenRefreshView
path("api/token/", TokenObtainPairView.as_view()),
path("api/token/refresh/", TokenRefreshView.as_view()),
常见误区
- 以为 JWT 加密了内容;Payload 可被解码阅读,禁止写密码、手机号等敏感数据。
- 验签不校验用户是否仍存在/被封禁,封禁后旧 access 在过期前仍可用;高安全场景需配合黑名单或短有效期。
追问
- JWT 为什么不需要查库?答:身份信息在签名 Payload 内,验签通过即信任,换取无状态。
- simplejwt 的双 Token 分别叫什么?答:
access短期访问令牌,refresh用于刷新 access。
04.7.17.2-006 JWT 的刷新流程与过期处理怎么做?
一句话结论
access 过期后客户端拿 refresh 调刷新接口,服务端校验 refresh 签名与有效期(可叠加黑名单校验),签发新的 access;refresh 自身过期后必须重新登录。simplejwt 提供 TokenRefreshView,刷新端点只接收 refresh 不返回旧 access;配置中可设置 ACCESS_TOKEN_LIFETIME、REFRESH_TOKEN_LIFETIME 与轮换策略。
概念解释
- 刷新是「用长效凭证换短效凭证」,refresh 不直接访问业务接口。
- 刷新窗口内登出/吊销要把 refresh 加入黑名单,否则旧凭证仍可换新。
原理流程
- 业务接口收到过期 access,返回 401 与过期提示。
- 客户端携带 refresh 请求刷新端点。
- 验签、查黑名单通过后签发新 access,必要时轮换 refresh。
代码或图示
from datetime import timedelta
from simplejwt.settings import api_settings
api_settings.ACCESS_TOKEN_LIFETIME = timedelta(minutes=15)
api_settings.REFRESH_TOKEN_LIFETIME = timedelta(days=7)
常见误区
- 把 access 有效期设得很长,失去短时令牌的意义;access 建议分钟级,refresh 天级。
- 只校验 access 过期不管 refresh 吊销,登出后 refresh 仍可换新 access;需要启用 blacklist 应用并在登出时吊销。
追问
- refresh 也能设置轮换吗?答:simplejwt 支持
ROTATE_REFRESH_TOKENS,刷新时签发新 refresh,旧 refresh 进入黑名单(待确认:具体配置项以 simplejwt 5.x 文档为准)。 - 401 后前端怎么区分未登录与令牌过期?答:响应体错误码或
detail字段区分,过期走刷新,未认证跳登录。
04.7.17.2-007 BasicAuthentication 适用场景是什么?
一句话结论
BasicAuthentication 从 Authorization: Basic <base64(user:password)> 解析账号密码,每次请求都校验凭证,适合调试工具、内部监控、HTTP 基础认证保护的后台,不适合面向浏览器的正式业务:凭证每个请求明文传输(必须 HTTPS),且没有会话或令牌机制。
概念解释
- Basic 是 HTTP 标准认证方案,浏览器会弹出原生登录框。
- 凭证格式
username:password经 Base64 编码,可被解码,不等于加密。
原理流程
- 请求头携带 Basic 编码串。
- 解码得到用户名密码,调 Django
authenticate校验。 - 成功返回
(user, None),失败抛AuthenticationFailed。
代码或图示
from rest_framework.authentication import BasicAuthentication
class MonitorView(APIView):
authentication_classes = [BasicAuthentication]
permission_classes = [IsAdminUser]
常见误区
- 在 HTTP 明文环境使用 Basic,凭证可被中间人直接解码;Basic 必须配合 HTTPS。
- 把 Basic 用于用户登录态接口,每次传密码导致凭证无法轮换、无法登出;正式业务用 Token/JWT/Session。
追问
- Basic 认证有状态吗?答:无状态,每次请求携带凭证,服务端不保存会话。
- 调试时浏览器弹登录框由什么触发?答:
authenticate_header返回Basic realm=...后 401 响应头触发。
04.7.17.2-008 认证类列表的顺序与首个成功认证如何短路?
一句话结论
authentication_classes 是有序列表,框架按顺序调用:某个认证类返回 (user, auth) 即认证成功,不再尝试后续类;返回 None 表示不识别该凭证,继续下一个;抛 AuthenticationFailed 立即终止并返回 401。因此列表首位是主认证源,后续是兼容源,顺序影响「凭证被谁解释」。
概念解释
- 短路语义与权限类的「全部通过」不同,认证是「首个成功即止」。
- 多源并存时要避免同一凭证被错误认证类先匹配。
原理流程
perform_authentication按列表迭代认证类。- 每个类返回三元结果:成功/不识别/失败。
- 成功短路,不识别继续,失败中断。
代码或图示
class MixedAuthView(APIView):
authentication_classes = [JWTAuthentication, SessionAuthentication]
# 优先解析 Bearer JWT;未带 JWT 时回退到会话 Cookie
常见误区
- 把识别范围宽的认证类放前面,吞掉本应给后续类处理的凭证;窄匹配在前、宽兼容在后。
- 多认证源下
request.auth语义不统一,下游代码假设了固定类型;响应与日志要记录认证方式。
追问
- 全部认证类都返回
None是什么结果?答:匿名用户,继续走权限判定,可能被IsAuthenticated拒绝为 401/403。 - 认证类抛
PermissionDenied合适吗?答:不合适,禁止访问由权限层处理,认证类只抛认证失败。
04.7.17.2-009 authenticate_header 与 401 的 WWW-Authenticate 头有什么关系?
一句话结论
未认证请求被权限拒绝时,DRF 取首个认证类的 authenticate_header(request) 返回值写入响应 WWW-Authenticate 头;返回 None 则不写该头。该头告诉客户端可用的认证方案(Basic realm、Bearer 等),并决定浏览器是否弹出原生登录框。
概念解释
- 401 是「未提供有效凭证」,403 是「已识别但无权限」,两者响应头语义不同。
- Bearer 方案的头值由 JWT/Basic 认证类按约定返回。
原理流程
- 权限判定发现匿名且需要登录。
- 异常处理器构造 401 响应。
- 调认证类
authenticate_header填充WWW-Authenticate。
代码或图示
def authenticate_header(self, request):
return 'Bearer realm="api"'
常见误区
- 自定义认证类不实现
authenticate_header,移动端/网关拿不到认证方案提示,只能靠响应体判断。 - 把 403 场景也补
WWW-Authenticate;该头属于 401 未认证语义,403 不需要。
追问
- 浏览器原生登录框何时出现?答:收到 401 且响应带
WWW-Authenticate: Basic ...时触发。 - 移动端 API 通常需要这个头吗?答:移动端自行处理 401 跳登录,头信息主要给浏览器与标准 HTTP 客户端用。
04.7.17.2-010 匿名用户在什么条件下出现?request.user 是什么类型?
一句话结论
所有认证类都返回 None(未识别凭证)时,DRF 把 request.user 置为 Django AnonymousUser 实例,request.auth 为 None。匿名对象具备 is_authenticated=False、is_staff=False、is_superuser=False 等属性,权限类据此放行或拒绝;已认证用户的 is_authenticated 为 True。
概念解释
- 匿名是「未认证」的统一表示,不是单独的认证类结果。
AnonymousUser不可调用模型实例方法,序列化时不要假设其有主键。
原理流程
- 认证遍历结束无成功结果。
- DRF 包装请求挂载匿名用户。
- 权限类读取
is_authenticated判定。
代码或图示
def get(self, request):
if request.user.is_authenticated:
return Response({"name": request.user.username})
return Response({"name": "guest"})
常见误区
- 把匿名用户当已登录用户访问关联对象(如
request.user.orders),抛匿名属性错误;先判is_authenticated。 - 权限类里直接比较
request.user.pk,匿名pk为None,应先判认证状态。
追问
AnonymousUser有主键吗?答:pk为None,不能作为外键保存。- 匿名访问哪些内置权限会放行?答:
AllowAny放行;IsAuthenticated及以上拒绝。
04.7.17.2-011 如何编写一个自定义认证类?
一句话结论
继承 BaseAuthentication,在 authenticate(request) 中从 Header、Cookie 或参数提取凭证,校验后返回 (user, auth);凭证缺失返回 None,凭证无效抛 AuthenticationFailed;按需实现 authenticate_header。认证类保持轻量,用户加载与校验逻辑可复用 Django authenticate 或业务用户模型方法。
概念解释
- 自定义认证常见场景:内部 API Key、双向证书、网关透传用户头、企业 SSO 票据校验。
- 认证类实例每次请求新建,不要在类属性上缓存请求状态。
原理流程
- 提取凭证并判断是否属于本认证源。
- 校验凭证有效性,加载对应用户。
- 按成功/不识别/失败三种语义返回或抛异常。
代码或图示
class GatewayUserHeaderAuthentication(BaseAuthentication):
def authenticate(self, request):
uid = request.headers.get("X-Gateway-Uid")
if not uid:
return None
try:
user = User.objects.get(pk=uid)
except User.DoesNotExist:
raise AuthenticationFailed("网关用户不存在")
return (user, None)
常见误区
- 信任网关注入的用户头却不校验网关签名/内网来源,外部可伪造头冒充用户;透传认证必须有来源校验。
- 在认证类里做数据库大查询或重 IO,拖慢所有请求;认证查询应走索引,必要时加缓存。
追问
- 自定义认证类如何注册?答:视图
authentication_classes或全局DEFAULT_AUTHENTICATION_CLASSES配置类路径。 - 认证类能访问序列化器上下文吗?答:不能直接访问,认证先于序列化器装配;需要的信息从
request读取。
04.7.17.2-012 DRF 认证与 Django 中间件认证是什么关系?
一句话结论
二者并行读取同一份 Django 会话/用户体系:Django 中间件(AuthenticationMiddleware)在请求早期把会话用户挂到 request,DRF 认证类在视图 initial 阶段再次识别凭证。Session 认证复用中间件加载的会话用户;Token/JWT 认证不依赖中间件用户,直接从凭证加载。DRF 权限判定以认证阶段写入的 request.user 为准。
概念解释
- Django 中间件服务模板与传统视图,DRF 认证服务 API 视图。
- 同一项目可同时存在两套认证路径,数据模型一致。
原理流程
- 中间件栈先执行,加载会话用户到
request。 - DRF 视图
initial执行认证类,按凭证覆盖或确认用户。 - 权限与业务代码读取 DRF 认证后的用户。
代码或图示
middleware → request.user(会话) → DRF authenticate → request.user(认证结果) → permission
常见误区
- 以为装了 DRF 认证就可以移除 Django 认证中间件;Session 认证与模板渲染仍依赖中间件。
- 中间件用户与 DRF 认证用户不一致时以谁为准?答:以 DRF 认证阶段结果为准,Session 认证场景两者通常一致。
追问
- JWT 认证还需要
AuthenticationMiddleware吗?答:API 视图不强依赖,但项目其他模板/后台仍需要,通常保留。 - 两套认证会重复查库吗?答:Session 复用中间件结果;Token/JWT 由认证类独立查询,注意缓存。
04.7.17.2-013 认证类何时返回 None,何时抛 AuthenticationFailed?
一句话结论
None 表示「请求没有携带本认证源认识的凭证」,框架继续尝试下一个认证类,最终匿名兜底;AuthenticationFailed 表示「携带了凭证但无效/过期/伪造」,立即终止认证并返回 401。区分这两种语义决定客户端看到的是匿名访问还是明确凭证错误。
概念解释
- 缺失与无效是两类问题:缺失可继续匿名,无效必须拒绝。
- 抛异常应携带可读
detail与可选code。
原理流程
- 解析凭证:取不到对应 Header/Cookie → 返回
None。 - 取到凭证但验签/查库失败 → 抛
AuthenticationFailed。 - 成功返回
(user, auth)。
代码或图示
def authenticate(self, request):
header = request.headers.get("Authorization")
if not header or not header.startswith("Bearer "):
return None # 不属于本认证源
token = header.split(" ", 1)[1]
if not valid(token):
raise AuthenticationFailed("令牌无效或已过期")
常见误区
- 凭证缺失也抛异常,导致未登录用户拿不到匿名放行路径(被
AllowAny放行的接口也 401)。 - 凭证无效却返回
None,错误被静默吞掉,客户端以为是未登录而反复刷新。
追问
AuthenticationFailed的 HTTP 状态码是多少?答:默认 401,可通过异常属性覆盖。- 认证失败响应体结构由谁生成?答:DRF 异常处理器按
APIException.detail归一为 JSON。
04.7.17.2-014 Token 如何轮换与吊销?simplejwt 黑名单怎么用?
一句话结论
内置 Token 吊销:删除或替换数据库 Token 记录;simplejwt 吊销:启用 rest_framework_simplejwt.token_blacklist 应用,登出时把 refresh(必要时 access)加入黑名单,刷新与认证时检查黑名单。轮换指定期或泄露后签发新凭证、旧凭证失效;JWT 无状态本身无法主动吊销,黑名单或短有效期是补偿手段。
概念解释
- 吊销解决「凭证在过期前需要立即失效」,纯 JWT 做不到,必须有服务端记录。
- 黑名单存储可用数据库或缓存,查询路径要轻量。
原理流程
- 登录签发凭证,记录 jti 或 Token 主键。
- 登出/吊销把凭证标识写入黑名单存储。
- 认证与刷新时先查黑名单,命中即拒绝。
代码或图示
from rest_framework_simplejwt.tokens import RefreshToken
def logout(request):
refresh = RefreshToken(request.data["refresh"])
refresh.blacklist()
return Response(status=205)
常见误区
- 启用黑名单应用却没执行迁移,黑名单表不存在,登出时报错。
- 只吊销 refresh 不处理泄露的 access;在 access 短有效期内无法主动失效,敏感操作需二次校验或缩短有效期。
追问
- 黑名单存数据库还是缓存?答:数据库持久但查询重,缓存轻量但重启丢失;按安全等级选择,refresh 黑名单通常持久化。
- JWT 为什么天然不能吊销?答:验签不查服务端记录,签发后在有效期内任何人持有都可用。
04.7.17.2-015 全局认证类在哪里配置?视图级如何覆盖?
一句话结论
全局默认在 settings.py 的 REST_FRAMEWORK.DEFAULT_AUTHENTICATION_CLASSES 配置认证类路径列表;视图或 ViewSet 的 authentication_classes 属性覆盖全局默认。视图级只列本接口需要的认证源,覆盖后全局列表不再继承;未显式配置的视图使用全局默认。
概念解释
- 全局配置兜底,视图级按接口场景裁剪认证方式。
- 公开接口可配
authentication_classes = []配合AllowAny。
原理流程
- 视图初始化读取
authentication_classes,缺省取全局设置。 - 认证阶段按该列表执行。
- 视图级列表完全替换全局,不是追加。
代码或图示
# settings.py
REST_FRAMEWORK = {
"DEFAULT_AUTHENTICATION_CLASSES": [
"rest_framework_simplejwt.authentication.JWTAuthentication",
"rest_framework.authentication.SessionAuthentication",
],
}
# 视图级覆盖
class PublicView(APIView):
authentication_classes = []
permission_classes = [AllowAny]
常见误区
- 以为视图级
authentication_classes是在全局基础上追加;实际是整体替换,遗漏需要的认证源。 - 全局配了强认证,个别公开接口忘记覆盖,导致公开资源被 401 拦截。
追问
- 全局配置与权限默认是同一个字典吗?答:同在
REST_FRAMEWORK字典下,认证与权限是不同键。 - 认证类可以在基类视图上统一配置吗?答:可以,业务视图继承基类即可复用认证与权限组合。
04.7.17.2-016 BasePermission 的契约方法有哪些?
一句话结论
权限类继承 BasePermission,实现 has_permission(self, request, view) 做视图级(全局/动作级)判定,返回布尔值;对象级判定实现 has_object_permission(self, request, view, obj),在取出具体对象后调用。两个方法默认返回 True,子类按需覆盖。权限类只做放行/拒绝判定,不负责加载用户或查询数据范围。
概念解释
- 视图级权限回答「这个用户能不能访问这个动作」,对象级回答「能不能操作这条记录」。
- 权限是可插拔策略,全局与视图级均可配置类列表。
原理流程
check_permissions遍历权限类调has_permission。get_object取出对象后check_object_permissions遍历调has_object_permission。- 任一方法返回
False抛PermissionDenied(403)。
代码或图示
from rest_framework.permissions import BasePermission
class IsOwner(BasePermission):
def has_object_permission(self, request, view, obj):
return obj.author_id == request.user.id
常见误区
- 只实现
has_permission就以为对象级受控;列表查询集不过滤时,其他用户仍能在 list 看到全部对象。 - 权限方法里写重查询或副作用;权限判定应轻量,数据范围交给查询集过滤。
追问
- 两个权限方法都要实现吗?答:按场景,动作级控制用
has_permission,记录归属控制用has_object_permission。 - 权限类返回
False抛什么异常?答:PermissionDenied,默认渲染为 403。
04.7.17.2-017 对象级权限在什么时候被调用?
一句话结论
对象级权限只在 GenericAPIView.get_object() 取出对象之后调用 check_object_permissions(request, obj);retrieve/update/destroy 动作经过这一步,list 列表动作不遍历每条记录做对象级检查。手写 APIView 直接从库取对象时不会自动触发,必须显式调 check_object_permissions。
概念解释
- 对象级权限依赖具体实例,因此无法在列表批量场景逐条执行,需要配合查询集过滤控制可见性。
- 调用顺序是先查到对象(404 兜底不存在),再判对象权限(403 兜底无权限)。
原理流程
get_object在过滤查询集上取单条。- 对象存在后遍历权限类调
has_object_permission。 - 拒绝则抛 403,通过才返回对象给动作方法。
代码或图示
def get_object(self):
obj = super().get_object()
self.check_object_permissions(self.request, obj)
return obj
常见误区
- 认为对象级权限会自动保护 list 中的每条数据;list 不走对象级检查,可见性必须靠
get_queryset过滤。 - 在对象权限里访问未预加载的关联对象,触发 N+1;判定字段应在查询集上取出。
追问
- 为什么 list 不做对象级权限?答:逐条权限判定成本高,且框架约定列表可见性由查询集过滤承担。
- 手写视图怎么做对象级授权?答:取出对象后显式调用
self.check_object_permissions(request, obj)。
04.7.17.2-018 DRF 内置权限类分别控制什么?
一句话结论
AllowAny 无条件放行;IsAuthenticated 要求已认证;IsAdminUser 要求 user.is_staff=True;IsAuthenticatedOrReadOnly 已认证可写、匿名只读;DjangoModelPermissions 对接 Django 模型权限(如 app.add_model),与后台权限体系一致;DjangoModelPermissionsOrAnonReadOnly 在前者基础上允许匿名只读。
概念解释
- 内置权限覆盖最常见的认证与角色判定,业务归属判断仍需自定义类。
DjangoModelPermissions依赖视图queryset推导模型,无 queryset 时权限名无法生成。
原理流程
- 全局或视图配置权限类列表。
check_permissions逐个调用has_permission。- 全部通过放行,任一拒绝 403。
代码或图示
from rest_framework.permissions import IsAuthenticated, IsAdminUser
class AdminViewSet(viewsets.ModelViewSet):
permission_classes = [IsAdminUser]
常见误区
- 把
IsAdminUser当成超级用户判定;它只看is_staff,is_superuser需额外判断。 DjangoModelPermissions对 GET/HEAD/OPTIONS 不校验查看权限,只约束写动作;需要读权限控制要自定义。
追问
- 如何判断超级用户?答:权限方法内读
request.user.is_superuser或自定义类。 - 匿名只读怎么配?答:
IsAuthenticatedOrReadOnly,或自定义类按request.method放行安全方法。
04.7.17.2-019 DjangoObjectPermissions 与 django-guardian 如何配合?
一句话结论
DjangoObjectPermissions 对接 Django 框架级对象权限协议,默认需要对象权限后端存储(如 django-guardian):为用户/组对具体对象授予 model.change_object 之类权限,权限类在 has_object_permission 调 user.has_perm(perm, obj) 校验。它解决「同一模型不同用户操作不同记录」的细粒度授权,比字段归属判断更通用。
概念解释
- Django 内置权限是模型级的,对象级权限需第三方后端补充记录。
- guardian 提供
UserObjectPermission/GroupObjectPermission表与授予 API。
原理流程
- 业务流程为对象给用户授予对象权限。
get_object取出对象后权限类调用has_perm。- 权限后端查对象权限记录,返回布尔结果。
代码或图示
from rest_framework.permissions import DjangoObjectPermissions
class DocumentViewSet(viewsets.ModelViewSet):
queryset = Document.objects.all()
permission_classes = [DjangoObjectPermissions]
常见误区
- 只挂
DjangoObjectPermissions没装 guardian/权限后端,has_perm始终为假,全部 403。 - 对象权限数据量随对象与用户增长膨胀,需要定期清理离职/解绑记录;高频判定可加缓存。
追问
- 对象权限与查询集过滤怎么配合?答:权限兜底单对象操作,列表可见性仍要按权限规则过滤查询集。
- guardian 授予权限的 API 是什么?答:
assign_perm(perm, user, obj)(待确认:函数名以 guardian 版本为准)。
04.7.17.2-020 视图级权限如何覆盖全局默认?
一句话结论
全局默认在 DEFAULT_PERMISSION_CLASSES 配置;视图/ViewSet 的 permission_classes 属性整体替换全局列表。也可重写 get_permissions() 按 self.action、用户角色动态返回权限实例列表。视图级覆盖是替换不是追加;公开接口显式配 AllowAny,管理接口收窄到管理员权限。
概念解释
- 权限实例在
get_permissions中构造,每个请求独立。 - 动态权限适合同一 ViewSet 不同动作权限不同的场景。
原理流程
- 视图读取
permission_classes或调get_permissions。 - 实例化权限类列表。
- 认证后
check_permissions遍历执行。
代码或图示
def get_permissions(self):
if self.action in ("list", "retrieve"):
return [AllowAny()]
if self.request.user.is_staff:
return [IsAdminUser()]
return [IsAuthenticated()]
常见误区
- 视图级写了部分权限类,以为全局默认权限仍然叠加;实际全局被整体替换,漏掉必要限制。
- 在
permission_classes上放实例而不是类;框架要求类列表,实例应在get_permissions返回。
追问
- 全局默认权限没配置时是什么?答:DRF 默认
AllowAny(待确认:当前版本默认值以 settings 文档为准),生产应显式收紧。 - 基类视图可以统一权限吗?答:可以,业务 ViewSet 继承配置好权限的基类。
04.7.17.2-021 权限校验与查询集过滤有什么区别?如何防水平越权?
一句话结论
查询集过滤在数据层限定「列表与单对象能查到哪些记录」(如只返回 author=request.user);对象级权限在取出对象后做「能不能操作这条记录」的最终判定。防水平越权两层都要有:列表靠 get_queryset 过滤,单对象靠 get_object 基于过滤后的查询集 + 对象权限;只做权限不做过滤,他人仍能在列表看到数据,只做过滤不做权限,手写视图可能绕过。
概念解释
- 水平越权指访问同角色下不属于自己的记录,典型手段是改主键遍历。
- 权限是兜底闸门,查询集是数据边界,二者互补。
原理流程
get_queryset按归属/状态过滤基础数据范围。filter_queryset叠加过滤后端。get_object在该范围取对象,再做对象级权限校验。
代码或图示
def get_queryset(self):
return self.request.user.articles.all()
def has_object_permission(self, request, view, obj):
return obj.author_id == request.user.id or request.user.is_staff
常见误区
- 只在
has_object_permission判归属,list 查询集不过滤,他人列表仍可见全部标题与摘要。 get_object重写时直接Model.objects.get(pk=...),绕过过滤查询集,导致越权取到他人对象。
追问
- 改主键遍历他人记录怎么防?答:查询集按归属过滤,
get_object只能在过滤范围内查找。 - 权限类能替代查询集过滤吗?答:不能,列表场景不逐条走对象权限,过滤必须在查询集完成。
04.7.17.2-022 如何编写一个自定义权限类?
一句话结论
继承 BasePermission,按需要实现 has_permission 与 has_object_permission,方法内读 request.user、request.method、view.action 与对象属性返回布尔值;复杂规则可组合多个内置权限类。权限类不抛业务异常,拒绝统一由框架转 403;需要附带拒绝原因时在响应细节中补充。
概念解释
- 常见自定义权限:资源归属、部门可见、角色 + 动作矩阵、只读安全方法放行。
- 权限类无状态,可在多视图复用。
原理流程
- 判定动作级条件(认证、角色、方法)。
- 判定对象级条件(归属、共享、协作关系)。
- 返回布尔,框架汇总放行或拒绝。
代码或图示
class IsOwnerOrReadOnly(BasePermission):
def has_permission(self, request, view):
return request.user.is_authenticated
def has_object_permission(self, request, view, obj):
if request.method in SAFE_METHODS:
return True
return obj.author_id == request.user.id
常见误区
- 权限方法里直接抛
ValidationError或业务异常,绕过 403 统一结构;拒绝只返回False。 - 把数据查询塞进权限方法且未索引,列表/详情接口被拖慢;归属字段应建索引,必要时预加载。
追问
- 权限类能拿到序列化器数据吗?答:不能直接拿,权限先于序列化器;需要业务字段时从对象或查询集读取。
- 多个自定义权限如何组合?答:在
permission_classes列表组合,框架按 AND 汇总。
04.7.17.2-023 权限失败时 403 与 401 如何判定?
一句话结论
401 Unauthorized 表示未提供有效认证凭证(匿名或凭证无效),由认证失败或要求登录但匿名触发;403 Forbidden 表示身份已识别但无权执行该动作。DRF 规则:匿名访问需要认证的资源返回 401,已认证用户被权限拒绝返回 403;认证类抛 AuthenticationFailed 走 401,权限类返回 False 走 403。
概念解释
- 401 先于 403 判定:认证身份不成立时谈不上授权。
- 客户端据状态码区分「重新登录」与「无权限提示」。
原理流程
- 认证阶段失败 → 401(带
WWW-Authenticate)。 - 认证成功后权限拒绝 → 403。
- 匿名命中要求认证的权限 → 框架按规则转 401。
代码或图示
匿名 + IsAuthenticated → 401
已认证 + 无对象权限 → 403
凭证伪造/过期 → 401 (AuthenticationFailed)
常见误区
- 所有拒绝都返回 403,客户端无法区分是登录过期还是权限不足;状态码语义要遵守 HTTP 规范。
- 权限类里抛
AuthenticationFailed制造 401;禁止访问应走PermissionDenied/返回False。
追问
- 401 响应体里有
detail吗?答:有,默认异常处理器归一为 JSON,含可读消息与可选 code。 - 网关层能改写状态码吗?答:可以,但应保持 401/403 语义一致,避免下游误判。
04.7.17.2-024 has_object_permission 拿不到对象时怎么处理?
一句话结论
对象级权限方法签名固定接收 obj,对象由 get_object 先取出;404(对象不存在)在进入对象权限之前抛出,因此权限方法不需要处理「对象为 None」。若在手写视图中先取对象再判权限,取不到对象应先抛 404,不调用对象权限。权限方法内不应假设对象一定非空,但框架标准流程已保证传入有效实例。
概念解释
- 404 与对象权限是先后两步:存在性判定先于授权判定。
- 自定义
get_object必须保持这一顺序。
原理流程
- 查询集过滤后
get()取对象,失败抛 404。 - 对象存在才执行对象级权限遍历。
- 权限方法基于有效对象判定归属。
代码或图示
def get_object(self):
obj = get_object_or_404(self.filter_queryset(self.get_queryset()),
pk=self.kwargs["pk"])
self.check_object_permissions(self.request, obj)
return obj
常见误区
- 在对象权限方法里反复判
obj is None并返回False,把不存在误判成无权限,掩盖 404 语义。 - 先调对象权限再查对象,权限方法读到空对象报错;顺序不能反。
追问
- 对象被软删除后走哪个状态?答:查询集过滤排除已删除记录,取对象时 404;不要在权限层判删除状态。
- 权限方法可以修改对象吗?答:不应在权限方法里改数据,判定只读,变更放动作/钩子。
04.7.17.2-025 多个权限类之间是什么逻辑关系?
一句话结论
权限类列表之间是 AND 关系:所有权限类的 has_permission 都返回 True 才放行,任一返回 False 即拒绝;对象级同理,全部 has_object_permission 通过才放行。OR 逻辑需要在单个权限类内部组合判断,或自定义一个聚合权限类,不能靠列表顺序实现「或」。
概念解释
- AND 便于逐层叠加约束:认证 + 角色 + 归属。
- 权限类按列表顺序执行,首个拒绝即短路。
原理流程
check_permissions遍历权限类。- 每个
has_permission结果汇总,全 True 放行。 - 任一 False 抛
PermissionDenied,后续类不再执行。
代码或图示
permission_classes = [IsAuthenticated, IsOwnerOrReadOnly]
# 等价于:已认证 且 归属/只读规则通过
常见误区
- 以为列表是 OR 关系,把两个互斥角色写成两个权限类,结果全部被拒。
- 权限类之间有依赖顺序(先认证再角色),认证类放前面更符合执行短路。
追问
- 怎么实现 OR 权限?答:写一个权限类,内部
return A.has_permission(...) or B.has_permission(...)。 - 权限实例顺序影响性能吗?答:轻量判定在前可短路,重查询权限类靠后。
04.7.17.2-026 认证与权限在 initial() 中的执行顺序是什么?
一句话结论
initial() 内部顺序:内容协商/版本解析 → perform_authentication() 认证装配 request.user/auth → check_permissions() 视图级权限 → check_object_permissions 在取对象时触发 → check_throttles() 限流。认证先于权限,权限先于限流;认证失败不进入权限判定,权限拒绝不执行限流计数。
概念解释
- 顺序保证权限判定能拿到已认证用户,限流在授权通过后消耗配额。
- 自定义
initial必须保留super()顺序,不能调换认证与权限。
原理流程
- 解析版本、协商内容、确定解析器。
- 认证写入身份信息。
- 权限校验通过后执行限流检查,再分发动作方法。
代码或图示
initial()
→ perform_authentication
→ check_permissions
→ check_throttles
→ dispatch → action(→ get_object → check_object_permissions)
常见误区
- 把限流放在认证之前执行,匿名刷接口消耗的是匿名配额,正常已认证用户被误限;按框架顺序认证后再限流更合理。
- 重写
initial漏调super(),整条认证权限限流链失效。
追问
- 对象级权限在
initial里吗?答:不在initial主体,而在动作方法内get_object阶段触发。 - 限流失败返回什么状态码?答:429 Too Many Requests,带
Retry-After。
04.7.17.2-027 DRF 限流整体流程是怎样的?
一句话结论
APIView.check_throttles() 遍历 throttle_classes,每个限流类 allow_request(request, view) 判断是否放行;不放行时 throttled() 计算等待时长,抛 Throttled 异常(429)并带 Retry-After。限流按缓存记录时间窗口内请求次数,key 由限流类按用户/IP/scope 生成。未配置限流类则不限制。
概念解释
- 限流保护接口不被高频刷爆,与认证权限正交:即使已认证也可能被限流。
- 限流状态存缓存后端,不依赖数据库。
原理流程
- 权限通过后
check_throttles遍历限流类。 - 每类读取缓存历史请求记录,判断窗口内是否超限。
- 超限抛
Throttled;放行则记录本次请求时间戳。
代码或图示
from rest_framework.throttling import UserRateThrottle
class ArticleViewSet(viewsets.ModelViewSet):
throttle_classes = [UserRateThrottle]
throttle_scope = "article"
常见误区
- 把限流当安全认证,认为限流通过就是合法请求;限流只控频率,身份仍由认证权限负责。
- 限流记录不清理,缓存只增不减;窗口过期后记录应可被淘汰。
追问
- 限流在哪一步执行?答:
initial()中权限检查之后、动作分发之前。 - 多个限流类如何叠加?答:AND 关系,任一限流类超限即 429。
04.7.17.2-028 AnonRateThrottle/UserRateThrottle/ScopedRateThrottle 分别按什么限流?
一句话结论
AnonRateThrottle 按匿名用户的客户端 IP 限流,UserRateThrottle 按已认证用户主键限流;ScopedRateThrottle 按视图 throttle_scope 命名的配额限流,同一用户在不同接口可配不同阈值。前两者 key 身份固定,后者通过 scope 把阈值与接口绑定,适合分级限流。
概念解释
- 匿名无用户标识,只能退到 IP;IP 可被代理池轮换,限流精度有限。
- scope 阈值在
DEFAULT_THROTTLE_RATES按名称配置。
原理流程
- 限流类
get_cache_key生成 key:匿名 IP / 用户 pk / scope + 标识。 - 读取缓存窗口内请求次数。
- 比对阈值决定放行或限流。
代码或图示
class ExportViewSet(viewsets.ReadOnlyModelViewSet):
throttle_classes = [ScopedRateThrottle]
throttle_scope = "export"
常见误区
- 匿名接口用
UserRateThrottle,未登录时取不到用户标识,退化为不可用或按匿名处理;匿名场景选AnonRateThrottle。 - 多个接口共用同一 scope,阈值互相挤占;高频导出与普通查询分开命名 scope。
追问
- 未登录用户
UserRateThrottle怎么处理?答:通常按匿名标识处理,语义上更推荐AnonRateThrottle。 - scope 名称在哪配阈值?答:
settings.py的DEFAULT_THROTTLE_RATES字典,键为 scope 名。
04.7.17.2-029 限流使用什么缓存后端?如何配置?
一句话结论
DRF 限流记录存在 Django 缓存框架中,默认使用 THROTTLE_CACHE 指定的缓存别名,未配置则用默认缓存(CACHES["default"])。单机可用本地内存缓存,多副本部署应换 Redis 等共享缓存,否则各副本独立计数,实际阈值被放大。缓存失效时间由限流窗口派生,过期记录自动淘汰。
概念解释
- 限流与 Django cache 体系复用,可切换 backend 而不改限流类。
- 本地内存缓存不共享、不持久,重启清零。
原理流程
- 限流类通过
THROTTLE_CACHE别名取缓存连接。 - 读写请求时间戳列表与计数。
- 窗口外记录在淘汰时清理。
代码或图示
REST_FRAMEWORK = {
"DEFAULT_THROTTLE_CLASSES": ["rest_framework.throttling.UserRateThrottle"],
"DEFAULT_THROTTLE_RATES": {"user": "100/min"},
}
# THROTTLE_CACHE 在 settings 中指向 caches 别名(待确认:配置键名以 DRF 3.1x 为准)
常见误区
- 多副本用默认本地内存缓存,每副本各限 100/min,整体 300/min 才触发;分布式必须共享缓存。
- 缓存后端不可用时限流抛错导致接口 500;缓存故障应降级放行或按业务策略处理。
追问
- 限流缓存能和业务缓存共用别名吗?答:可以,但建议独立别名便于淘汰策略与监控隔离。
- 缓存里存什么数据?答:cache key 下保存窗口内请求时间戳列表(或计数 + 起始时间)。
04.7.17.2-030 限流速率配置 DEFAULT_THROTTLE_RATES 与 scope 怎么配合?
一句话结论
DEFAULT_THROTTLE_RATES 字典定义命名阈值,格式 "数量/周期",周期支持 second/minute/hour/day;UserRateThrottle/AnonRateThrottle 用固定键 user/anon,ScopedRateThrottle 用视图 throttle_scope 作为字典键。视图 throttle_scope 必须在速率字典中有对应项,否则该 scope 不限制或报错(按版本行为)。
概念解释
- 速率配置与限流类解耦:改阈值不动代码。
- 周期单位是 DRF 解析的后缀,不是任意表达式。
原理流程
- 限流类取自身 scope 名(user/anon/自定义)。
- 从速率字典解析数量与周期长度。
- 换算成缓存窗口与时间戳判定。
代码或图示
REST_FRAMEWORK = {
"DEFAULT_THROTTLE_RATES": {
"anon": "10/min",
"user": "100/min",
"export": "5/hour",
}
}
常见误区
- 速率写法
"100/m"等缩写不被识别;周期后缀必须用完整minute等单位。 - 只配全局速率不配视图 scope,
ScopedRateThrottle找不到对应键;新增 scope 同步更新速率字典。
追问
- 阈值能按用户等级区分吗?答:自定义限流类按用户角色取不同速率,或在
allow_request内分支。 - 速率修改需要重启吗?答:缓存与设置在进程启动时读取,改 settings 需重启服务生效。
04.7.17.2-031 DRF 默认限流用的是什么算法?
一句话结论
DRF 内置限流类基于缓存实现固定窗口(或滚动时间戳列表)算法:在 key 下保存窗口内请求时间戳,超出窗口的记录剔除,计数达到阈值即拒绝。它不是令牌桶或漏桶,不做平滑排队;默认实现适合粗粒度频率控制,不适合需要严格突发控制的场景。窗口长度由速率配置换算,记录存储在缓存后端。
概念解释
- 固定窗口在窗口边界可能出现双倍突发(窗口末尾 + 下窗口开头)。
- 时间戳列表方式接近滑动窗口,但实现简单、精度依赖缓存读写。
原理流程
allow_request取当前时间与缓存历史时间戳。- 剔除窗口外记录,统计窗口内次数。
- 未超限追加当前时间戳写回缓存;超限返回 False。
代码或图示
class SimpleThrottle(BaseThrottle):
def allow_request(self, request, view):
self.key = self.get_cache_key(request, view)
self.history = self.cache.get(self.key, [])
now = self.timer()
self.history = [t for t in self.history if now - t < self.duration]
if len(self.history) >= self.num_requests:
return False
self.history.append(now)
self.cache.set(self.key, self.history, self.duration)
return True
常见误区
- 以为 DRF 限流是令牌桶;默认实现不预发令牌,突发流量在窗口内集中到达仍可能被限。
- 缓存时间戳列表在高并发下有读写竞争,计数可能略偏;精确限流需分布式原子脚本。
追问
- 固定窗口有什么缺点?答:窗口边界双倍突发,阈值边缘流量被误限。
- 内置限流类可换算法吗?答:继承
BaseThrottle重写allow_request与wait实现自定义算法。
04.7.17.2-032 多副本部署下分布式限流怎么实现?
一句话结论
单机缓存各副本独立计数,阈值被副本数放大;分布式限流要把计数放到共享存储(Redis),用原子操作保证计数准确:固定窗口用 INCR + 过期时间,滑动窗口用 ZSET 按时间戳排序清理,令牌桶用 Lua 脚本补充与取令牌。限流 key 按用户/IP/scope 生成,所有副本读写同一 Redis 实例或集群。
概念解释
- 共享存储解决计数一致性,原子脚本解决并发竞争。
- Redis 不可用时的降级策略要预先约定(放行或拒绝)。
原理流程
- 请求到达生成限流 key。
- Redis 原子脚本读取/更新窗口计数或令牌数。
- 超限返回 429,放行则记录请求。
代码或图示
-- 令牌桶示意:key 下存 last_refill 与 tokens
local tokens = tonumber(redis.call("hget", KEYS[1], "tokens"))
local last = tonumber(redis.call("hget", KEYS[1], "last"))
-- 按时间补充令牌,再判断是否可取令牌
常见误区
- 用 Redis 但先读再写,高并发下计数超卖;必须用 Lua 或事务保证原子性。
- 限流 key 只按 IP,NAT 出口用户被互相牵连;已认证场景优先按用户标识。
追问
- 滑动窗口在 Redis 怎么存?答:ZSET 成员为时间戳,按分数范围清理旧记录并计数。
- 分布式限流还需要本地限流吗?答:可做两层:本地粗拦挡明显刷量,Redis 做精确配额。
04.7.17.2-033 限流响应的 429 与 Retry-After 如何返回?
一句话结论
超限抛 Throttled 异常,默认状态码 429 Too Many Requests;异常处理器生成响应,wait() 方法返回建议等待秒数,写入 Retry-After 响应头。客户端按该头等待后重试;响应体 detail 说明限流原因。Throttled 可自定义 detail 与 wait 时长。
概念解释
- 429 是标准限流状态码,
Retry-After是标准重试等待头。 - 与 503 不同:429 明确是频率限制,服务本身可用。
原理流程
- 限流类
allow_request返回 False。 - 视图调
throttled(request, wait)抛Throttled(wait=...)。 - 异常处理器渲染 429 响应并附
Retry-After。
代码或图示
from rest_framework.exceptions import Throttled
raise Throttled(detail="请求过于频繁,请稍后再试", wait=30)
常见误区
- 限流失败返回 403 或 500,客户端无法识别为可重试的频率限制;状态码必须用 429。
- 不返回
Retry-After,客户端盲目立即重试形成重试风暴;等待时长应随窗口剩余时间给出。
追问
wait()返回什么单位?答:秒数,供Retry-After头使用。- 前端收到 429 怎么处理?答:按
Retry-After退避重试,指数退避避免集中重试。
04.7.17.2-034 如何编写自定义限流类?
一句话结论
继承 BaseThrottle,实现 allow_request(request, view) 返回布尔值,wait() 返回建议等待秒数;在 get_cache_key 中按业务标识生成缓存 key,速率从 DEFAULT_THROTTLE_RATES 或视图 scope 读取。自定义类可按用户等级、接口类型、请求来源分流阈值,注册到 throttle_classes 或全局默认。
概念解释
- 限流类与认证/权限一样是可插拔策略。
- 缓存读写通过
self.cache与配置的缓存别名完成。
原理流程
- 构造时解析速率与窗口时长。
allow_request生成 key、读历史、判超限、记录请求。- 超限由视图抛
Throttled,wait给出剩余等待。
代码或图示
class RoleThrottle(BaseThrottle):
def get_cache_key(self, request, view):
ident = request.user.pk if request.user.is_authenticated else self.get_ident(request)
return f"throttle:{view.throttle_scope}:{ident}"
def allow_request(self, request, view):
self.key = self.get_cache_key(request, view)
self.history = self.cache.get(self.key, [])
self.now = self.timer()
# 剔除时间窗口之外的历史记录
while self.history and self.history[-1] <= self.now - self.duration:
self.history.pop()
if len(self.history) >= self.num_requests:
return self.throttle_failure()
return self.throttle_success()
def wait(self):
if not self.history:
return None
return self.duration - (self.now - self.history[0])
常见误区
- 自定义类忘记实现
wait,429 响应缺Retry-After;默认wait可返回None。 - 限流 key 包含可变或高基数字段(如请求 ID),每次请求独立计数,限流失效。
追问
- 自定义限流类怎么取速率?答:解析
view.throttle_scope对应DEFAULT_THROTTLE_RATES,或在类内写死/读配置。 - 限流类能访问数据库吗?答:可以但应避免,判定标识优先从请求与缓存取。
04.7.17.2-035 限流 key 如何生成?get_cache_key 负责什么?
一句话结论
get_cache_key(request, view) 生成缓存键,标识「谁在哪个接口上被限流」:匿名用客户端 IP(get_ident),已认证用用户主键,Scoped 类拼接 scope 前缀。key 结构通常为 throttle:<scope>:<ident>,保证不同接口、不同身份配额互不干扰。key 生成是限流隔离粒度的关键设计。
概念解释
- 同一用户跨接口是否共享配额由 key 是否含 scope 决定。
- IP 提取要考虑反向代理头(
X-Forwarded-For)与可信代理配置。
原理流程
- 判断认证状态选择标识来源。
- 拼接 scope 与标识形成 key。
- 缓存读写都以该 key 为命名空间。
代码或图示
def get_cache_key(self, request, view):
ident = request.user.pk if request.user.is_authenticated else self.get_ident(request)
return f"throttle:{view.throttle_scope}:{ident}"
常见误区
- 取 IP 直接用
request.META["REMOTE_ADDR"],部署在代理后拿到的是代理 IP,所有用户共享一个 key;需配置可信代理头解析。 - key 不含 scope,全接口共用一个配额,普通查询挤占导出接口限额。
追问
get_ident默认取什么?答:客户端 IP 地址,匿名限流的基础标识。- 多租户怎么加隔离?答:key 中追加租户 ID,避免跨租户配额混淆。
04.7.17.2-036 限流如何依赖认证结果?匿名与登录用户分别按什么计数?
一句话结论
限流在认证之后执行,因此能区分身份:已认证按用户主键计数,匿名按 IP 计数。UserRateThrottle 对已认证用户用 pk,未登录回退匿名标识;AnonRateThrottle 只对匿名生效。认证状态决定限流 key 的身份维度,也决定阈值字典使用 user 还是 anon 键。
概念解释
- 先认证后限流的顺序使配额可以按身份发放,避免匿名与登录互相挤占。
- 未认证接口通常同时挂匿名与用户限流类做两层控制。
原理流程
initial完成认证,request.user确定。- 限流类按认证状态选标识生成 key。
- 匹配对应速率阈值计数。
代码或图示
throttle_classes = [AnonRateThrottle, UserRateThrottle]
# 匿名受 anon 阈值限制,登录后受 user 阈值限制,两类互不影响
常见误区
- 认证顺序被调换,限流先于认证执行,拿不到用户标识,所有请求按 IP 计数。
- 把已认证用户也按 IP 限流,同 NAT 下多用户互相牵连;登录场景应按用户 pk。
追问
- 同一用户换 IP 会重置配额吗?答:按用户 pk 计数不会;按 IP 计数会,标识维度决定隔离性。
- 限流能识别伪造用户身份吗?答:不能,身份真实性由认证类保证,限流只使用认证结果。
04.7.17.2-037 DRF 三种分页方式分别是什么?
一句话结论
PageNumberPagination 按页码 + 每页条数切片(?page=2&page_size=20),直观但深度分页性能差;LimitOffsetPagination 按偏移量 + 条数(?limit=20&offset=40),灵活但偏移越大扫描越慢;CursorPagination 按不透明游标定位,基于排序字段定位上一页/下一页,适合大数据量稳定翻页,不支持跳转到指定页。
概念解释
- 页码/偏移分页依赖位置计算,深翻页
OFFSET成本高;游标分页基于索引键定位,避免大偏移。 - 三种分页器都实现
paginate_queryset与get_paginated_response。
原理流程
- 分页器解析请求参数确定当前页范围。
- 对查询集切片取当前页对象。
- 序列化后包装分页元数据返回。
代码或图示
from rest_framework.pagination import PageNumberPagination, LimitOffsetPagination, CursorPagination
# 游标分页要求查询集有稳定唯一排序字段
class CursorPagination(CursorPagination):
ordering = "-created_at"
page_size = 20
常见误区
- 数据频繁新增/删除时用页码分页,翻页重复或遗漏记录;实时流场景选游标分页。
- 游标分页字段不唯一(如纯
created_at同毫秒多条),翻页可能漏数据;排序键应唯一或加主键兜底。
追问
- 哪种分页支持跳转到第 N 页?答:页码与偏移分页支持;游标分页只有上一页/下一页。
- 大数据量深翻页用哪种?答:游标分页,避免大
OFFSET扫描。
04.7.17.2-038 page_size/page_size_query_param/max_page_size 如何配置?
一句话结论
page_size 是默认每页条数;page_size_query_param 开启前端通过查询参数覆盖每页条数(如 ?page_size=50);max_page_size 限制前端可请求的最大条数,防止超大页拖垮服务。三者配合:默认值保底,参数可调,上限兜底。分页器类在视图 pagination_class 或全局 DEFAULT_PAGINATION_CLASS 配置。
概念解释
- 放开
page_size_query_param必须同时设max_page_size,否则前端可请求全量。 - 页大小影响单次序列化对象数与响应体积。
原理流程
- 分页器读默认
page_size。 - 若配置了查询参数名,从
request.query_params取覆盖值。 - 覆盖值超过
max_page_size时截断到上限。
代码或图示
class ArticlePagination(PageNumberPagination):
page_size = 20
page_size_query_param = "page_size"
max_page_size = 100
常见误区
- 只设
page_size_query_param不设max_page_size,前端传page_size=10000一次拉全量,内存与序列化压力骤增。 - 全局默认页过大,小列表接口也返回大量数据;按接口需要在视图级覆盖分页器。
追问
- 未开启
page_size_query_param时前端改页大小生效吗?答:不生效,只能用默认page_size。 max_page_size超过默认page_size时以谁为准?答:请求参数不超过上限即可,默认值仍是page_size。
04.7.17.2-039 CursorPagination 的排序与稳定性怎么保证?
一句话结论
游标分页基于 ordering 指定的唯一稳定排序字段生成不透明游标(编码排序键与方向),下一页从游标位置之后继续取,不使用偏移量。排序字段必须有数据库索引且值唯一稳定:单字段同值会漏记录,推荐 (created_at, id) 这类组合;新增数据插入列表头部时,已翻页位置不会因新数据错位。
概念解释
- 游标是位置快照,不是页码;翻页依赖前后游标,不能跳跃。
- 排序方向与查询集默认排序不一致会导致游标定位错乱。
原理流程
- 首请求按
ordering取第一页并生成前后游标。 - 后续请求携带游标,解码出排序键边界。
- 查询集在边界之后(或之前)按同方向切片。
代码或图示
class FeedPagination(CursorPagination):
ordering = "-created_at"
cursor_query_param = "cursor"
page_size = 20
常见误区
- 排序字段可空或重复,游标边界把同值记录拆分到两页造成漏读;排序键选非空唯一字段或组合主键。
- 查询集在视图层又叠加
order_by覆盖分页器排序,游标解码与实际顺序不一致,翻页异常。
追问
- 游标里编码了什么?答:排序键值与翻页方向,经编码后不透明暴露给前端。
- 游标分页能按多字段排序吗?答:
ordering可配字段列表,最终需保证组合唯一。
04.7.17.2-040 分页响应结构与自定义分页类怎么做?
一句话结论
默认分页响应含计数、上一页/下一页链接与当前页结果列表;自定义分页类继承对应分页器,重写 get_paginated_response 调整包装结构(如把结果放进 items、补充 total/has_more),同时保持 paginate_queryset 切片逻辑。全局分页器统一响应结构,视图级可换不同分页器。
概念解释
- 分页类负责切片与包装两件事,序列化仍由视图序列化器完成。
- 响应结构要前后端约定一致,schema 文档同步标注。
原理流程
paginate_queryset返回当前页查询集。- 视图序列化当前页数据。
get_paginated_response(data)包装分页元数据并返回响应。
代码或图示
class StandardPagination(PageNumberPagination):
def get_paginated_response(self, data):
return Response({
"total": self.page.paginator.count,
"page": self.page.number,
"page_size": self.get_page_size(self.request),
"items": data,
})
常见误区
- 只改响应包装不改切片,或反之;两个方法要配套,分页元数据与结果列表对应。
- 自定义分页响应丢掉下一页链接字段,前端无法继续翻页;按需保留导航信息。
追问
- 分页器能在 list 之外动作使用吗?答:框架约定在 list 动作调用,其他动作手动调分页方法需自行装配上下文。
- 响应里的上一页/下一页 URL 怎么生成?答:分页器通过
request与reverse/查询参数构造绝对或相对链接。
04.7.17.2-041 全局分页配置与视图级覆盖如何工作?
一句话结论
全局默认分页器在 DEFAULT_PAGINATION_CLASS 与 PAGE_SIZE 配置;视图类 pagination_class 属性整体替换全局分页器,设为 None 关闭分页。分页器在 list 动作中被 ListModelMixin 调用,retrieve 等单对象动作不经过分页。需要不同分页策略的接口在视图级单独指定。
概念解释
- 全局兜底统一默认行为,视图级按数据量与场景裁剪。
- 关闭分页的接口要自行控制返回量级。
原理流程
- 视图取
pagination_class,缺省用全局默认。 - list 动作实例化分页器切片查询集。
- 包装分页响应或返回全量序列化结果。
代码或图示
# settings.py
REST_FRAMEWORK = {
"DEFAULT_PAGINATION_CLASS": "rest_framework.pagination.PageNumberPagination",
"PAGE_SIZE": 20,
}
# 视图级关闭
class ExportViewSet(viewsets.ReadOnlyModelViewSet):
pagination_class = None
常见误区
- 视图级
pagination_class = None后仍期待分页元数据,响应变成纯列表,前端解析报错。 - 全局分页器页大小过大,批量下拉/导出接口被迫分页;这类接口视图级关闭分页并做量级控制。
追问
- 分页器实例每请求新建吗?答:是,list 动作内按请求参数装配。
- 全局
PAGE_SIZE与分页器page_size谁优先?答:分页器属性优先,全局PAGE_SIZE作为缺省兜底。
04.7.17.2-042 哪些场景应该关闭分页或不分页?
一句话结论
导出全量报表、下拉选项树、字典枚举、批量同步、内部任务拉取等场景不分页;关闭分页后必须控制数据量级:流式导出、分批处理、限制最大返回数,避免全量序列化撑爆内存。公开下拉接口可按条件过滤后返回少量选项,而不是拉全表。
概念解释
- 分页是面向交互式浏览的保护,批量场景有自己的量级控制手段。
- 不分页不等于无限制,需要独立的上限或流式方案。
原理流程
- 判定接口用途:浏览翻页用分页,批量拉取走不分页方案。
- 不分页接口加量级上限或流式读取。
- 序列化分批进行,避免一次性实例化全量对象。
代码或图示
class OptionViewSet(viewsets.ReadOnlyModelViewSet):
queryset = Category.objects.filter(active=True).only("id", "name")
serializer_class = OptionSerializer
pagination_class = None
常见误区
- 字典表不分页直接
all(),表增长后接口响应膨胀;选项也要按条件过滤并限制条数。 - 导出接口在请求内同步序列化全量数据,大导出 OOM;应分批写文件或走异步任务。
追问
- 不分页怎么返回总数?答:独立计数查询(
count()),不要对全量序列化结果取长度。 - 大批量导出推荐同步还是异步?答:数据量大走异步任务 + 文件下载,同步接口只提交导出请求。
04.7.17.2-043 DjangoFilterBackend 与 FilterSet 如何使用?
一句话结论
DjangoFilterBackend 把查询参数映射成 ORM 过滤条件,过滤规则定义在 FilterSet 子类中:声明可过滤字段、查找类型(精确、包含、区间、下拉多选),后端在 filter_queryset 时按 FilterSet 过滤查询集。视图配置 filter_backends 并指定 filterset_fields 或自定义 filterset_class。
概念解释
- FilterSet 是声明式过滤声明,底层生成
filter(**条件)查询集。 - 与 SearchFilter 的模糊搜索不同,FilterSet 做结构化条件过滤。
原理流程
- 后端从
request.query_params提取参数。 - FilterSet 校验参数并构造过滤查询集。
- 返回过滤后的 QuerySet 交给分页/序列化。
代码或图示
from django_filters.rest_framework import DjangoFilterBackend, FilterSet
class ArticleFilterSet(FilterSet):
class Meta:
model = Article
fields = ["status", "author", "category"]
class ArticleViewSet(viewsets.ReadOnlyModelViewSet):
queryset = Article.objects.all()
filter_backends = [DjangoFilterBackend]
filterset_class = ArticleFilterSet
常见误区
filterset_fields直接暴露模型全部字段可过滤,未加索引的字段成为全表扫描入口;只开放必要字段并核对索引。- FilterSet 方法过滤里返回未过滤查询集,参数被静默忽略;显式构造条件。
追问
- FilterSet 依赖哪个包?答:
django-filter,需加入INSTALLED_APPS并在 DRF 后端配置引用。 - 区间过滤怎么写?答:FilterSet 字段用
NumberFilter(lookup_expr="gte")/lte或DateFromToRangeFilter。
04.7.17.2-044 SearchFilter 与 search_fields 语法怎么用?
一句话结论
SearchFilter 对 search_fields 列出的字段做模糊搜索,查询参数默认 ?search=关键词;字段前缀控制查找类型:^ 开头匹配、= 精确、@ 全文检索(依赖数据库)、无前缀包含。多字段按 OR 组合,关键词分词后匹配。它适合简单关键词检索,复杂搜索应接搜索引擎。
概念解释
- 搜索是文本包含匹配,与 FilterSet 的结构化条件互补。
search_fields可跨关系字段(如author__username)。
原理流程
- 后端取
search查询参数。 - 按
search_fields构造 OR 查找条件。 - 查询集过滤后进入分页与序列化。
代码或图示
from rest_framework.filters import SearchFilter
class ArticleViewSet(viewsets.ReadOnlyModelViewSet):
queryset = Article.objects.all()
filter_backends = [SearchFilter]
search_fields = ["title", "^body", "author__username"]
常见误区
- 大表上对无索引文本字段做包含搜索,
LIKE '%kw%'全表扫描;文本检索量上来后迁全文索引或搜索引擎。 - 多词搜索被当成整体字符串;SearchFilter 的分词行为按后端实现,精确需求用 FilterSet 方法过滤。
追问
@前缀依赖什么?答:数据库全文检索能力(如 MySQL/FTS、PostgreSQL 全文索引),未配置则不可用。- 搜索字段能跨表吗?答:能,用双下划线关系路径,注意关联加载与索引。
04.7.17.2-045 OrderingFilter 与 ordering_fields 如何配置?
一句话结论
OrderingFilter 按 ordering 查询参数排序(如 ?ordering=-created_at,views),ordering_fields 白名单允许排序的字段;未列入白名单的排序参数被忽略,防止注入任意字段排序。默认排序可在查询集 order_by 或分页器 ordering 设定。排序字段应核对数据库索引,否则排序代价随数据量上升。
概念解释
- 白名单同时是安全控制:避免前端传入内部字段或表达式排序。
- 多字段排序按参数顺序生效,负号表示降序。
原理流程
- 后端解析
ordering参数拆分字段列表。 - 与
ordering_fields白名单校验,非法字段丢弃。 - 对查询集应用
order_by,再分页。
代码或图示
from rest_framework.filters import OrderingFilter
class ArticleViewSet(viewsets.ReadOnlyModelViewSet):
queryset = Article.objects.all().order_by("-created_at")
filter_backends = [OrderingFilter]
ordering_fields = ["created_at", "views", "title"]
常见误区
- 不设
ordering_fields直接开放全部字段排序,内部字段被暴露且可能命中无索引列;白名单必填。 - 排序字段与游标分页排序冲突,翻页顺序错乱;两者排序口径要统一。
追问
- 降序怎么传?答:字段名前加负号,如
?ordering=-created_at。 - 默认排序在哪里设?答:查询集
order_by、视图ordering属性或分页器ordering。
04.7.17.2-046 自定义 FilterSet 如何声明字段、lookup_expr 与方法过滤?
一句话结论
FilterSet 字段显式声明过滤列与查找类型:filterset.Filter 子类(NumberFilter、CharFilter、DateFilter 等)配 field_name、lookup_expr(exact/icontains/gte/lte 等);method 参数挂自定义函数,签名 (queryset, name, value) 返回过滤后的查询集。方法过滤适合跨字段、聚合或业务规则条件,声明式字段适合简单等值与区间。
概念解释
field_name指定模型字段,lookup_expr指定 ORM 查找表达式。- 方法过滤可访问请求上下文吗?FilterSet 可通过
self.request取请求(后端装配时注入)。
原理流程
- FilterSet 实例化并绑定查询参数。
- 声明字段按 lookup 构造条件;方法字段调用自定义函数。
- 合并条件返回最终查询集。
代码或图示
class ArticleFilterSet(FilterSet):
keyword = CharFilter(field_name="title", lookup_expr="icontains")
min_views = NumberFilter(field_name="views", lookup_expr="gte")
recent = BooleanFilter(method="filter_recent")
def filter_recent(self, queryset, name, value):
if value:
return queryset.filter(created_at__gte=timezone.now() - timedelta(days=7))
return queryset
class Meta:
model = Article
fields = ["status", "category"]
常见误区
- 方法过滤函数忘记返回查询集,或返回未过滤的原集,条件被静默忽略。
lookup_expr用错类型(数值字段配icontains),生成非法 ORM 条件报错;按字段类型选查找表达式。
追问
- FilterSet 怎么拿到当前请求?答:DjangoFilterBackend 装配时把
request挂到 FilterSet,方法内读self.request。 - 多选等值过滤怎么写?答:
BaseInFilter配合lookup_expr="in",或字段声明lookup_expr="in"接收列表参数。
04.7.17.2-047 过滤后端链的执行顺序与 filter_queryset 是什么关系?
一句话结论
filter_backends 是有序列表,filter_queryset(queryset) 按列表顺序逐个调用后端的 filter_queryset(request, queryset, view),前一个后端的输出作为后一个的输入。顺序影响条件叠加结果:先结构化过滤再搜索排序通常更高效;全局后端与视图级后端合并时,视图级列表整体替换全局配置。
概念解释
- 后端链是责任链模式,每个后端只负责一类过滤。
filter_queryset是GenericAPIView提供的汇总入口,list 与get_object都经过它。
原理流程
get_queryset返回基础查询集。- 遍历
filter_backends依次过滤。 - 最终查询集交给分页或单对象查找。
代码或图示
filter_backends = [DjangoFilterBackend, SearchFilter, OrderingFilter]
# 先按结构化条件过滤,再关键词搜索,最后排序
常见误区
- 以为全局后端会与视图级后端追加合并;实际视图级整体替换,遗漏必要后端导致过滤失效。
- 排序后端放在过滤前执行,先排序再过滤浪费排序成本;条件过滤在前更合理。
追问
- 自定义后端实现哪个方法?答:
filter_queryset(self, request, queryset, view),返回过滤后的 QuerySet。 - 后端链能短路吗?答:不能,各后端依次执行;需要强条件过滤放查询集层。
04.7.17.2-048 过滤、权限、分页在 list 链路中分别处于什么位置?
一句话结论
list 链路顺序:认证 → 视图级权限 → 限流 → get_queryset 基础查询集 → filter_queryset 过滤后端(结构化/搜索/排序)→ 分页切片 → 序列化当前页 → 分页包装响应。对象级权限不在 list 链路,而在 get_object 阶段;过滤控制数据范围,权限控制动作与对象闸门,分页控制单次返回量级。
概念解释
- 三层职责分离:权限回答能不能访问,过滤回答返回哪些记录,分页回答返回多少条。
- 定位问题按链路分层:401/403 查认证权限,数据不对查过滤,响应过大查分页。
原理流程
- 前置横切通过后进入 list 动作。
- 查询集经过滤后端裁剪。
- 分页器切片,序列化当前页并包装响应。
代码或图示
认证 → 权限 → 限流 → get_queryset → filter_queryset
→ paginate_queryset → get_serializer(many=True) → 分页响应
常见误区
- 把归属过滤写进权限类,list 仍返回全量;归属条件属于查询集/过滤层。
- 在序列化器里做全量过滤,绕过后端链与分页,数据边界失控。
追问
- list 为什么不做对象级权限?答:逐条判定成本高,框架约定列表可见性由查询集过滤承担。
- 过滤条件未生效先查哪里?答:
filter_backends配置、FilterSet 字段声明、查询集是否被后续覆盖。
04.7.17.2-049 搜索与过滤字段的性能和索引要注意什么?
一句话结论
等值过滤、排序、外键关联字段应建数据库索引;icontains/LIKE '%kw%' 前缀通配无法用普通 B-Tree 索引,大表需全文索引或搜索引擎;区间过滤字段复合索引顺序要与查询条件匹配。上线前用查询计划核对扫描行数,避免列表接口随数据量退化。
概念解释
- 索引服务于过滤、连接、排序三类操作;无索引字段成为全表扫描入口。
- 复合索引遵循最左前缀,等值在前、区间在后。
原理流程
- 梳理开放给前端的过滤/搜索/排序字段。
- 为高频条件与排序列建索引,核对查询计划。
- 文本检索量增长后迁移全文索引或外部搜索引擎。
代码或图示
class Article(models.Model):
status = models.CharField(max_length=16, db_index=True)
category = models.ForeignKey("Category", on_delete=models.CASCADE, db_index=True)
created_at = models.DateTimeField(db_index=True)
class Meta:
indexes = [models.Index(fields=["status", "created_at"])]
常见误区
- 给每个字段单独建索引,写入开销与索引体积膨胀;按实际查询组合建复合索引。
- 排序字段无索引,
ORDER BY大表 filesort;排序列与过滤列组合评估索引。
追问
icontains能用索引吗?答:前缀通配LIKE 'kw%'可利用 B-Tree,包含通配%kw%通常不能。- 文本搜索量大了怎么演进?答:数据库全文索引过渡,最终接 Elasticsearch/OpenSearch 等搜索引擎。
04.7.17.2-050 如何防止前端排序字段注入?
一句话结论
OrderingFilter 通过 ordering_fields 白名单限制可排序字段,不在白名单内的参数被忽略;自定义过滤/排序也要维护字段映射表,把前端传入的字段名映射到安全的 ORM 字段,禁止直接把查询参数拼进 order_by 或 filter 表达式。排序参数不支持双下划线跨层暴露内部字段。
概念解释
- 注入风险来自把用户输入直接拼进 ORM 表达式或原始 SQL。
- 白名单是最小权限原则在查询层的落地。
原理流程
- 解析
ordering参数拆分字段。 - 与白名单集合校验,非法字段丢弃。
- 合法字段映射到 ORM 列后应用
order_by。
代码或图示
ORDERING_MAP = {"created": "created_at", "views": "views"}
def apply_ordering(queryset, ordering):
field = ORDERING_MAP.get(ordering.lstrip("-"))
if not field:
return queryset
return queryset.order_by(("-" if ordering.startswith("-") else "") + field)
常见误区
- 直接
queryset.order_by(request.query_params["ordering"]),传入内部字段或异常列导致报错甚至信息暴露。 - 白名单只校验字段名不校验方向符号,负号处理遗漏导致排序方向反转。
追问
- 排序参数能传多字段吗?答:可以,逗号分隔逐个过白名单,任一非法即丢弃对应字段。
- 防注入还要注意哪些查询入口?答:FilterSet 方法过滤、自定义查询参数、原始 SQL 接口都要做白名单或参数化。
04.7.17.2-051 内容协商如何选择渲染器?
一句话结论
DRF 内容协商(ContentNegotiation)结合请求 Accept 头、视图 renderer_classes 与全局默认渲染器列表,选出可接受的媒体类型与对应渲染器;协商结果写入请求上下文,finalize_response 用该渲染器编码响应体并设置 Content-Type。解析器选择则依据 Content-Type 头确定输入解析方式。
概念解释
- 协商分输出渲染与输入解析两侧,分别配置渲染器与解析器列表。
- 渲染器按列表顺序匹配,首个可接受者胜出。
原理流程
perform_content_negotiation读取 Accept 与渲染器列表。- 匹配媒体类型确定渲染器与解析器。
- 响应阶段渲染器
render产出响应体。
代码或图示
from rest_framework.renderers import JSONRenderer, BrowsableAPIRenderer
class ArticleView(APIView):
renderer_classes = [JSONRenderer, BrowsableAPIRenderer]
常见误区
- 渲染器列表顺序决定默认输出,把浏览渲染器放前面可能导致接口客户端拿到 HTML 而非 JSON。
- 自定义渲染器未声明
media_type/format,协商无法匹配媒体类型。
追问
- 协商结果存在哪里?答:
request.accepted_renderer与request.accepted_media_type。 - 不支持的 Accept 返回什么?答:内容协商失败返回 406 Not Acceptable。
04.7.17.2-052 BrowsableAPIRenderer 在生产环境有什么风险?如何关闭?
一句话结论
BrowsableAPIRenderer 把响应渲染成可点击的 HTML 浏览页,展示接口列表、表单与可提交按钮;生产环境保留它会暴露接口结构、参数与示例数据,扩大信息泄露面,且浏览器访问可能触发写动作。生产配置只保留 JSONRenderer:全局 DEFAULT_RENDERER_CLASSES 移除浏览渲染器,或视图级 renderer_classes = [JSONRenderer]。
概念解释
- 浏览渲染器是开发调试工具,不是生产渲染目标。
- 它还会在 OPTIONS/GET 页面暴露权限与序列化字段信息。
原理流程
- 开发环境渲染器列表含 BrowsableAPI,浏览器访问得到 HTML 页面。
- 生产环境全局配置只挂 JSONRenderer。
- 响应统一按 JSON 编码,不再生成浏览表单。
代码或图示
REST_FRAMEWORK = {
"DEFAULT_RENDERER_CLASSES": [
"rest_framework.renderers.JSONRenderer",
],
}
常见误区
- 生产用
DEBUG=False就以为浏览页关闭;BrowsableAPIRenderer 是否启用取决于渲染器配置,与 DEBUG 无关。 - 只在部分视图关闭浏览渲染器,其他接口仍可被浏览器探测;应在全局生产配置统一移除。
追问
- 内部后台还需要浏览页怎么办?答:按环境区分配置,内网管理后台可单独挂浏览渲染器,公网接口关闭。
- 浏览渲染器会自动提交写操作吗?答:页面提供表单按钮,登录态下点击可触发 POST/PUT/DELETE,属于暴露面。
04.7.17.2-053 JSONRenderer 的缩进与编码行为如何控制?
一句话结论
JSONRenderer 默认输出紧凑 JSON,UTF-8 编码;可通过 indent 参数控制缩进(开发调试美化输出),ensure_ascii 决定非 ASCII 字符是否转义。响应 Content-Type 为 application/json。中文等字符在默认配置下按 UTF-8 原样输出,避免 \uXXXX 转义影响可读性。
概念解释
- 紧凑输出体积小,适合生产;缩进输出便于调试但增大体积。
- 编码由渲染器与 Django 响应编码共同保证。
原理流程
- 渲染器接收
Response.data。 - 按配置调用 JSON 序列化(缩进、ensure_ascii)。
- 写入响应体并设置媒体类型与字符集。
代码或图示
from rest_framework.renderers import JSONRenderer
class PrettyJSONRenderer(JSONRenderer):
indent = 2
常见误区
- 生产开启大缩进,响应体积无谓增大;缩进只在调试环境使用。
- 中文被转义成
\uXXXX后前端仍可解析,但日志与排查可读性差;按需关闭 ASCII 转义。
追问
- JSON 日期字段输出什么格式?答:由序列化器
DateTimeField格式控制,默认 ISO 8601 字符串。 - 渲染器能输出其他格式吗?答:可自定义渲染器产出 XML、CSV 等,按协商媒体类型匹配。
04.7.17.2-054 全局渲染器配置与视图级 renderer_classes 如何覆盖?
一句话结论
全局默认渲染器在 DEFAULT_RENDERER_CLASSES 配置;视图类 renderer_classes 整体替换全局列表,与认证/权限一样是替换不是追加。需要纯 JSON 接口、CSV 导出或调试浏览页时在视图级指定对应渲染器;解析器同理由 parser_classes 与 DEFAULT_PARSER_CLASSES 配置。
概念解释
- 渲染器决定输出格式,解析器决定输入格式,两侧独立配置。
- 视图级覆盖便于个别接口使用特殊渲染/解析方式。
原理流程
- 视图读取
renderer_classes,缺省取全局默认。 - 内容协商在该列表内匹配媒体类型。
- 选定渲染器编码响应。
代码或图示
class ReportView(APIView):
renderer_classes = [CSVRenderer]
parser_classes = [MultiPartParser, FormParser]
常见误区
- 视图级只列一个渲染器,以为其他全局渲染器仍可用;实际全局被替换。
- 上传接口忘记挂
MultiPartParser,request.FILES解析为空,文件字段校验失败。
追问
- 解析器全局在哪配?答:
DEFAULT_PARSER_CLASSES,默认含 JSON、表单、多部分解析器(待确认:当前版本默认清单以文档为准)。 - 一个接口能同时返回 JSON 和 CSV 吗?答:可挂多个渲染器,按 Accept 协商选择。
04.7.17.2-055 认证、权限、限流在 initial() 中的完整执行顺序是什么?
一句话结论
initial() 标准顺序:版本解析 → 内容协商(解析器/渲染器)→ perform_authentication 认证装配身份 → check_permissions 视图级权限 → check_throttles 限流检查。对象级权限在后续 get_object 触发。认证先于权限,权限先于限流;前置任一步失败即抛异常短路,不进入动作方法。
概念解释
- 顺序保证后续环节能拿到身份信息,限流消耗在授权通过之后。
- 自定义基类重写
initial必须调super().initial(...)保留顺序。
原理流程
- 解析版本与协商内容格式。
- 认证写入
request.user/auth。 - 权限判定,通过后限流检查,再分发动作。
代码或图示
initial()
→ 版本 / 内容协商
→ perform_authentication
→ check_permissions
→ check_throttles
→ dispatch → action
常见误区
- 重写
initial把业务校验放在认证之前,匿名请求触发业务逻辑;前置横切必须先于业务。 - 调换权限与限流顺序,未授权请求也消耗限流配额,既浪费计数又掩盖授权失败。
追问
- 版本解析在认证之前吗?答:是,版本属于请求上下文解析,先于身份与授权。
check_object_permissions在initial里吗?答:不在主体,动作内get_object阶段调用。
04.7.17.2-056 匿名访问与权限放行如何组合判定?
一句话结论
权限判定基于认证结果:匿名用户 is_authenticated=False,命中 AllowAny 放行,命中 IsAuthenticated 拒绝(401),IsAuthenticatedOrReadOnly 对 GET/HEAD/OPTIONS 放行、写方法拒绝。组合判定由各权限类 AND 汇总;公开只读接口应显式配置放行权限,避免全局默认收紧后匿名被拦。
概念解释
- 匿名是认证结果,不是单独权限类。
- 安全方法(GET/HEAD/OPTIONS)通常视为只读,可对匿名开放。
原理流程
- 认证结束确定匿名/已认证状态。
- 权限类列表逐个判定。
- 全 True 放行,匿名命中认证要求转 401,已认证无权转 403。
代码或图示
from rest_framework.permissions import IsAuthenticatedOrReadOnly
class PublicArticleViewSet(viewsets.ReadOnlyModelViewSet):
permission_classes = [IsAuthenticatedOrReadOnly]
常见误区
- 公开接口忘记配
AllowAny,全局IsAuthenticated下匿名全部 401。 - 把匿名放行写进自定义权限却不限制方法,写动作也被匿名访问;按方法细分。
追问
- 匿名请求的
request.auth是什么?答:None。 - 只读方法如何识别?答:
request.method in ("GET", "HEAD", "OPTIONS"),DRF 提供SAFE_METHODS常量。
04.7.17.2-057 多认证源并存时 request.auth 取什么值?
一句话结论
request.auth 取首个成功认证类返回的二元组第二项:Token 认证返回 Token 实例,JWT 认证返回验证后的载荷(或令牌对象),Session/Basic 通常返回 None。多认证源下 auth 类型不统一,下游代码不能假设固定类型;响应日志与业务逻辑应先判断认证方式再使用 auth。
概念解释
- 认证成功即短路,后续认证类不再执行,
auth来自胜出认证类。 auth是凭证对象,用户信息始终在request.user。
原理流程
- 认证类按列表顺序尝试。
- 首个返回
(user, auth)的类胜出。 auth挂到请求供下游读取。
代码或图示
def get(self, request):
if request.auth is not None:
# 按认证类型读取凭证信息
pass
return Response({"user": request.user.username})
常见误区
- 假设
request.auth一定是 JWT 字典,Session 认证场景下为None,访问键抛异常。 - 在
auth上做授权判断;授权属于权限层,auth只携带凭证信息。
追问
- JWT 认证返回的 auth 是什么?答:simplejwt 通常返回 validated token 实例或载荷字典(待确认:具体类型以所装版本实现为准)。
- 能在响应里回传 auth 标识吗?答:可以记录认证方式与凭证标识,不要回传完整敏感凭证。
04.7.17.2-058 CORS 与 DRF 认证如何配合?Cookie 会话与 JWT 各注意什么?
一句话结论
跨域由 django-cors-headers 等中间件处理 CORS 头与预检请求,DRF 认证不负责跨域。Cookie 会话认证:跨域必须配置 Allow-Credentials、允许具体来源(不能用 * 携带凭证),并带 CSRF 头;JWT Bearer 模式:凭证放 Authorization 头,不依赖 Cookie,跨域相对简单,但令牌存储(本地存储/内存)要防范 XSS。
概念解释
- CORS 是浏览器层安全策略,服务端通过响应头放行;认证是身份校验,两者独立。
- 携带 Cookie 的跨域请求不能使用通配来源。
原理流程
- 浏览器先发 OPTIONS 预检,中间件返回 CORS 头。
- 实际请求带 Cookie/凭证头到达。
- DRF 认证类识别凭证,权限限流继续。
代码或图示
# CORS 配置示意(django-cors-headers)
CORS_ALLOW_CREDENTIALS = True
CORS_ALLOWED_ORIGINS = ["https://app.example.com"]
常见误区
- 配置
CORS_ALLOW_ALL_ORIGINS=True同时允许凭证,浏览器拒绝携带凭证的通配响应,登录态丢失。 - JWT 存浏览器本地存储后被 XSS 窃取;敏感客户端应权衡存储位置与令牌有效期。
追问
- 预检请求会经过 DRF 认证吗?答:OPTIONS 预检通常由 CORS 中间件直接响应,不进入业务视图认证。
- 为什么 Cookie 跨域要 CSRF?答:Cookie 自动携带,跨站伪造风险由 CSRF Token 防护,与 CORS 互补。
04.7.17.2-059 如何按接口分级配置限流阈值(scope 实战)?
一句话结论
用 ScopedRateThrottle 为不同接口命名 scope:普通查询宽松、写接口中等、导出/短信等高危接口严格。视图设 throttle_scope,DEFAULT_THROTTLE_RATES 按 scope 配阈值;也可组合多个限流类(匿名 + 用户 + 接口 scope)。分级避免高频查询挤占高危操作配额,阈值按业务容量与压测结果调整。
概念解释
- scope 是接口级配额命名空间,同一用户跨 scope 独立计数。
- 分级阈值要与接口成本(DB 负载、下游调用)匹配。
原理流程
- 视图声明
throttle_scope与限流类。 - 限流 key 拼接 scope 与身份标识。
- 速率字典按 scope 取阈值判定。
代码或图示
class SensitiveActionViewSet(viewsets.ViewSet):
throttle_classes = [ScopedRateThrottle]
throttle_scope = "sensitive"
# DEFAULT_THROTTLE_RATES = {"anon": "20/min", "user": "100/min", "sensitive": "5/min"}
常见误区
- 所有接口共用
user配额,批量导出把普通查询额度耗尽;高危动作单独 scope。 - 阈值拍脑袋不压测,宽松到失去保护意义,严格到误伤正常用户;以容量压测为依据。
追问
- 同一用户能受多个 scope 限制吗?答:组合多个限流类,各类独立计数,任一超限即 429。
- 管理员能免限流吗?答:自定义限流类按用户角色放宽或跳过
allow_request。
04.7.17.2-060 一次受保护 list 请求的完整链路是什么?
一句话结论
完整链路:请求进入视图 → initial 版本解析与内容协商 → 认证装配 request.user/auth → 视图级权限判定 → 限流检查 → 分发到 list 动作 → get_queryset 取基础查询集 → filter_queryset 走 FilterSet/Search/Ordering 后端 → 分页切片当前页 → get_serializer(many=True) 序列化 → 分页包装 → 渲染器输出 JSON。任一步失败由异常处理归一为 401/403/429/400 响应。
概念解释
- 这条链路串起认证、权限、限流、过滤、分页五个横切与数据层。
- 定位故障按状态码分层:401 认证、403 权限、429 限流、400 校验、500 服务端。
原理流程
- 前置横切:协商 → 认证 → 权限 → 限流。
- 数据编排:查询集 → 过滤 → 分页。
- 表示输出:序列化 → 包装 → 渲染。
代码或图示
request → dispatch → initial(协商/认证/权限/限流)
→ list → get_queryset → filter_queryset → paginate_queryset
→ get_serializer(many=True) → get_paginated_response → render
常见误区
- 接口被限流却先查序列化器代码;429 说明问题在配额与缓存计数,不在业务逻辑。
- 列表数据越权只查权限类;水平越权根因通常是查询集未按归属过滤。
追问
- 链路中哪一步决定返回哪些记录?答:
filter_queryset叠加查询集归属条件。 - 哪一步决定单次返回条数?答:分页器
paginate_queryset切片。
本节高频题
- 认证类契约与
authenticate返回值(002、013) - Token/Session/JWT 取舍与刷新(003、004、005、006、014)
- 匿名用户与
request.user(010、056) - 对象级权限调用时机(016、017、024)
- 权限与查询集过滤防越权(021)
- 401 与 403 语义(023、055)
- 限流类型与缓存后端(027、028、029)
- 分布式限流与 429 响应(031、032、033)
- 三种分页与页大小限制(037、038、039)
- FilterSet/Search/Ordering(043、044、045、046)
- 过滤后端链顺序(047、048)
- 排序注入白名单(050)
- 内容协商与 BrowsableAPI 生产风险(051、052)
- CORS 与认证配合(058)
- 受保护 list 全链路(060)