04.7.16.4 认证、权限、缓存与信号
所属:全栈开发面试题库 / 04 后端语言与运行时 / 04.7 Python / 04.7.16 Django 框架
覆盖范围
AbstractUser/AbstractBaseUser与自定义用户模型、AUTH_USER_MODEL迁移代价authenticate/login/logout、ModelBackend认证后端链Permission/Group、has_perm、user_passes_test与行级权限边界- Session 后端选型、过期策略、并发登录与 Cookie 安全
- 缓存框架、
cache_page/vary、击穿/穿透/雪崩与 Redis 后端 - 信号触发时机、事务边界、
transaction.on_commit与 Celery 投递 django.contrib组件职责、国际化、USE_TZ时区陷阱、messages 与认证测试
04.7.16.4-001 AbstractUser 与 AbstractBaseUser 有什么区别?
一句话结论
AbstractUser 提供完整用户模型实现:用户名、邮箱、密码、first_name/last_name、is_active/is_staff/is_superuser 与默认管理器,适合在标准字段上增删自定义字段;AbstractBaseUser 只提供密码哈希与认证核心机制,字段与管理器全部自定义,适合认证体系与默认模型差异很大的场景。绝大多数项目继承 AbstractUser 即可。
概念解释
AbstractUser内部组合了AbstractBaseUser与PermissionsMixin,权限字段随后者带入。- 二者都不直接替换
User,需要在AUTH_USER_MODEL指向自定义模型后才生效。
原理流程
- 选择基类:标准字段够用 →
AbstractUser;认证标识(手机号/邮箱)体系不同 →AbstractBaseUser。 - 声明模型继承基类,追加业务字段。
- 配置
AUTH_USER_MODEL = "应用.模型名"。 - 首次迁移生成用户表,后续外键引用用户用
settings.AUTH_USER_MODEL。
代码或图示
from django.contrib.auth.models import AbstractUser
from django.db import models
class CustomUser(AbstractUser):
phone = models.CharField(max_length=20, unique=True, blank=True)
avatar = models.ImageField(upload_to="avatars/", blank=True)
常见误区
- 项目已有数据后才换基类:用户表迁移代价高,字段结构变更需要重建与数据迁移。
- 继承
AbstractBaseUser却忘了带权限 Mixin:is_superuser、组与权限关联缺失,Admin 鉴权异常。 - 在模型里覆盖
password字段语义:密码必须走基类的哈希方法,不能存明文。
追问
PermissionsMixin提供什么?答:is_superuser、组与权限多对多关系及权限检查方法。- 自定义用户模型能改登录标识字段吗?答:
AbstractUser仍以USERNAME_FIELD为用户名,可在子类改指;AbstractBaseUser直接定义USERNAME_FIELD。 - 为什么外键不直接写
User?答:避免导入期模型耦合,统一引用settings.AUTH_USER_MODEL。
04.7.16.4-002 自定义用户模型的完整步骤是什么?
一句话结论
步骤:新建应用 → 定义继承 AbstractUser(或 AbstractBaseUser)的用户模型 → settings.AUTH_USER_MODEL 指向 "应用.模型" → 首次迁移前完成配置 → 代码中外键引用用户用 settings.AUTH_USER_MODEL。关键约束:必须在第一次迁移之前确定,已有用户表后再更换属于高风险迁移。
概念解释
AUTH_USER_MODEL在模型加载期读取,改配置后旧迁移记录与新模型不匹配会报错。- 自定义模型的管理器可继承
UserManager复用create_user/create_superuser。
原理流程
- 创建
accounts应用并加入INSTALLED_APPS。 - 编写
CustomUser模型与自定义管理器。 settings.py设置AUTH_USER_MODEL = "accounts.CustomUser"。- 执行
makemigrations生成初始迁移,migrate建表;后续代码按配置引用用户。
代码或图示
# settings.py
AUTH_USER_MODEL = "accounts.CustomUser"
# models.py
from django.contrib.auth.models import AbstractUser
from django.contrib.auth.models import UserManager
class CustomUser(AbstractUser):
objects = UserManager()
常见误区
- 先跑了默认
auth迁移再改配置:历史迁移表结构与新模型冲突,需清理迁移或重建数据库。 - 代码里
ForeignKey("User")硬编码:换用户模型后外键指向错误对象。 - 忘记把应用放在
INSTALLED_APPS前部:用户模型未注册,启动期检查报错。
追问
- 什么时候必须用自定义用户模型?答:需要额外必填字段、改登录标识、对接外部账号体系时;纯展示扩展可考虑 Profile 方案。
AUTH_USER_MODEL能在运行时切换吗?答:不能,它是启动期配置,切换需配套迁移与数据搬迁。- 第三方应用如何兼容自定义用户?答:应用通过
settings.AUTH_USER_MODEL引用,不直接导入User。
04.7.16.4-003 为什么要在项目初期就定 AUTH_USER_MODEL?事后更换代价是什么?
一句话结论
Django 对“已有用户表后再换用户模型”没有平滑路径:默认 auth.User 表与权限、会话、外键、迁移历史深度绑定,事后更换需要重建用户表、迁移账号数据、重写所有用户外键并校验权限关联。因此新项目第一步就定义自定义用户模型,即使字段暂时与默认一致,也保留后续扩展空间。
概念解释
- 迁移系统按模型历史生成表结构,切换基类会让既有迁移与新模型字段对不上。
- 生产环境更换涉及停机窗口、数据双写校验与回滚预案,成本远高于初期决策。
原理流程
- 初始化项目时评估账号体系:登录标识、扩展字段、外部对接。
- 确定自定义模型并完成首次迁移。
- 后续字段演进走常规
makemigrations增量迁移。 - 若已上线才发现需要换模型:导出账号数据 → 建新用户表 → 迁移并核对权限/外键 → 切换引用 → 验证登录。
代码或图示
# 初始化阶段就生成自定义用户表
python manage.py makemigrations accounts
python manage.py migrate
常见误区
- “先用默认 User,以后再说”:以后的迁移成本被严重低估,往往被迫长期忍受默认字段。
- 更换模型后忘记重建权限数据:旧
auth_permission记录与新 content type 不对应,授权失效。 - 在多应用间分散定义用户模型:只能有一个
AUTH_USER_MODEL,其他应用引用配置项。
追问
- 不换模型但想加字段有哪些退路?答:一对一 Profile、继承 proxy、后期再评估更换,各有代价。
- 测试数据库能快速重建吗?答:测试库按迁移重建,不代表生产更换可行,生产必须单独演练。
- Django 文档对初始自定义用户有什么建议?答:新项目默认推荐一开始就配自定义用户模型,避免后期受限。
04.7.16.4-004 扩展现有用户对象有哪几种方式?
一句话结论
三种主流方式:一对一 Profile 模型挂额外字段(不改用户表结构,解耦但多一次关联查询);继承 AbstractUser 自定义用户模型(字段进用户表,需在迁移前确定);Proxy 模型(不改表结构,只改查询行为与方法)。只读扩展用 Profile,结构性扩展用自定义模型,行为包装用 proxy。
概念解释
- OneToOne 关系在访问
user.profile时触发关联查询,可预取优化。 - Proxy 模型共享同一张表,不能新增数据库字段。
原理流程
- 评估扩展性质:新字段且长期演进 → 自定义用户模型;字段较少、与用户表解耦 → Profile;只加方法/默认排序 → Proxy。
- Profile 方案建
UserProfile,外键OneToOneField(settings.AUTH_USER_MODEL, on_delete=CASCADE)。 - 按需在信号或保存钩子里创建配套 Profile。
- 模板/视图通过关联访问扩展字段。
代码或图示
from django.db import models
from django.conf import settings
class UserProfile(models.Model):
user = models.OneToOneField(
settings.AUTH_USER_MODEL, on_delete=models.CASCADE, related_name="profile"
)
nickname = models.CharField(max_length=30)
bio = models.TextField(blank=True)
常见误区
- Profile 未在用户创建时初始化:访问
user.profile抛RelatedObjectDoesNotExist。 - 把高频查询字段放 Profile:每次用户信息渲染多一次关联,应评估冗余或预取。
- Proxy 模型里加
models.CharField:proxy 不能加字段,迁移会生成新表意图。
追问
- Profile 与用户如何保持一一对应?答:
OneToOneField数据库层唯一约束,创建用户后同步建 Profile。 - 什么时候选 Proxy?答:需要不同默认排序、方法封装或 Admin 分组,且不新增列。
- 自定义用户模型与 Profile 能共存吗?答:能,自定义模型放核心认证字段,Profile 放非核心业务资料。
04.7.16.4-005 UserManager 提供哪些创建方法?自定义管理器要注意什么?
一句话结论
UserManager 提供 create_user(username, email, password, **extra) 与 create_superuser(username, email, password, **extra):前者按普通用户创建,后者标记 is_staff/is_superuser=True;内部对密码调用 set_password 哈希存储。自定义管理器继承 UserManager,保持 USERNAME_FIELD 一致,并在模型 objects 上挂接。
概念解释
- 明文密码绝不入库,
set_password使用配置的哈希器迭代计算。 - 创建超级用户时会校验必填字段,缺失在
createsuperuser命令阶段提示。
原理流程
- 调用
create_user,传入登录标识、邮箱与密码。 - 管理器
normalize_email规范化邮箱,set_password哈希密码。 - 写入额外字段后
save()。 create_superuser复用创建逻辑,再置管理员标志。
代码或图示
from django.contrib.auth.models import UserManager
class CustomUserManager(UserManager):
def create_user(self, phone, password=None, **extra):
extra.setdefault("username", phone)
return super().create_user(phone, "", password, **extra)
常见误区
- 直接
User(password=raw)入库:密码未哈希,登录校验失败。 - 覆写管理器方法不调
super():密码哈希、邮箱规范化等默认逻辑丢失。 - 模型
USERNAME_FIELD与管理器取参不一致:创建命令找不到标识字段。
追问
- 密码哈希用什么算法?答:默认 PBKDF2,可在
PASSWORD_HASHERS配置 Argon2/bcrypt。 createsuperuser命令调用哪个方法?答:create_superuser,交互输入的字段经管理器校验。- 邮箱为什么要 normalize?答:统一大小写域与别名格式,避免同邮箱多条记录。
04.7.16.4-006 authenticate() 的认证流程是什么?
一句话结论
authenticate(request=None, **credentials) 按 AUTHENTICATION_BACKENDS 顺序逐个调用后端的 authenticate 方法;任一后端返回用户对象即成功,全部失败返回 None。它只校验凭证并返回用户,不写会话;登录状态保持要再调 login()。后端还可接收 request 用于记录登录来源。
概念解释
- 凭证键通常是
username/password,自定义后端可接受phone、email等。 - 认证失败统一返回
None,不区分是用户不存在还是密码错误,避免账号枚举。
原理流程
- 视图/表单收集凭证,调用
authenticate(request, username=..., password=...)。 - 框架遍历后端链,依次调用
backend.authenticate(request, **credentials)。 - 后端校验通过返回用户实例,框架记录其后端路径到
user.backend。 - 全部后端未命中返回
None,视图返回登录失败提示。
代码或图示
from django.contrib.auth import authenticate, login
def sign_in(request):
user = authenticate(request, username=request.POST["username"],
password=request.POST["password"])
if user is not None:
login(request, user)
return redirect("home")
return render(request, "login.html", {"error": "凭证无效"})
常见误区
- 把
authenticate当登录:它不建立会话,后续request.user仍匿名。 - 后端返回未激活用户:需在后端或视图判断
is_active,避免禁用账号进入后续流程。 - 多个后端重复校验密码:链路过长增加开销,认证后端应按明确职责排序。
追问
user.backend记录什么?答:成功认证的后端点路径,login()据此写入会话。- 认证失败怎么防枚举?答:统一“用户名或密码错误”提示,不分别提示账号是否存在。
- 后端能做二次校验吗?答:能,如检查账号锁定、短信验证码、外部 SSO 票据,通过才返回用户。
04.7.16.4-007 login() 具体做了哪些事情?
一句话结论
login(request, user, backend=None) 把用户绑定到当前会话:在 session 中保存用户主键与认证后端,刷新会话 ID 防会话固定,设置 request.user;后续请求由 AuthenticationMiddleware 根据会话恢复用户。它依赖已加载的会话,必须在 SessionMiddleware 之后执行。
概念解释
- 登录时更换 session identifier(
cycle)防止登录前被种下的会话 ID 被利用。 backend显式指定认证后端;未指定时用user.backend,单后端场景可省略。
原理流程
- 确认用户已通过
authenticate,传入login。 - 框架清空旧会话数据,保存
_auth_user_id与_auth_user_backend。 - 必要时保存
_auth_user_hash(密码变更后使旧会话失效)。 - 会话写回 Cookie,
request.user置为该用户。
代码或图示
from django.contrib.auth import login
user = authenticate(request, username=name, password=pwd)
if user and user.is_active:
login(request, user)
常见误区
- 未认证直接
login(request, user):绕过凭证校验,等于任意登录。 - 会话中间件未启用:
request.session不可用,登录无法持久化。 - 登录后不跳转到受保护页面:用户停留在登录页,刷新后才看到状态变化。
追问
- 登录后会话 ID 为什么要刷新?答:防会话固定攻击,避免攻击者预植入 session ID。
- 密码改了旧会话还生效吗?答:
_auth_user_hash与密码哈希比对,密码变更后旧会话自动失效。 login()能用于第三方登录回调吗?答:能,SSO 回调校验票据后构造/取出用户再login。
04.7.16.4-008 logout() 如何销毁会话?
一句话结论
logout(request) 清除当前会话中的认证信息并销毁会话数据,刷新会话 Cookie,request.user 变回匿名用户;它不删除 Cookie 本身之外的服务端记录,也不清理其他设备会话。登出后应跳转到首页或登录页,避免后退按钮看到受保护内容。
概念解释
- 服务端会话记录在登出时被清空,
SESSION_ENGINE对应的存储释放该条目。 - 登出只影响当前会话,多设备登录需额外按用户/设备撤销会话。
原理流程
- 视图调用
logout(request)。 - 会话中
_auth_user_id等认证键被删除,会话数据标记销毁。 - 会话 Cookie 过期或重写,
request.user重置为AnonymousUser。 - 响应跳转到公开页面。
代码或图示
from django.contrib.auth import logout
from django.shortcuts import redirect
def sign_out(request):
logout(request)
return redirect("home")
常见误区
- 只清前端状态不调
logout:服务端会话仍有效,抓包可继续使用。 - 登出后缓存了受保护页面:后退刷新仍显示,需设置响应不缓存或清理浏览器缓存。
- 认为
logout踢掉了所有设备:需要遍历该用户会话并删除,或使用多设备会话管理方案。
追问
- 如何实现“在其他设备登出”?答:查询会话存储中该用户记录并删除,或在用户表记录版本号使旧会话失效。
- 登出后 Cookie 为什么还在?答:Cookie 被置空/过期,浏览器不再带回有效 session ID。
logout需要 POST 吗?答:建议 POST 或带确认,防止链接触发登出的 CSRF 滥用。
04.7.16.4-009 ModelBackend 认证链如何工作?
一句话结论
AUTHENTICATION_BACKENDS 是有序后端列表,默认 ModelBackend:按用户名取用户、校验密码哈希、检查 is_active,并代理权限与组检查。请求认证时按列表顺序尝试,第一个返回用户的后端胜出;自定义后端(邮箱、手机、SSO、LDAP)插入列表后可与默认后端共存。
概念解释
- 后端同时承担认证(
authenticate)与授权(get_user、权限检查)两类职责。 - 顺序决定多后端场景下的命中优先级与密码校验负担。
原理流程
- 启动期读取后端配置,导入各后端类。
authenticate遍历列表,调用每个后端的authenticate(request, **credentials)。ModelBackend查用户、check_password校验、返回用户。- 后续请求经
get_user(user_id)从对应后端恢复用户对象。
代码或图示
# settings.py
AUTHENTICATION_BACKENDS = [
"django.contrib.auth.backends.ModelBackend",
"accounts.backends.PhoneBackend",
]
常见误区
- 自定义后端只实现
authenticate没实现get_user:后续请求恢复用户失败,状态掉线。 - 后端链里重复密码校验:多个后端都查同一用户并比对,浪费 CPU。
- 后端返回非活跃用户:未在链路层拦截,进入业务后产生越权风险。
追问
- 后端
get_user何时调用?答:已登录请求恢复会话中的用户时,按记录的后端加载。 - 能禁用默认 ModelBackend 吗?答:可以,纯外部认证体系可只保留自定义后端,但权限检查需自行实现。
- 后端顺序影响权限结果吗?答:影响命中先后;权限检查由
has_perm经后端链委托。
04.7.16.4-010 如何写一个邮箱/手机号登录的自定义认证后端?
一句话结论
实现后端类,提供 authenticate(request, **credentials) 与 get_user(user_id):前者按邮箱或手机号查询用户、check_password 校验后返回用户;后者按主键恢复用户对象。在 AUTHENTICATION_BACKENDS 注册,表单收集对应标识字段即可。后端要处理用户不存在、密码错误与停用账号,统一返回 None。
概念解释
check_password比对明文与数据库哈希,支持哈希算法升级后的重哈希。- 后端可叠加额外校验:账号锁定、验证码、MFA 票据,通过后才返回用户。
原理流程
- 定义
EmailBackend,authenticate取出email与password。 User.objects.filter(email=email).first()查用户,不存在返回None。user.check_password(password)通过且is_active为真,返回用户。get_user按主键返回实例或None,供会话恢复。
代码或图示
from django.contrib.auth import get_user_model
from django.contrib.auth.backends import BaseBackend
User = get_user_model()
class EmailBackend(BaseBackend):
def authenticate(self, request, email=None, password=None, **kwargs):
user = User.objects.filter(email=email).first()
if user and user.check_password(password) and user.is_active:
return user
return None
def get_user(self, user_id):
return User.objects.filter(pk=user_id).first()
常见误区
- 邮箱未做唯一约束:同邮箱多条记录时认证命中不确定。
get_user直接返回User.objects.get(pk=...):删除用户会抛异常,应filter().first()。- 后端内泄露“邮箱未注册/密码错误”区别:响应层统一提示,避免账号枚举。
追问
- 多标识字段(邮箱或手机都能登录)怎么写?答:
authenticate内分别按字段尝试,或拆两个后端按顺序匹配。 - 密码正确但账号停用返回什么?答:返回
None,视图层可单独提示账号已禁用。 - 后端能记住登录方式吗?答:可在用户对象上挂临时属性,或会话中记录渠道标识。
04.7.16.4-011 认证后端如何委托权限检查?
一句话结论
后端除认证外还实现 has_perm(user, perm) 与 has_module_perms(user, app_label),User.has_perm 沿后端链依次询问,任一后端返回 True 即有权限。默认 ModelBackend 查用户直接权限、组权限与超级用户标志;自定义后端可接入外部权限系统(RBAC 服务、LDAP 组)。
概念解释
- 权限检查与认证解耦:同一用户可由本地后端加外部后端共同授权。
- 超级用户
is_superuser=True在默认后端直接短路为全部权限。
原理流程
- 视图或模板调用
user.has_perm("app.change_post")。 - 框架按
AUTHENTICATION_BACKENDS逐个调用后端has_perm。 ModelBackend查直接授予与组内权限,命中返回True。- 全部后端未命中返回
False。
代码或图示
class ExternalPermBackend(BaseBackend):
def has_perm(self, user, perm, obj=None):
if not user.is_authenticated:
return False
return remote_rbac.check(user.username, perm, obj)
常见误区
- 自定义后端只写
authenticate:权限检查落到默认后端,外部授权不生效。 - 后端
has_perm抛异常被吞成无权限:外部服务故障时应降级策略明确,不能静默拒绝或放行。 - 多个后端权限口径冲突:任一通过即放行,需要收紧时梳理后端职责。
追问
- 对象级权限后端怎么收参?答:
has_perm(user, perm, obj=None),默认后端不按对象过滤,行级判断在自定义后端或服务层。 - 权限结果会缓存吗?答:会话期内用户实例的权限查询可被后端实现缓存,刷新需重新加载用户。
has_module_perms判断什么?答:用户是否拥有某应用下任意权限,常用于 Admin 应用入口可见性。
04.7.16.4-012 request.user 在请求链路中什么时候绑定?
一句话结论
AuthenticationMiddleware 在请求段加载会话,按会话中的用户 ID 与后端恢复用户对象并挂到 request.user;未登录则为 AnonymousUser。它位于 SessionMiddleware 之后,视图、上下文处理器与模板读到的 request.user 都是这一步绑定的结果。
概念解释
- 中间件顺序:Session 先加载会话,Authentication 再读会话键恢复用户。
request.user是请求级对象,请求结束销毁,不跨请求保存。
原理流程
SessionMiddleware从 Cookie 解析 session ID,加载会话字典。AuthenticationMiddleware读_auth_user_id,调后端get_user。- 校验用户哈希与活跃状态后绑定
request.user;缺失或失效用匿名用户。 - 后续视图、模板通过
request.user判断登录态与权限。
代码或图示
# 视图中直接读取
def profile(request):
if request.user.is_authenticated:
return render(request, "profile.html", {"user": request.user})
return redirect("login")
常见误区
- 中间件顺序把 Authentication 放 Session 前:会话未加载,用户永远匿名。
- 在上下文处理器之前假设
request.user已就绪:处理器同样依赖中间件绑定顺序。 - 异步链路中同步访问用户属性:需确认异步用户对象加载方式,避免阻塞循环。
追问
- 匿名用户有哪些属性?答:
is_authenticated=False、is_staff/is_superuser=False,权限检查全部拒绝。 - 如何在中间件外层拿到用户?答:外层先于 Authentication 执行,读不到用户,需要用户信息的逻辑应放内层或视图。
- 切换账号后旧
request.user残留吗?答:单请求内不会,新请求重新从会话加载。
04.7.16.4-013 Permission 模型与 ContentType 是什么关系?
一句话结论
Permission 记录“某应用某模型上的操作权限”,通过外键关联 ContentType(对应具体模型);每条权限含 codename(如 add_post)、name(可读名称)与 content_type。模型注册后,Django 为 add/change/delete/view 自动生成四条默认权限,迁移时写入 auth_permission 表。
概念解释
ContentType是模型的“模型级注册表”,让权限、通用外键跨模型引用。- 自定义权限在模型
Meta.permissions中声明,迁移后生成对应Permission记录。
原理流程
- 应用迁移时,框架为每个模型生成增改删查四条默认权限。
- 权限记录关联到该模型的
ContentType。 - 用户/组通过多对多关系授予权限记录。
- 检查权限时按
codename拼接app_label.action_model匹配。
代码或图示
class Article(models.Model):
title = models.CharField(max_length=100)
class Meta:
permissions = [
("publish_article", "可以发布文章"),
]
常见误区
- 改模型
Meta.permissions后没跑迁移:新权限记录未入库,授权界面看不到。 - 直接操作
Permission表绕过迁移:环境间权限数据不一致。 - 权限 codename 跨应用重复:拼接全名含应用标签,重名不冲突,但命名要清晰。
追问
- 默认四条权限分别是什么?答:
add、change、delete、view,对应模型增改删查。 - 权限与组怎么关联?答:
Group.permissions多对多挂权限,用户加入组即继承组权限。 ContentType能关联哪些模型?答:所有注册模型,通用外键靠它实现多态指向。
04.7.16.4-014 组(Group)如何做权限聚合?
一句话结论
Group 是权限集合,用户加入组后继承组内全部权限;权限检查沿“用户直接权限 ∪ 所属各组权限”合并。组用于按角色聚合授权(编辑者、审核员、运营),避免给每个用户逐条配权限。组本身不含对象级数据,只承载角色与权限映射。
概念解释
- 用户与组是多对多:一个用户可属多个组,权限取并集。
- 组权限变更对所有成员即时生效(下次权限检查时读取)。
原理流程
- 按业务角色建组,如
editor、reviewer。 - 把对应
Permission授予组。 - 用户加入一个或多个组。
has_perm检查时合并直接权限与组权限集合。
代码或图示
from django.contrib.auth.models import Group, Permission
editor, _ = Group.objects.get_or_create(name="editor")
perm = Permission.objects.get(codename="change_article")
editor.permissions.add(perm)
user.groups.add(editor)
常见误区
- 把具体业务数据挂到组上:组是角色授权容器,数据归属应在业务模型上记录。
- 组权限与用户直接权限重复授予:并集不冲突,但清理时要两处核对。
- 依赖组做行级隔离:组只给“能不能操作某类对象”,不区分具体记录归属。
追问
- 一个用户多个组权限怎么算?答:取并集,任一来源有权限即通过。
- 组可以嵌套吗?答:内置
Group不支持组嵌套,层级角色需自建关系表。 - 权限变更后需要重新登录吗?答:不需要,权限检查实时查库;缓存了用户实例才需刷新。
04.7.16.4-015 has_perm/has_perms 的检查机制与缓存是怎样的?
一句话结论
user.has_perm(perm) 沿后端链检查单条权限,has_perms(perm_list) 批量检查;默认后端把用户直接权限与组权限合并为集合后判断。权限在用户实例上不做长期持久缓存,每次检查查询关联表;高频鉴权场景可在服务层按请求缓存权限集合,注意失效时机。
概念解释
- 权限字符串格式:
app_label.codename,模型名在默认生成时并入 codename。 - 超级用户短路:
is_superuser直接通过所有权限检查。
原理流程
- 调用
has_perm("blog.publish_article")。 - 默认后端取用户直接权限与组权限集合。
- 目标权限在集合中返回
True,否则问下一个后端。 has_perms对列表逐条判断,可要求全部通过。
代码或图示
if request.user.has_perm("blog.publish_article"):
return redirect("publish")
raise PermissionDenied
常见误区
- 以为权限结果跨请求缓存:用户对象每请求重建,权限集合重新查询。
- 在循环里逐条
has_perm触发多次关联查询:应一次性取权限集合再判断。 - 检查对象级权限却用默认
has_perm:内置后端不按对象过滤,需自定义后端或服务层判断。
追问
- 权限字符串里模型名在哪一段?答:默认 codename 形如
change_post,全名blog.change_post,模型体现在 codename 中。 - 如何列出用户所有权限?答:
user.get_all_permissions()返回合并后的权限名集合。 - 权限检查失败抛什么?答:视图层抛
PermissionDenied转 403,不要静默返回 404。
04.7.16.4-016 Django 权限的命名规则是什么?
一句话结论
完整权限名格式为 app_label.codename;默认 codename 为 add_<model>、change_<model>、delete_<model>、view_<model>,模型名取 Meta.model 或表名小写。自定义权限在 Meta.permissions 中声明 codename 与名称,检查时必须与注册记录完全一致(含应用标签)。
概念解释
- 应用标签来自应用配置
label,通常等于应用目录名。 - 权限名(
name)是展示文本,codename 是程序判断用标识,二者不要混用。
原理流程
- 模型迁移生成默认权限,codename 按操作 + 模型名拼接。
- 自定义权限在
Meta.permissions列表声明(codename, name)。 - 代码与模板用
app_label.codename检查。 - 重命名 codename 需迁移并同步所有检查点。
代码或图示
# 检查点
request.user.has_perm("orders.cancel_order")
# 模型声明
class Order(models.Model):
class Meta:
permissions = [("cancel_order", "取消订单")]
常见误区
- 权限名只写 codename 漏应用标签:解析到错误应用或找不到权限。
- 改模型名后旧 codename 残留:迁移生成新权限,旧记录需清理或兼容。
- 中文 codename:标识应保持 ASCII,中文只放展示
name。
追问
- 权限在 Admin 哪里配置?答:用户/组编辑页的权限多选框,按应用分组展示。
- 如何批量核对权限名?答:
Permission.objects.values_list("content_type__app_label", "codename")。 - 第三方应用的权限能改吗?答:可在迁移或数据脚本中调整,升级应用时注意被覆盖。
04.7.16.4-017 user_passes_test 与 permission_required 怎么用?
一句话结论
permission_required(perm, raise_exception=False) 装饰器检查用户是否具备指定权限,缺失重定向登录页或抛 403;user_passes_test(test_func) 接收自定义判断函数,返回 False 时拒绝。类视图用 method_decorator 包裹;两者都在视图入口拦截,不替代对象级归属校验。
概念解释
permission_required可传权限列表,默认要求全部通过。raise_exception=True时无权限抛PermissionDenied(403),否则未登录跳登录页。
原理流程
- 请求进入装饰器包装层。
- 判断登录态:匿名用户按配置跳转或拒绝。
- 调用权限测试函数/
has_perm检查。 - 通过进入视图;不通过返回重定向或 403。
代码或图示
from django.contrib.auth.decorators import permission_required, user_passes_test
@permission_required("blog.publish_article", raise_exception=True)
def publish(request):
...
@user_passes_test(lambda u: u.is_staff, login_url="/login/")
def staff_page(request):
...
常见误区
- 装饰器只校验“能否操作该类对象”,未校验具体记录归属:对象级越权仍需在视图判断。
- 类视图直接堆装饰器:必须经
method_decorator包裹dispatch或方法。 - 权限名拼写错误:检查恒为
False,应在启动检查或测试中覆盖。
追问
permission_required支持多权限吗?答:传列表,perm_list全部满足才通过;任一即可需自定义user_passes_test。- 未登录与无权限响应区别?答:未登录可跳登录页;
raise_exception无权限返回 403。 - 类视图等价写法?答:
@method_decorator(permission_required(...), name="dispatch")。
04.7.16.4-018 Django 内置为什么不提供行级权限?
一句话结论
内置权限体系是“模型级/类级”的:判断用户能否对某模型做某操作,不区分具体记录。行级(对象级)权限需要结合数据归属判断(作者、部门、租户),Django 不内置通用实现,常见做法:视图/服务层显式校验归属、自定义认证后端收 obj 参数、或引入第三方行级权限库。
概念解释
- 模型级权限回答“能不能改文章”,行级权限回答“能不能改这一篇文章”。
- 归属规则因业务而异(团队共享、部门继承、数据密级),框架难以抽象成通用表结构。
原理流程
- 视图取到具体对象后,调用服务层校验归属或角色。
- 校验通过进入编辑,否则抛
PermissionDenied。 - 需要复用的行级规则沉淀为后端
has_perm(user, perm, obj)或权限服务函数。 - 列表查询集按可见范围过滤,避免详情接口泄露。
代码或图示
def edit_post(request, pk):
post = get_object_or_404(Post, pk=pk)
if post.author != request.user and not request.user.is_staff:
raise PermissionDenied
return render(request, "post_edit.html", {"post": post})
常见误区
- 以为
has_perm传对象就做行级判断:默认后端忽略obj,不按记录过滤。 - 只在详情页校验归属,列表/接口不过滤:泄露标题、摘要与计数。
- 行级规则散落在各视图:口径不一致,应抽公共权限服务或 Mixin。
追问
- 第三方行级权限方案有哪些?答:如 django-guardian 等对象级权限库,按对象记录授权;简单归属规则用服务层判断即可。
- 行级权限如何在列表生效?答:
get_queryset按归属/租户过滤,与详情校验形成双保险。 - 团队共享对象怎么授权?答:业务模型记录协作成员/团队,检查时匹配成员关系。
04.7.16.4-019 is_staff 与 is_superuser 有什么区别?
一句话结论
is_staff 是“可进入 Admin 后台”的标志,仍受模型级权限约束;is_superuser 是超级用户,绕过所有权限检查、拥有全部授权。普通运营给 is_staff + 具体权限,只有最高管理角色给 is_superuser。二者都不代表行级归属。
概念解释
- Admin 入口判断
is_staff;功能按钮与数据可见性再按权限与查询集控制。 - 超级用户短路所有
has_perm检查,无法通过撤销组权限收回其权限。
原理流程
- 登录用户进入 Admin,先检查
is_staff。 - 各模型操作按
has_perm判断可见性与可操作性。 is_superuser=True在默认后端直接返回全部权限。- 业务视图可叠加归属校验,超级用户也可能受行级规则约束(按实现)。
代码或图示
if request.user.is_staff:
# 可访问后台入口
if request.user.is_superuser:
# 最高权限角色
常见误区
- 给运营开
is_superuser图省事:绕过授权体系,误操作与审计风险高。 - 以为
is_staff就能改所有数据:仍需对应模型权限。 - 在业务代码里用
is_superuser替代归属判断:行级越权保护被跳过。
追问
is_active控制什么?答:账号是否可登录/启用,停用后认证与会话恢复被拒。- 超级用户能被行级规则限制吗?答:内置权限层不限制,业务层可显式判断归属。
- 如何审计后台操作?答:Admin 日志记录后台改动,敏感操作补充业务日志与操作人。
04.7.16.4-020 权限如何在模板与视图中使用?
一句话结论
模板用 {% if perms.blog.change_post %} 判断权限(perms 上下文处理器注入),视图用 user.has_perm(...) 或装饰器;按钮、链接按权限渲染,后端视图仍必须独立校验。模板隐藏只是体验优化,不能作为安全边界。
概念解释
perms对象提供perms.<app>.<codename>属性访问,未登录为空权限集合。- 权限判断在服务端执行,模板拿到的是已计算结果,前端不可篡改。
原理流程
- 上下文处理器把用户权限集合注入
perms。 - 模板按权限渲染操作入口。
- 视图入口用装饰器或
has_perm二次校验。 - 具体对象归属在视图/服务层判断,防止直接访问 URL 越权。
代码或图示
{% if perms.blog.publish_article %}
<a href="{% url 'publish' %}">发布文章</a>
{% endif %}
常见误区
- 只在模板隐藏按钮,视图不校验:直接构造请求即可越权操作。
- 模板里访问未注册权限名:属性为空,判断恒假,不报错。
- 把对象归属判断写进模板:模板拿不到完整查询规则,归属校验应在后端。
追问
perms从哪来?答:django.contrib.auth.context_processors.auth上下文处理器注入。- 模板能检查对象级权限吗?答:可调用自定义方法,但规则应在服务层定义,模板只展示结果。
- 权限判断结果需要缓存吗?答:单请求内复用即可,跨请求缓存要考虑授权变更时效。
04.7.16.4-021 Django Session 的整体机制是什么?
一句话结论
登录后服务端把用户标识等数据存入会话存储,生成 session ID 写入浏览器 Cookie;后续请求 Cookie 带回 session ID,服务端按 ID 取回会话字典。Django 不把认证状态放 Cookie 明文,Cookie 只存随机 ID,会话内容留在服务端,后端可随时使会话失效。
概念解释
- 会话数据键含
_auth_user_id、_auth_user_backend、_auth_user_hash等认证信息。 - 会话在请求懒加载,响应阶段
SessionMiddleware检测变更后写回存储。
原理流程
- 首次响应下发 session ID Cookie(匿名会话也可建立)。
- 登录时会话字典写入用户标识,保存到会话后端。
- 后续请求解析 Cookie 中的 session ID,加载对应会话。
- 响应阶段若会话被修改,写回存储并刷新 Cookie 过期时间。
代码或图示
# 视图中读写会话
def cart(request):
request.session["cart"] = ["item-1", "item-2"]
return JsonResponse({"cart": request.session.get("cart")})
常见误区
- 把敏感数据全塞会话:会话后端容量受限,大对象应入库,会话只存引用。
- 会话未标记修改就期望持久化:可变对象内部修改可能不触发脏标记,需
session.modified = True。 - 以为 Cookie 里存了用户信息:Cookie 只有 session ID,用户数据在服务端。
追问
- 会话 ID 如何防伪造?答:随机生成并经签名/服务端校验,不可预测;Cookie 配合
HttpOnly防脚本读取。 - 会话什么时候创建?答:请求中写入会话数据时懒创建,响应时下发 Cookie。
- 会话数据能跨子域共享吗?答:配置
SESSION_COOKIE_DOMAIN后可在父域下共享,后端需同一份存储。
04.7.16.4-022 Session 后端有哪几种?如何选型?
一句话结论
内置后端:db(数据库表,持久可靠、查询有开销)、cached(缓存存储,快但缓存失效会丢会话)、cache_db(缓存为主、数据库兜底,兼顾速度与持久)、file(本地文件,单机部署简单、不适合多机)、signed_cookies(签名 Cookie,数据存客户端、无服务端存储,容量受限且不能服务端主动失效)。多实例生产常用 cache_db 或 db。
概念解释
- 选型权衡:持久化 vs 速度、单机 vs 多机、能否服务端踢下线。
- 签名 Cookie 后端不查服务端,会话无法在服务端主动删除,只靠过期。
原理流程
SESSION_ENGINE指定后端模块路径。- 会话读写经后端接口:
load、save、delete、exists。 cached直接读写缓存;cache_db先查缓存,未命中查库并回填。- 多机部署要求后端共享(缓存/数据库/共享文件存储)。
代码或图示
# settings.py
SESSION_ENGINE = "django.contrib.sessions.backends.cache_db"
# 或
SESSION_ENGINE = "django.contrib.sessions.backends.db"
常见误区
- 多机部署用
file后端:各机文件互不可见,登录状态在节点间漂移。 - 高价值会话用纯
cached:缓存淘汰或重启后用户集体掉线。 - 用
signed_cookies存敏感数据:数据在客户端可解码(仅签名不加密),不能放密码、隐私字段。
追问
cache_db读取顺序?答:先缓存,未命中查数据库并回填缓存;缓存丢了库里仍有会话。- 签名 Cookie 后端能主动登出吗?答:不能服务端删除,只能等 Cookie 过期或改
SECRET_KEY使签名失效。 - 文件后端适合什么场景?答:单机小规模、无缓存/数据库依赖的内部工具。
04.7.16.4-023 SESSION_ENGINE 与缓存后端如何配合?代价是什么?
一句话结论
SESSION_ENGINE 选择会话存储实现;cached/cache_db 复用 CACHES 配置的缓存后端。缓存后端快,但受内存淘汰、过期策略与可用性影响;数据库后端持久但每次读写多一次查询。会话与业务缓存共用 Redis 时要注意 key 前缀隔离与容量规划,避免会话被业务缓存挤掉。
概念解释
- 会话缓存与普通缓存可分库/分前缀,故障域隔离。
- 会话写入频率高,缓存后端需评估连接数与内存占用。
原理流程
- 配置
CACHES(如 Redis),SESSION_ENGINE指向缓存型后端。 - 会话加载先读缓存,
cache_db未命中回源数据库。 - 会话保存写缓存,
cache_db同步落库。 - 缓存淘汰/重启时按后端策略决定是否从库恢复。
代码或图示
CACHES = {
"default": {
"BACKEND": "django.core.cache.backends.redis.RedisCache",
"LOCATION": "redis://127.0.0.1:6379/1",
"KEY_PREFIX": "ann",
}
}
SESSION_ENGINE = "django.contrib.sessions.backends.cache_db"
常见误区
- 会话缓存与业务热点缓存共用同一 Redis 实例无隔离:大 key 淘汰波及登录态。
- 缓存后端宕机时会话不可用:
cache_db可回源库,纯cached直接掉线。 - 会话过期时间与缓存 TTL 不一致:缓存先过期导致会话提前失效。
追问
- 会话 key 有前缀吗?答:受缓存
KEY_PREFIX与会话后端命名规则影响,多应用共用缓存需隔离。 - 数据库会话表需要清理吗?答:过期会话由清理命令/任务定期删除,避免表膨胀。
- 会话读写会拖慢请求吗?答:每次请求加载会话,后端慢会直接增加接口延迟。
04.7.16.4-024 会话过期策略由哪些配置控制?
一句话结论
SESSION_COOKIE_AGE(默认 1209600 秒,两周)控制 Cookie 有效期;SESSION_EXPIRE_AT_BROWSER_CLOSE=True 时会话 Cookie 为会话级,关浏览器即失效;SESSION_SAVE_EVERY_REQUEST=True 每次请求刷新过期时间,否则按最后写入时间计算。服务端会话记录也有对应过期清理策略。
概念解释
- 空闲超时与绝对时长是两种策略:每次活动续期属于空闲超时,固定到期属于绝对时长。
- 敏感系统应缩短 Cookie 年龄并配合闲置登出。
原理流程
- 登录/写会话时按配置计算过期时间写入 Cookie 与会话记录。
- 后续请求按
SESSION_SAVE_EVERY_REQUEST决定是否续期。 - 浏览器按 Cookie 有效期携带 session ID。
- 服务端会话过期后加载为空,用户回到匿名态。
代码或图示
SESSION_COOKIE_AGE = 3600 * 8 # 8 小时
SESSION_EXPIRE_AT_BROWSER_CLOSE = False
SESSION_SAVE_EVERY_REQUEST = True
常见误区
- 期望“固定 8 小时后必登出”却开了每次续期:变成只要活跃就永不过期。
- 关浏览器后会话仍在:Cookie 是持久 Cookie 而非会话 Cookie,检查
EXPIRE_AT_BROWSER_CLOSE。 - 只设 Cookie 过期不清服务端会话:旧 session ID 若被复用仍可能有效,需后端过期清理。
追问
- 如何实现“记住我”延长有效期?答:登录时按勾选设置会话过期时间,覆盖默认
SESSION_COOKIE_AGE。 - 服务端会话过期怎么清理?答:定期任务调用会话后端清理过期记录,或依赖后端 TTL。
- 闲置超时与绝对超时能同时做吗?答:可在业务层记录最后活动与登录时间,双重判断。
04.7.16.4-025 多设备并发登录与会话管理怎么做?
一句话结论
默认每个浏览器会话独立,同一账号可在多设备同时在线,会话之间互不知道;要实现“踢掉其他设备”“查看在线设备”“单设备登录”,需要在会话存储中按用户索引会话记录,登出/下线时遍历删除对应 session。内置会话表不直接提供用户到会话的反查,需自建映射或查询会话数据。
概念解释
- 会话 ID 是主键,用户标识存在会话字典里,反查需扫描或维护索引表。
- 单设备登录:新会话建立后删除该用户其他会话记录。
原理流程
- 登录成功,会话写入用户 ID。
- 维护用户与会话 ID 的映射(额外表或缓存集合)。
- 多设备列表从映射读取;下线指定设备删除对应会话。
- 单设备策略:新会话生效后清除旧会话 ID 对应记录。
代码或图示
def kick_other_sessions(request, user):
from django.contrib.auth import get_user_model
session_store = request.session.session_key
# 遍历会话存储中属于该用户的记录并删除(按所选后端实现)
for key in user_session_keys(user):
if key != session_store:
request.session.delete() # 实际按后端删除对应 key
常见误区
- 以为
logout会登出所有设备:只销毁当前会话,其他节点会话仍有效。 - 会话索引与实际会话不一致:删除映射未删会话,残留可登录记录。
- 高并发下同时登录无锁:竞态可能导致新旧会话并存,按业务接受度处理。
追问
- 如何强制全平台下线?答:删除该用户全部会话记录,或升级用户令牌版本使旧会话哈希校验失败。
- 在线人数怎么统计?答:基于会话后端扫描或缓存集合计数,注意过期与重复登录去重。
- 会话备份能恢复登录态吗?答:恢复会话记录后旧 session ID 可继续使用,需评估安全风险。
04.7.16.4-026 会话 Cookie 有哪些安全属性?
一句话结论
关键属性:HttpOnly(禁止 JS 读取,防 XSS 窃取)、Secure(仅 HTTPS 传输)、SameSite(Lax/Strict/None,限制跨站携带)、SESSION_COOKIE_DOMAIN 与路径。生产环境应开启 HttpOnly 与 Secure,按站点形态设 SameSite;这些属性由 Django 对应 SESSION_COOKIE_* 配置控制。
概念解释
- CSRF 防护与 Cookie 属性互补:
SameSite减少跨站携带,CSRF token 校验表单提交。 Secure在 HTTP 开发环境会导致 Cookie 不下发,需按环境区分配置。
原理流程
- 响应设置会话 Cookie 时读取
SESSION_COOKIE_SECURE、HTTPONLY、SAMESITE。 - 浏览器按属性决定是否在后续请求携带、是否允许脚本访问。
- 跨站表单/导航按
SameSite策略限制 Cookie 发送。 - 会话 ID 泄露风险随属性收紧而降低。
代码或图示
SESSION_COOKIE_HTTPONLY = True
SESSION_COOKIE_SECURE = True
SESSION_COOKIE_SAMESITE = "Lax"
常见误区
- 生产忘了开
Secure:HTTP 链路会话 ID 可被中间人窃听。 - 关闭
HttpOnly:XSS 漏洞可直接读取会话 Cookie,提升接管风险。 - 跨站嵌入页面设
SameSite=None却不配Secure:浏览器拒绝该 Cookie。
追问
SameSite=Lax与Strict区别?答:Strict完全不跨站携带;Lax允许顶级导航 GET 携带,平衡可用性与防护。- 会话 Cookie 能被 JS 覆盖吗?答:
HttpOnly后 JS 不能读取/改写,只能由浏览器管理。 - 子域共享 Cookie 怎么配?答:
SESSION_COOKIE_DOMAIN=".example.com",注意父域下其他应用可读写。
04.7.16.4-027 缓存型会话丢数据会有什么一致性问题?
一句话结论
纯 cached 后端把会话只放缓存:缓存淘汰、重启、过期或故障都会导致会话丢失,用户掉线、购物车/临时填写内容清空;cache_db 在缓存未命中时回源数据库,持久性更好。会话与业务数据一致性要求高的场景,不要用纯缓存后端,也不要把不可恢复的数据只放会话。
概念解释
- 缓存是易失存储,会话是认证状态,丢失代价高于普通缓存未命中。
cache_db仍存在短暂不一致:缓存与库写入分两步,故障窗口内可能丢最新修改。
原理流程
- 会话保存写缓存(纯 cached)或缓存 + 库(cache_db)。
- 缓存失效后纯 cached 读不到会话;cache_db 回源库恢复。
- 库恢复的是上次落库版本,未落库修改丢失。
- 敏感业务数据应入库持久化,会话只存临时标识。
代码或图示
# 持久优先:数据库后端或 cache_db
SESSION_ENGINE = "django.contrib.sessions.backends.cache_db"
常见误区
- 把订单草稿、填写中表单存会话又用纯缓存后端:缓存清理后数据不可恢复。
- 误以为 Redis 持久化就不会丢:RDB/AOF 窗口内仍可能丢数据,且内存淘汰策略会剔除 key。
- 多副本缓存会话不同步:节点读到空会话,表现为随机掉线。
追问
- 会话写缓存失败要不要阻断请求?答:认证类会话失败应明确报错或回源库,静默继续会产生半登录态。
- 如何监控会话丢失?答:统计匿名化后重新登录比例、缓存未命中与后端错误日志。
- 会话能放外部 KV 存储吗?答:可实现后端对接 Redis/数据库等,只要满足会话存储接口与多机共享。
04.7.16.4-028 匿名会话与登录后的会话如何合并?
一句话结论
Django 默认登录不合并匿名会话数据:login() 刷新会话标识,登录前写在匿名会话里的临时数据(如未登录购物车)需要手动迁移到新会话。常见做法:登录前把临时数据存业务表关联临时标识,登录后按用户归属;或在登录视图读取旧会话数据写入新会话。
概念解释
- 会话固定防护要求登录后更换 session ID,因此不能直接复用旧会话条目。
- 未登录场景的业务数据应入库并挂临时令牌,而不是只依赖会话字典。
原理流程
- 匿名访客把购物车写入会话或临时记录。
- 提交登录,
authenticate校验通过后login生成新会话。 - 视图读取旧会话/临时记录,合并到新会话或绑定用户。
- 清理匿名临时数据,避免悬空记录。
代码或图示
def sign_in(request):
anon_cart = request.session.get("cart", [])
user = authenticate(...)
if user:
login(request, user)
if anon_cart:
request.session["cart"] = anon_cart # 合并到新会话
return redirect("home")
常见误区
- 依赖
login自动迁移匿名数据:框架不做合并,临时内容随旧会话丢弃。 - 临时购物车只存会话 Cookie 后端:清 Cookie 即丢失,重要草稿应入库。
- 合并时未去重:登录前已有的用户购物车与匿名车重复叠加。
追问
- 电商未下单购物车怎么持久化?答:挂匿名 token 存数据库,登录后按 token 合并到用户购物车。
- 登录后旧会话还在吗?答:默认更换 session ID,旧条目由过期策略清理,可主动删除。
- 合并逻辑放信号还是视图?答:登录是业务流程,放登录视图/服务层更可控,不建议用信号隐式合并。
04.7.16.4-029 Django 缓存框架的整体设计是什么?
一句话结论
缓存框架提供统一 cache 接口(get/set/add/delete/incr/decr/clear),后端可替换为内存、文件、数据库、Redis 等;缓存粒度分整页(cache_page)、视图片段({% cache %})与低级别手动缓存。框架按“key 前缀 + 版本 + 键名”定位条目,业务代码不感知后端实现。
概念解释
- 缓存是在读多写少场景下用空间换时间,降低数据库与下游压力。
- 缓存层引入一致性问题:数据更新后缓存失效/更新时机决定陈旧窗口。
原理流程
- 配置
CACHES选择后端与参数。 - 读路径:先查缓存,命中返回;未命中查数据库/计算后回填缓存。
- 写路径:更新数据库后按策略失效或更新缓存。
- 缓存条目带 TTL 与 key 命名空间,过期自动淘汰。
代码或图示
from django.core.cache import cache
def top_tags():
key = "top-tags"
tags = cache.get(key)
if tags is None:
tags = Tag.objects.popular()
cache.set(key, tags, timeout=300)
return tags
常见误区
- 把强一致要求的数据放缓存:陈旧窗口内读到旧值,需要及时失效策略。
- 缓存 key 不区分租户/用户/语言:不同上下文数据串号。
- 缓存空值不当:未命中反复回源,穿透问题需空值缓存或互斥锁。
追问
- 缓存接口后端可换吗?答:可,
CACHES配置多后端,caches["default"]按名获取。 - 缓存能存复杂对象吗?答:能,经序列化存储;注意可序列化类型与版本兼容。
- 什么数据不该缓存?答:实时性极强、写入频繁、单条访问且计算很轻的数据。
04.7.16.4-030 内置缓存后端各自有什么特点?
一句话结论
LocMemCache 进程内内存,快但多进程/多机不共享、重启丢失;FileBasedCache 本地文件,单机可用、读写慢;DatabaseCache 数据库表持久但增加查询压力;RedisCache 跨机共享、支持过期与丰富数据结构,生产主流;DummyCache 不存数据,用于测试禁用缓存。
概念解释
- 进程内缓存在多 worker 间各自一份,命中率数据不互通。
- Redis 后端需客户端依赖,连接池与 key 前缀按部署规划。
原理流程
- 按
CACHES["default"]["BACKEND"]选择实现类。 - 序列化值写入对应存储,key 按前缀与版本组织。
- 读取时反序列化返回,过期条目由后端清理。
- 多实例共享必须用外部后端(Redis/数据库),不能用本地内存/文件。
代码或图示
CACHES = {
"default": {
"BACKEND": "django.core.cache.backends.redis.RedisCache",
"LOCATION": "redis://127.0.0.1:6379/0",
"TIMEOUT": 300,
"KEY_PREFIX": "ann",
}
}
常见误区
- 多机部署用 LocMem:节点间缓存不互通,数据库压力不降反波动。
- 文件缓存目录权限不当:进程无法读写,缓存全部未命中。
- 数据库缓存表未建:读写缓存报错,需执行缓存表迁移。
追问
- LocMem 缓存进程间共享吗?答:不共享,每个 worker 独立,重启清空。
- Redis 连接池在哪配置?答:后端客户端参数(如 django-redis 配置项),按并发设置池大小。
- 测试用哪个后端?答:
DummyCache或本地内存,避免污染开发 Redis。
04.7.16.4-031 cache_page 如何做整页缓存?缓存粒度怎么选?
一句话结论
cache_page(timeout) 装饰器按 URL 缓存整个响应,适用于公开、读多写少、不随登录态变化的页面;缓存键默认含路径与查询串。粒度选择:公开静态页用整页缓存,登录相关/个性化内容用片段缓存或手动缓存;整页缓存命中时不执行视图与数据库查询,收益最大但一致性窗口也最大。
概念解释
cache_page可指定cache后端与key_prefix,配合vary_on_headers区分响应变体。- 响应头
Cache-Control/ETag可与 Django 缓存分层配合。
原理流程
- 请求进入,按路径/查询串/vary 头生成缓存键。
- 命中则直接返回缓存响应,跳过视图。
- 未命中执行视图生成响应,按 timeout 回填缓存。
- 数据更新后需主动失效对应键,避免长期陈旧。
代码或图示
from django.views.decorators.cache import cache_page
@cache_page(60 * 5, key_prefix="home")
def home(request):
...
常见误区
- 把含用户信息的页面整页缓存:所有访问者看到同一用户的数据,串号泄露。
- 缓存未按查询串/语言区分:搜索结果、分页串号。
- 数据更新后不失效缓存:旧内容停留到 TTL 到期。
追问
- 类视图怎么挂整页缓存?答:
method_decorator(cache_page(...), name="dispatch")。 - 整页缓存能缓存 POST 响应吗?答:默认缓存 GET 响应,写操作不应整页缓存。
- 缓存超时如何按接口配置?答:装饰器传
timeout,不同视图差异化设置。
04.7.16.4-032 vary 与缓存键由哪些部分组成?
一句话结论
缓存键默认包含站点别名、路径、查询串;vary_on_headers("Accept-Language", "Cookie") 把指定请求头纳入键计算,vary_on_cookie 按 Cookie 区分。响应的 Vary 头告诉下游缓存(CDN/浏览器)按哪些头区分变体。键组成不区分上下文,会导致不同语言、用户角色共享缓存条目。
概念解释
- Django 内部键还会叠加
KEY_PREFIX与CACHE_VERSION,便于整体版本切换。 Vary头是给 HTTP 缓存层看的约定,Django 缓存键计算与之对应。
原理流程
- 请求到达,收集路径、查询串与配置的 vary 头/Cookie。
- 叠加前缀、版本生成最终缓存键。
- 命中按键返回对应变体;未命中计算后回填。
- 响应
Vary头声明区分维度,下游缓存据此独立存储。
代码或图示
from django.views.decorators.cache import vary_on_headers, vary_on_cookie
@vary_on_headers("Accept-Language")
def localized_page(request):
...
@vary_on_cookie
def personal_page(request):
...
常见误区
- 多语言页面不加
Accept-Languagevary:中文用户看到英文缓存页。 - 对敏感个性化内容
vary_on_cookie后整页缓存:Cookie 高度分化,缓存命中率极低,应改片段缓存。 - 自定义头没加入 vary:下游 CDN 与 Django 缓存口径不一致,出现错变体。
追问
- 缓存键能包含用户 ID 吗?答:可在手动缓存 key 中拼用户标识;整页装饰器不自动按用户拆分。
Vary: Cookie有什么副作用?答:共享缓存难以合并,命中率下降,公开页应避免按 Cookie 区分。- 如何查看实际缓存键?答:按后端规则组合前缀、版本、路径、查询串与 vary 归一化值。
04.7.16.4-033 KEY_PREFIX 与 CACHE_VERSION 解决什么问题?
一句话结论
KEY_PREFIX 给同一缓存后端上的不同应用/环境加命名空间,避免 key 冲突;CACHE_VERSION 是缓存版本号,结构或序列化格式变更时提升版本即可让旧条目整体失效,无需手动清理。set/get 可单独传 version 覆盖默认版本。
概念解释
- 前缀隔离多项目共用 Redis;版本用于平滑切换缓存 schema。
- 提升版本后旧 key 留在后端直到 TTL 过期,不会主动删除。
原理流程
- 配置
KEY_PREFIX(如环境名)与CACHE_VERSION(整数)。 - 实际存储键 = 前缀 + 版本 + 业务键名。
- 代码
cache.get/set按当前版本读写。 - 数据格式不兼容时升版本,旧版本自然淘汰。
代码或图示
CACHES = {
"default": {
"BACKEND": "django.core.cache.backends.redis.RedisCache",
"LOCATION": "redis://127.0.0.1:6379/0",
"KEY_PREFIX": "ann_prod",
"VERSION": 1,
}
}
常见误区
- 多环境共用 Redis 无前缀:开发缓存覆盖生产条目。
- 序列化类路径变更后不升版本:反序列化旧对象失败。
- 手动拼业务键时漏掉前缀约定:同一数据出现两份缓存。
追问
- 版本能按 key 单独指定吗?答:
cache.get(key, version=2)支持,用于灰度迁移期间并存。 - 前缀太长有代价吗?答:key 内存占用略增,可读与隔离优先。
- 如何批量清某应用缓存?答:按前缀扫描删除,或提升版本;生产慎用
cache.clear()清全库。
04.7.16.4-034 什么是缓存击穿?如何兜底?
一句话结论
热点 key 过期瞬间,大量并发请求同时未命中缓存,全部回源数据库,瞬间压垮下游。兜底:热点 key 互斥重建(只放一个请求查库,其余等待旧值或短暂空值)、热点数据不过期改异步刷新、加分布式锁或单飞机制。击穿针对“单个高并发热点”,与穿透(查询不存在数据)、雪崩(大批同时过期)区分。
概念解释
- 击穿发生在失效时刻,平时缓存正常;热点越热,瞬间回源压力越大。
- 互斥重建要控制锁超时与降级值,避免持锁阻塞全部请求。
原理流程
- 热点条目 TTL 到期,缓存中无值。
- 并发请求同时
get未命中,准备回源。 - 加锁/单飞:第一个请求查库重建缓存,其余等待或读旧值/空值。
- 重建完成后释放锁,后续请求命中新值。
代码或图示
from django.core.cache import cache
import time
def hot_detail(key, loader):
value = cache.get(key)
if value is not None:
return value
lock = f"lock:{key}"
if cache.add(lock, "1", timeout=5):
try:
value = loader()
cache.set(key, value, timeout=300)
return value
finally:
cache.delete(lock)
time.sleep(0.05)
return cache.get(key) # 等待重建后再读
常见误区
- 所有请求无锁回源:击穿时数据库连接被打满。
- 锁粒度太粗:一个热点阻塞其他热点重建。
- 降级返回空值不区分场景:错误页面扩散,应保留旧值或兜底数据。
追问
- 击穿与雪崩区别?答:击穿是单个热点过期并发回源;雪崩是大量 key 同时过期导致整体回源。
- 互斥锁用什么实现?答:缓存
add原子占键、分布式锁或数据库行锁,按后端选型。 - 热点数据可以永不过期吗?答:可由后台任务定期刷新,避免请求期重建,但要接受刷新窗口的陈旧。
04.7.16.4-035 什么是缓存穿透?怎么防?
一句话结论
查询不存在的数据(非法 ID、恶意探测),缓存永远未命中,请求反复打到数据库。防护:缓存空值(短 TTL 存 None/空标记)、布隆过滤器前置拦截、参数与存在性校验在入口拒绝。穿透针对“根本不存在的记录”,与击穿的“存在但刚过期”不同。
概念解释
- 恶意构造大量不存在 ID 遍历接口,是常见爬虫/攻击手段。
- 空值缓存要短过期,避免真实数据创建后长期读到空标记。
原理流程
- 请求查询一个数据库不存在的对象。
- 缓存未命中,回源查库为空。
- 写入短 TTL 空标记,后续相同查询命中空值不再回源。
- 前置过滤器(布隆过滤器/参数规则)直接拦截明显非法请求。
代码或图示
def get_post(post_id):
key = f"post:{post_id}"
value = cache.get(key)
if value is not None:
return None if value == "__none__" else value
post = Post.objects.filter(pk=post_id).first()
if post is None:
cache.set(key, "__none__", timeout=60)
else:
cache.set(key, post, timeout=300)
return post
常见误区
- 空值长期缓存:对象后来创建,接口仍返回空。
- 只在应用层防穿透:恶意流量先打到数据库连接,入口限流与校验要前置。
- 布隆过滤器误判:只拦截“一定不存在”,存在概率内仍需回源校验。
追问
- 穿透与击穿对比?答:穿透查不存在的数据,缓存永不命中;击穿查存在的数据,过期瞬间并发回源。
- 空值用什么标记?答:区别于合法空结果的哨兵值,序列化后存入缓存。
- 列表/搜索接口怎么防穿透?答:结果集为空也短缓存,过滤非法分页与参数。
04.7.16.4-036 什么是缓存雪崩?如何缓解?
一句话结论
大批缓存条目在同一时刻集中过期,或缓存后端整体故障,请求集体回源数据库,导致下游过载。缓解:TTL 加随机抖动避免同时失效、热点数据分级过期、缓存高可用与多副本、回源限流降级、预热关键数据。雪崩是“面”上的大面积失效,区别于单 key 击穿。
概念解释
- 同一批初始化的缓存若 TTL 相同,会在同一时刻集体到期。
- 缓存宕机时没有兜底策略,数据库直接承受全部读流量。
原理流程
- 批量条目 TTL 一致,到达时刻集中过期。
- 并发请求未命中,回源量突增。
- 数据库/下游连接耗尽,响应变慢甚至雪崩扩散。
- 随机过期、互斥重建、限流降级与缓存集群冗余压低风险。
代码或图示
import random
def set_jitter(key, value, base=300):
timeout = base + random.randint(-30, 30)
cache.set(key, value, timeout=timeout)
常见误区
- 所有列表/详情缓存用固定 TTL:到期时刻重合,定期冲击数据库。
- 缓存故障直接打穿数据库:缺少熔断与降级静态/兜底数据。
- 上线后无预热:冷启动全部未命中,首波流量压库。
追问
- 雪崩与击穿、穿透的一句话区分?答:面失效(雪崩)、点过期并发(击穿)、查不存在(穿透)。
- TTL 随机幅度多大合适?答:在基础时长上加减 10%–20% 抖动,按业务容忍度调整。
- 缓存集群高可用怎么做?答:主从/哨兵/集群部署,客户端重试与降级,避免单点故障。
04.7.16.4-037 缓存更新策略有哪几种?
一句话结论
常见策略:Cache-Aside(旁路缓存,读时回填、写库后删缓存)、写穿(写请求同步更新缓存)、写回(先写缓存异步落库)。Django 项目最常用旁路缓存:更新数据库后删除缓存条目,下次读重建;要求强一致的关键数据不宜长缓存。删除比更新缓存更安全,避免并发写造成脏覆盖。
概念解释
- 旁路缓存:缓存不承担写入主路径,业务先写库再失效缓存。
- 先更新库还是先删缓存:常见顺序是先更新库、再删缓存;并发下仍有小概率旧值回填,按一致性要求评估。
原理流程
- 读:查缓存,未命中查库并回填。
- 写:更新数据库,然后删除对应缓存键。
- 下次读取未命中,从库重建新值。
- 多关联条目(详情 + 列表 + 计数)需一并失效。
代码或图示
def update_post(post, **fields):
for k, v in fields.items():
setattr(post, k, v)
post.save()
cache.delete(f"post:{post.pk}")
cache.delete("post:latest")
常见误区
- 写库后更新缓存而不是删除:并发请求可能把旧值覆盖进缓存。
- 只删详情缓存不删列表/计数:列表显示旧标题或旧数量。
- 长 TTL + 不主动失效:陈旧窗口覆盖整个 TTL 周期。
追问
- 先删缓存还是先更库?答:旁路缓存通常先更库再删缓存;先删缓存并发读可能回填旧值。
- 缓存与库双写一致性能做到多强?答:旁路缓存有短暂陈旧窗口,强一致场景应直读库或加版本校验。
- 关联缓存怎么批量失效?答:按 key 规则归类,更新时删除相关前缀下条目,或升版本整体淘汰。
04.7.16.4-038 模板片段缓存 {% cache %} 怎么用?
一句话结论
{% cache 超时秒 片段名 %} 把模板内一段渲染结果缓存起来,适合页面中重复出现的公共块(侧栏、统计块、推荐列表);缓存键按片段名与传入参数生成。个性化内容必须把区分维度(用户、语言)作为标签传入,否则不同用户共享同一片段。
概念解释
- 片段缓存依赖
cache模板标签,需在模板{% load cache %}。 - 片段不随整页缓存刷新,失效策略与页面缓存独立。
原理流程
- 模板加载
cache标签,定义片段块与缓存标签。 - 渲染时先按片段名与参数查缓存,命中直接输出。
- 未命中渲染片段内容,按 timeout 回填。
- 数据更新后按对应键失效片段。
代码或图示
{% load cache %}
{% cache 300 "sidebar" request.user.id %}
<aside>...</aside>
{% endcache %}
常见误区
- 片段标签不带用户/语言参数:登录用户看到他人侧栏。
- 缓存含实时变动数字又不失效:计数长期陈旧。
- 把整页都包进
{% cache %}:等同整页缓存,应直接用cache_page。
追问
- 片段缓存键包含哪些参数?答:标签后的所有位置参数,作为键组成部分。
- 片段能传复杂对象做标签吗?答:建议传 id/标识等可序列化标量,避免对象参与键计算。
- 片段缓存后端与页面缓存同一套吗?答:默认用
CACHES["default"],可在标签指定后端。
04.7.16.4-039 Redis 缓存后端如何配置连接池?
一句话结论
Django 5.x 内置 RedisCache 基于 redis-py 客户端,连接参数在 LOCATION 与 OPTIONS 中配置;连接池大小、超时、解码按并发规模设置。生产建议会话缓存与业务缓存分库或分前缀,监控连接数、命中率与内存淘汰;多 worker 进程各自持有连接池,总连接数 = worker × 池大小,不能超过 Redis 上限。
概念解释
- 内置后端与第三方 django-redis 配置项有差异,按所用后端文档核对。
- 连接复用避免每次请求新建 TCP 连接,降低握手开销。
原理流程
CACHES指定 Redis 后端与地址。- 客户端按
OPTIONS建立连接池,进程内复用连接。 - 缓存读写从池取连接,用完归还。
- 监控命中率、键数量、内存与淘汰策略,规划容量。
代码或图示
CACHES = {
"default": {
"BACKEND": "django.core.cache.backends.redis.RedisCache",
"LOCATION": "redis://127.0.0.1:6379/0",
"OPTIONS": {
"socket_timeout": 3,
"socket_connect_timeout": 3,
},
"KEY_PREFIX": "ann",
}
}
常见误区
- 池大小按单机设置,忽略多 worker 总量:Redis 连接数被打满。
- 会话与大 value 业务缓存同库:大 key 淘汰影响登录态。
- 未设超时:缓存客户端挂起会拖住整个请求线程。
追问
- Redis 持久化影响缓存吗?答:持久化防进程崩溃丢数据,但内存淘汰与备份窗口仍可能丢条目。
- 如何看缓存命中率?答:Redis INFO 的 keyspace hits/misses 与后端统计,按业务键拆分观察。
- 缓存能存二进制吗?答:客户端按序列化协议处理,复杂对象走 pickled/JSON 序列化。
04.7.16.4-040 缓存与数据库一致性如何权衡?
一句话结论
缓存天然引入陈旧窗口:旁路缓存下“写库后删缓存”到下次重建之间,读到的是旧值;并发写、多副本缓存、下游 CDN 都会放大不一致。按数据敏感度分级:强一致数据直读库,读多写少数据加 TTL 与主动失效,关键写操作清理关联缓存并监控陈旧告警。
概念解释
- 一致性要求越高,缓存收益越低;不要为性能牺牲必须实时正确的数据。
- 多副本/多级缓存(应用 → Redis → CDN)每层都有各自陈旧窗口。
原理流程
- 识别数据一致性等级:实时金额、库存 vs 资讯、统计。
- 读路径缓存,写路径更新库并失效缓存。
- 关联条目(详情、列表、计数、聚合)一并清理。
- 监控缓存未命中与陈旧反馈,必要时降级直读库。
代码或图示
def change_stock(order):
with transaction.atomic():
order.reserve_stock()
cache.delete(f"stock:{order.sku}")
cache.delete("stock:ranking")
常见误区
- 库存、余额类数据长缓存:超卖/错账风险,应直读库或加版本校验。
- 删缓存只删主键:列表、推荐、计数仍展示旧值。
- 依赖 TTL 兜底一致性:陈旧时间不可控,写频繁数据应主动失效。
追问
- 并发写缓存怎么避免脏覆盖?答:写路径删缓存而非更新缓存;需要更新时带版本号比较。
- 数据库主从延迟会影响缓存吗?答:从库延迟期间回填的是旧值,缓存放大延迟窗口。
- 如何验证缓存陈旧?答:对比缓存值与库值抽样,记录差异比例与持续时长。
04.7.16.4-041 手动缓存 get/set/add/delete 各有什么行为差异?
一句话结论
get(key) 未命中返回 None(可配默认值);set(key, value, timeout) 无条件写入覆盖;add(key, value, timeout) 仅在键不存在时写入,已存在不覆盖,适合抢占锁;delete(key) 删除条目;incr/decr 对数值原子增减。add 的原子性常用于单飞锁与防重复提交。
概念解释
set覆盖语义与add占用语义区分明确,混用会导致锁失效或重复写入。- 超时
None用后端默认 TTL,0表示不过期(按后端支持)。
原理流程
- 读:
get命中返回值,未命中走回填逻辑。 - 写:
set直接覆盖;add先判断存在性,原子占键成功才写入。 - 删:
delete移除条目,不存在也不报错。 - 计数:
incr/decr在后端原子操作,避免读改写竞态。
代码或图示
cache.set("page:1", data, timeout=120)
if cache.add("lock:order:99", "1", timeout=10):
try:
... # 占锁成功执行
finally:
cache.delete("lock:order:99")
count = cache.incr("counter:visit")
常见误区
- 用
set做锁:覆盖他人持有的锁,互斥失效,应add。 - 把合法值
None与未命中混淆:get未命中返回None,需用哨兵或区分类型。 incr键不存在行为按后端:部分后端报错,先set初始值。
追问
cache.get_or_set是什么?答:未命中时调用回调加载并回填,简化读路径写法。- 批量读写有接口吗?答:
get_many/set_many减少网络往返,适合多 key 场景。 delete支持前缀吗?答:基础接口按精确键删除,前缀清理需后端扫描或升版本。
04.7.16.4-042 什么场景不应该使用缓存?
一句话结论
不适合缓存:强一致实时数据(余额、库存、风控判定)、写入频繁且读少的数据、单次计算很轻的小查询、强个性化且无复用的内容、调试期需要看实时结果的功能。缓存引入一致性、失效与复杂度成本,命中率低时反而增加开销与故障面。
概念解释
- 缓存收益 = 命中节省的下游成本 − 缓存维护与一致性代价。
- 命中率低、key 高度分化时,缓存层是纯额外负担。
原理流程
- 评估读多写少程度、计算成本、复用率与一致性要求。
- 满足“读远多于写、计算重、可容忍陈旧、可复用”才上缓存。
- 不满足场景直读数据库/服务层计算。
- 上线后用命中率与回源量验证是否值得保留。
代码或图示
# 轻量且实时:直接查库,不加缓存
def current_balance(user):
return Wallet.objects.get(user=user).balance
常见误区
- 为“可能用到”提前缓存:key 分散、命中率低,内存被占满。
- 把每次都变的个性化结果缓存:缓存条目近乎不复用。
- 调试环境开生产缓存策略:改数据看不到效果,误以为代码未生效。
追问
- 怎么判断缓存该不该留?答:看命中率、回源量、下游压力下降幅度与陈旧投诉。
- 临时排查问题怎么绕过缓存?答:删对应键或短时禁用缓存后端(测试用 DummyCache)。
- 缓存层级越多越好吗?答:层级越多一致性窗口越长,按收益逐层引入。
04.7.16.4-043 Django 信号机制如何工作?receiver 如何注册?
一句话结论
信号是发布订阅机制:Signal 实例维护 receiver 函数列表,模型/框架在特定时机 send() 通知所有 receiver;receiver 用 @receiver(signal) 装饰或 signal.connect() 注册,参数带 sender 与实例。信号解耦了“事件发生”与“事件后续动作”,但执行仍在同一调用链内,不是异步消息队列。
概念解释
- 内置信号:
pre_save/post_save、pre_delete/post_delete、m2m_changed、post_migrate、request_started/finished等。 - receiver 签名
(sender, instance, **kwargs),可按sender过滤只接收特定模型。
原理流程
- 在应用
ready()或模块导入期连接信号,确保 receiver 已注册。 - 业务代码触发模型保存/删除,框架发出对应信号。
- 信号遍历 receiver 依次调用,传入发送者与实例。
- receiver 执行副作用,返回值不回传主流程(除非显式约定)。
代码或图示
from django.db.models.signals import post_save
from django.dispatch import receiver
from .models import Profile, User
@receiver(post_save, sender=User)
def create_profile(sender, instance, created, **kwargs):
if created:
Profile.objects.create(user=instance)
常见误区
- receiver 未在
ready()导入注册:信号触发时无人响应,静默失效。 - 信号当成异步任务:receiver 同步执行在请求链路内,慢操作拖慢主请求。
- receiver 抛异常向上传播:会中断保存/删除主流程,需在内部捕获兜底。
追问
- 信号能跨进程/跨服务吗?答:不能,仅同进程内发布订阅;跨进程用消息队列(Celery/Redis Stream 等)。
- 一个信号能挂多个 receiver 吗?答:能,按注册顺序执行,注意顺序依赖。
- 如何断开信号?答:
signal.disconnect(receiver, sender=...),测试隔离时常用。
04.7.16.4-044 pre_save 与 post_save 分别在什么时机触发?实例状态有何差异?
一句话结论
pre_save 在 save() 执行 SQL 之前触发,实例尚未入库,主键可能为 None,可修改字段后再保存;post_save 在 INSERT/UPDATE 完成后触发,实例已有主键与数据库值,created 参数区分新建还是更新。post_save 常用于创建关联对象、发通知,pre_save 用于派生字段计算与最终校验。
概念解释
- 两次信号都在模型实例方法调用链内,尚未等到外层事务提交。
raw=True表示迁移 fixture 加载,receiver 应跳过业务副作用。
原理流程
- 调用
instance.save(),框架先发pre_save。 - receiver 可调整实例字段,随后执行 SQL。
- SQL 完成后发
post_save,携带created标志。 - 关联对象创建、缓存失效、通知等挂在
post_save。
代码或图示
@receiver(pre_save, sender=Article)
def derive_slug(sender, instance, **kwargs):
if not instance.slug:
instance.slug = slugify(instance.title)
@receiver(post_save, sender=Article)
def after_save(sender, instance, created, **kwargs):
cache.delete(f"article:{instance.pk}")
常见误区
- 在
pre_save里访问自增主键:尚未 INSERT,主键为None。 post_save中再次保存同一实例:递归触发信号,注意防重入。- 把
created当成“首次发布”:它只表示本次 save 是 INSERT 还是 UPDATE。
追问
post_save能拿到更新前后的旧值吗?答:信号只传当前实例,旧值需在pre_save缓存或字段快照里读取。- 批量
bulk_create发信号吗?答:不发save信号,批量操作绕过实例保存钩子。 - 信号 receiver 里能改实例吗?答:
pre_save可以影响入库值;post_save改值需再次save()。
04.7.16.4-045 pre_delete/post_delete 与 m2m_changed 何时触发?
一句话结论
pre_delete 在删除 SQL 前触发,实例仍在;post_delete 删除完成后触发,实例已从库移除但对象引用仍可用。m2m_changed 在多对多关系增删、清空、同步时触发,action 标识 pre_add/post_add/pre_remove/post_remove/pre_clear/post_clear。关联级联删除会沿外键链逐模型触发对应信号。
概念解释
- 删除信号同样处于事务内,回滚后已执行的 receiver 副作用不会自动撤销。
- m2m 信号不携带主模型完整实例,需通过
instance与pk_set判断。
原理流程
- 删除对象,先
pre_delete,再执行 DELETE SQL,然后post_delete。 - 外键级联删除逐个触发子对象信号。
- m2m 关系变更时按动作阶段发
m2m_changed。 - receiver 做清理文件、释放缓存、记录审计等收尾工作。
代码或图示
@receiver(post_delete, sender=Attachment)
def cleanup_file(sender, instance, **kwargs):
instance.file.delete(save=False)
@receiver(m2m_changed, sender=Post.tags.through)
def tag_changed(sender, instance, action, **kwargs):
if action == "post_add":
cache.delete("tag:popular")
常见误区
post_delete后还查数据库取该对象:记录已删,查询为空,应使用信号传入的实例引用。- 级联删除信号漏处理子文件:主记录删了,磁盘/对象存储残留。
- m2m 信号在
pre_*阶段修改pk_set:动作阶段不同,可改性需按 Django 版本核对。
追问
- 级联删除一定会发子对象信号吗?答:数据库级联(
on_delete=CASCADE由 ORM 模拟时逐对象删除会触发;数据库外键约束级联可能绕过 ORM 信号)。 m2m_changed的pk_set是什么?答:本次动作涉及的关联主键集合。- 清空 m2m 触发哪个 action?答:
pre_clear/post_clear。
04.7.16.4-046 post_migrate 信号适合做什么?
一句话结论
post_migrate 在迁移完成后触发,适合初始化默认数据(创建默认组、权限、配置项)、更新 content type 相关记录;幂等是硬要求:receiver 用 get_or_create,重复执行不产生重复数据。它替代手工 fixtures 与启动期硬编码初始化,但不应放重任务或外部依赖。
概念解释
- 信号携带
sender、app_config、verbosity,可按应用过滤。 - 迁移数据初始化与代码版本绑定,适合“每次部署确保存在”的基础记录。
原理流程
migrate执行完某应用迁移,框架发post_migrate。- receiver 按应用判断,
get_or_create默认组/配置。 - 重复迁移不新增重复记录。
- 复杂种子数据仍建议用数据迁移脚本管理版本。
代码或图示
from django.db.models.signals import post_migrate
from django.dispatch import receiver
from django.contrib.auth.models import Group
@receiver(post_migrate)
def seed_default_groups(sender, **kwargs):
Group.objects.get_or_create(name="editor")
Group.objects.get_or_create(name="reviewer")
常见误区
- receiver 用
create不判重:每次迁移重复插入默认数据。 - 在
post_migrate调外部 API 或发邮件:迁移环境可能无网络,阻塞发布流程。 - 把业务运营数据当种子初始化:应走后台录入或专门数据迁移,不随代码部署自动生成。
追问
post_migrate每次启动都跑吗?答:只在migrate命令执行后触发,不是进程启动期。- 数据迁移与信号初始化怎么选?答:需要随版本演进、回滚配套的用数据迁移;纯幂等默认项可用信号。
- 如何按应用过滤 receiver?答:判断
kwargs["app_config"].label对应目标应用。
04.7.16.4-047 信号与事务的边界是什么?为什么 post_save 不等于提交后?
一句话结论
信号在模型 save() 调用链内同步触发,此时外层 transaction.atomic() 可能尚未提交;post_save receiver 读到的是未提交事务内的数据,若事务回滚,已执行的 receiver 副作用(发通知、写缓存、调外部)不会自动撤销。需要“提交成功后才执行”的动作,应挂 transaction.on_commit 而不是信号。
概念解释
- 信号触发时机 ≠ 事务提交时机,二者是两个层次。
- 回滚后外部系统已被通知/写入,形成分布式不一致。
原理流程
- 视图包
atomic,调用save()发post_save。 - receiver 立即执行,可能投递任务、发通知。
- 后续业务异常导致事务回滚。
- 已发出的外部副作用无法收回;
on_commit回调只在提交成功后执行。
代码或图示
from django.db import transaction
@receiver(post_save, sender=Order)
def after_order_save(sender, instance, created, **kwargs):
if not created:
return
transaction.on_commit(lambda: notify_customer(instance.pk))
常见误区
- 在
post_save直接发异步任务:任务可能读到未提交或已回滚的数据。 - 以为信号结束事务就提交:外层事务边界由视图/服务层决定。
- receiver 内开新事务与主事务混算:隔离级别与可见性容易判断错。
追问
on_commit回调何时执行?答:当前最外层事务提交成功后;事务回滚则不执行。- 信号 receiver 能感知事务是否提交吗?答:不能直接感知,需用
on_commit注册延迟动作。 - 测试中回滚会触发
on_commit吗?答:TestCase包事务回滚,on_commit不执行;测试需显式提交或用TransactionTestCase。
04.7.16.4-048 为什么不建议在信号里做重活?
一句话结论
信号 receiver 同步运行在请求/事务链路内,重活(大查询、外部 API、文件处理、批量计算)会拉长主请求、占用数据库连接、放大失败影响;信号异常还可能中断主流程。重任务应投递异步队列(Celery),信号只做“触发投递”的轻量动作,且注意提交边界。
概念解释
- 信号隐藏了调用关系:新人读视图看不到后续重逻辑,排查与排障困难。
- 同步阻塞无法利用 worker 弹性扩容,主进程被慢下游拖住。
原理流程
- 模型保存触发信号。
- 若 receiver 直接处理重业务,与主请求争抢 CPU/连接。
- 慢下游超时导致请求堆积,数据库连接耗尽。
- 正确做法:信号内校验后
on_commit投递任务,由 worker 异步执行。
代码或图示
@receiver(post_save, sender=Report)
def queue_render(sender, instance, created, **kwargs):
if created:
transaction.on_commit(lambda: render_report.delay(instance.pk))
常见误区
- receiver 里循环查库/批量导出:主请求超时,接口雪崩。
- 信号里直接调第三方支付/短信:外部故障拖垮保存流程。
- 多个 receiver 叠加重活:单模型一次保存触发一串同步任务,链路不可控。
追问
- 信号里发 HTTP 请求超时怎么办?答:不应在信号内同步调用;投递异步任务并在 worker 内设超时与重试。
- 轻量动作有哪些适合信号?答:创建一对一关联对象、失效缓存、写审计记录等毫秒级操作。
- 信号能做限流/熔断吗?答:不适合,横切控制应在中间件/服务层显式实现。
04.7.16.4-049 什么时候应该用显式服务层调用替代信号?
一句话结论
当后续动作是业务流程的必经步骤、需要参与事务、失败要回滚或需要明确可见性时,应在服务层显式调用,而不是藏在信号里;信号适合“模型事件的附加通知/衍生记录”这类弱耦合动作。显式调用让流程可读、可测试、事务边界清晰,避免信号隐式串联导致的维护成本。
概念解释
- 判断标准:拿掉这段动作业务是否还成立;成立且为附属 → 信号;核心流程 → 服务层。
- 显式调用可在单测中直接断言调用链,信号测试需额外隔离连接。
原理流程
- 梳理保存后动作:关联创建、通知、缓存失效、外部同步。
- 核心且需事务一致的动作放进服务方法,与保存同事务。
- 附属通知/衍生记录可保留信号,或在服务层末尾显式触发。
- 测试覆盖服务流程,信号只测试自身 receiver 逻辑。
代码或图示
# 显式服务层:流程可见、事务可控
def create_order(items, user):
with transaction.atomic():
order = Order.objects.create(user=user)
OrderLine.bulk_create_for(order, items)
deduct_inventory(order) # 核心扣减,随事务回滚
notify_customer.delay(order.pk) # 附属通知走异步
return order
常见误区
- 把核心领域规则写进信号:视图/服务层看不到规则,测试与复用困难。
- 信号链式触发:A 保存发信号建 B,B 保存又触发 C,链路失控。
- 用信号绕过事务边界:需要回滚一致性的动作不能放到提交后或异步任务。
追问
- 信号最大的代价是什么?答:调用关系隐式,阅读代码时容易遗漏副作用,调试链路长。
- 关联对象创建适合信号吗?答:一对一 Profile 这类标准附属记录可以;复杂聚合关系应在服务层显式建。
- 重构存量信号怎么入手?答:先列出所有 receiver 与触发点,按核心/附属分类,核心动作上移服务层。
04.7.16.4-050 transaction.on_commit 解决什么问题?
一句话结论
transaction.on_commit(callback) 注册一个回调,仅在当前事务成功提交后执行;回滚或未提交则不执行。它解决“提交后才允许副作用”的问题:发通知、投递任务、写缓存、调外部系统都应挂这里,避免任务读到未提交数据或在回滚后产生脏副作用。回调在提交后同步执行,重任务仍需再投递异步队列。
概念解释
- 嵌套
atomic下,回调等到最外层事务提交才触发。 - 回调内异常不会回滚已提交数据,需自行记录与告警。
原理流程
- 业务方法在
atomic内保存数据并注册on_commit回调。 - 事务提交成功,框架依次执行注册的回调。
- 事务回滚,回调列表丢弃,不执行。
- 回调内投递 Celery 任务,worker 读取的已是提交后数据。
代码或图示
from django.db import transaction
def submit_article(form):
with transaction.atomic():
article = form.save()
transaction.on_commit(lambda: after_submit(article.pk))
def after_submit(pk):
article = Article.objects.get(pk=pk)
notify_editors.delay(pk)
常见误区
- 回调里再开事务或依赖主事务状态:提交后上下文已变化,按新状态查询。
- 注册回调在事务外:
on_commit无活动事务时会立即执行。 - 回调抛错无人处理:提交后失败只记录日志,不影响主数据,需补偿机制。
追问
on_commit回调顺序?答:按注册顺序执行,先注册先执行。- 测试如何触发回调?答:
TestCase整体回滚不触发;TransactionTestCase显式提交后触发,或测试中手动调用回调。 - 回调能访问请求对象吗?答:提交后请求可能已结束,应把所需数据(主键/标识)传入闭包,不依赖请求上下文。
04.7.16.4-051 信号解耦的代价与适用边界是什么?
一句话结论
信号收益是发布方与接收方解耦,新增附属动作不改模型代码;代价是调用关系隐式、执行顺序难追踪、调试链路长、事务边界易踩坑。适用:标准附属衍生(Profile 创建、缓存失效、审计记录);不适用:核心业务规则、需要事务一致性的流程、重任务、跨进程协作。
概念解释
- 解耦不是越彻底越好:关键流程的可见性与可测试性优先于减少耦合。
- 信号数量与触发点要克制,避免“保存即一串副作用”。
原理流程
- 评估动作与模型的依赖强度:附属观察 → 信号;核心流程 → 服务层。
- 信号 receiver 保持轻量、幂等、可独立测试。
- 文档化信号触发点与 receiver 清单,弥补隐式调用。
- 复杂事件协作转向消息队列,明确生产消费边界。
代码或图示
# 清单示例:在应用 README 或模块 docstring 记录
# post_save(User) → create_profile
# post_save(Order) → on_commit: notify_customer
常见误区
- 把信号当万能扩展点:任何保存后逻辑都挂信号,模型副作用堆积。
- 跨应用信号互相依赖顺序:receiver 注册顺序影响结果,耦合回隐式顺序。
- 信号测试与主流程测试混在一起:回滚环境
on_commit不触发,断言易失败。
追问
- 信号和观察者模式什么关系?答:信号是 Django 内置的观察者实现,发布者维护订阅者列表。
- 如何降低信号隐式成本?答:命名清晰、集中注册、文档清单、单测覆盖 receiver。
- 什么时候考虑移除信号?答:动作进入核心流程、需要事务一致或多分支复用时,上移服务层。
04.7.16.4-052 信号如何与 Celery 集成投递异步任务?
一句话结论
典型模式:post_save/post_delete receiver 内用 transaction.on_commit 包裹 task.delay(pk),确保任务在数据提交后投递,worker 按主键重新查询读取最新数据。不要把实例对象直接序列化进任务,传主键;任务内做幂等与重试处理。信号只负责触发投递,业务处理在 Celery worker 完成。
概念解释
- 直接在
post_savedelay:事务未提交时 worker 可能查不到或读到旧数据。 - 任务参数只传可序列化标识,避免对象状态在队列中过期。
原理流程
- 模型保存,
post_savereceiver 判断创建/更新场景。 on_commit回调注册提交后动作。- 提交成功,回调调
task.delay(instance.pk)投递任务。 - worker 消费任务,按主键查库执行,失败按队列策略重试。
代码或图示
# tasks.py
from celery import shared_task
@shared_task
def notify_customer(order_pk):
order = Order.objects.get(pk=order_pk)
# 发送通知、写外部记录
# signals.py
@receiver(post_save, sender=Order)
def on_order_created(sender, instance, created, **kwargs):
if created:
transaction.on_commit(lambda: notify_customer.delay(instance.pk))
常见误区
- 任务参数传模型实例:序列化快照过期,且耦合模型状态。
- 未用
on_commit:任务在回滚前投递,消费者读到不存在的记录。 - 任务非幂等:重试导致重复通知/重复扣减,需按业务去重或允许重复。
追问
- Celery 任务失败会回滚订单吗?答:不会,提交后主数据已落库;需失败告警与补偿任务。
- 信号投递与视图直接投递怎么选?答:多处复用的触发点放信号;单流程显式投递放服务层更清晰。
- 如何避免重复投递?答:数据库唯一约束、任务内状态判断、
on_commit保证仅提交后一次。
04.7.16.4-053 django.contrib 各内置组件分别负责什么?
一句话结论
auth 用户/权限/组;sessions 会话存储;messages 一次性提示消息;contenttypes 模型注册表与通用外键;admin 后台管理界面;staticfiles 静态文件收集服务;sites 多站点配置;humanize 数值格式化过滤器;postgres PostgreSQL 特性扩展。按需加入 INSTALLED_APPS,未注册的组件能力不生效。
概念解释
- 组件之间有依赖:
admin依赖auth、contenttypes、messages;messages依赖sessions。 - 组件表结构随迁移创建,移除前需评估数据。
原理流程
INSTALLED_APPS列出启用组件。- 启动期注册模型、模板标签、上下文处理器与中间件。
- 迁移创建对应数据表与默认权限。
- 视图/模板按组件 API 使用其能力。
代码或图示
INSTALLED_APPS = [
"django.contrib.admin",
"django.contrib.auth",
"django.contrib.contenttypes",
"django.contrib.sessions",
"django.contrib.messages",
"django.contrib.staticfiles",
]
常见误区
- 漏装依赖组件:Admin 登录/消息渲染报错或用户对象缺失。
- 把不需要的组件全装上:迁移表与启动开销增加,攻击面变大。
- 直接改
contrib源码:升级被覆盖,定制应在项目层扩展。
追问
contenttypes解决什么问题?答:让外键/权限跨模型引用,实现通用关联(如通用附件、评论)。sites什么时候用?答:一套代码部署多个站点、按域名区分内容配置时。staticfiles只在开发期有用吗?答:开发期服务静态文件,collectstatic也是其生产收集流程。
04.7.16.4-054 Django 国际化(i18n)怎么组织?
一句话结论
代码与模板中用 gettext 标记待译字符串,makemessages 抽取生成 .po 翻译文件,翻译后 compilemessages 编译为 .mo;LocaleMiddleware 按请求头/会话/URL 选择语言,模板与代码按当前语言输出。语言文件按 LOCALE_PATHS 目录与语言代码组织,翻译文本不硬编码在业务逻辑里。
概念解释
- 代码用
_("...")或gettext_lazy;模板用{% trans %}/{% blocktrans %}。 - 懒翻译(
gettext_lazy)在求值时才取当前语言,适合模型字段默认值。
原理流程
- 源码标记可翻译字符串。
makemessages -l zh_Hans抽取到.po,补翻译条目。compilemessages生成二进制.mo。- 中间件解析语言偏好,渲染时按当前语言查翻译目录。
代码或图示
from django.utils.translation import gettext_lazy as _
class Article(models.Model):
title = models.CharField(max_length=100, verbose_name=_("标题"))
{% load i18n %}
<h1>{% trans "文章列表" %}</h1>
常见误区
- 字符串拼接后再翻译:语序无法适配不同语言,应保留带参数槽位的整句翻译。
- 模型定义用
gettext而非gettext_lazy:导入期固定语言,切换语言不生效。 - 翻译文件未编译:线上只显示原文,
.mo缺失不报错提示。
追问
- 语言偏好如何确定?答:
LocaleMiddleware按 URL 前缀、会话、Cookie、Accept-Language依次匹配。 - 翻译文件放哪?答:应用
locale/或项目LOCALE_PATHS指定目录,按语言代码分层。 - 复数形式怎么处理?答:
ngettext/{% blocktrans count %}按语言复数规则选择译文。
04.7.16.4-055 USE_TZ 下 naive 与 aware datetime 有什么陷阱?
一句话结论
USE_TZ=True 时 Django 存储与处理 aware datetime(带时区信息);naive datetime(无时区)混入比较或赋值会抛 TypeError 或产生错误时间。数据库存 UTC,展示时按 TIME_ZONE 或用户时区转换。常见错误:从外部库取 naive 时间直接入库、字符串解析不带时区、跨时区比较混用两类对象。
概念解释
- aware 对象带
tzinfo,naive 对象没有;Python 3 二者直接比较抛异常。 - Django 模型字段自动把 aware 值转 UTC 存储;读取后转回当前时区。
原理流程
- 配置
USE_TZ=True与TIME_ZONE。 - 代码构造 datetime 时用
django.utils.timezone工具附时区。 - 入库转 UTC 存储,出库转为时区感知对象。
- 模板/视图按目标时区格式化展示。
代码或图示
from django.utils import timezone
from datetime import datetime
now = timezone.now() # aware, UTC
naive = datetime(2026, 1, 1, 12, 0) # naive,避免直接入库
aware = timezone.make_aware(naive, timezone.get_current_timezone())
常见误区
- 直接用
datetime.now()入库:naive 对象,跨时区与比较出错。 - 解析前端时间字符串不带时区:默认按服务器时区理解,夏令时/地域偏差。
- 关闭
USE_TZ后混用历史 aware 数据:两套时间语义不一致,迁移需统一。
追问
timezone.now()返回什么时区?答:aware datetime,UTC 时刻;展示再转本地时区。- 数据库存本地时间还是 UTC?答:
USE_TZ=True存 UTC,避免夏令时与迁库问题。 - 如何把 naive 转 aware?答:
timezone.make_aware(value, current_timezone);UTC 可用timezone.utc。
04.7.16.4-056 时区在数据库存储与模板展示之间如何流转?
一句话结论
USE_TZ=True 时数据库统一存 UTC;模型字段读写自动在 UTC 与 aware datetime 间转换;模板通过 date/time 过滤器按当前 TIME_ZONE 渲染,多用户时区场景需在请求层切换到用户时区或在模板显式转换。跨时区业务(国际化、跨地域团队)要明确存储、传输、展示三层各自的时区口径。
概念解释
- 存储层 UTC 无关地域;展示层按时区偏好转换;传输层 API 建议 ISO 8601 带偏移。
- 服务器时区、数据库会话时区、应用
TIME_ZONE三者要对齐排查。
原理流程
- 写入:aware datetime 转 UTC 落库。
- 读取:字段返回 aware datetime(UTC 基准)。
- 展示:模板过滤器按当前时区格式化;需要用户时区则请求内
activate(tz)。 - 跨系统传输:用带时区偏移的 ISO 字符串,避免裸本地时间。
代码或图示
from django.utils import timezone
# 请求内按用户时区激活
timezone.activate(user.timezone)
# 模板
{{ article.created_at|date:"Y-m-d H:i" }}
常见误区
- 展示前没转时区:UTC 时间直接当本地时间显示,偏差固定小时数。
- 按服务器时区解释前端提交时间:用户时区未参与换算。
- 日志里打 naive 时间:跨服务排查时无法对齐时刻。
追问
TIME_ZONE与USE_TZ关系?答:USE_TZ=True下TIME_ZONE是默认展示/激活时区,存储仍为 UTC。- 怎么按用户时区切换?答:中间件或视图读取用户偏好,
timezone.activate(),结束deactivate()。 - 日期范围查询怎么避免时区偏差?答:用 aware 边界值,先转 UTC 再过滤,不按本地日期字符串裸比较。
04.7.16.4-057 messages 框架如何传递一次性提示?
一句话结论
messages 用于跨请求的一次性反馈:视图 messages.add_message(request, level, message) 写入会话,下一请求模板遍历 messages 渲染后清除。级别分 DEBUG/INFO/SUCCESS/WARNING/ERROR;存储后端依赖 session 或 cookie。刷新后消息不再出现,适合操作成功/失败提示。
概念解释
- 消息在会话中暂存,读取一次后清除,不是长期通知中心。
- 模板遍历
messages并按级别渲染样式类。
原理流程
- 视图处理后调用
messages.success/error(...)写入当前会话。 - 重定向到下一页面,
MessageMiddleware加载未读消息。 - 模板
{% for message in messages %}渲染。 - 消息标记已读,下次请求不再带出。
代码或图示
from django.contrib import messages
def save_profile(request):
form = ProfileForm(request.POST)
if form.is_valid():
form.save()
messages.success(request, "资料已保存")
return redirect("profile")
messages.error(request, "请检查表单")
{% for message in messages %}
<div class="msg {{ message.tags }}">{{ message }}</div>
{% endfor %}
常见误区
- 同请求渲染页面却依赖 messages:消息为下一请求设计,当前页提示应直接传上下文。
- 漏装
MessageMiddleware/session 后端:消息写不进会话,页面不显示。 - 把长期通知中心建在 messages 上:持久通知应入库建模。
追问
- 消息级别与标签怎么对应?答:
message.tags给出级别文本,可映射 CSS 类名。 - 消息能存富文本吗?答:支持字符串,HTML 需自行转义,避免 XSS。
- 不用 session 能存消息吗?答:可用 cookie 后端,容量受限且可读,敏感提示不要放。
04.7.16.4-058 Admin 与 auth 组件是什么关系?
一句话结论
django.contrib.admin 基于 auth 做后台界面:登录校验用认证体系,按 is_staff 与模型权限控制可见与可操作;ModelAdmin 配置列表、表单、筛选、内联与动作。Admin 是内部运营工具,不对外暴露;权限模型复用用户、组、权限三件套,行级归属仍需在自定义 Admin 方法中判断。
概念解释
- Admin 依赖
auth、contenttypes、sessions、messages组件。 - 模型注册
admin.site.register(Model, ModelAdmin)后进入后台导航。
原理流程
- 管理员登录走 auth 认证,校验
is_staff。 - 按用户权限显示对应应用与模型操作入口。
ModelAdmin定义列表列、搜索、过滤器、表单字段与内联。- 后台增改删记录写入业务表,可记录 Admin 操作日志。
代码或图示
from django.contrib import admin
from .models import Article
@admin.register(Article)
class ArticleAdmin(admin.ModelAdmin):
list_display = ("title", "author", "created_at")
list_filter = ("created_at",)
search_fields = ("title",)
常见误区
- 给外部用户开放 Admin:后台暴露模型与批量动作,应自建面向用户的界面。
- 在 Admin 里写复杂业务规则:维护困难,核心规则应在服务层复用。
- 依赖 Admin 做行级权限:默认只做模型级权限,归属过滤需覆写
get_queryset。
追问
- 如何限制 Admin 只看本部门数据?答:覆写
get_queryset按当前用户过滤,对象操作再覆写保存/删除校验。 - Admin 操作有日志吗?答:内置
LogEntry记录后台增改删,可在历史中查看。 - 自定义 Admin 页面怎么加?答:
ModelAdmin加视图方法或注册独立AdminSite视图。
04.7.16.4-059 如何做登录限流与暴力破解防护?
一句话结论
防护层:按用户名/IP 限制登录尝试次数,失败计数用缓存或数据库记录,超阈值锁定或要求验证码;登录失败统一提示防枚举;密码强度策略、MFA、异常地点告警作为纵深。Django 内置不提供登录限流,需中间件/装饰器/服务层计数,配合 Celery 或缓存过期释放锁定。
概念解释
- 限流维度:IP 防单机器爆破,用户名防定向破解,两者结合防绕过。
- 锁定要有过期与解锁机制,避免攻击者锁定正常账号。
原理流程
- 登录请求到达,读取该 IP 与用户名失败计数。
- 超阈值直接拒绝,不进入认证。
- 认证失败累加计数并设过期;成功清零。
- 连续失败触发验证码/锁定/告警,记录安全日志。
代码或图示
from django.core.cache import cache
from django.http import JsonResponse
def login_throttle(view):
def wrapped(request, *args, **kwargs):
key = f"login:fail:{request.META['REMOTE_ADDR']}"
if cache.get(key, 0) >= 5:
return JsonResponse({"detail": "尝试过多,请稍后再试"}, status=429)
response = view(request, *args, **kwargs)
if response.status_code == 401:
cache.set(key, cache.get(key, 0) + 1, timeout=300)
return response
return wrapped
常见误区
- 只按 IP 限流:分布式代理下误伤,且可换 IP 绕过;需结合用户名维度。
- 锁定永不过期:攻击者可恶意锁定他人账号。
- 失败响应区分“用户不存在/密码错误”:帮助枚举有效账号,应统一文案。
追问
- 密码策略在哪配置?答:
AUTH_PASSWORD_VALIDATORS校验长度、相似度、常见密码、数字组合。 - MFA 怎么接入?答:认证成功后追加二次验证步骤,或引入第三方认证后端/插件。
- 异常登录怎么发现?答:记录登录地点、设备、时间,偏离基线触发告警与强制改密。
04.7.16.4-060 认证相关测试怎么写?force_login 与 client.login 区别?
一句话结论
测试客户端 client.login(username=..., password=...) 走真实认证流程建立会话;client.force_login(user) 直接绑定指定用户实例,跳过凭证校验,速度快且不依赖密码。测试受保护视图用 force_login 最常见;验证登录流程本身(认证、限流、错误提示)才用 login。测试中可断言 response.wsgi_request.user 或响应状态与模板上下文。
概念解释
force_login仍写入会话并记录后端,模拟已登录状态。- 测试数据库独立迁移,用户实例在测试库创建后即可强制登录。
原理流程
- 测试建立用户实例(必要时设已知密码)。
force_login(user)绑定用户到测试客户端会话。- 请求受保护视图,断言状态码、上下文与跳转。
- 登录流程测试用
client.login,检查凭证错误与成功分支。
代码或图示
from django.test import TestCase, Client
from django.contrib.auth import get_user_model
User = get_user_model()
class ProfileTest(TestCase):
def setUp(self):
self.user = User.objects.create_user(username="u1", password="pw12345")
self.client.force_login(self.user)
def test_profile(self):
resp = self.client.get("/profile/")
self.assertEqual(resp.status_code, 200)
常见误区
- 测试未登录访问受保护视图却断言 200:忘记登录或会话中间件未生效。
force_login后断言密码校验逻辑:跳过了认证,登录流程需另测。- 在测试间复用客户端会话:每个测试方法独立客户端,避免状态串扰。
追问
client.login失败返回什么?答:布尔值,False表示凭证无效。- 如何测试未登录跳转?答:不登录直接请求,断言 302 到登录页或 403。
- 权限测试怎么写?答:创建带/不带权限的用户,
force_login后分别断言 200 与 403。
本节高频题
- 自定义用户模型与
AUTH_USER_MODEL迁移代价(002、003) - 认证后端链与邮箱/手机登录(009、010)
- 权限、组与模型级边界(013、014、018)
- Session 后端选型与持久代价(021、022、027)
- 会话过期、多设备与 Cookie 安全(024、025、026)
- 缓存粒度与 vary 键组成(031、032)
- 击穿/穿透/雪崩区分与兜底(034、035、036)
- 旁路缓存与一致性权衡(037、040)
- 信号触发时机与事务边界(044、047)
on_commit与 Celery 投递(050、052)USE_TZ时区陷阱(055、056)- 登录限流与认证测试(059、060)