Ud over grundlæggende Depends understøtter FastAPIs afhængighedsinjection avancerede mønstre: underafhængigheder, afhængigheder med parametre (klassebaserede eller via fabrikker), ressourcer med omfang (yield), og til test — hvilket gør det til et alsidigt værktøj til strukturering af rigtige applikationer.
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
Afhængigheder kan afhænge af andre afhængigheder og danner et træ, som FastAPI løser automatisk (og cacher delte over en anmodning, så get_token køres én gang selv hvis det bruges af flere afhængigheder).
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(): ...
En klasse med __call__ er en konfigurerbar afhængighed — du parameteriserer den på brugstidspunktet (f.eks. forskellige hastighedsbegrænsninger pr. rute).
@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
Anvend afhængigheder app-bredt eller pr. router til krydsskærende krav (auth, hastighedsbegrænsning).
app.dependency_overrides[get_db] = get_test_db # swap any dependency in tests
FastAPIs afhængighedsinjection er en af dets mest kraftfulde funktioner, og disse avancerede mønstre er det, der gør det muligt at strukturere rigtige, komplekse applikationer elegant.
At forstå dem er værdifuld kendskab på seniorplan: underafhængigheder bygger genbrug af lag (token → bruger → admin) med automatisk opløsning og caching pr. anmodning (undgår redundant arbejde); parameteriserede/klassebaserede afhængigheder skaber konfigurerbare, genanvendelige komponenter (hastighedsbegrænsere, tilladelseskontroller med forskellige indstillinger pr. rute); afhængigheder som bivirkninger håndhæver krav rent (auth) uden at rodet funktionssignaturer; og globale/router-niveau afhængigheder anvender krydsvendende bekymringer (godkendelse, hastighedsbegrænsning) på hele grupper af ruter på ét sted.
Væsentligt er det, at afhængighedsoverskrivninger gør selv komplekse afhængighedsgrafer trivielt testbare.
At mestre disse mønstre — sammensætning af afhængigheder, parameterisering af dem, omfang af dem globalt eller pr. router, og overskrivning af dem i tests — er det, der muliggør ren, DRY, testbar arkitektur i ikke-trivielle FastAPI-applikationer, og som sondrer udvikler, der fuldt ud kan udnytte rammeværkets DI-system, fra dem, der kun bruger grundlæggende Depends.
Det er et vigtigt emne til at bygge velstrukturerede, vedligeholdelsebare, storskalerede FastAPI-apps.