Wie definieren Sie Routen (Pfadoperationen)?

Question

Accepted Answer

In FastAPI ist eine **Pfadoperation** eine Route — eine Funktion, die mit einem HTTP-Method-Dekorator (`@app.get`, `@app.post` usw.) dekoriert ist und Anfragen an einen Pfad verarbeitet. Der Rückgabewert der Funktion wird automatisch in JSON serialisiert.

## Routen für jede HTTP-Methode definieren

```python
from fastapi import FastAPI
app = FastAPI()

@app.get("/items")                # GET /items
def list_items():
    return [{"id": 1}, {"id": 2}]  # dict/list → automatically JSON-serialized

@app.get("/items/{item_id}")      # GET /items/5 — path parameter
def get_item(item_id: int):        # type hint converts "5" → int (and validates)
    return {"id": item_id}

@app.post("/items")               # POST /items
def create_item(item: Item):
    return item

@app.put("/items/{item_id}")      # PUT, PATCH, DELETE work the same way
@app.delete("/items/{item_id}")
def delete_item(item_id: int):
    return {"deleted": item_id}
```

Jeder Dekorator ordnet eine HTTP-Methode + Pfad einem Handler zu. Der Funktionsname liegt bei dir; der Dekorator definiert die Route. Zurückgegebene dicts/lists/Pydantic-Modelle werden automatisch in JSON serialisiert — kein manuelles `json.dumps`.

## Die Reihenfolge ist wichtig für überlappende Pfade

```python
@app.get("/users/me")            # ✅ specific route FIRST
def read_me(): ...
@app.get("/users/{user_id}")     # dynamic AFTER — else "me" matches {user_id}
def read_user(user_id: int): ...
```

FastAPI matched Routen in Deklarationsreihenfolge, also stelle statische Pfade vor dynamische.

## Operationsmetadaten (treibt die Docs an)

```python
@app.get("/items", tags=["items"], summary="List items", status_code=200)
def list_items(): ...
```

Dekorator-Parameter (`tags`, `summary`, `status_code`, `response_model`) konfigurieren das Verhalten und bereichern die automatisch generierte Dokumentation.

## Warum es wichtig ist

Pfadoperationen sind das Fundament jeder FastAPI-Anwendung — sie definieren die Endpoints deiner API und wie Anfragen verarbeitet werden.

Das Verständnis des Dekorator-pro-HTTP-Methode-Musters, dass Rückgabewerte automatisch in JSON serialisiert werden (kein Boilerplate), dass Type Hints auf Parametern Konvertierung und Validierung steuern, und dass die Routenreihenfolge bei überlappenden Pfaden wichtig ist, ist wesentliches Alltagswissen zum Erstellen eines jeden Endpoints.

Die Dekorator-Metadaten speisen auch FastAPIs automatische Dokumentation und verbinden Routen direkt mit den Docs.

Dies ist das erste und fundamentalste Konzept, das man in FastAPI beherrschen muss.