Conas a oibríonn saolré an request in FastAPI?

Question

IT Interview Practice · Accepted Answer

Ritheann FastAPI ar **ASGI**, mar sin taistealaíonn request trí phíblíne async: glacann an ASGI server leis, fillteann middleware é, meaitseálann an router path, **réitítear na dependencies**, ritheann do path operation, agus serialize-áiltear an luach a fhilltear isteach sa response.

## Na céimeanna

```
uvicorn (ASGI server)
   │  scope + receive/send
   ▼
ASGI / Starlette middleware  ── (CORS, GZip, saincheaptha)
   ▼
Routing  ── meaitseáil method + path → path operation
   ▼
Dependencies (Depends)  ── réitigh sub-deps, security, yield-setup
   ▼
Path operation function  ── ritheann do handler
   ▼
Response model  ── validate + serialize go JSON
   ▼
Background tasks  ── rith tar éis an response a sheoladh
   ▼
Response ──▶ client
```

1. **ASGI server** (uvicorn/hypercorn) glacann sé leis an gceangal agus cuireann sé `scope` móide callables `receive`/`send` chuig an app.
2. **Middleware** ritheann sé ón taobh amuigh isteach ar an mbealach isteach agus ón taobh istigh amach ar an mbealach amach (`BaseHTTPMiddleware` nó middleware ASGI íon). Cónaíonn CORS, GZip, agus uainiú saincheaptha anseo.
3. **Routing** meaitseálann sé an method HTTP + path le path operation; baintear amach agus validate-áiltear na paraiméadair path/query/body ag **Pydantic**.
4. **Dependency injection** — réitíonn `Depends(...)` gach dependency (DB session, an t-úsáideoir reatha, settings), ag caching laistigh den request. Ritheann dependency le `yield` an setup roimh an handler agus an teardown ina dhiaidh.
5. **Path operation** — ritheann do `async def` (nó `def`, a ritear i threadpool) an loighic ghnó.
6. **Response** — brúitear an luach a fhilltear go dtí an `response_model` dearbhaithe, validate-áiltear é, agus serialize-áiltear go JSON é; cuirtear an status code agus na headers i bhfeidhm.
7. **Background tasks** a chláraítear trí `BackgroundTasks` ritheann siad *tar éis* an response a sheoladh.

```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. serialize-áilte trí response_model
```

Gabhtar eisceachtaí ag **exception handlers** (`@app.exception_handler(...)` / `HTTPException`), a thiontaíonn iad ina responses in ionad an request a thuairteáil.

## Cén fáth a bhfuil sé tábhachtach

Is é saolré an request an áit a dtarlaíonn príomhghnéithe FastAPI i ndáiríre: nascann I/O async, validáil Pydantic, agus dependency injection go léir isteach i gcéimeanna ar leith. Nuair a bhíonn a fhios agat an t-ord — middleware, ansin routing, ansin dependencies, ansin an handler, ansin serialization — ligeann sé duit loighic thrasghearrthach a chur san áit cheart (auth mar dependency, uainiú mar middleware, glanadh i ndependency `yield`), a dhífhabhtú cén fáth a lasann earráid validáilte nó auth roimh do chód, agus an event loop a sheachaint a bhlocáil laistigh de handler async.

Na céimeanna

Cén fáth a bhfuil sé tábhachtach

Ceisteanna gaolmhara