Beyond basic Depends, FastAPI's dependency injection supports advanced patterns: sub-dependencies, dependencies with parameters (class-based or via factories), scoped resources (yield), global/router dependencies, and for testing — making it a versatile tool for structuring real applications.
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
Avhengigheter kan avhenge av andre avhengigheter, og danner et tre som FastAPI løser automatisk (og mellomlagrer delte ressurser per forespørsel, slik at get_token kjører bare en gang selv om den brukes av flere avhengigheter).
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 avhengighet — du parameteriserer den ved brukstidspunkt (f.eks. ulike hastighetsbegrensninger per 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
Use avhengigheter på hele appen eller per-ruter for tverrgående krav (auth, hastighetsbegrensning).
app.dependency_overrides[get_db] = get_test_db # swap any dependency in tests
FastAPI's avhengighetsinjeksjon er en av dens mest kraftige funksjoner, og disse avanserte mønstrene er det som lar deg strukturere virkelige, komplekse applikasjoner elegant.
Å forstå dem er verdifull kunskap på seniornnivå: sub-dependencies bygger gjenbrukbare lag (token → bruker → admin) med automatisk oppløsning og per-forespørsel-caching (unngår redundant arbeid); parameteriserte/klassebaserte avhengigheter skaper konfigurerbare, gjenbrukbare komponenter (hastighetsbegrensere, tillatelseskontroller med ulike innstillinger per rute); avhengigheter som bivirkninger håndhever krav rent (auth) uten å fylte funksjonetersignaturer; og globale/rutternivå-avhengigheter anvender tverrgående bekymringer (autentisering, hastighetsbegrensning) på hele grupper av ruter på ett sted.
Avgjørende er at dependency overrides gjør selv komplekse avhengighetsgrafer trivielt testbare.
Å mestre disse mønstrene — komponere avhengigheter, parameterisere dem, begrense dem globalt eller per-ruter, og overstyre dem i tester — er det som muliggjør ren, DRY, testbar arkitektur i ikke-trivielle FastAPI-applikasjoner, og skiller utviklere som fullt ut kan utnytte rammeverkets DI-system fra de som bare bruker grunnleggende Depends.
Det er et viktig emne for bygging av velstrukturerte, vedlikeoldbare, storstilte FastAPI-apper.