Dincolo de Depends de bază, injecția de dependențe din FastAPI suportă modele avansate: sub-dependențe, dependențe cu parametri (bazate pe clase sau prin fabrici), resurse cu domeniu de aplicare (yield), , și pentru testare — ceea ce o face un instrument versatil pentru structurarea aplicațiilor reale.
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
Dependențele pot depinde de alte dependențe, formând un arbore pe care FastAPI îl rezolvă automat (și pune în cache pe cele partajate per cerere, deci get_token se execută o singură dată chiar dacă este folosit de mai multe dependențe).
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(): ...
O clasă cu __call__ este o dependență configurabilă — o parametrizezi la momentul utilizării (de ex. limite de viteză diferite per rută).
@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
Aplicați dependențe la nivelul întregii aplicații sau per-router pentru cerințe transversale (autentificare, rate limiting).
app.dependency_overrides[get_db] = get_test_db # swap any dependency in tests
Injecția de dependențe din FastAPI este una dintre cele mai puternice caracteristici ale acesteia, iar aceste modele avansate sunt ceea ce vă permite să structurați aplicații reale și complexe elegant.
Înțelegerea lor este cunoaștere de nivel senior valoroasă: sub-dependențele construiesc straturi reutilizabile (token → utilizator → admin) cu rezolvare automată și cache per cerere (evitând munca redundantă); dependențele parametrizate/bazate pe clase creează componente configurabile și reutilizabile (limitatori de viteză, verificări de permisiuni cu setări diferite per rută); dependențele ca efecte secundare forțează elegant cerințele (autentificare) fără a încărca semnăturile funcțiilor; iar dependențele globale/la nivel de router aplică probleme transversale (autentificare, rate limiting) grupurilor întregi de rute într-un singur loc.
Important, override-urile de dependențe fac chiar și graficele de dependență complexe trivial testabile.
Stăpânirea acestor modele — compunerea dependențelor, parametrizarea lor, sfera lor la nivel global sau per-router, și override-urile lor în teste — este ceea ce permite arhitectură curată, DRY și testabilă în aplicații FastAPI netriviale, distingând dezvoltatorii care pot valorifica pe deplin sistemul DI al framework-ului de cei care folosesc doar Depends de bază.
Este un subiect important pentru construirea aplicațiilor FastAPI bine structurate, ușor de întreținut și la scară mare.