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

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 是对 Django HttpRequest 的惰性包装,认证结果缓存在请求对象上。
  • 认证与授权分离:回答「你是谁」与「你能不能做」是两套独立机制。

原理流程

  1. initial() 先完成内容协商与版本解析。
  2. perform_authentication 遍历认证类列表调用 authenticate。
  3. 首个成功认证写入 user/auth;未识别则继续,最终匿名兜底。

代码或图示

# 视图内读取认证结果
def get(self, request):
    user = request.user
    auth = request.auth  # Token 实例、JWT 载荷或 None
    return Response({"user": user.username})

常见误区

  • 以为认证成功就代表有权限;认证只识别身份,匿名或已认证用户都要再过权限类。
  • 多个认证类混用,前一个返回部分身份后短路,后续认证源不再尝试;顺序设计要明确主认证源。

追问

  • 认证结果缓存在哪里?答:request._user/request._auth 与 DRF Request 对象属性,单次请求内有效。
  • 不配置任何认证类默认是什么?答:由全局 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;禁止访问属于权限层职责。

原理流程

  1. 框架调用 authenticate(request) 传入 DRF 请求对象。
  2. 解析凭证(Header/Cookie/参数),校验有效性后构造用户对象。
  3. 失败按语义选择返回 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 中间件认证共享同一份会话数据。

原理流程

  1. 请求带 Cookie,Django 会话中间件加载会话。
  2. SessionAuthentication.authenticate 读取会话用户。
  3. 写操作经 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 并执行迁移。

原理流程

  1. 登录接口校验账号密码后 Token.objects.get_or_create(user=...)。
  2. 客户端后续请求在 Header 携带 Token。
  3. 认证类按 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,降低泄露窗口。

原理流程

  1. 登录接口校验凭证,simplejwt 生成 pair:access(短时)+ refresh(较长)。
  2. 客户端存 access,后续请求 Bearer 携带。
  3. 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 加入黑名单,否则旧凭证仍可换新。

原理流程

  1. 业务接口收到过期 access,返回 401 与过期提示。
  2. 客户端携带 refresh 请求刷新端点。
  3. 验签、查黑名单通过后签发新 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 编码,可被解码,不等于加密。

原理流程

  1. 请求头携带 Basic 编码串。
  2. 解码得到用户名密码,调 Django authenticate 校验。
  3. 成功返回 (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。因此列表首位是主认证源,后续是兼容源,顺序影响「凭证被谁解释」。

概念解释

  • 短路语义与权限类的「全部通过」不同,认证是「首个成功即止」。
  • 多源并存时要避免同一凭证被错误认证类先匹配。

原理流程

  1. perform_authentication 按列表迭代认证类。
  2. 每个类返回三元结果:成功/不识别/失败。
  3. 成功短路,不识别继续,失败中断。

代码或图示

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 认证类按约定返回。

原理流程

  1. 权限判定发现匿名且需要登录。
  2. 异常处理器构造 401 响应。
  3. 调认证类 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 不可调用模型实例方法,序列化时不要假设其有主键。

原理流程

  1. 认证遍历结束无成功结果。
  2. DRF 包装请求挂载匿名用户。
  3. 权限类读取 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 票据校验。
  • 认证类实例每次请求新建,不要在类属性上缓存请求状态。

原理流程

  1. 提取凭证并判断是否属于本认证源。
  2. 校验凭证有效性,加载对应用户。
  3. 按成功/不识别/失败三种语义返回或抛异常。

代码或图示

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 视图。
  • 同一项目可同时存在两套认证路径,数据模型一致。

原理流程

  1. 中间件栈先执行,加载会话用户到 request。
  2. DRF 视图 initial 执行认证类,按凭证覆盖或确认用户。
  3. 权限与业务代码读取 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。

原理流程

  1. 解析凭证:取不到对应 Header/Cookie → 返回 None。
  2. 取到凭证但验签/查库失败 → 抛 AuthenticationFailed。
  3. 成功返回 (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 做不到,必须有服务端记录。
  • 黑名单存储可用数据库或缓存,查询路径要轻量。

原理流程

  1. 登录签发凭证,记录 jti 或 Token 主键。
  2. 登出/吊销把凭证标识写入黑名单存储。
  3. 认证与刷新时先查黑名单,命中即拒绝。

代码或图示

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。

原理流程

  1. 视图初始化读取 authentication_classes,缺省取全局设置。
  2. 认证阶段按该列表执行。
  3. 视图级列表完全替换全局,不是追加。

代码或图示

# 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,子类按需覆盖。权限类只做放行/拒绝判定,不负责加载用户或查询数据范围。

概念解释

  • 视图级权限回答「这个用户能不能访问这个动作」,对象级回答「能不能操作这条记录」。
  • 权限是可插拔策略,全局与视图级均可配置类列表。

原理流程

  1. check_permissions 遍历权限类调 has_permission。
  2. get_object 取出对象后 check_object_permissions 遍历调 has_object_permission。
  3. 任一方法返回 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 兜底无权限)。

原理流程

  1. get_object 在过滤查询集上取单条。
  2. 对象存在后遍历权限类调 has_object_permission。
  3. 拒绝则抛 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 时权限名无法生成。

原理流程

  1. 全局或视图配置权限类列表。
  2. check_permissions 逐个调用 has_permission。
  3. 全部通过放行,任一拒绝 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。

原理流程

  1. 业务流程为对象给用户授予对象权限。
  2. get_object 取出对象后权限类调用 has_perm。
  3. 权限后端查对象权限记录,返回布尔结果。

代码或图示

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 不同动作权限不同的场景。

原理流程

  1. 视图读取 permission_classes 或调 get_permissions。
  2. 实例化权限类列表。
  3. 认证后 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 基于过滤后的查询集 + 对象权限;只做权限不做过滤,他人仍能在列表看到数据,只做过滤不做权限,手写视图可能绕过。

概念解释

  • 水平越权指访问同角色下不属于自己的记录,典型手段是改主键遍历。
  • 权限是兜底闸门,查询集是数据边界,二者互补。

原理流程

  1. get_queryset 按归属/状态过滤基础数据范围。
  2. filter_queryset 叠加过滤后端。
  3. 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;需要附带拒绝原因时在响应细节中补充。

概念解释

  • 常见自定义权限:资源归属、部门可见、角色 + 动作矩阵、只读安全方法放行。
  • 权限类无状态,可在多视图复用。

原理流程

  1. 判定动作级条件(认证、角色、方法)。
  2. 判定对象级条件(归属、共享、协作关系)。
  3. 返回布尔,框架汇总放行或拒绝。

代码或图示

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 判定:认证身份不成立时谈不上授权。
  • 客户端据状态码区分「重新登录」与「无权限提示」。

原理流程

  1. 认证阶段失败 → 401(带 WWW-Authenticate)。
  2. 认证成功后权限拒绝 → 403。
  3. 匿名命中要求认证的权限 → 框架按规则转 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 必须保持这一顺序。

原理流程

  1. 查询集过滤后 get() 取对象,失败抛 404。
  2. 对象存在才执行对象级权限遍历。
  3. 权限方法基于有效对象判定归属。

代码或图示

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 便于逐层叠加约束:认证 + 角色 + 归属。
  • 权限类按列表顺序执行,首个拒绝即短路。

原理流程

  1. check_permissions 遍历权限类。
  2. 每个 has_permission 结果汇总,全 True 放行。
  3. 任一 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() 顺序,不能调换认证与权限。

原理流程

  1. 解析版本、协商内容、确定解析器。
  2. 认证写入身份信息。
  3. 权限校验通过后执行限流检查,再分发动作方法。

代码或图示

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 生成。未配置限流类则不限制。

概念解释

  • 限流保护接口不被高频刷爆,与认证权限正交:即使已认证也可能被限流。
  • 限流状态存缓存后端,不依赖数据库。

原理流程

  1. 权限通过后 check_throttles 遍历限流类。
  2. 每类读取缓存历史请求记录,判断窗口内是否超限。
  3. 超限抛 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 按名称配置。

原理流程

  1. 限流类 get_cache_key 生成 key:匿名 IP / 用户 pk / scope + 标识。
  2. 读取缓存窗口内请求次数。
  3. 比对阈值决定放行或限流。

代码或图示

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 而不改限流类。
  • 本地内存缓存不共享、不持久,重启清零。

原理流程

  1. 限流类通过 THROTTLE_CACHE 别名取缓存连接。
  2. 读写请求时间戳列表与计数。
  3. 窗口外记录在淘汰时清理。

代码或图示

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 解析的后缀,不是任意表达式。

原理流程

  1. 限流类取自身 scope 名(user/anon/自定义)。
  2. 从速率字典解析数量与周期长度。
  3. 换算成缓存窗口与时间戳判定。

代码或图示

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 下保存窗口内请求时间戳,超出窗口的记录剔除,计数达到阈值即拒绝。它不是令牌桶或漏桶,不做平滑排队;默认实现适合粗粒度频率控制,不适合需要严格突发控制的场景。窗口长度由速率配置换算,记录存储在缓存后端。

概念解释

  • 固定窗口在窗口边界可能出现双倍突发(窗口末尾 + 下窗口开头)。
  • 时间戳列表方式接近滑动窗口,但实现简单、精度依赖缓存读写。

原理流程

  1. allow_request 取当前时间与缓存历史时间戳。
  2. 剔除窗口外记录,统计窗口内次数。
  3. 未超限追加当前时间戳写回缓存;超限返回 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 不可用时的降级策略要预先约定(放行或拒绝)。

原理流程

  1. 请求到达生成限流 key。
  2. Redis 原子脚本读取/更新窗口计数或令牌数。
  3. 超限返回 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 明确是频率限制,服务本身可用。

原理流程

  1. 限流类 allow_request 返回 False。
  2. 视图调 throttled(request, wait) 抛 Throttled(wait=...)。
  3. 异常处理器渲染 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 与配置的缓存别名完成。

原理流程

  1. 构造时解析速率与窗口时长。
  2. allow_request 生成 key、读历史、判超限、记录请求。
  3. 超限由视图抛 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)与可信代理配置。

原理流程

  1. 判断认证状态选择标识来源。
  2. 拼接 scope 与标识形成 key。
  3. 缓存读写都以该 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 键。

概念解释

  • 先认证后限流的顺序使配额可以按身份发放,避免匿名与登录互相挤占。
  • 未认证接口通常同时挂匿名与用户限流类做两层控制。

原理流程

  1. initial 完成认证,request.user 确定。
  2. 限流类按认证状态选标识生成 key。
  3. 匹配对应速率阈值计数。

代码或图示

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。

原理流程

  1. 分页器解析请求参数确定当前页范围。
  2. 对查询集切片取当前页对象。
  3. 序列化后包装分页元数据返回。

代码或图示

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,否则前端可请求全量。
  • 页大小影响单次序列化对象数与响应体积。

原理流程

  1. 分页器读默认 page_size。
  2. 若配置了查询参数名,从 request.query_params 取覆盖值。
  3. 覆盖值超过 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) 这类组合;新增数据插入列表头部时,已翻页位置不会因新数据错位。

概念解释

  • 游标是位置快照,不是页码;翻页依赖前后游标,不能跳跃。
  • 排序方向与查询集默认排序不一致会导致游标定位错乱。

原理流程

  1. 首请求按 ordering 取第一页并生成前后游标。
  2. 后续请求携带游标,解码出排序键边界。
  3. 查询集在边界之后(或之前)按同方向切片。

代码或图示

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 文档同步标注。

原理流程

  1. paginate_queryset 返回当前页查询集。
  2. 视图序列化当前页数据。
  3. 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 等单对象动作不经过分页。需要不同分页策略的接口在视图级单独指定。

概念解释

  • 全局兜底统一默认行为,视图级按数据量与场景裁剪。
  • 关闭分页的接口要自行控制返回量级。

原理流程

  1. 视图取 pagination_class,缺省用全局默认。
  2. list 动作实例化分页器切片查询集。
  3. 包装分页响应或返回全量序列化结果。

代码或图示

# 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 哪些场景应该关闭分页或不分页?

一句话结论

导出全量报表、下拉选项树、字典枚举、批量同步、内部任务拉取等场景不分页;关闭分页后必须控制数据量级:流式导出、分批处理、限制最大返回数,避免全量序列化撑爆内存。公开下拉接口可按条件过滤后返回少量选项,而不是拉全表。

概念解释

  • 分页是面向交互式浏览的保护,批量场景有自己的量级控制手段。
  • 不分页不等于无限制,需要独立的上限或流式方案。

原理流程

  1. 判定接口用途:浏览翻页用分页,批量拉取走不分页方案。
  2. 不分页接口加量级上限或流式读取。
  3. 序列化分批进行,避免一次性实例化全量对象。

代码或图示

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 做结构化条件过滤。

原理流程

  1. 后端从 request.query_params 提取参数。
  2. FilterSet 校验参数并构造过滤查询集。
  3. 返回过滤后的 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)。

原理流程

  1. 后端取 search 查询参数。
  2. 按 search_fields 构造 OR 查找条件。
  3. 查询集过滤后进入分页与序列化。

代码或图示

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 设定。排序字段应核对数据库索引,否则排序代价随数据量上升。

概念解释

  • 白名单同时是安全控制:避免前端传入内部字段或表达式排序。
  • 多字段排序按参数顺序生效,负号表示降序。

原理流程

  1. 后端解析 ordering 参数拆分字段列表。
  2. 与 ordering_fields 白名单校验,非法字段丢弃。
  3. 对查询集应用 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 取请求(后端装配时注入)。

原理流程

  1. FilterSet 实例化并绑定查询参数。
  2. 声明字段按 lookup 构造条件;方法字段调用自定义函数。
  3. 合并条件返回最终查询集。

代码或图示

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 都经过它。

原理流程

  1. get_queryset 返回基础查询集。
  2. 遍历 filter_backends 依次过滤。
  3. 最终查询集交给分页或单对象查找。

代码或图示

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 查认证权限,数据不对查过滤,响应过大查分页。

原理流程

  1. 前置横切通过后进入 list 动作。
  2. 查询集经过滤后端裁剪。
  3. 分页器切片,序列化当前页并包装响应。

代码或图示

认证 → 权限 → 限流 → 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 索引,大表需全文索引或搜索引擎;区间过滤字段复合索引顺序要与查询条件匹配。上线前用查询计划核对扫描行数,避免列表接口随数据量退化。

概念解释

  • 索引服务于过滤、连接、排序三类操作;无索引字段成为全表扫描入口。
  • 复合索引遵循最左前缀,等值在前、区间在后。

原理流程

  1. 梳理开放给前端的过滤/搜索/排序字段。
  2. 为高频条件与排序列建索引,核对查询计划。
  3. 文本检索量增长后迁移全文索引或外部搜索引擎。

代码或图示

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。
  • 白名单是最小权限原则在查询层的落地。

原理流程

  1. 解析 ordering 参数拆分字段。
  2. 与白名单集合校验,非法字段丢弃。
  3. 合法字段映射到 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 头确定输入解析方式。

概念解释

  • 协商分输出渲染与输入解析两侧,分别配置渲染器与解析器列表。
  • 渲染器按列表顺序匹配,首个可接受者胜出。

原理流程

  1. perform_content_negotiation 读取 Accept 与渲染器列表。
  2. 匹配媒体类型确定渲染器与解析器。
  3. 响应阶段渲染器 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 页面暴露权限与序列化字段信息。

原理流程

  1. 开发环境渲染器列表含 BrowsableAPI,浏览器访问得到 HTML 页面。
  2. 生产环境全局配置只挂 JSONRenderer。
  3. 响应统一按 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 响应编码共同保证。

原理流程

  1. 渲染器接收 Response.data。
  2. 按配置调用 JSON 序列化(缩进、ensure_ascii)。
  3. 写入响应体并设置媒体类型与字符集。

代码或图示

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

概念解释

  • 渲染器决定输出格式,解析器决定输入格式,两侧独立配置。
  • 视图级覆盖便于个别接口使用特殊渲染/解析方式。

原理流程

  1. 视图读取 renderer_classes,缺省取全局默认。
  2. 内容协商在该列表内匹配媒体类型。
  3. 选定渲染器编码响应。

代码或图示

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(...) 保留顺序。

原理流程

  1. 解析版本与协商内容格式。
  2. 认证写入 request.user/auth。
  3. 权限判定,通过后限流检查,再分发动作。

代码或图示

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)通常视为只读,可对匿名开放。

原理流程

  1. 认证结束确定匿名/已认证状态。
  2. 权限类列表逐个判定。
  3. 全 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。

原理流程

  1. 认证类按列表顺序尝试。
  2. 首个返回 (user, auth) 的类胜出。
  3. 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 的跨域请求不能使用通配来源。

原理流程

  1. 浏览器先发 OPTIONS 预检,中间件返回 CORS 头。
  2. 实际请求带 Cookie/凭证头到达。
  3. 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 负载、下游调用)匹配。

原理流程

  1. 视图声明 throttle_scope 与限流类。
  2. 限流 key 拼接 scope 与身份标识。
  3. 速率字典按 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 服务端。

原理流程

  1. 前置横切:协商 → 认证 → 权限 → 限流。
  2. 数据编排:查询集 → 过滤 → 分页。
  3. 表示输出:序列化 → 包装 → 渲染。

代码或图示

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)