FastAPI 中的请求生命周期是如何工作的？

Question

IT Interview Practice · Accepted Answer

FastAPI 运行在 **ASGI** 之上，因此一个请求会经过一条异步 pipeline：ASGI server 接收它，middleware 包裹它，router 匹配 path，**依赖被解析**，你的 path operation 运行，返回值被 serialize 成响应。

## 各阶段

```
uvicorn (ASGI server)
   │  scope + receive/send
   ▼
ASGI / Starlette middleware  ── (CORS, GZip, custom)
   ▼
Routing  ── 匹配 method + path → path operation
   ▼
Dependencies (Depends)  ── 解析 sub-deps、security、yield-setup
   ▼
Path operation function  ── 你的 handler 运行
   ▼
Response model  ── validate + serialize 成 JSON
   ▼
Background tasks  ── 在响应发送后运行
   ▼
Response ──▶ client
```

1. **ASGI server**（uvicorn/hypercorn）接受连接，并向 app 传递一个 `scope` 以及 `receive`/`send` 两个 callable。
2. **Middleware** 在进入时由外向内运行、在返回时由内向外运行（`BaseHTTPMiddleware` 或纯 ASGI middleware）。CORS、GZip 和自定义计时都在这里。
3. **Routing** 将 HTTP method + path 匹配到一个 path operation；path/query/body 参数由 **Pydantic** 提取并 validate。
4. **Dependency injection** — `Depends(...)` 解析每个依赖（DB session、当前 user、settings），并在请求内缓存。带 `yield` 的依赖会在 handler 之前运行 setup、之后运行 teardown。
5. **Path operation** — 你的 `async def`（或在 threadpool 中运行的 `def`）执行业务逻辑。
6. **Response** — 返回值被强制转换为声明的 `response_model`，经过 validate，并 serialize 成 JSON；应用 status code 和 headers。
7. **Background tasks** 通过 `BackgroundTasks` 注册的任务在响应发送*之后*运行。

```python
from fastapi import FastAPI, Depends, Request

app = FastAPI()

@app.middleware("http")
async def timing(request: Request, call_next):   # 2. middleware
    response = await call_next(request)
    response.headers["X-Time"] = "..."
    return response

async def get_db():                               # 4. dependency (yield)
    db = Session()
    try:
        yield db
    finally:
        db.close()

@app.get("/items/{id}")                           # 3. routing
async def read_item(id: int, db=Depends(get_db)): # 5. handler
    return db.get(Item, id)                        # 6. 通过 response_model 进行 serialize
```

异常由 **exception handlers**（`@app.exception_handler(...)` / `HTTPException`）捕获，将它们转换为响应，而不是让请求崩溃。

## 为什么这很重要

请求生命周期正是 FastAPI 招牌特性真正发生的地方：async I/O、Pydantic validation 和 dependency injection 都挂接到特定阶段。了解顺序——middleware，然后 routing，然后 dependencies，然后 handler，然后 serialization——让你能把横切逻辑放在正确的位置（auth 作为依赖、计时作为 middleware、清理放在 `yield` 依赖中），调试为什么一个 validation 或 auth 错误会在你的代码运行之前触发，并避免在 async handler 内部阻塞 event loop。

各阶段

为什么这很重要

相关问题