Come funziona l'iniezione di dipendenze (Depends)?

Question

Accepted Answer

Il sistema di **iniezione di dipendenze** di FastAPI ti permette di dichiarare dipendenze riutilizzabili (funzioni/classi) che FastAPI chiama e **inietta** nelle tue operazioni di percorso tramite `Depends()`. Viene utilizzato per la logica condivisa come sessioni di database, autenticazione e parametri comuni — mantenendo il codice DRY e testabile.

## Una dipendenza base

```python
from fastapi import Depends

# a dependency is just a callable that returns something
def pagination(skip: int = 0, limit: int = 10):
    return {"skip": skip, "limit": limit}

@app.get("/items")
def list_items(params: dict = Depends(pagination)):   # FastAPI calls pagination() and injects the result
    return params
# the skip/limit query params are now handled by the reusable dependency
```

Dichiarare `params = Depends(pagination)` dice a FastAPI di chiamare `pagination` (risolvendo *i suoi* parametri dalla richiesta) e passare il risultato nella tua funzione. La dipendenza è riutilizzabile in molti endpoint.

## Dipendenze con pulizia (yield) — ad es. sessioni di database

```python
def get_db():
    db = SessionLocal()
    try:
        yield db                  # provide the session to the endpoint
    finally:
        db.close()                # cleanup runs AFTER the response — guaranteed

@app.get("/users")
def list_users(db = Depends(get_db)):
    return db.query(User).all()    # uses the injected, auto-closed session
```

Una dipendenza `yield` fornisce una risorsa ed esegue il teardown dopo la richiesta — il modello standard per le sessioni di database (apri prima, chiudi dopo, automaticamente).

## Le dipendenze possono dipendere da dipendenze

```python
def get_current_user(token: str = Depends(get_token)):   # depends on another dependency
    return decode(token)

@app.get("/me")
def me(user: User = Depends(get_current_user)):           # auth via injection
    return user
```

Le dipendenze formano un albero — FastAPI risolve l'intera catena. Questo è il modo in cui l'autenticazione viene tipicamente implementata (una dipendenza `get_current_user`).

## Dipendenze di classe e riutilizzo

```python
@app.get("/items", dependencies=[Depends(verify_api_key)])   # run a dependency without using its return
def items(): ...                                              # e.g. enforce auth as a side effect
```

## Perché è importante

L'iniezione di dipendenze è una delle caratteristiche più potenti e importanti di FastAPI — è il modo in cui condividi e riutilizzi la logica in modo pulito tra gli endpoint (sessioni di database, autenticazione, parametri di query comuni, controlli di permessi) senza duplicazione.

Comprenderla è essenziale perché è alla base di modelli fondamentali: la **dipendenza `yield`** è il modo standard per gestire le sessioni di database (con pulizia garantita dopo ogni richiesta), e una **dipendenza `get_current_user`** è il modo idiomatico per implementare l'autenticazione.

L'iniezione di dipendenze rende anche il codice altamente **testabile** — puoi sovrascrivere le dipendenze con mock nei test.

L'eleganza del sistema (le dipendenze risolvono i loro stessi parametri dalla richiesta, possono dipendere da altre dipendenze formando un albero, e si integrano con la documentazione) lo rende uno strumento versatile per strutturare applicazioni reali, quindi padroneggiare `Depends` è fondamentale per costruire app FastAPI ben organizzate, mantenibili e testabili.