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 typing import Annotated
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:

TeilBeschreibung
common_parametersAbhängigkeitsfunktionen, die gemeinsame Query-Parameter verarbeiten
Depends(common_parameters)Parameter deklarierencommonsDer Wert kommt von der Abhängigkeitsfunktion
commons: dictEmpfä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:

  1. Routenfunktionen und ihre Abhängigkeiten identifizieren
  2. Abhängigkeitsfunktionen ausführen (in Abhängigkeitsreihenfolge)
  3. Den Rückgabewert der Abhängigkeitsfunktion an die Routenfunktion übergeben.
  4. Routenfunktion ausführen

Klasse als Abhängigkeit

Neben Funktionen können Sie auch Klassen als Abhängigkeiten verwenden:

Beispiel

from typing import Annotated
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 typing import Annotated
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

from fastapi import Depends, FastAPI, Header, HTTPException

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

from fastapi import Depends, FastAPI, Header, HTTPException

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 typing import Annotated
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:

  1. Wenn die Anfrage eintrifft, ausführenyieldDer Code davor, der eine Datenbankverbindung herstellt
  2. yieldDie Verbindung an die Routenfunktion übergeben
  3. Nachdem die Routenfunktion abgeschlossen ist, ausführenfinallyBereinigungscode 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.
  • NutzungDepends()Abhängigkeiten in den Parametern der Routenfunktion deklarieren
  • Abhängigkeiten können verschachtelt werden und Abhängigkeitsketten bilden
  • des DekoratorsdependenciesParameter, die für Abhängigkeiten verwendet werden, die keine Rückgabewerte benötigen
  • NutzungyieldAbhängigkeiten unterstützen die Ressourcenbereinigung
  • Globale Abhängigkeiten gelten für alle Routen
Weitere Erweiterungen