Bagaimanakah kitaran hayat request berfungsi dalam FastAPI?

Question

IT Interview Practice · Accepted Answer

FastAPI berjalan di atas **ASGI**, jadi sesuatu request bergerak melalui satu pipeline async: ASGI server menerimanya, middleware membalutnya, router memadankan path, **dependencies diselesaikan**, path operation anda dijalankan, dan nilai pulangan diserialize menjadi response.

## Peringkat-peringkatnya

```
uvicorn (ASGI server)
   │  scope + receive/send
   ▼
ASGI / Starlette middleware  ── (CORS, GZip, custom)
   ▼
Routing  ── padankan method + path → path operation
   ▼
Dependencies (Depends)  ── selesaikan sub-deps, security, yield-setup
   ▼
Path operation function  ── handler anda dijalankan
   ▼
Response model  ── validate + serialize ke JSON
   ▼
Background tasks  ── berjalan selepas response dihantar
   ▼
Response ──▶ client
```

1. **ASGI server** (uvicorn/hypercorn) menerima sambungan dan menghantar satu `scope` beserta callable `receive`/`send` kepada app.
2. **Middleware** berjalan luar-ke-dalam semasa masuk dan dalam-ke-luar semasa keluar (`BaseHTTPMiddleware` atau ASGI middleware tulen). CORS, GZip, dan pengukuran masa tersuai berada di sini.
3. **Routing** memadankan HTTP method + path kepada satu path operation; parameter path/query/body diekstrak dan divalidate oleh **Pydantic**.
4. **Dependency injection** — `Depends(...)` menyelesaikan setiap dependency (DB session, current user, settings), dengan caching dalam skop request. Sesuatu dependency dengan `yield` menjalankan setup sebelum dan teardown selepas handler.
5. **Path operation** — `async def` anda (atau `def`, dijalankan dalam threadpool) melaksanakan logik perniagaan.
6. **Response** — nilai pulangan dipaksa menjadi `response_model` yang diisytiharkan, divalidate, dan diserialize menjadi JSON; status code dan headers digunakan.
7. **Background tasks** yang didaftarkan melalui `BackgroundTasks` berjalan *selepas* response dihantar.

```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. diserialize melalui response_model
```

Exception ditangkap oleh **exception handlers** (`@app.exception_handler(...)` / `HTTPException`), yang menukarkannya menjadi response dan bukannya menyebabkan request crash.

## Mengapa ia penting

Kitaran hayat request ialah tempat ciri-ciri utama FastAPI sebenarnya berlaku: async I/O, validasi Pydantic, dan dependency injection semuanya bergantung pada peringkat-peringkat tertentu. Mengetahui susunannya — middleware, kemudian routing, kemudian dependencies, kemudian handler, kemudian serialization — membolehkan anda meletakkan logik merentas (cross-cutting) di tempat yang betul (auth sebagai dependency, pengukuran masa sebagai middleware, pembersihan dalam dependency `yield`), menyahpepijat mengapa ralat validasi atau auth berlaku sebelum kod anda dijalankan, dan mengelakkan penyekatan event loop di dalam handler async.

Peringkat-peringkatnya

Mengapa ia penting

Soalan berkaitan