Wie empfängt man einen JSON-Anforderungskörper?

Question

Accepted Answer

Um einen JSON-Anforderungskörper in FastAPI zu empfangen, deklarieren Sie einen Funktionsparameter, der als **Pydantic-Modell** typisiert ist. FastAPI liest den Body, parsed das JSON, validiert es gegen das Modell und übergibt Ihnen ein typisiertes Objekt — automatisch.

## Warum es wichtig ist

```python
from pydantic import BaseModel

class Item(BaseModel):
    name: str
    price: float
    description: str | None = None      # optional field

@app.post("/items")
def create_item(item: Item):             # `item: Item` → read & validate the JSON body
    # `item` is a fully-validated Item object here
    return {"name": item.name, "total": item.price * 1.1}
```

```json
// request body the client sends:
{ "name": "Phone", "price": 999.0 }
```

Das Deklarieren von `item: Item` teilt FastAPI mit, den Anforderungskörper als JSON zu lesen, ihn in ein `Item` zu parsen und es zu **validieren** — Ihre Funktion erhält ein typisiertes, gültiges Objekt. Ungültige Eingaben werden automatisch abgelehnt:

```json
// POST { "name": "Phone" }  (missing price) → automatic 422:
{ "detail": [{ "loc": ["body", "price"], "msg": "field required" }] }
```

## Body + Pfad + Query zusammen

```python
@app.put("/items/{item_id}")
def update(item_id: int, item: Item, notify: bool = False):
    # item_id = path param, item = JSON body (Pydantic model), notify = query param
    # FastAPI distinguishes them by type/location automatically
```

FastAPI leitet Parameter intelligent weiter: ein Pfadplatzhalter → Pfadparameter, ein Pydantic-Modell → Anforderungskörper, ein einfach typisierter Parameter → Query-Parameter.

## Mehrere Body-Parameter / Teilaktualisierungen

```python
@app.patch("/items/{id}")
def patch(id: int, item: ItemUpdate):       # use a model with all-optional fields for PATCH
    update_data = item.model_dump(exclude_unset=True)   # only fields the client sent
```

## Warum es wichtig ist

Das Empfangen und Validieren von Anforderungskörpern ist essentiell — fast jede API, die Daten erstellt oder aktualisiert, benötigt dies, und FastAPI macht es bemerkenswert sauber: Das Deklarieren eines Pydantic-Modell-Parameters gibt Ihnen automatisches JSON-Parsing, vollständige **Validierung** (mit klaren Feld-Level-422-Fehlern) und ein typisiertes Objekt, was das mühsame, fehleranfällige manuelle Parsing und die Validierung eliminiert, die andere Frameworks erfordern.

Die Validierung ist auch ein wichtiger **Sicherheits-/Robustheitsvorteil** — falsch formatierte Eingaben werden abgelehnt, bevor sie Ihre Logik erreichen.

Zu verstehen, wie man ein Body-Modell definiert, wie FastAPI Body von Pfad-/Query-Parametern automatisch unterscheidet, und Muster wie `exclude_unset` für Teilaktualisierungen ist fundamentales alltägliches Wissen für das Erstellen eines beliebigen Write-Endpunkts.