Kif jaħdem iċ-ċiklu tal-ħajja tar-request f'FastAPI?

Question

IT Interview Practice · Accepted Answer

FastAPI jaħdem fuq **ASGI**, għalhekk request jivvjaġġa minn pipeline async: l-ASGI server jaċċettah, il-middleware jgeżwru, ir-router jaqbel path, **id-dependencies jiġu riżolti**, il-path operation tiegħek tiġri, u l-valur li jintbagħat lura jiġi serializzat fir-response.

## L-istadji

```
uvicorn (ASGI server)
   │  scope + receive/send
   ▼
ASGI / Starlette middleware  ── (CORS, GZip, custom)
   ▼
Routing  ── aqbel method + path → path operation
   ▼
Dependencies (Depends)  ── irriżolvi sub-deps, security, yield-setup
   ▼
Path operation function  ── il-handler tiegħek jiġri
   ▼
Response model  ── ivvalida + serializza għal JSON
   ▼
Background tasks  ── jiġru wara li r-response jintbagħat
   ▼
Response ──▶ client
```

1. **ASGI server** (uvicorn/hypercorn) jaċċetta l-konnessjoni u jgħaddi `scope` flimkien mal-callables `receive`/`send` lill-app.
2. **Middleware** jiġri minn barra għal ġewwa fit-triq 'l ġewwa u minn ġewwa għal barra fit-triq 'l barra (`BaseHTTPMiddleware` jew ASGI middleware pur). CORS, GZip, u timing custom jgħixu hawn.
3. **Routing** jaqbel il-HTTP method + path ma' path operation; il-params tal-path/query/body jiġu estratti u vvalidati minn **Pydantic**.
4. **Dependency injection** — `Depends(...)` jirriżolvi kull dependency (DB session, current user, settings), b'caching fi ħdan ir-request. Dependency b'`yield` tiġri s-setup qabel u t-teardown wara l-handler.
5. **Path operation** — l-`async def` tiegħek (jew `def`, li jiġri fi threadpool) jesegwixxi l-business logic.
6. **Response** — il-valur li jintbagħat lura jiġi mġiegħel għar-`response_model` iddikjarat, ivvalidat, u serializzat għal JSON; il-status code u l-headers jiġu applikati.
7. **Background tasks** irreġistrati permezz ta' `BackgroundTasks` jiġru *wara* li r-response jintbagħat.

```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. serializzat via response_model
```

L-eċċezzjonijiet jinqabdu minn **exception handlers** (`@app.exception_handler(...)` / `HTTPException`), li jikkonvertuhom f'responses minflok jaqilbu r-request.

## Għaliex huwa importanti

Iċ-ċiklu tal-ħajja tar-request huwa fejn il-karatteristiċi ewlenin ta' FastAPI fil-fatt iseħħu: async I/O, validazzjoni b'Pydantic, u dependency injection kollha jintrabtu ma' stadji speċifiċi. Li tkun taf l-ordni — middleware, imbagħad routing, imbagħad dependencies, imbagħad handler, imbagħad serialization — jippermettilek tqiegħed logic cross-cutting fil-post it-tajjeb (auth bħala dependency, timing bħala middleware, cleanup f'dependency `yield`), tagħmel debug għaliex żball ta' validazzjoni jew auth jitla' qabel ma jiġri l-kodiċi tiegħek, u tevita li timblokka l-event loop ġewwa handler async.

L-istadji

Għaliex huwa importanti

Mistoqsijiet relatati