FastAPI-Abhängigkeitsinjektion
FastAPI bietet ein leistungsstarkes und prägnantes Dependency-Injection-System.
Dependency Injection ist ein Entwurfsmuster, mit dem Sie gemeinsame Logik (wie Datenbankverbindungen, Authentifizierung, Parametervalidierung usw.) in wiederverwendbare Komponenten extrahieren und sie dann nach Bedarf in Routen verwenden können.

Was ist Dependency Injection
Einfach gesagt,AbhängigkeitSie ist im Wesentlichen eine Funktion, die dieselben Parameter wie Pfadoperation-Funktionen verwenden kann (Query-Parameter, Pfadparameter, Request-Body usw.). FastAPI ruft die Abhängigkeitsfunktion automatisch auf, bevor die Routenfunktion ausgeführt wird, und übergibt ihren Rückgabewert an die Routenfunktion.
Beispiel
from fastapi import Depends, FastAPI
app = FastAPI()
# 1. Abhängigkeitsfunktion definieren
def common_parameters(q: str | None = None, skip: int = 0, limit: int = 100):
return {"q": q, "skip": skip, "limit": limit}
# 2. Abhängigkeiten in Routen verwenden
@app.get("/items/")
async def read_items(commons: dict = Depends(common_parameters)):
# commons empfängt den Rückgabewert der Abhängigkeitsfunktion
return commons
@app.get("/users/")
async def read_users(commons: dict = Depends(common_parameters)):
# Mehrere Routen können dieselbe Abhängigkeit wiederverwenden
return commons
Code-Erklärung:
| Teil | Beschreibung |
|---|---|
common_parameters | Abhängigkeitsfunktionen, die gemeinsame Query-Parameter verarbeiten |
Depends(common_parameters) | Parameter deklarierencommonsDer Wert kommt von der Abhängigkeitsfunktion |
commons: dict | Empfängt das von der Abhängigkeitsfunktion zurückgegebene Dictionary |
Abhängigkeitsfunktionen und Pfadoperationsfunktionen verwenden denselben Stil zur Parameterdeklaration, und FastAPI löst die Parameter der Abhängigkeitsfunktion automatisch auf. Das bedeutet, dass Abhängigkeitsfunktionen auch Query-Parameter, Pfadparameter, Request-Body usw. verwenden können.
Ablauf der Abhängigkeitsausführung
Wenn eine Anfrage eintrifft, lautet die Verarbeitungsreihenfolge von FastAPI:
- Routenfunktionen und ihre Abhängigkeiten identifizieren
- Abhängigkeitsfunktionen ausführen (in Abhängigkeitsreihenfolge)
- Den Rückgabewert der Abhängigkeitsfunktion an die Routenfunktion übergeben.
- Routenfunktion ausführen
Klasse als Abhängigkeit
Neben Funktionen können Sie auch Klassen als Abhängigkeiten verwenden:
Beispiel
from fastapi import Depends, FastAPI
app = FastAPI()
# Abhängigkeiten mit Klassen deklarieren
class CommonQueryParams:
def __init__(self, q: str | None = None, skip: int = 0, limit: int = 100):
self.q = q
self.skip = skip
self.limit = limit
# Eine Klasse als Abhängigkeit verwenden
@app.get("/items/")
async def read_items(commons: Annotated[CommonQueryParams, Depends()]):
return {"q": commons.q, "skip": commons.skip, "limit": commons.limit}
WannDepends()Wenn kein Parameter übergeben wird, verwendet FastAPI automatisch die Typannotation des Parameters (CommonQueryParams) als Abhängigkeit.
Unterabhängigkeit
Abhängigkeiten können ihre eigenen Abhängigkeiten haben, wodurch eine Abhängigkeitskette entsteht:
Beispiel
from fastapi import Depends, FastAPI
app = FastAPI()
# Abhängigkeitsfunktionen
def query_extractor(q: str | None = None):
return q
# Unterabhängigkeit: hängt von query_extractor ab.
def query_checker(q: str = Depends(query_extractor)):
if q == "admin":
# Unterabhängigkeiten können validiert werden
return q + " (checked)"
return q
# Routen verwenden Unterabhängigkeiten
@app.get("/items/")
async def read_items(q: str = Depends(query_checker)):
return {"q": q}
Ausführungsablauf:query_extractor -> query_checker-> Routenfunktion
Abhängigkeiten in Dekoratoren verwenden
Manchmal benötigen Sie nur die Seiteneffekte der Abhängigkeit (wie Berechtigungsprüfungen), nicht ihren Rückgabewert. Im DekoratordependenciesIn Parametern deklariert:
Beispiel
app = FastAPI()
# Abhängigkeit: API-Schlüssel validieren
async def verify_api_key(x_api_key: str = Header()):
if x_api_key != "secret-key":
raise HTTPException(status_code=400, detail="X-API-Key ungültig")
# Abhängigkeit im Decorator verwenden, kein Rückgabewert erforderlich
@app.get("/items/", dependencies=[Depends(verify_api_key)])
async def read_items():
return [{"item": "Foo"}]
# Abhängigkeit auf die gesamte Routengruppe anwenden
@app.get("/users/", dependencies=[Depends(verify_api_key)])
async def read_users():
return [{"user": "Bar"}]
Globale Abhängigkeiten
Sie könnenFastAPIDeklariere globale Abhängigkeiten auf der Instanz, wirksam für alle Routen:
Beispiel
async def verify_token(x_token: str = Header()):
if x_token != "fake-super-secret-token":
raise HTTPException(status_code=400, detail="X-Token-Header ungültig")
# Globale Abhängigkeit: Alle Routen müssen die Token-Validierung bestehen
app = FastAPI(dependencies=[Depends(verify_token)])
@app.get("/items/")
async def read_items():
return [{"item": "Foo"}]
@app.get("/users/")
async def read_users():
return [{"user": "Bar"}]
Abhängigkeiten mit yield
Wenn eine Abhängigkeit Aufräumoperationen ausführen muss (wie das Schließen von Datenbankverbindungen), verwendeyield:
Beispiel
from fastapi import Depends, FastAPI
app = FastAPI()
# Abhängigkeiten, die yield verwenden: Erstelle eine Verbindung vor der Anfrage und schließe sie nach der Anfrage.
def get_db():
db = "database_connection" # Simuliere das Erstellen einer Datenbankverbindung
try:
yield db # Während der Bearbeitung der Anfrage eine Datenbankverbindung bereitstellen
finally:
print("Datenbankverbindung schließen") # Ressourcen nach Abschluss der Anfrage bereinigen
@app.get("/items/")
async def read_items(db: str = Depends(get_db)):
return {"db": db}
Ausführungsablauf:
- Wenn die Anfrage eintrifft, ausführen
yieldDer Code davor, der eine Datenbankverbindung herstellt yieldDie Verbindung an die Routenfunktion übergeben- Nachdem die Routenfunktion abgeschlossen ist, ausführen
finallyBereinigungscode im Block
yieldAbhängigkeiten sind ideal für die Verwaltung von Ressourcen, die bereinigt werden müssen, wie Datenbankverbindungen und Dateihandles. Der Bereinigungscode wird ausgeführt, unabhängig davon, ob die Routenfunktion eine Ausnahme auslöst.
Zusammenfassung
- Abhängigkeitsinjektion extrahiert gemeinsame Logik in wiederverwendbare Funktionen oder Klassen.
- Nutzung
Depends()Abhängigkeiten in den Parametern der Routenfunktion deklarieren - Abhängigkeiten können verschachtelt werden und Abhängigkeitsketten bilden
- des Dekorators
dependenciesParameter, die für Abhängigkeiten verwendet werden, die keine Rückgabewerte benötigen - Nutzung
yieldAbhängigkeiten unterstützen die Ressourcenbereinigung - Globale Abhängigkeiten gelten für alle Routen