Hvordan modtager du en JSON-anmodningskrop?

Question

Accepted Answer

For at modtage en JSON-anmodningskrop i FastAPI deklarerer du en funktionsparameter typet som en **Pydantic-model**. FastAPI læser kroppen, parser JSON, validerer det mod modellen og sender dig et typet objekt — automatisk.

## Mønstret

```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 }
```

At erklære `item: Item` fortæller FastAPI at læse anmodningskroppen som JSON, parse den til en `Item`, og **validere** den — din funktion modtager et typet, gyldigt objekt. Dårligt input afvises automatisk:

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

## Krop + sti + forespørgsel sammen

```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 dirigerer intelligent parametre: en stiplaceholder → stiparameter, en Pydantic-model → anmodningskrop, en enkelt-typet parameter → forespørgselsparameter.

## Flere kropparametre / delvise opdateringer

```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
```

## Hvorfor det betyder noget

At modtage og validere anmodningskroppe er vigtig — næsten alle API'er, der opretter eller opdaterer data, har brug for det, og FastAPI gør det bemærkelsesværdigt rent: deklaration af en Pydantic-modelparameter giver dig automatisk JSON-parsing, fuld **validering** (med klare felt-niveau 422-fejl) og et typet objekt, hvilket eliminerer det trættende, fejlbehægtet manuelt parsing og validering, som andre frameworks kræver.

Valideringen er også en vigtig **sikkerhed/robusthed**-fordel — fejlformateret input afvises, før det når din logik.

At forstå, hvordan man definerer en kropmodel, hvordan FastAPI automatisk skelner krop fra sti-/forespørgselsparametre, og mønstre som `exclude_unset` for delvise opdateringer, er grundlæggende hverdagsviden for at bygge en hvilken som helst skriveendepunkt.