04.7.9 Web、数据库与异步服务
所属:全栈开发面试题库 / 04 后端语言与运行时 / 04.7 Python
覆盖范围
- WSGI 与 ASGI、请求生命周期、上下文中
- Django / Flask / FastAPI 的核心机制
- ORM、Session、连接池、事务与迁移
- 缓存、任务队列、限流、文件上传
- 安全:注入、XSS、CSRF、认证
- 部署模型与容量规划
04.7.9-001 WSGI 和 ASGI 有什么区别?
一句话结论
WSGI 是同步协议:服务器调用 app(environ, start_response) 并拿到完整响应体,一个请求占一个 worker,不支持长连接/WebSocket。ASGI 是异步协议:await app(scope, receive, send) 以事件流方式收发,支持 HTTP、WebSocket、生命周期事件,可单进程承载大量并发连接。
概念解释
- WSGI 的
environ是 dict,响应通过start_response(status, headers)+ 可迭代 body。 - ASGI 的
scope描述连接类型与路径,receive/send是异步消息通道。
原理流程
- WSGI 服务器调用同步 app,一次性返回响应体。
- ASGI 服务器由事件循环驱动,通过 receive/send 收发异步消息流。
- ASGI 服务器(uvicorn/hypercorn)负责协议解析与事件循环。
代码或图示
def wsgi_app(environ, start_response):
start_response("200 OK", [("Content-Type", "text/plain")])
return [b"ok"]
async def asgi_app(scope, receive, send):
await send({"type": "http.response.start", "status": 200})
await send({"type": "http.response.body", "body": b"ok"})
常见误区
- WSGI 应用不能直接跑在 ASGI 服务器上,需
WSGIMiddleware包装(会退化到线程池);WSGI 不支持 WebSocket,协议是“请求-响应”一次性模型,没有双向通道。 - ASGI 不是一定更快:高并发 IO 场景更快,CPU 密集或同步代码下未必;选型:存量 Django/Flask 同步栈用 WSGI,新异步服务/WebSocket 用 ASGI;异步框架不能直接跑在 WSGI 上,需 ASGI 服务器或
asgiref桥接。
追问
- 为什么 WSGI 不支持 WebSocket?答:协议是“请求-响应”一次性模型,没有双向通道。
- ASGI 一定更快吗?答:高并发 IO 场景更快;CPU 密集或同步代码下未必。
- 能把异步框架跑在 WSGI 上吗?答:不能,需 ASGI 服务器或
asgiref桥接。
04.7.9-002 一个 HTTP 请求在 Web 框架里经历哪些阶段?
一句话结论
服务器接收连接并解析 HTTP → 构造请求对象 → 中间件/钩子链(认证、日志、CORS、会话)→ 路由匹配 → 视图/控制器 → 业务与数据访问 → 响应序列化 → 中间件回程(压缩、header)→ 服务器写回。异常在各层被捕获并转换为统一错误响应。
概念解释
- Django:WSGIHandler → 中间件
process_request/process_view/process_response→ URLconf → View → Template/Response。 - 请求 ID 应在最外层生成并贯穿日志。
原理流程
- 服务器解析 HTTP 报文,构造请求对象。
- 请求穿过中间件链,路由匹配到视图。
- 执行业务与数据访问,响应序列化后沿中间件链回程写回。
代码或图示
client → server → middleware → router → view → service → repository → db
← response ← ...
常见误区
- 每层都可能短路(认证失败直接返回),也会影响性能;中间件顺序影响被保护的范围与开销。
- 响应序列化会成为瓶颈:大对象遍历与 JSON 编码是 CPU 密集;Flask
RequestContext入栈 →before_request→ view →after_request;FastAPI 是 ASGI 中间件 → 依赖解析 → 路由函数 → 响应模型序列化。
追问
- 中间件顺序为什么重要?答:先认证再限流还是反之,会改变被保护的范围与开销。
- 请求 ID 有什么用?答:贯穿日志、链路追踪、错误定位。
- 为什么响应序列化也会成为瓶颈?答:大对象遍历与 JSON 编码是 CPU 密集。
04.7.9-003 Flask 的请求上下文是什么?g 有什么用?
一句话结论
Flask 用 LocalStack/ContextVar 保存请求上下文(request、session)与应用上下文(current_app、g),视图执行时入栈,结束后出栈。g 是“单次请求内的临时存储”,适合放当前用户、数据库连接、请求级缓存。
概念解释
- 上下文基于
contextvars,因此异步/多线程下彼此隔离。 g在请求结束时销毁,不能跨请求保存状态。
原理流程
- 请求进入时把请求/应用上下文压入 LocalStack。
- 视图与钩子通过
request/g/current_app访问上下文。 - 请求结束后上下文出栈,
g数据销毁。
代码或图示
@app.before_request
def load_user():
g.user = current_user
@app.get("/me")
def me():
return {"id": g.user.id}
常见误区
- 在视图外使用
request会报“working outside of request context”,需with app.test_request_context();后台线程不能直接访问请求上下文,必须显式传值。 g按请求隔离且自动销毁,全局变量跨请求共享;异步视图基于 contextvars,同一请求内安全,跨任务需复制上下文;before_request里赋值给g,视图与after_request可读取。
追问
- 为什么后台任务拿不到
request?答:上下文已出栈,线程/协程也没有继承。 g和全局变量有什么区别?答:g按请求隔离且自动销毁,全局变量跨请求共享。- 异步视图里上下文安全吗?答:基于 contextvars,同一请求内安全,跨任务需复制上下文。
04.7.9-004 Flask 的蓝图(Blueprint)和应用工厂是什么?
一句话结论
蓝图把路由/模板/静态资源按功能模块拆分,注册到应用上,避免单文件膨胀;应用工厂 create_app(config) 延迟创建应用实例,便于测试、按环境配置、避免循环导入。
概念解释
- 蓝图可设置
url_prefix、template_folder,支持嵌套注册。 - 蓝图内用
current_app而非直接 import app。
原理流程
- 工厂函数内创建 Flask 实例并加载配置。
- 初始化扩展、注册蓝图与请求钩子。
- 返回应用实例,测试可对不同配置创建独立实例。
代码或图示
def create_app(config=None):
app = Flask(__name__)
app.config.from_object(config or "config.Default")
from .api import bp
app.register_blueprint(bp, url_prefix="/api")
return app
常见误区
- 模块级
app = Flask(__name__)不好:导入即创建,配置与测试难隔离,易循环导入;工厂模式在create_app内初始化扩展(db.init_app(app)),避免模块级单例。 - 蓝图能嵌套,但过深层级会让路由难追踪;扩展初始化与请求钩子也应在工厂内注册;工厂模式下请求内用
current_app,测试可对不同配置创建独立 app 实例,互不污染。
追问
- 为什么模块级
app = Flask(__name__)不好?答:导入即创建,配置与测试难隔离,易循环导入。 - 蓝图能嵌套吗?答:能,但过深层级会让路由难追踪。
- 工厂模式下如何拿 app?答:
current_app(请求内)或flask.current_app._get_current_object()。
04.7.9-005 Django 中间件是怎么执行的?
一句话结论
Django 中间件是“洋葱模型”:请求阶段自上而下执行 process_request(或 __call__ 前半段),响应阶段自下而上执行 process_response。process_view 在路由确定后、视图调用前执行;process_exception 在视图抛异常时逆序调用。
概念解释
- 新式中间件写成
def __call__(self, request)包get_response,更灵活。 - 认证、会话、CSRF、消息、安全头都是内置中间件。
原理流程
- 请求沿
MIDDLEWARE列表自上而下穿过各中间件前半段。 - 视图执行后,响应自下而上穿过各中间件后半段。
- 视图异常时
process_exception逆序调用。
代码或图示
class TimingMiddleware:
def __init__(self, get_response): self.get_response = get_response
def __call__(self, request):
t0 = time.perf_counter()
response = self.get_response(request)
response["X-Cost"] = f"{time.perf_counter() - t0:.3f}"
return response
常见误区
- 中间件顺序在
MIDDLEWARE列表中配置,顺序影响行为与性能;在中间件里读请求体要小心(request.body只能读一次,需缓存)。 - 异步中间件需
async def并正确await;响应阶段逆序是洋葱结构,最外层最后处理响应;process_exception返回响应会吞掉异常,继续走响应链;中间件里做数据库查询会拖慢每个请求,除非必要(如认证),且要加缓存。
追问
- 为什么响应阶段是逆序?答:洋葱结构,最外层最后处理响应。
process_exception返回响应会怎样?答:异常被吞掉,继续走响应链。- 中间件里做数据库查询合适吗?答:会拖慢每个请求,除非必要(如认证),且要加缓存。
04.7.9-006 Django ORM 的 N+1 问题怎么解决?
一句话结论
N+1 指“查 1 次主表 + 每行再查 1 次关联表”。用 select_related(外键/一对一,JOIN 一次取回)与 prefetch_related(多对多/一对多,额外 1 次查询后在 Python 侧拼接)消除;用 django-debug-toolbar 或 assertNumQueries 检测。
概念解释
select_related("author", "category")生成 JOIN,适合单值关联。- 序列化器里懒加载最容易触发 N+1,需在查询层解决。
原理流程
- 主表查询一次,未预加载时遍历每行触发关联查询。
select_related通过 JOIN 一次取回单值关联。prefetch_related批量查关联后在 Python 侧按外键拼接。
代码或图示
qs = Post.objects.select_related("author").prefetch_related("tags")
for p in qs:
print(p.author.name, [t.name for t in p.tags.all()])
常见误区
select_related不能用于多对多:JOIN 会笛卡尔膨胀,应用prefetch_related;prefetch_related每类关联一次,嵌套会更多查询。- 嵌套 prefetch 用
Prefetch("comments", queryset=...)控制子查询;只取需要的字段用only/defer,减少数据传输;ORM 层解决比视图层好:视图层逐条优化易漏,查询层一次覆盖全链路。
追问
select_related能用于多对多吗?答:不能,JOIN 会笛卡尔膨胀,应用prefetch_related。prefetch_related一定只有 2 次查询吗?答:每类关联一次,嵌套会更多。- 为什么 ORM 层解决比视图层好?答:视图层逐条优化易漏,查询层一次覆盖全链路。
04.7.9-007 Django 的 transaction.atomic 有什么用?有哪些坑?
一句话结论
atomic 把代码块包成一个事务:正常退出提交,异常回滚。可嵌套(保存点);必须保证异常能传播出 atomic 块才会回滚。坑包括:捕获异常后不回滚、在 atomic 内做外部 IO、长事务锁表、异步任务在提交前启动。
概念解释
- 嵌套
atomic内层用 savepoint,内层异常被捕获后外层仍可提交。 transaction.on_commit(func)把“提交后才执行”的动作(发消息、清缓存)延后。
原理流程
- 进入 atomic 块开启事务(嵌套则建保存点)。
- 正常退出提交;异常传播出块则回滚。
on_commit注册的回调在提交成功后执行。
代码或图示
with transaction.atomic():
order = Order.objects.create(...)
transaction.on_commit(lambda: notify.delay(order.id))
常见误区
- 不能在事务里发 MQ 消息:消息可能先发出而事务回滚,造成脏数据;捕获异常后事务不会自动回滚,需显式标记回滚或重新抛出。
- 长事务持有行锁、增加死锁概率,应缩短事务边界;
select_for_update做行锁,注意加锁顺序避免死锁;on_commit在测试里默认事务不提交,需captureOnCommitCallbacks。
追问
- 为什么不能在事务里发 MQ 消息?答:消息可能先发出而事务回滚,造成脏数据。
- 捕获异常后事务还会回滚吗?答:不会,需显式标记回滚或重新抛出。
on_commit在测试里会执行吗?答:默认事务不提交,需captureOnCommitCallbacks。
04.7.9-008 FastAPI 的依赖注入是怎么工作的?
一句话结论
用 Depends(callable) 声明依赖,FastAPI 在请求时按依赖树解析:递归解析子依赖、缓存同请求内的结果、把返回值注入参数。依赖可带 yield 做“进入-退出”资源管理(类似上下文管理器),适合数据库会话、鉴权。
概念解释
- 依赖函数参数同样可声明
Depends,形成依赖树。 - 依赖可抛
HTTPException做鉴权短路。
原理流程
- 请求到达后按依赖声明递归解析子依赖。
- 同请求内相同依赖按
use_cache缓存结果。 - 注入参数;
yield依赖的清理在响应发送后执行,异常也会执行。
代码或图示
def get_db():
db = SessionLocal()
try:
yield db
finally:
db.close()
@app.get("/items")
def items(db: Session = Depends(get_db)):
return db.query(Item).all()
常见误区
yield依赖里能捕获异常:异常会抛进yield之后,可 try/except 做回滚;依赖缓存有副作用问题:若依赖有副作用且期望多次执行,需use_cache=False。- 全局依赖用
app = FastAPI(dependencies=[Depends(verify)]);与路由参数/资源相关用依赖,全局横切(日志/CORS)用中间件。
追问
yield依赖里能捕获异常吗?答:能,异常会抛进yield之后,可 try/except 做回滚。- 依赖缓存会导致问题吗?答:会,若依赖有副作用且期望多次执行,需
use_cache=False。 - 依赖和中间件怎么选?答:与路由参数/资源相关用依赖,全局横切(日志/CORS)用中间件。
04.7.9-009 Pydantic 在 FastAPI 里承担什么角色?
一句话结论
Pydantic 负责请求体/查询参数/响应的类型解析与校验:把 JSON 转成模型、做类型转换与约束校验、生成 OpenAPI Schema、按 response_model 过滤输出字段。它是“边界校验层”,内部业务不必重复校验。
概念解释
- 校验失败返回 422 与结构化错误详情。
- 嵌套模型与列表模型自动递归校验。
原理流程
- 输入 JSON 按模型声明做类型转换与约束校验。
- 校验通过生成模型实例,失败返回字段级错误。
- 响应按
response_model裁剪字段并做输出校验。
代码或图示
class ItemIn(BaseModel):
name: str = Field(min_length=1, max_length=50)
price: Decimal = Field(gt=0)
@app.post("/items", response_model=ItemOut)
def create(item: ItemIn):
...
常见误区
- 响应也要建模:防止内部字段泄露、保证契约稳定、生成文档;
model_config = ConfigDict(from_attributes=True)支持从 ORM 对象读取。 - Pydantic v1 和 v2 校验器 API、性能与配置方式有变化,迁移需注意;大响应序列化慢时用
model_dump(mode="json")或 ORJSONResponse,避免重复校验;Field(gt=0, max_length=10)、Literal、自定义validator表达约束。
追问
- 为什么响应也要建模?答:防止内部字段泄露、保证契约稳定、生成文档。
- Pydantic v1 和 v2 差异大吗?答:校验器 API、性能与配置方式有变化,迁移需注意。
- 大响应序列化慢怎么办?答:用
model_dump(mode="json")或 ORJSONResponse,避免重复校验。
04.7.9-010 FastAPI 里同步路由和异步路由有什么区别?
一句话结论
async def 路由在事件循环中执行,内部只能用非阻塞调用;def 路由会被丢到线程池执行,可用同步库但占用线程。选错会导致事件循环被阻塞或线程池耗尽。
概念解释
async def里调用同步 DB/HTTP 会卡住所有请求,必须await异步客户端或to_thread。- 同一应用可混用,但要按依赖库能力选择。
原理流程
async def路由由事件循环直接调度。def路由被 AnyIO 线程池包装执行。- 阻塞调用在异步路由里卡住循环,在线程池路由里占用线程。
代码或图示
@app.get("/a")
async def a():
return await async_client.get(...) # 异步栈
@app.get("/b")
def b():
return sync_client.get(...) # 线程池
常见误区
async def里time.sleep会阻塞事件循环线程,所有协程停摆;线程池默认约 40 个,高并发时排队,可通过 AnyIO 配置调整,但本质是容量问题。- 异步路由里 CPU 密集计算同样阻塞循环;依赖(
Depends)的同步/异步属性也要匹配;混合栈迁移先统一 HTTP/DB 客户端,再逐路由改异步。
追问
- 为什么
async def里time.sleep会拖垮服务?答:阻塞事件循环线程,所有协程停摆。 - 线程池大小能调吗?答:可通过 AnyIO 配置调整,但本质是容量问题。
- 混合栈怎么迁移?答:先统一 HTTP/DB 客户端,再逐路由改异步。
04.7.9-011 RESTful API 设计要注意什么?
一句话结论
用名词复数表示资源(/users/1/orders)、HTTP 方法表达语义(GET 查询、POST 创建、PUT/PATCH 更新、DELETE 删除)、状态码表达结果(201/204/400/401/403/404/409/422/429/500)、分页/排序/过滤用查询参数、错误响应统一结构。
概念解释
- 资源 ID 放路径,筛选条件放 query。
- 版本化:
/v1/...或 header,保持向后兼容。
原理流程
- URL 标识资源,HTTP 方法标识动作。
- 状态码表达结果类别,查询参数表达筛选与分页。
- 错误响应走统一结构。
代码或图示
GET /v1/users?limit=20&cursor=xxx
POST /v1/users
PATCH /v1/users/1
DELETE /v1/users/1
常见误区
- 避免在 URL 里放动词(
/getUser),用方法语义表达;幂等:GET/PUT/DELETE 应幂等,POST 用幂等键支持重试。 - 分页用
limit/offset或 cursor(大数据优先 cursor);PUT 替换整体,PATCH 局部更新,PATCH 不一定幂等;offset 在数据变动时会重复/跳过,cursor 稳定且高效;语法/格式错误 400,语义校验失败 422(FastAPI 默认)。
追问
- PATCH 和 PUT 的区别?答:PUT 替换整体,PATCH 局部更新;PATCH 不一定幂等。
- 为什么分页要用 cursor?答:offset 在数据变动时会重复/跳过,cursor 稳定且高效。
- 错误用 400 还是 422?答:语法/格式错误 400,语义校验失败 422(FastAPI 默认)。
04.7.9-012 如何实现接口幂等?
一句话结论
用“幂等键”(客户端生成的唯一请求 ID)+ 服务端去重表/Redis SETNX:首次请求执行业务并记录结果,重复请求直接返回首次结果。数据库层可用唯一索引兜底(如订单号唯一),更新用条件更新(CAS)。
概念解释
- 幂等键需与业务绑定(用户 + 场景 + 业务 ID),并设置合理 TTL。
- 幂等不等于“并发安全”,仍需锁/唯一约束保证。
原理流程
- 客户端生成幂等键,重试时复用。
- 服务端用 SETNX/唯一键抢占处理权。
- 首次执行并记录结果,重复请求返回首次结果或处理中状态。
代码或图示
key = f"pay:{user_id}:{order_id}"
if not redis.set(key, "1", nx=True, ex=3600):
return get_previous_result(key)
常见误区
- 处理中状态要可见(避免并发重复执行),可用分布式锁或“插入唯一键”抢占;失败要清理幂等记录或标记可重试,避免永久锁死。
- 唯一索引是最后防线:分布式锁可能失效,数据库约束是强一致兜底;幂等键由客户端生成并重试时复用,服务端不能每次重新生成;消息消费幂等用业务唯一键 + 去重表,或状态机条件更新。
追问
- 为什么唯一索引是最后防线?答:分布式锁可能失效,数据库约束是强一致兜底。
- 幂等键由谁生成?答:客户端生成并重试时复用,服务端不能每次重新生成。
- 重复请求返回什么?答:返回首次结果或“处理中”状态,不能返回错误。
04.7.9-013 JWT 和 Session 怎么选?
一句话结论
Session 是服务端存状态、客户端只存 ID(Cookie),易于注销与权限变更,但需要共享存储(Redis)做多副本。JWT 是自包含令牌(签名 + 声明),无状态、易横向扩展,但难以即时失效、体积大、需注意泄露与重放。
概念解释
- JWT 必须验证签名与
exp/iss/aud,禁止接受alg=none。 - 短期 access token + 长期 refresh token 是常见组合。
原理流程
- Session:服务端存储会话,Cookie 只存会话 ID。
- JWT:签发时把声明签名后下发,校验时验签并检查声明。
- 注销/封禁需黑名单或版本号,牺牲部分无状态性。
代码或图示
jwt.encode({"sub": uid, "exp": now + 900}, key, algorithm="HS256")
常见误区
- 敏感信息不要放 JWT(base64 可解码);Cookie 存 token 需
HttpOnly/Secure/SameSite防 XSS/CSRF。 - JWT 原生不能撤销,需要黑名单/短有效期/密钥轮换;不用 localStorage 存 token:XSS 可直接读取,HttpOnly Cookie 更安全(但要防 CSRF);多服务共享密钥用非对称签名(RS256)分发公钥,或集中密钥管理。
追问
- JWT 能撤销吗?答:原生不能,需要黑名单/短有效期/密钥轮换。
- 为什么不用 localStorage 存 token?答:XSS 可直接读取,HttpOnly Cookie 更安全(但要防 CSRF)。
- 多服务如何共享密钥?答:用非对称签名(RS256)分发公钥,或集中密钥管理。
04.7.9-014 CORS 是什么?为什么“加了 header 还是报错”?
一句话结论
CORS 是浏览器跨源请求的安全机制:服务端通过 Access-Control-Allow-Origin 等响应头声明允许的来源、方法、头。报错常见原因:预检 OPTIONS 未处理、Allow-Origin 不能是 * 且带凭据、Allow-Headers 未覆盖自定义头、中间件顺序导致头被覆盖。
概念解释
- 简单请求直接发;带自定义头/非简单方法会先发
OPTIONS预检。 - 错误响应也要带 CORS 头,否则前端只看到 CORS 错误而非真实错误。
原理流程
- 浏览器判断是否为简单请求,非简单先发 OPTIONS 预检。
- 服务端返回允许的来源、方法、头、缓存时长。
- 预检通过后才发实际请求。
代码或图示
@app.options("/{path:path}")
async def preflight(path: str):
return Response(headers={
"Access-Control-Allow-Origin": origin,
"Access-Control-Allow-Methods": "GET,POST,PATCH,DELETE",
"Access-Control-Allow-Headers": "content-type,authorization",
})
常见误区
- 带 Cookie 时必须指定具体源且
Allow-Credentials: true,不能用*(规范禁止,避免任意站点带 Cookie 访问);预检响应要返回Allow-Methods/Allow-Headers/Max-Age。 - 401 时前端报 CORS 错误:错误响应没带 CORS 头,浏览器隐藏了真实状态码;生产不要把源反射成任意值,需白名单校验;网关和框架都加 CORS 会头重复或冲突,需明确只在一层处理。
追问
- 为什么 401 时前端报 CORS 错误?答:错误响应没带 CORS 头,浏览器隐藏了真实状态码。
*为什么不能配凭据?答:规范禁止,避免任意站点带 Cookie 访问。- 网关和框架都加 CORS 会怎样?答:头重复或冲突,需明确只在一层处理。
04.7.9-015 SQLAlchemy 的 Session 生命周期怎么管?
一句话结论
Session 是“工作单元/身份映射”,不是连接本身:从连接池借连接、跟踪对象状态、在 commit/rollback 后结束事务。应按“请求/用例”创建并关闭,不要全局共享;异步用 AsyncSession 并在同一协程内使用。
概念解释
sessionmaker创建工厂,with SessionLocal() as s:或依赖注入管理。- 多线程/多协程共享 Session 不安全。
原理流程
- Session 从连接池借连接,跟踪对象状态。
- 提交/回滚结束事务,关闭时归还连接。
- 长生命周期 Session 积累身份映射、持有连接、读到过期数据。
代码或图示
def get_db():
db = SessionLocal()
try:
yield db
finally:
db.close()
常见误区
expire_on_commit=True会在提交后使对象过期,访问属性触发新查询(可能报 detached);提交后访问对象报错:Session 已关闭或对象过期后需要新连接刷新。- Session 按需借还连接,池负责复用;异步 Session 同一协程内可以共享,但不能被多个任务并发使用;只读查询可用
Session的autobegin事务并在结束时 rollback/close。
追问
- 为什么提交后访问对象会报错?答:Session 已关闭或对象过期后需要新连接刷新。
- Session 和连接池的关系?答:Session 按需借还连接,池负责复用。
- 异步 Session 能跨
await共享吗?答:同一协程内可以,但不能被多个任务并发使用。
04.7.9-016 数据库连接池大小怎么设?
一句话结论
按“worker 数 × 每 worker 池大小 ≤ 数据库最大连接(留余量)”反推,再按压测调优。池太小会排队、太大反而增加数据库上下文切换与内存。还要考虑连接超时、回收、健康检查与阻塞等待上限。
概念解释
- SQLAlchemy:
pool_size、max_overflow、pool_timeout、pool_recycle、pool_pre_ping。 - 长事务会长期占用连接,需缩短事务。
原理流程
- 按 worker 数与池大小估算总连接上限。
- 对照数据库最大连接数留余量。
- 压测观察排队、等待时长与延迟,回调池大小。
代码或图示
create_engine(url, pool_size=10, max_overflow=5, pool_timeout=5, pool_recycle=1800, pool_pre_ping=True)
常见误区
- 加了 worker 后数据库连接爆了:每 worker 独立池,总连接数相乘;池满时请求等待
pool_timeout后抛超时异常。 - 连接数不是越多吞吐越高:超过 DB 处理能力后延迟与锁竞争上升;
pool_pre_ping防“连接被中间件断开”后的首次失败,但有额外往返;pool_recycle小于 DB/代理的空闲超时,避免使用死连接;异步驱动(asyncpg)池大小同样要受 DB 限制。
追问
- 为什么加了 worker 后数据库连接爆了?答:每 worker 独立池,总连接数相乘。
- 池满时请求会怎样?答:等待
pool_timeout后抛超时异常。 - 连接数越多吞吐越高吗?答:不是,超过 DB 处理能力后延迟与锁竞争上升。
04.7.9-017 事务隔离级别有哪些?Python 侧要注意什么?
一句话结论
四级:READ UNCOMMITTED(脏读)、READ COMMITTED(不可重复读)、REPEATABLE READ(幻读)、SERIALIZABLE(串行化)。MySQL InnoDB 默认 REPEATABLE READ,PostgreSQL 默认 READ COMMITTED。Python 侧要在连接/会话层明确设置,并处理死锁重试与长事务。
概念解释
- 隔离越高一致性越强、并发越低,需按业务选择。
- 只读事务可减轻锁竞争(部分数据库支持)。
原理流程
- 按隔离级别决定事务能看到其他事务的哪些变更。
- 应用层“先查再改”在 READ COMMITTED 下仍可能丢失更新。
- 死锁由数据库检测并回滚一方,应用捕获后有限重试。
代码或图示
session.execute(text("SET TRANSACTION ISOLATION LEVEL READ COMMITTED"))
常见误区
- 应用层“先查再改”在 READ COMMITTED 下仍可能丢失更新,需
SELECT ... FOR UPDATE或条件更新;事务内不要做 HTTP 调用/发消息,避免长事务与不一致。 - 幻读:同一事务两次查询之间,别的事务插入了新行,结果集变化;MySQL 默认 RR 是历史与一致性取舍,RR 下普通 SELECT 快照读;死锁重试要幂等、有限次数、退避,避免雪崩。
追问
- 幻读是什么?答:同一事务两次查询之间,别的事务插入了新行,结果集变化。
- 为什么 MySQL 默认 RR 而不是 RC?答:历史与一致性取舍,RR 下普通 SELECT 快照读。
- 死锁重试要注意什么?答:幂等、有限次数、退避,避免雪崩。
04.7.9-018 数据库迁移(Alembic)怎么用才安全?
一句话结论
迁移脚本纳入版本管理,按“可回滚、可重复执行、向前兼容”设计:新增列给默认值/可空、改名用“新增 + 双写 + 迁移 + 删除”分步、大表加索引用在线工具或并发建索引、生产执行前先在影子库演练。
概念解释
alembic revision --autogenerate生成草案,必须人工审查(自动生成常有遗漏)。- 部署顺序:先迁移再发新代码(向前兼容),或双版本兼容期。
原理流程
- 从模型变更生成迁移草案并人工审查。
- 编写 upgrade/downgrade,确保可回退。
- 影子库演练后,生产执行迁移并与代码版本对齐。
代码或图示
alembic revision --autogenerate -m "add user.email"
alembic upgrade head
常见误区
- autogenerate 不可全信:重命名会识别为“删+建”,索引/约束可能漏;大表加非空列先加可空 + 回填 + 再改约束。
- 加索引用
CREATE INDEX CONCURRENTLY(PostgreSQL)避免锁表;迁移失败先downgrade,必要时用备份恢复,禁止直接改生产表;多实例同时启动会重复迁移,需迁移锁或单独迁移 Job;upgrade/downgrade都要能跑,downgrade 至少保证可回退到上一版。
追问
- 为什么 autogenerate 不可全信?答:重命名会识别为“删+建”,索引/约束可能漏。
- 迁移失败怎么回滚?答:先
downgrade,必要时用备份恢复,禁止直接改生产表。 - 多实例同时启动会重复迁移吗?答:会,需迁移锁或单独迁移 Job。
04.7.9-019 异步 ORM 有哪些坑?
一句话结论
异步 ORM(SQLAlchemy Async、Tortoise、Django async ORM)要求所有 DB 操作 await,且 Session/连接绑定事件循环;懒加载在异步下会抛错(不能隐式 IO),必须显式预加载;事务与并发任务共享会话会串数据。
概念解释
- SQLAlchemy 异步需
create_async_engine+AsyncSession,驱动用 asyncpg/aiomysql。 - 事务取消时要确保 rollback,避免连接残留状态。
原理流程
- 异步引擎与会话绑定事件循环。
- 所有查询必须
await,懒加载会触发隐式同步 IO。 - 预加载替代懒加载,每任务独立会话。
代码或图示
async with AsyncSession(engine) as s:
result = await s.execute(select(User).options(selectinload(User.posts)))
常见误区
- 懒加载属性访问会触发同步 IO,异步下报
MissingGreenlet,需selectinload/joinedload;同一AsyncSession不能被多个任务并发使用,需每任务独立会话。 - 异步驱动对连接池、超时、取消的支持差异较大,需压测;异步 ORM 更容易 N+1:懒加载不可用,忘记预加载会在序列化时报错或额外查询;异步事务同一协程内可以,跨任务不安全;业务以复杂 JOIN/事务为主、异步生态不成熟时,同步 + 线程池更稳。
追问
- 为什么异步 ORM 更容易 N+1?答:懒加载不可用,忘记预加载会在序列化时报错或额外查询。
- 异步事务能跨
await吗?答:同一协程内可以,跨任务不安全。 - 什么时候不值得上异步 ORM?答:业务以复杂 JOIN/事务为主、异步生态不成熟时,同步 + 线程池更稳。
04.7.9-020 Redis 缓存的常见模式有哪些?
一句话结论
Cache-Aside(读时查缓存、未命中查库回填)、Read-Through(缓存层负责回源)、Write-Through(写时同时写缓存)、Write-Behind(异步写回)。最常用 Cache-Aside + 删除缓存(而非更新缓存),配合 TTL 兜底。
概念解释
- 更新策略:先更库再删缓存(失败可重试),或延迟双删降低不一致窗口。
- 大 value 会拖慢 Redis,需拆分或压缩。
原理流程
- 读请求先查缓存,命中返回;未命中查库并回填缓存。
- 写请求先更新库,再删除缓存。
- TTL 兜底长期不一致。
代码或图示
def get_user(uid):
if (v := redis.get(f"u:{uid}")) is not None:
return json.loads(v)
u = db.get(uid)
redis.setex(f"u:{uid}", 300 + random.randint(0, 60), json.dumps(u))
return u
常见误区
- 缓存穿透:查不存在的数据 → 空值缓存或布隆过滤器;缓存击穿:热点 key 失效 → 互斥锁/单飞(singleflight);缓存雪崩:大量 key 同时失效 → TTL 加随机抖动、多级缓存。
- 删除缓存而不是更新缓存:并发更新顺序难保证,删除更简单且下次读自然回填;先删缓存再更库有问题:删除后、更新前有请求回填旧值,造成长期不一致;TTL 按可接受不一致时长与回源成本权衡,并加随机抖动。
追问
- 为什么是删除缓存而不是更新缓存?答:并发更新顺序难保证,删除更简单且下次读自然回填。
- 先删缓存再更库有什么问题?答:删除后、更新前有请求回填旧值,造成长期不一致。
- TTL 该设多久?答:按可接受不一致时长与回源成本权衡,并加随机抖动。
04.7.9-021 缓存与数据库的一致性怎么保证?
一句话结论
强一致需要把缓存纳入同一事务/锁,成本高;工程上通常接受“最终一致”:更新库后删除缓存、TTL 兜底、必要时延迟双删或订阅 binlog 异步失效。读多写少场景可接受短暂脏读。
概念解释
- Cannal/CDC 订阅数据库变更,异步删缓存,解耦业务代码。
- 对账任务定期修复不一致。
原理流程
- 更新数据库后删除缓存。
- 延迟双删或 CDC 订阅变更降低不一致窗口。
- TTL 兜底,版本号/时间戳校验过期。
代码或图示
db.update(...)
redis.delete(key)
time.sleep(0.1)
redis.delete(key) # 延迟双删
常见误区
- 延迟双删也不能保证强一致:延迟窗口内的并发写仍可能回填旧值;适合缓存的数据:读多写少、可容忍短暂不一致、回源昂贵。
- 缓存和 DB 双写失败以 DB 为准,缓存失效由 TTL 或补偿任务修复;分布式锁保护“回填”过程,避免旧值被并发写回;版本号/时间戳写进 value,读时校验是否过期。
追问
- 为什么延迟双删也不能保证强一致?答:延迟窗口内的并发写仍可能回填旧值。
- 什么数据适合缓存?答:读多写少、可容忍短暂不一致、回源昂贵。
- 缓存和 DB 双写失败怎么办?答:以 DB 为准,缓存失效由 TTL 或补偿任务修复。
04.7.9-022 Celery 的工作原理是什么?
一句话结论
Celery 是分布式任务队列:生产者调用 .delay()/.apply_async() 把任务消息投递到 Broker(Redis/RabbitMQ),Worker 拉取并执行,结果可写回 Backend。任务以“模块路径 + 函数名 + 参数”序列化,Worker 需能导入同一代码。
概念解释
- 消息确认(ack)策略影响可靠性:
acks_late=True执行后确认,崩溃会重投(需幂等)。 beat负责定时投递,需单实例或分布式锁。
原理流程
- 生产者序列化任务消息投递到 Broker。
- Worker 拉取消息、导入任务函数、执行。
- 确认消息,结果写回 Backend(可选)。
代码或图示
@app.task(bind=True, max_retries=3, acks_late=True)
def send_mail(self, uid):
...
常见误区
- Worker 找不到任务:代码版本不一致或模块路径变更,消息里的路径无法导入;任务重复执行靠幂等设计 + 去重键,
acks_late下更常见。 prefetch_multiplier控制预取,避免慢任务占积压;路由(task_routes)把不同任务分到不同队列,隔离资源;Broker 用 Redis 持久化与确认语义弱于 RabbitMQ,需评估可靠性;监控用 Flower、Prometheus exporter。
追问
- 为什么 Worker 找不到任务?答:代码版本不一致或模块路径变更,消息里的路径无法导入。
- 任务重复执行怎么办?答:幂等设计 + 去重键,
acks_late下更常见。 - Broker 用 Redis 有什么限制?答:持久化与确认语义弱于 RabbitMQ,需评估可靠性。
04.7.9-023 异步任务的重试、超时与死信怎么设计?
一句话结论
重试要区分可重试异常、设上限与指数退避;超时要分“软超时(标记)”与“硬超时(杀进程)”;多次失败后进死信队列并告警,支持人工重放。全链路要幂等,避免重试造成重复副作用。
概念解释
- Celery 的
max_retries、retry_backoff、retry_jitter。 - 重试次数与总时长要小于业务可接受延迟。
原理流程
- 任务失败判断异常是否可重试。
- 可重试则按退避 + 抖动重试,达上限进死信。
- 死信记录原因与入参,告警后人工排查重放。
代码或图示
@task(bind=True, autoretry_for=(TimeoutError,), retry_backoff=True, max_retries=5)
def call_api(self, payload): ...
常见误区
- 重试要加抖动:避免所有任务同时重试造成二次雪崩;硬超时(
task_time_limit)会杀 Worker 子进程,注意资源清理;软超时只是标记。 - 死信队列可用独立队列/表,记录失败原因与入参;重放要幂等且限速,避免瞬间打爆下游;硬超时会终止进程,软超时只是标记。
追问
- 为什么重试要加抖动?答:避免所有任务同时重试造成二次雪崩。
- 超时后任务还会继续跑吗?答:硬超时会终止进程,软超时只是标记。
- 死信任务怎么处理?答:告警 + 人工排查 + 修复后批量重放。
04.7.9-024 接口限流怎么做?
一句话结论
按维度(IP、用户、API Key、接口)用固定窗口/滑动窗口/令牌桶/漏桶计数,存在 Redis 保证多副本一致;超限返回 429 + Retry-After。网关层做粗粒度,应用层做细粒度,二者配合。
概念解释
- 固定窗口简单但有边界突刺;滑动窗口更平滑但存储多。
- 限流要可观测:命中率、拒绝量、按维度分布。
原理流程
- 按维度生成限流键,选择算法计数。
- Redis 原子更新计数并设过期。
- 超限返回 429 与重试提示。
代码或图示
key = f"rl:{uid}:{minute}"
n = redis.incr(key)
if n == 1:
redis.expire(key, 60)
if n > limit:
raise HTTPException(429)
常见误区
- INCR 和 EXPIRE 要放 Lua:两条命令之间崩溃会导致 key 无过期,永久限流;限流控速率,熔断在下游故障时快速失败。
- 单机限流不够:多副本下每实例独立计数,总速率是 N 倍,需集中式或配额分配;令牌桶允许突发、限制平均速率,适合 API;分布式限流要考虑 Redis 故障降级(本地桶/放行策略)。
追问
- 为什么 INCR 和 EXPIRE 要放 Lua?答:两条命令之间崩溃会导致 key 无过期,永久限流。
- 限流和熔断的区别?答:限流控速率,熔断在下游故障时快速失败。
- 单机限流够吗?答:多副本下每实例独立计数,总速率是 N 倍,需集中式或配额分配。
04.7.9-025 文件上传怎么处理才不会打爆内存?
一句话结论
不要 await request.body()/request.files 全量读入内存。用流式读取(分块写临时文件/对象存储)、限制大小与类型、校验文件名与路径、上传后异步处理(转码/缩略图),并设置超时。
概念解释
- FastAPI 的
UploadFile是 spool 临时文件,仍需限制大小。 - 大文件用分片上传/断点续传(S3 multipart)。
原理流程
- 分块读取请求体,边读边累计大小校验。
- 写入临时文件/对象存储,文件名随机并清洗路径。
- 上传完成后转异步任务处理。
代码或图示
@app.post("/upload")
async def upload(file: UploadFile, size: int = 0):
with open(tmp_path, "wb") as out:
while chunk := await file.read(1024 * 1024):
size += len(chunk)
if size > LIMIT: raise HTTPException(413)
out.write(chunk)
常见误区
- 不能信任
Content-Length:客户端可伪造,必须边读边校验;文件名要清洗(防路径穿越../),存储用随机名。 - 上传后立刻同步处理有问题:占请求线程/协程,失败无法重试,应转异步任务;上传目录不要放在可执行/可访问路径,避免 webshell;防病毒/恶意文件靠类型嗅探 + 隔离存储 + 扫描服务。
追问
- 为什么不能信任
Content-Length?答:客户端可伪造,必须边读边校验。 - 上传后立刻同步处理有什么问题?答:占请求线程/协程,失败无法重试,应转异步任务。
- 如何防病毒/恶意文件?答:类型嗅探 + 隔离存储 + 扫描服务。
04.7.9-026 统一错误响应该怎么设计?
一句话结论
定义统一结构(code、message、details、request_id),用异常处理器把内部异常映射为 HTTP 状态码与业务码;对外不暴露堆栈与内部细节,对内记录完整 traceback;区分“可展示给用户”和“仅内部可见”的信息。
概念解释
- 业务异常 → 4xx + 业务码;未知异常 → 500 + 通用提示 + 告警。
- 请求 ID 回传给客户端,便于客服/排查对账。
原理流程
- 定义错误响应结构与异常映射规则。
- 异常处理器捕获内部异常,映射状态码与业务码。
- 对外返回脱敏信息,对内记录完整 traceback。
代码或图示
@app.exception_handler(AppError)
async def handle(request, exc):
return JSONResponse(
{"code": exc.code, "message": str(exc), "request_id": request.state.rid},
status_code=exc.status,
)
常见误区
- 不能把异常字符串直接返回:可能泄露 SQL、路径、内部实现;校验错误返回字段级 details,便于前端定位。
- 错误码要稳定、可枚举、有文档,避免直接用中文消息当码;错误响应也要走 CORS/日志/指标中间件;404 资源不存在,403 存在但无权访问(或出于安全统一 404);状态码表达类别,业务码表达具体原因,二者配合。
追问
- 为什么不能把异常字符串直接返回?答:可能泄露 SQL、路径、内部实现。
- 404 和 403 怎么选?答:资源不存在 404;存在但无权访问 403(或出于安全统一 404)。
- 错误码和 HTTP 状态码的关系?答:状态码表达类别,业务码表达具体原因,二者配合。
04.7.9-027 如何防 SQL 注入?
一句话结论
永远用参数化查询(ORM 或驱动提供的 placeholder),不要拼接 SQL 字符串;必须动态拼接时用白名单校验标识符(表名/列名),并对值做类型转换。ORM 的 extra/raw 与 text() 同样要参数化。
概念解释
cursor.execute("SELECT ... WHERE id=%s", (uid,));禁止 f-string 拼 SQL。- 最小权限数据库账号,避免注入后横向提权。
原理流程
- SQL 结构与参数分离,参数按数据而非语法解析。
- 动态标识符查表名/列名白名单。
- 数据库账号最小权限限制注入影响面。
代码或图示
# 错
cursor.execute(f"SELECT * FROM users WHERE name='{name}'")
# 对
cursor.execute("SELECT * FROM users WHERE name=%s", (name,))
常见误区
- 排序字段、表名无法参数化,需映射白名单(
{"name": "name", "age": "age"});LIKE 查询要转义%/_,并参数化。 - ORM 不一定安全:
raw/extra/字符串条件仍可能注入;二次注入是恶意数据先入库,后续拼接查询时触发;WAF 只能兜底,不能替代参数化。
追问
- 参数化为什么能防注入?答:值被当作数据而非 SQL 语法解析。
- ORM 就一定安全吗?答:
raw/extra/字符串条件仍可能注入。 - 二次注入是什么?答:恶意数据先入库,后续拼接查询时触发。
04.7.9-028 XSS 和 CSRF 分别怎么防?
一句话结论
XSS:输出时按上下文转义(HTML/JS/URL),设置 Content-Security-Policy,Cookie 加 HttpOnly,富文本用白名单清洗。CSRF:用 SameSite Cookie、CSRF Token、校验 Origin/Referer,敏感操作要求二次确认。
概念解释
- 模板引擎默认转义的要用默认,
|safe/Markup是风险点。 - API + JWT(非 Cookie)天然规避 CSRF,但要注意 token 存储安全。
原理流程
- XSS 防御:输出按上下文转义 + CSP 限制脚本来源 + 富文本清洗。
- CSRF 防御:SameSite 属性 + Token 绑定会话 + Origin 校验。
- Cookie 属性降低两者影响面。
代码或图示
response.set_cookie("sid", token, httponly=True, secure=True, samesite="Lax")
常见误区
- HttpOnly 只能防“读取 Cookie”,不能防页面内执行脚本;SameSite=Lax 能挡多数跨站 POST,但 GET 型敏感操作仍需 Token。
- 转义要分上下文:HTML/JS/URL 的转义规则不同,用错仍可注入;CSRF Token 要绑定会话且一次性/轮换;前后端分离用自定义头 + CORS 白名单,避免简单请求被跨站伪造;CSP 限制脚本来源,能大幅降低 XSS 影响。
追问
- HttpOnly 能防 XSS 吗?答:只能防“读取 Cookie”,不能防页面内执行脚本。
- SameSite=Lax 足够吗?答:能挡多数跨站 POST,但 GET 型敏感操作仍需 Token。
- 为什么转义要分上下文?答:HTML/JS/URL 的转义规则不同,用错仍可注入。
04.7.9-029 Python 微服务常用什么通信方式?
一句话结论
同步内部调用常用 HTTP/JSON(简单、易调试)或 gRPC(强类型、HTTP/2、性能好);异步解耦用消息队列(RabbitMQ/Kafka/Redis Stream)。gRPC 适合服务间高频、契约稳定的场景,HTTP 适合对外 API 与快速迭代。
概念解释
- gRPC 用 protobuf 定义契约,支持流式、双向流、超时与元数据。
- 服务发现与负载均衡(K8s Service/网关)。
原理流程
- 同步调用按契约经 HTTP/gRPC 通信。
- 异步场景经消息队列解耦生产者与消费者。
- 契约变更版本化,避免破坏调用方。
代码或图示
# grpcio:存根调用
stub = UserServiceStub(channel)
resp = stub.GetUser(GetUserRequest(id=1), timeout=2)
常见误区
- gRPC 性能来自 HTTP/2 多路复用 + 二进制编码 + 头部压缩;调试用 grpcurl、反射、统一日志与链路追踪。
- 浏览器直连需 gRPC-Web,对外公开 API、团队不熟悉时不宜上 gRPC;HTTP 客户端需统一超时、重试、连接池、熔断;跨语言时 protobuf 比 JSON 更省心;契约变更要版本化。
追问
- gRPC 为什么性能更好?答:HTTP/2 多路复用 + 二进制编码 + 头部压缩。
- gRPC 调试难怎么办?答:用 grpcurl、反射、统一日志与链路追踪。
- 什么时候不该用 gRPC?答:浏览器直连(需 gRPC-Web)、对外公开 API、团队不熟悉时。
04.7.9-030 Web 服务应该开多少 worker?
一句话结论
同步 WSGI(gunicorn):worker = 2 × 核数 + 1 是经验起点,IO 等待多可上调,但受内存与 DB 连接限制;异步 ASGI(uvicorn):每进程 1 个事件循环,workers ≈ 核数,并发由协程承载,CPU 密集需单独进程池。
概念解释
- 每个 worker 是独立进程,内存 × worker 数是主要约束。
- 容器 CPU limit 会影响 worker 实际可用核数,按 limit 计算。
原理流程
- 同步 worker 阻塞时无法处理其他请求,需多开进程。
- 异步 worker 瓶颈是单核 CPU 与事件循环延迟,开太多反而上下文切换。
- 总连接数 = worker × 池大小,必须 ≤ DB 上限。
代码或图示
gunicorn app:app -w 8 -k gthread --threads 4 --timeout 30
uvicorn app:app --workers 4
常见误区
2n+1不是绝对标准:取决于 IO 占比与内存,必须压测确认;同步 worker 阻塞时无法处理其他请求,所以要多开;异步 worker 开太多反而上下文切换。- 异步服务一般不需要多线程,除非有阻塞库需线程池;单 worker 吞吐 × worker 数 ≈ 总吞吐,但受下游与 CPU 限制;总连接数 = worker × 池大小,必须 ≤ DB 上限;容器按 CPU limit 计算可用核数。
追问
- 为什么
2n+1不是绝对标准?答:取决于 IO 占比与内存,必须压测确认。 - 异步服务要开多线程吗?答:一般不需要,除非有阻塞库需线程池。
- worker 数与 QPS 的关系?答:单 worker 吞吐 × worker 数 ≈ 总吞吐,但受下游与 CPU 限制。
本节高频题
- WSGI vs ASGI(001)
- 请求生命周期(002)
- Flask 上下文与 g(003)
- Django 中间件(005)
- N+1 与 select_related/prefetch_related(006)
transaction.atomic与 on_commit(007)- FastAPI 依赖注入(008)
- 同步/异步路由(010)
- 幂等设计(012)
- JWT vs Session(013)
- CORS(014)
- Session 生命周期与连接池(015、016)
- 缓存模式与一致性(020、021)
- Celery(022、023)
- 限流(024)
- SQL 注入(027)
- worker 容量(030)