Naast basis Depends ondersteunt FastAPI's dependency injection geavanceerde patronen: sub-afhankelijkheden, afhankelijkheden met parameters (class-based of via factories), scoped resources (yield), , en voor testen — wat het een veelzijdig instrument maakt voor het structureren van echte applicaties.
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
Afhankelijkheden kunnen afhangen van andere afhankelijkheden, wat een boom vormt die FastAPI automatisch oplost (en cached gedeelde afhankelijkheden per request, dus get_token wordt slechts eenmaal uitgevoerd zelfs als deze door meerdere afhankelijkheden wordt gebruikt).
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(): ...
Een klasse met __call__ is een configureerbare afhankelijkheid — je parametriseert deze op het moment van gebruik (bijv. verschillende rate limits per 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
Pas afhankelijkheden app-breed of per-router toe voor cross-cutting requirements (auth, rate limiting).
app.dependency_overrides[get_db] = get_test_db # swap any dependency in tests
FastAPI's dependency injection is een van zijn meest krachtige functies, en deze geavanceerde patronen zijn wat je in staat stelt echte, complexe applicaties elegant te structureren.
Deze patronen begrijpen is waardevolle senior-level kennis: sub-afhankelijkheden bouwen herbruikbare lagen (token → user → admin) met automatische resolutie en caching per request (vermijdend redundant werk); geparameteriseerde/class-based afhankelijkheden creëren configureerbare, herbruikbare componenten (rate limiters, permissie checks met verschillende instellingen per route); afhankelijkheden als neveneffecten handhaven vereisten schoon (auth) zonder functiehandtekeningen rommelig te maken; en globale/router-level afhankelijkheden passen cross-cutting concerns (authenticatie, rate limiting) op hele groepen routes in één keer toe.
Crucciaal, dependency overrides maken zelfs complexe afhankelijkheidsgrafeken triviaal testbaar.
Deze patronen beheersen — afhankelijkheden samenstellen, ze parametriseren, ze globaal of per-router scopen, en ze in testen overschrijven — is wat schone, DRY, testbare architectuur in niet-triviale FastAPI-applicaties mogelijk maakt, wat ontwikkelaars die het DI-systeem van het framework volledig kunnen benutten onderscheidt van degenen die alleen basis Depends gebruiken.
Het is een belangrijk onderwerp voor het bouwen van goed gestructureerde, onderhoudbare FastAPI-apps op grote schaal.