Oltre al basic Depends, il dependency injection di FastAPI supporta pattern avanzati: sub-dipendenze, dipendenze con parametri (basate su classi o via factory), risorse scoped (yield), dipendenze globali/router, e per i test — rendendolo uno strumento versatile per strutturare applicazioni reali.
def get_token(authorization: str = Header()):
return parse(authorization)
def get_current_user(token: str = Depends(get_token)): # depends on another dependency
return decode(token)
def get_admin(user: User = Depends(get_current_user)): # depends on that, in turn
if not user.is_admin: raise HTTPException(403)
return user
# FastAPI resolves the whole chain, caching shared dependencies within a request
Le dipendenze possono dipendere da altre dipendenze, formando un albero che FastAPI risolve automaticamente (e cachea quelle condivise per request, quindi get_token viene eseguito una sola volta anche se utilizzato da più dipendenze).
class RateLimiter:
def __init__(self, calls: int): # configure the dependency
self.calls = calls
def __call__(self, request: Request): # callable → acts as a dependency
check_rate_limit(request, self.calls)
@app.get("/items", dependencies=[Depends(RateLimiter(calls=100))]) # configured per route
def items(): ...
Una classe con __call__ è una dipendenza configurabile — la si parametrizza al momento dell'uso (es. limiti di rate diversi per rotta).
@app.get("/admin", dependencies=[Depends(verify_admin)]) # run for the effect (auth check)
def admin(): ... # don't need its return value
app = FastAPI(dependencies=[Depends(verify_api_key)]) # applies to EVERY route
router = APIRouter(dependencies=[Depends(get_current_user)]) # to all routes in a router
Applica dipendenze a tutta l'app o per-router per requisiti trasversali (auth, rate limiting).
app.dependency_overrides[get_db] = get_test_db # swap any dependency in tests
Il dependency injection di FastAPI è una delle sue caratteristiche più potenti, e questi pattern avanzati sono ciò che ti permette di strutturare applicazioni reali e complesse elegantemente.
Comprenderli è conoscenza di livello senior: le sub-dipendenze costruiscono layer riusabili (token → user → admin) con risoluzione automatica e caching per request (evitando lavoro ridondante); le dipendenze parametrizzate/basate su classi creano componenti riusabili e configurabili (limitatori di rate, controlli di permessi con impostazioni diverse per rotta); le dipendenze come side-effect impongono chiaramente requisiti (auth) senza ingombrare le firme delle funzioni; e le dipendenze globali/router applicano cross-cutting concerns (autenticazione, rate limiting) a interi gruppi di rotte in un unico posto.
Crucialmente, i dependency overrides rendono banalmente testabili anche grafi di dipendenze complessi.
Padroneggiare questi pattern — componendo dipendenze, parametrizzandole, scavalcandole globalmente o per-router, e sostituendole nei test — è ciò che abilita architettura pulita, DRY, testabile in applicazioni FastAPI non banali, distinguendo sviluppatori che riescono a sfruttare appieno il sistema DI del framework da quelli che usano solo il basic Depends.
È un argomento importante per costruire app FastAPI ben strutturate, mantenibili e su larga scala.