Kaip veikia užklausos gyvavimo ciklas FastAPI?

Question

IT Interview Practice · Accepted Answer

FastAPI veikia ant **ASGI**, todėl užklausa keliauja per asinchroninį konvejerį: ASGI serveris ją priima, middleware ją apgaubia, router suderina kelią (path), **priklausomybės (dependencies) yra išsprendžiamos**, jūsų path operation įvykdoma, o grąžinama reikšmė yra serializuojama į atsakymą (response).

## Etapai

```
uvicorn (ASGI serveris)
   │  scope + receive/send
   ▼
ASGI / Starlette middleware  ── (CORS, GZip, custom)
   ▼
Routing  ── suderina method + path → path operation
   ▼
Dependencies (Depends)  ── išsprendžia sub-deps, security, yield-setup
   ▼
Path operation funkcija  ── jūsų handler įvykdoma
   ▼
Response model  ── validuoja + serializuoja į JSON
   ▼
Background tasks  ── vykdoma po to, kai response išsiųstas
   ▼
Response ──▶ klientas
```

1. **ASGI serveris** (uvicorn/hypercorn) priima ryšį ir perduoda `scope` kartu su `receive`/`send` iškviečiamaisiais objektais (callables) į programą.
2. **Middleware** įeinant vykdoma iš išorės į vidų, o išeinant iš vidaus į išorę (`BaseHTTPMiddleware` arba grynas ASGI middleware). CORS, GZip ir individualus laiko matavimas glūdi čia.
3. **Routing** suderina HTTP method + path su path operation; path/query/body parametrai yra išgaunami ir validuojami **Pydantic**.
4. **Dependency injection** — `Depends(...)` išsprendžia kiekvieną priklausomybę (DB session, dabartinis vartotojas, settings), talpindama rezultatą užklausos ribose. Priklausomybė su `yield` vykdo paruošimą (setup) prieš ir sutvarkymą (teardown) po handler.
5. **Path operation** — jūsų `async def` (arba `def`, vykdomas gijų telkinyje (threadpool)) įvykdo verslo logiką.
6. **Response** — grąžinama reikšmė yra priverstinai konvertuojama į deklaruotą `response_model`, validuojama ir serializuojama į JSON; pritaikomas statuso kodas ir antraštės (headers).
7. **Background tasks**, užregistruotos per `BackgroundTasks`, vykdomos *po to*, kai response išsiųstas.

```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. serializuojama per response_model
```

Išimtys (exceptions) yra gaudomos **exception handler'ių** (`@app.exception_handler(...)` / `HTTPException`), kurie jas paverčia atsakymais, užuot sugriovę užklausą.

## Kodėl tai svarbu

Užklausos gyvavimo ciklas yra ta vieta, kur iš tikrųjų vyksta pagrindinės FastAPI savybės: asinchroninis I/O, Pydantic validacija ir dependency injection — visos jos prisikabina prie konkrečių etapų. Žinant eiliškumą — middleware, tada routing, tada priklausomybės, tada handler, tada serializacija — galima kertinę (cross-cutting) logiką padėti į tinkamą vietą (auth kaip priklausomybė, laiko matavimas kaip middleware, valymas `yield` priklausomybėje), suprasti (debug), kodėl validacijos ar auth klaida iššauna dar prieš įvykdant jūsų kodą, ir išvengti event loop blokavimo asinchroniniame handler viduje.

Etapai

Kodėl tai svarbu

Susiję klausimai