Poza podstawowym Depends, wstrzykiwanie zależności w FastAPI obsługuje zaawansowane wzorce: pod-zależności, zależności z parametrami (oparte na klasach lub poprzez fabryki), zasoby o określonym zakresie (yield), oraz do testowania — czyniąc to wszechstronnym narzędziem do strukturyzacji rzeczywistych aplikacji.
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
Zależności mogą zależeć od innych zależności, tworząc drzewo, które FastAPI automatycznie rozwiązuje (i buforuje wspólne zależności na żądanie, więc get_token wykonuje się raz, nawet jeśli jest używany przez kilka zależności).
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(): ...
Klasa z __call__ to konfigurowalna zależność — parametryzujesz ją w momencie użycia (np. różne limity szybkości na trasę).
@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
Zastosuj zależności na całej aplikacji lub na poszczególnym routerze dla wymagań występujących wszędzie (uwierzytelnianie, ograniczenie szybkości).
app.dependency_overrides[get_db] = get_test_db # swap any dependency in tests
Wstrzykiwanie zależności w FastAPI to jedna z jego najpotężniejszych funkcji, a te zaawansowane wzorce to właśnie to, co pozwala ci elegancko strukturyzować rzeczywiste, złożone aplikacje.
Rozumienie ich to cenna wiedza na poziomie seniora: pod-zależności budują wielowarstwy zdefiniujące na nowo (token → użytkownik → admin) z automatycznym rozwiązywaniem i buforowaniem na żądanie (unikając zbędnej pracy); sparametryzowane/oparte na klasach zależności tworzą konfigurowalne, wielokrotnie używane komponenty (ograniczniki szybkości, kontrole uprawnień z różnymi ustawieniami na trasę); zależności jako efekty uboczne czyszczą wymagania (uwierzytelnianie) bez zaśmiecania podpisów funkcji; a zależności na poziomie globalnym/routerowym stosują problemy występujące wszędzie (uwierzytelnianie, ograniczenie szybkości) do całych grup tras w jednym miejscu.
W szczególności, zastępowanie zależności sprawia, że nawet złożone wykresy zależności są banalne do testowania.
Opanowanie tych wzorców — komponowanie zależności, ich parametryzacja, określanie ich zakresu globalnie lub na routerze oraz zastępowanie ich w testach — to właśnie to, co umożliwia czystą, DRY, testowalna architekturę w nietrywialne aplikacjach FastAPI, różnicując deweloperów, którzy mogą w pełni wykorzystać system DI frameworka, od tych, którzy używają tylko podstawowego Depends.
To ważny temat do budowania dobrze ustrukturyzowanych, łatwych w utrzymaniu, dużych aplikacji FastAPI.