Neben dem grundlegenden Depends unterstützt FastAPIs Dependency-Injection erweiterte Muster: Sub-Abhängigkeiten, Abhängigkeiten mit Parametern (klassenbasiert oder über Factories), scoped Resources (yield), und zum Testen — was sie zu einem vielseitigen Werkzeug für die Strukturierung echter Anwendungen macht.
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
Abhängigkeiten können von anderen Abhängigkeiten abhängen und bilden einen Baum, den FastAPI automatisch auflöst (und cached gemeinsame pro Request, sodass get_token einmal ausgeführt wird, auch wenn es von mehreren Abhängigkeiten verwendet wird).
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(): ...
Eine Klasse mit __call__ ist eine konfigurierbare Abhängigkeit — Sie parametrisieren sie zur Nutzungszeit (z. B. unterschiedliche Rate Limits pro Route).
@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
Wenden Sie Abhängigkeiten App-weit oder pro Router an, um übergreifende Anforderungen (Auth, Rate Limiting) zu erfüllen.
app.dependency_overrides[get_db] = get_test_db # swap any dependency in tests
FastAPIs Dependency Injection ist eines ihrer mächtigsten Features, und diese erweiterten Muster sind das, was Sie in die Lage versetzt, echte, komplexe Anwendungen elegant zu strukturieren.
Das Verständnis dafür ist wertvolles Senior-Level-Wissen: Sub-Abhängigkeiten bauen wiederverwendbare Schichten auf (Token → Benutzer → Admin) mit automatischer Auflösung und Per-Request-Caching (Vermeidung redundanter Arbeit); parametrisierte/klassenbasierte Abhängigkeiten erstellen konfigurierbare, wiederverwendbare Komponenten (Rate Limiter, Permission Checks mit unterschiedlichen Einstellungen pro Route); Abhängigkeiten als Nebenwirkungen erzwingen Anforderungen (Auth) sauber, ohne Funktionssignaturen zu verstopfen; und globale/Router-Level-Abhängigkeiten wenden übergreifende Belange (Authentifizierung, Rate Limiting) in einer Stelle auf ganze Gruppen von Routes an.
Entscheidend ist, dass Dependency Overrides sogar komplexe Dependency Graphs trivial testbar machen.
Die Beherrschung dieser Muster — Abhängigkeiten komponieren, parametrisieren, global oder pro Router scopen und in Tests überridden — ist das, was saubere, DRY, testbare Architektur in nicht-trivialen FastAPI-Anwendungen ermöglicht und Entwickler unterscheidet, die das DI-System des Frameworks vollständig nutzen können, von denen, die nur grundlegendes Depends nutzen.
Es ist ein wichtiges Thema für den Aufbau gut strukturierter, wartbarer, großflächiger FastAPI-Apps.