Wie funktioniert Dependency Injection (Depends)?

Question

Accepted Answer

FastAPIs **Dependency-Injection**-System ermöglicht es dir, wiederverwendbare Dependencies (Funktionen/Klassen) zu deklarieren, die FastAPI aufruft und über `Depends()` in deine Path Operations **injiziert**. Es wird für gemeinsame Logik wie Datenbanksitzungen, Authentifizierung und allgemeine Parameter verwendet — hält Code DRY und testbar.

## Eine grundlegende Dependency

```python
from fastapi import Depends

# a dependency is just a callable that returns something
def pagination(skip: int = 0, limit: int = 10):
    return {"skip": skip, "limit": limit}

@app.get("/items")
def list_items(params: dict = Depends(pagination)):   # FastAPI calls pagination() and injects the result
    return params
# the skip/limit query params are now handled by the reusable dependency
```

Die Deklaration `params = Depends(pagination)` teilt FastAPI mit, `pagination` aufzurufen (auch *ihre* Parameter aus der Anfrage zu lösen) und das Ergebnis an deine Funktion zu übergeben. Die Dependency ist über viele Endpoints hinweg wiederverwendbar.

## Dependencies mit Bereinigung (yield) — z. B. Datenbanksitzungen

```python
def get_db():
    db = SessionLocal()
    try:
        yield db                  # provide the session to the endpoint
    finally:
        db.close()                # cleanup runs AFTER the response — guaranteed

@app.get("/users")
def list_users(db = Depends(get_db)):
    return db.query(User).all()    # uses the injected, auto-closed session
```

Eine `yield` Dependency stellt eine Ressource bereit und führt nach der Anfrage die Bereinigung durch — das Standardmuster für Datenbanksitzungen (vorher öffnen, nachher schließen, automatisch).

## Dependencies können von Dependencies abhängen

```python
def get_current_user(token: str = Depends(get_token)):   # depends on another dependency
    return decode(token)

@app.get("/me")
def me(user: User = Depends(get_current_user)):           # auth via injection
    return user
```

Dependencies bilden einen Baum — FastAPI löst die gesamte Kette auf. So wird typischerweise Authentifizierung implementiert (eine `get_current_user` Dependency).

## Klassen-Dependencies und Wiederverwendung

```python
@app.get("/items", dependencies=[Depends(verify_api_key)])   # run a dependency without using its return
def items(): ...                                              # e.g. enforce auth as a side effect
```

## Warum es wichtig ist

Dependency Injection ist eines der mächtigsten und wichtigsten Features von FastAPI — es ist, wie du Logik sauber über Endpoints verteilst und wiederverwendest (Datenbanksitzungen, Authentifizierung, häufige Query-Parameter, Berechtigungsprüfungen) ohne Duplizierung.

Es zu verstehen ist wesentlich, weil es Kernmuster unterstützt: Die **`yield` Dependency** ist der Standard-Weg, Datenbanksitzungen zu verwalten (mit garantierter Bereinigung nach jeder Anfrage), und eine **`get_current_user` Dependency** ist der idiomatische Weg, Authentifizierung zu implementieren.

DI macht Code auch hochgradig **testbar** — du kannst Dependencies in Tests mit Mocks überschreiben.

Die Eleganz des Systems (Dependencies lösen ihre eigenen Parameter aus der Anfrage auf, können von anderen Dependencies abhängen, die einen Baum bilden, und sind in die Dokumentation integriert) macht es zu einem vielseitigen Werkzeug zur Strukturierung echter Anwendungen. Die Beherrschung von `Depends` ist daher der Schlüssel zum Erstellen von gut organisierten, wartbaren, testbaren FastAPI-Apps.