Bortom grundläggande Depends stöder FastAPIs beroendeinjektion avancerade mönster: delmönster-beroenden, beroenden med parametrar (klassbaserade eller via fabriker), omfattade resurser (yield), globala/router-beroenden och för testning — vilket gör det till ett mångsidigt verktyg för att strukturera verkliga 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
Beroenden kan bero på andra beroenden och formar ett träd som FastAPI löser automatiskt (och cachelagrar delade per begäran, så get_token körs en gång även om det används av flera beroenden).
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 klass med __call__ är ett konfigurerbart beroende — du parametriserar det vid användningstid (t.ex. olika hastighetsbegränsningar per rutt).
@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
Tillämpa beroenden app-brett eller per-router för övergripande krav (auth, hastighetsbegränsning).
app.dependency_overrides[get_db] = get_test_db # swap any dependency in tests
FastAPIs beroendeinjektion är en av dess mest kraftfulla funktioner, och dessa avancerade mönster är vad som låter dig strukturera verkliga, komplexa applikationer elegant.
Att förstå dem är värdefull kunskap på seniorsnivå: delmönster-beroenden bygger återanvändbara lager (token → användare → admin) med automatisk upplösning och per-begäran-caching (undviker redundant arbete); parametriserade/klassbaserade beroenden skapar konfigurerbara, återanvändbara komponenter (hastighetsbegränsare, behörighetskontroller med olika inställningar per rutt); beroenden som bieffekter upprätthåller krav rent (auth) utan att röra upp funktionssignaturer; och globala/router-nivå-beroenden tillämpar övergripande frågor (autentisering, hastighetsbegränsning) på hela grupper av rutter på ett ställe.
Avgörande är att beroendeåsidosättningar gör även komplexa beroendegrafer trivielt testbara.
Att bemästra dessa mönster — komponera beroenden, parametrisera dem, begränsa dem globalt eller per-router och åsidosätt dem i tester — är vad som möjliggör ren, DRY, testbar arkitektur i icke-trivial FastAPI-applikationer och skiljer utvecklare som kan utnyttja ramverkets DI-system fullt ut från de som endast använder grundläggande Depends.
Det är ett viktigt ämne för att bygga väl-strukturerade, underhållbara, storskaliga FastAPI-appar.