Hur tar du emot en JSON-förfrågningstekst?

Question

Accepted Answer

För att ta emot en JSON-förfrågningstekst i FastAPI deklarerar du en funktionsparameter typificerad som en **Pydantic-modell**. FastAPI läser texten, tolkar JSON, validerar det mot modellen och ger dig ett typificerat objekt — automatiskt.

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

Att deklarera `item: Item` talar om för FastAPI att läsa förfrågningens text som JSON, tolka den till ett `Item` och **validera** den — din funktion får ett typificerat, giltigt objekt. Felaktig inmatning avvisas automatiskt:

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

## Brödtext + sökväg + fråga tillsammans

```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 dirigerar intelligenta parametrar: en sökvägsplatsmarkör → sökvägsparameter, en Pydantic-modell → förfrågningsbrödtext, en enkelt typificerad parameter → frågeparameter.

## Flera brödtextparametrar / partiella uppdateringar

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

## Varför det spelar roll

Att ta emot och validera förfrågningsbrödtext är väsentligt — nästan varje API som skapar eller uppdaterar data behöver det, och FastAPI gör det anmärkningsvärt enkelt: en deklaration av en Pydantic-modellparameter ger dig automatisk JSON-tolkning, fullständig **validering** (med tydliga felmeddelanden på fältnivå 422) och ett typificerat objekt, vilket eliminerar den mödsam, felbenägen manuell tolkning och validering som andra ramverk kräver.

Valideringen är också en nyckel **säkerhet/robusthet**-fördelar — felformerad inmatning avvisas innan den når din logik.

Att förstå hur man definierar en brödtextmodell, hur FastAPI automatiskt skiljer brödtext från sökväg/frågeparametrar och mönster som `exclude_unset` för partiella uppdateringar är grundläggande daglig kunskap för att bygga någon skrivslutpunkt.