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

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 指向自定义模型后才生效。

原理流程

  1. 选择基类:标准字段够用 → AbstractUser;认证标识(手机号/邮箱)体系不同 → AbstractBaseUser。
  2. 声明模型继承基类,追加业务字段。
  3. 配置 AUTH_USER_MODEL = "应用.模型名"。
  4. 首次迁移生成用户表,后续外键引用用户用 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。

原理流程

  1. 创建 accounts 应用并加入 INSTALLED_APPS。
  2. 编写 CustomUser 模型与自定义管理器。
  3. settings.py 设置 AUTH_USER_MODEL = "accounts.CustomUser"。
  4. 执行 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 表与权限、会话、外键、迁移历史深度绑定,事后更换需要重建用户表、迁移账号数据、重写所有用户外键并校验权限关联。因此新项目第一步就定义自定义用户模型,即使字段暂时与默认一致,也保留后续扩展空间。

概念解释

  • 迁移系统按模型历史生成表结构,切换基类会让既有迁移与新模型字段对不上。
  • 生产环境更换涉及停机窗口、数据双写校验与回滚预案,成本远高于初期决策。

原理流程

  1. 初始化项目时评估账号体系:登录标识、扩展字段、外部对接。
  2. 确定自定义模型并完成首次迁移。
  3. 后续字段演进走常规 makemigrations 增量迁移。
  4. 若已上线才发现需要换模型:导出账号数据 → 建新用户表 → 迁移并核对权限/外键 → 切换引用 → 验证登录。

代码或图示

# 初始化阶段就生成自定义用户表
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 模型共享同一张表,不能新增数据库字段。

原理流程

  1. 评估扩展性质:新字段且长期演进 → 自定义用户模型;字段较少、与用户表解耦 → Profile;只加方法/默认排序 → Proxy。
  2. Profile 方案建 UserProfile,外键 OneToOneField(settings.AUTH_USER_MODEL, on_delete=CASCADE)。
  3. 按需在信号或保存钩子里创建配套 Profile。
  4. 模板/视图通过关联访问扩展字段。

代码或图示

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 命令阶段提示。

原理流程

  1. 调用 create_user,传入登录标识、邮箱与密码。
  2. 管理器 normalize_email 规范化邮箱,set_password 哈希密码。
  3. 写入额外字段后 save()。
  4. 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,不区分是用户不存在还是密码错误,避免账号枚举。

原理流程

  1. 视图/表单收集凭证,调用 authenticate(request, username=..., password=...)。
  2. 框架遍历后端链,依次调用 backend.authenticate(request, **credentials)。
  3. 后端校验通过返回用户实例,框架记录其后端路径到 user.backend。
  4. 全部后端未命中返回 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,单后端场景可省略。

原理流程

  1. 确认用户已通过 authenticate,传入 login。
  2. 框架清空旧会话数据,保存 _auth_user_id 与 _auth_user_backend。
  3. 必要时保存 _auth_user_hash(密码变更后使旧会话失效)。
  4. 会话写回 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 对应的存储释放该条目。
  • 登出只影响当前会话,多设备登录需额外按用户/设备撤销会话。

原理流程

  1. 视图调用 logout(request)。
  2. 会话中 _auth_user_id 等认证键被删除,会话数据标记销毁。
  3. 会话 Cookie 过期或重写,request.user 重置为 AnonymousUser。
  4. 响应跳转到公开页面。

代码或图示

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、权限检查)两类职责。
  • 顺序决定多后端场景下的命中优先级与密码校验负担。

原理流程

  1. 启动期读取后端配置,导入各后端类。
  2. authenticate 遍历列表,调用每个后端的 authenticate(request, **credentials)。
  3. ModelBackend 查用户、check_password 校验、返回用户。
  4. 后续请求经 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 票据,通过后才返回用户。

原理流程

  1. 定义 EmailBackend,authenticate 取出 email 与 password。
  2. User.objects.filter(email=email).first() 查用户,不存在返回 None。
  3. user.check_password(password) 通过且 is_active 为真,返回用户。
  4. 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 在默认后端直接短路为全部权限。

原理流程

  1. 视图或模板调用 user.has_perm("app.change_post")。
  2. 框架按 AUTHENTICATION_BACKENDS 逐个调用后端 has_perm。
  3. ModelBackend 查直接授予与组内权限,命中返回 True。
  4. 全部后端未命中返回 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 是请求级对象,请求结束销毁,不跨请求保存。

原理流程

  1. SessionMiddleware 从 Cookie 解析 session ID,加载会话字典。
  2. AuthenticationMiddleware 读 _auth_user_id,调后端 get_user。
  3. 校验用户哈希与活跃状态后绑定 request.user;缺失或失效用匿名用户。
  4. 后续视图、模板通过 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 记录。

原理流程

  1. 应用迁移时,框架为每个模型生成增改删查四条默认权限。
  2. 权限记录关联到该模型的 ContentType。
  3. 用户/组通过多对多关系授予权限记录。
  4. 检查权限时按 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 是权限集合,用户加入组后继承组内全部权限;权限检查沿“用户直接权限 ∪ 所属各组权限”合并。组用于按角色聚合授权(编辑者、审核员、运营),避免给每个用户逐条配权限。组本身不含对象级数据,只承载角色与权限映射。

概念解释

  • 用户与组是多对多:一个用户可属多个组,权限取并集。
  • 组权限变更对所有成员即时生效(下次权限检查时读取)。

原理流程

  1. 按业务角色建组,如 editor、reviewer。
  2. 把对应 Permission 授予组。
  3. 用户加入一个或多个组。
  4. 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 直接通过所有权限检查。

原理流程

  1. 调用 has_perm("blog.publish_article")。
  2. 默认后端取用户直接权限与组权限集合。
  3. 目标权限在集合中返回 True,否则问下一个后端。
  4. 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 是程序判断用标识,二者不要混用。

原理流程

  1. 模型迁移生成默认权限,codename 按操作 + 模型名拼接。
  2. 自定义权限在 Meta.permissions 列表声明 (codename, name)。
  3. 代码与模板用 app_label.codename 检查。
  4. 重命名 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),否则未登录跳登录页。

原理流程

  1. 请求进入装饰器包装层。
  2. 判断登录态:匿名用户按配置跳转或拒绝。
  3. 调用权限测试函数/has_perm 检查。
  4. 通过进入视图;不通过返回重定向或 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 参数、或引入第三方行级权限库。

概念解释

  • 模型级权限回答“能不能改文章”,行级权限回答“能不能改这一篇文章”。
  • 归属规则因业务而异(团队共享、部门继承、数据密级),框架难以抽象成通用表结构。

原理流程

  1. 视图取到具体对象后,调用服务层校验归属或角色。
  2. 校验通过进入编辑,否则抛 PermissionDenied。
  3. 需要复用的行级规则沉淀为后端 has_perm(user, perm, obj) 或权限服务函数。
  4. 列表查询集按可见范围过滤,避免详情接口泄露。

代码或图示

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 检查,无法通过撤销组权限收回其权限。

原理流程

  1. 登录用户进入 Admin,先检查 is_staff。
  2. 各模型操作按 has_perm 判断可见性与可操作性。
  3. is_superuser=True 在默认后端直接返回全部权限。
  4. 业务视图可叠加归属校验,超级用户也可能受行级规则约束(按实现)。

代码或图示

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> 属性访问,未登录为空权限集合。
  • 权限判断在服务端执行,模板拿到的是已计算结果,前端不可篡改。

原理流程

  1. 上下文处理器把用户权限集合注入 perms。
  2. 模板按权限渲染操作入口。
  3. 视图入口用装饰器或 has_perm 二次校验。
  4. 具体对象归属在视图/服务层判断,防止直接访问 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 检测变更后写回存储。

原理流程

  1. 首次响应下发 session ID Cookie(匿名会话也可建立)。
  2. 登录时会话字典写入用户标识,保存到会话后端。
  3. 后续请求解析 Cookie 中的 session ID,加载对应会话。
  4. 响应阶段若会话被修改,写回存储并刷新 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 后端不查服务端,会话无法在服务端主动删除,只靠过期。

原理流程

  1. SESSION_ENGINE 指定后端模块路径。
  2. 会话读写经后端接口:load、save、delete、exists。
  3. cached 直接读写缓存;cache_db 先查缓存,未命中查库并回填。
  4. 多机部署要求后端共享(缓存/数据库/共享文件存储)。

代码或图示

# 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 前缀隔离与容量规划,避免会话被业务缓存挤掉。

概念解释

  • 会话缓存与普通缓存可分库/分前缀,故障域隔离。
  • 会话写入频率高,缓存后端需评估连接数与内存占用。

原理流程

  1. 配置 CACHES(如 Redis),SESSION_ENGINE 指向缓存型后端。
  2. 会话加载先读缓存,cache_db 未命中回源数据库。
  3. 会话保存写缓存,cache_db 同步落库。
  4. 缓存淘汰/重启时按后端策略决定是否从库恢复。

代码或图示

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 年龄并配合闲置登出。

原理流程

  1. 登录/写会话时按配置计算过期时间写入 Cookie 与会话记录。
  2. 后续请求按 SESSION_SAVE_EVERY_REQUEST 决定是否续期。
  3. 浏览器按 Cookie 有效期携带 session ID。
  4. 服务端会话过期后加载为空,用户回到匿名态。

代码或图示

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 是主键,用户标识存在会话字典里,反查需扫描或维护索引表。
  • 单设备登录:新会话建立后删除该用户其他会话记录。

原理流程

  1. 登录成功,会话写入用户 ID。
  2. 维护用户与会话 ID 的映射(额外表或缓存集合)。
  3. 多设备列表从映射读取;下线指定设备删除对应会话。
  4. 单设备策略:新会话生效后清除旧会话 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 可继续使用,需评估安全风险。

一句话结论

关键属性: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 不下发,需按环境区分配置。

原理流程

  1. 响应设置会话 Cookie 时读取 SESSION_COOKIE_SECURE、HTTPONLY、SAMESITE。
  2. 浏览器按属性决定是否在后续请求携带、是否允许脚本访问。
  3. 跨站表单/导航按 SameSite 策略限制 Cookie 发送。
  4. 会话 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 仍存在短暂不一致:缓存与库写入分两步,故障窗口内可能丢最新修改。

原理流程

  1. 会话保存写缓存(纯 cached)或缓存 + 库(cache_db)。
  2. 缓存失效后纯 cached 读不到会话;cache_db 回源库恢复。
  3. 库恢复的是上次落库版本,未落库修改丢失。
  4. 敏感业务数据应入库持久化,会话只存临时标识。

代码或图示

# 持久优先:数据库后端或 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,因此不能直接复用旧会话条目。
  • 未登录场景的业务数据应入库并挂临时令牌,而不是只依赖会话字典。

原理流程

  1. 匿名访客把购物车写入会话或临时记录。
  2. 提交登录,authenticate 校验通过后 login 生成新会话。
  3. 视图读取旧会话/临时记录,合并到新会话或绑定用户。
  4. 清理匿名临时数据,避免悬空记录。

代码或图示

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 前缀 + 版本 + 键名”定位条目,业务代码不感知后端实现。

概念解释

  • 缓存是在读多写少场景下用空间换时间,降低数据库与下游压力。
  • 缓存层引入一致性问题:数据更新后缓存失效/更新时机决定陈旧窗口。

原理流程

  1. 配置 CACHES 选择后端与参数。
  2. 读路径:先查缓存,命中返回;未命中查数据库/计算后回填缓存。
  3. 写路径:更新数据库后按策略失效或更新缓存。
  4. 缓存条目带 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 前缀按部署规划。

原理流程

  1. 按 CACHES["default"]["BACKEND"] 选择实现类。
  2. 序列化值写入对应存储,key 按前缀与版本组织。
  3. 读取时反序列化返回,过期条目由后端清理。
  4. 多实例共享必须用外部后端(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 缓存分层配合。

原理流程

  1. 请求进入,按路径/查询串/vary 头生成缓存键。
  2. 命中则直接返回缓存响应,跳过视图。
  3. 未命中执行视图生成响应,按 timeout 回填缓存。
  4. 数据更新后需主动失效对应键,避免长期陈旧。

代码或图示

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 缓存键计算与之对应。

原理流程

  1. 请求到达,收集路径、查询串与配置的 vary 头/Cookie。
  2. 叠加前缀、版本生成最终缓存键。
  3. 命中按键返回对应变体;未命中计算后回填。
  4. 响应 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-Language vary:中文用户看到英文缓存页。
  • 对敏感个性化内容 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 过期,不会主动删除。

原理流程

  1. 配置 KEY_PREFIX(如环境名)与 CACHE_VERSION(整数)。
  2. 实际存储键 = 前缀 + 版本 + 业务键名。
  3. 代码 cache.get/set 按当前版本读写。
  4. 数据格式不兼容时升版本,旧版本自然淘汰。

代码或图示

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 互斥重建(只放一个请求查库,其余等待旧值或短暂空值)、热点数据不过期改异步刷新、加分布式锁或单飞机制。击穿针对“单个高并发热点”,与穿透(查询不存在数据)、雪崩(大批同时过期)区分。

概念解释

  • 击穿发生在失效时刻,平时缓存正常;热点越热,瞬间回源压力越大。
  • 互斥重建要控制锁超时与降级值,避免持锁阻塞全部请求。

原理流程

  1. 热点条目 TTL 到期,缓存中无值。
  2. 并发请求同时 get 未命中,准备回源。
  3. 加锁/单飞:第一个请求查库重建缓存,其余等待或读旧值/空值。
  4. 重建完成后释放锁,后续请求命中新值。

代码或图示

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 遍历接口,是常见爬虫/攻击手段。
  • 空值缓存要短过期,避免真实数据创建后长期读到空标记。

原理流程

  1. 请求查询一个数据库不存在的对象。
  2. 缓存未命中,回源查库为空。
  3. 写入短 TTL 空标记,后续相同查询命中空值不再回源。
  4. 前置过滤器(布隆过滤器/参数规则)直接拦截明显非法请求。

代码或图示

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 相同,会在同一时刻集体到期。
  • 缓存宕机时没有兜底策略,数据库直接承受全部读流量。

原理流程

  1. 批量条目 TTL 一致,到达时刻集中过期。
  2. 并发请求未命中,回源量突增。
  3. 数据库/下游连接耗尽,响应变慢甚至雪崩扩散。
  4. 随机过期、互斥重建、限流降级与缓存集群冗余压低风险。

代码或图示

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 项目最常用旁路缓存:更新数据库后删除缓存条目,下次读重建;要求强一致的关键数据不宜长缓存。删除比更新缓存更安全,避免并发写造成脏覆盖。

概念解释

  • 旁路缓存:缓存不承担写入主路径,业务先写库再失效缓存。
  • 先更新库还是先删缓存:常见顺序是先更新库、再删缓存;并发下仍有小概率旧值回填,按一致性要求评估。

原理流程

  1. 读:查缓存,未命中查库并回填。
  2. 写:更新数据库,然后删除对应缓存键。
  3. 下次读取未命中,从库重建新值。
  4. 多关联条目(详情 + 列表 + 计数)需一并失效。

代码或图示

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 %}。
  • 片段不随整页缓存刷新,失效策略与页面缓存独立。

原理流程

  1. 模板加载 cache 标签,定义片段块与缓存标签。
  2. 渲染时先按片段名与参数查缓存,命中直接输出。
  3. 未命中渲染片段内容,按 timeout 回填。
  4. 数据更新后按对应键失效片段。

代码或图示

{% 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 连接,降低握手开销。

原理流程

  1. CACHES 指定 Redis 后端与地址。
  2. 客户端按 OPTIONS 建立连接池,进程内复用连接。
  3. 缓存读写从池取连接,用完归还。
  4. 监控命中率、键数量、内存与淘汰策略,规划容量。

代码或图示

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)每层都有各自陈旧窗口。

原理流程

  1. 识别数据一致性等级:实时金额、库存 vs 资讯、统计。
  2. 读路径缓存,写路径更新库并失效缓存。
  3. 关联条目(详情、列表、计数、聚合)一并清理。
  4. 监控缓存未命中与陈旧反馈,必要时降级直读库。

代码或图示

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 表示不过期(按后端支持)。

原理流程

  1. 读:get 命中返回值,未命中走回填逻辑。
  2. 写:set 直接覆盖;add 先判断存在性,原子占键成功才写入。
  3. 删:delete 移除条目,不存在也不报错。
  4. 计数: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 高度分化时,缓存层是纯额外负担。

原理流程

  1. 评估读多写少程度、计算成本、复用率与一致性要求。
  2. 满足“读远多于写、计算重、可容忍陈旧、可复用”才上缓存。
  3. 不满足场景直读数据库/服务层计算。
  4. 上线后用命中率与回源量验证是否值得保留。

代码或图示

# 轻量且实时:直接查库,不加缓存
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 过滤只接收特定模型。

原理流程

  1. 在应用 ready() 或模块导入期连接信号,确保 receiver 已注册。
  2. 业务代码触发模型保存/删除,框架发出对应信号。
  3. 信号遍历 receiver 依次调用,传入发送者与实例。
  4. 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 应跳过业务副作用。

原理流程

  1. 调用 instance.save(),框架先发 pre_save。
  2. receiver 可调整实例字段,随后执行 SQL。
  3. SQL 完成后发 post_save,携带 created 标志。
  4. 关联对象创建、缓存失效、通知等挂在 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 判断。

原理流程

  1. 删除对象,先 pre_delete,再执行 DELETE SQL,然后 post_delete。
  2. 外键级联删除逐个触发子对象信号。
  3. m2m 关系变更时按动作阶段发 m2m_changed。
  4. 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,可按应用过滤。
  • 迁移数据初始化与代码版本绑定,适合“每次部署确保存在”的基础记录。

原理流程

  1. migrate 执行完某应用迁移,框架发 post_migrate。
  2. receiver 按应用判断,get_or_create 默认组/配置。
  3. 重复迁移不新增重复记录。
  4. 复杂种子数据仍建议用数据迁移脚本管理版本。

代码或图示

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 而不是信号。

概念解释

  • 信号触发时机 ≠ 事务提交时机,二者是两个层次。
  • 回滚后外部系统已被通知/写入,形成分布式不一致。

原理流程

  1. 视图包 atomic,调用 save() 发 post_save。
  2. receiver 立即执行,可能投递任务、发通知。
  3. 后续业务异常导致事务回滚。
  4. 已发出的外部副作用无法收回;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 弹性扩容,主进程被慢下游拖住。

原理流程

  1. 模型保存触发信号。
  2. 若 receiver 直接处理重业务,与主请求争抢 CPU/连接。
  3. 慢下游超时导致请求堆积,数据库连接耗尽。
  4. 正确做法:信号内校验后 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 什么时候应该用显式服务层调用替代信号?

一句话结论

当后续动作是业务流程的必经步骤、需要参与事务、失败要回滚或需要明确可见性时,应在服务层显式调用,而不是藏在信号里;信号适合“模型事件的附加通知/衍生记录”这类弱耦合动作。显式调用让流程可读、可测试、事务边界清晰,避免信号隐式串联导致的维护成本。

概念解释

  • 判断标准:拿掉这段动作业务是否还成立;成立且为附属 → 信号;核心流程 → 服务层。
  • 显式调用可在单测中直接断言调用链,信号测试需额外隔离连接。

原理流程

  1. 梳理保存后动作:关联创建、通知、缓存失效、外部同步。
  2. 核心且需事务一致的动作放进服务方法,与保存同事务。
  3. 附属通知/衍生记录可保留信号,或在服务层末尾显式触发。
  4. 测试覆盖服务流程,信号只测试自身 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 下,回调等到最外层事务提交才触发。
  • 回调内异常不会回滚已提交数据,需自行记录与告警。

原理流程

  1. 业务方法在 atomic 内保存数据并注册 on_commit 回调。
  2. 事务提交成功,框架依次执行注册的回调。
  3. 事务回滚,回调列表丢弃,不执行。
  4. 回调内投递 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 创建、缓存失效、审计记录);不适用:核心业务规则、需要事务一致性的流程、重任务、跨进程协作。

概念解释

  • 解耦不是越彻底越好:关键流程的可见性与可测试性优先于减少耦合。
  • 信号数量与触发点要克制,避免“保存即一串副作用”。

原理流程

  1. 评估动作与模型的依赖强度:附属观察 → 信号;核心流程 → 服务层。
  2. 信号 receiver 保持轻量、幂等、可独立测试。
  3. 文档化信号触发点与 receiver 清单,弥补隐式调用。
  4. 复杂事件协作转向消息队列,明确生产消费边界。

代码或图示

# 清单示例:在应用 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_save delay:事务未提交时 worker 可能查不到或读到旧数据。
  • 任务参数只传可序列化标识,避免对象状态在队列中过期。

原理流程

  1. 模型保存,post_save receiver 判断创建/更新场景。
  2. on_commit 回调注册提交后动作。
  3. 提交成功,回调调 task.delay(instance.pk) 投递任务。
  4. 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。
  • 组件表结构随迁移创建,移除前需评估数据。

原理流程

  1. INSTALLED_APPS 列出启用组件。
  2. 启动期注册模型、模板标签、上下文处理器与中间件。
  3. 迁移创建对应数据表与默认权限。
  4. 视图/模板按组件 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)在求值时才取当前语言,适合模型字段默认值。

原理流程

  1. 源码标记可翻译字符串。
  2. makemessages -l zh_Hans 抽取到 .po,补翻译条目。
  3. compilemessages 生成二进制 .mo。
  4. 中间件解析语言偏好,渲染时按当前语言查翻译目录。

代码或图示

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 存储;读取后转回当前时区。

原理流程

  1. 配置 USE_TZ=True 与 TIME_ZONE。
  2. 代码构造 datetime 时用 django.utils.timezone 工具附时区。
  3. 入库转 UTC 存储,出库转为时区感知对象。
  4. 模板/视图按目标时区格式化展示。

代码或图示

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 三者要对齐排查。

原理流程

  1. 写入:aware datetime 转 UTC 落库。
  2. 读取:字段返回 aware datetime(UTC 基准)。
  3. 展示:模板过滤器按当前时区格式化;需要用户时区则请求内 activate(tz)。
  4. 跨系统传输:用带时区偏移的 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 并按级别渲染样式类。

原理流程

  1. 视图处理后调用 messages.success/error(...) 写入当前会话。
  2. 重定向到下一页面,MessageMiddleware 加载未读消息。
  3. 模板 {% for message in messages %} 渲染。
  4. 消息标记已读,下次请求不再带出。

代码或图示

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) 后进入后台导航。

原理流程

  1. 管理员登录走 auth 认证,校验 is_staff。
  2. 按用户权限显示对应应用与模型操作入口。
  3. ModelAdmin 定义列表列、搜索、过滤器、表单字段与内联。
  4. 后台增改删记录写入业务表,可记录 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 防单机器爆破,用户名防定向破解,两者结合防绕过。
  • 锁定要有过期与解锁机制,避免攻击者锁定正常账号。

原理流程

  1. 登录请求到达,读取该 IP 与用户名失败计数。
  2. 超阈值直接拒绝,不进入认证。
  3. 认证失败累加计数并设过期;成功清零。
  4. 连续失败触发验证码/锁定/告警,记录安全日志。

代码或图示

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 仍写入会话并记录后端,模拟已登录状态。
  • 测试数据库独立迁移,用户实例在测试库创建后即可强制登录。

原理流程

  1. 测试建立用户实例(必要时设已知密码)。
  2. force_login(user) 绑定用户到测试客户端会话。
  3. 请求受保护视图,断言状态码、上下文与跳转。
  4. 登录流程测试用 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)