Hoe ga je om met fouten en raise je HTTP-uitzonderingen?

Question

IT Interview Practice · Accepted Answer

FastAPI verwerkt fouten door **exceptions op te werpen** die het omzet in juiste HTTP-responses. `HTTPException` dekt de meeste gevallen af; aangepaste exception handlers geven je controle over foutformattering op globaal niveau.

## HTTPException opwerpen

```python
from fastapi import HTTPException

@app.get("/items/{id}")
def get_item(id: int):
    item = db.get(id)
    if not item:
        raise HTTPException(status_code=404, detail="Item not found")   # → 404 JSON response
    if not item.is_public:
        raise HTTPException(status_code=403, detail="Forbidden")
    return item
```

`raise HTTPException(status_code=..., detail=...)` is de idomatische manier om een fout te retourneren — FastAPI produceert een JSON-response `{"detail": "..."}` met de gegeven status. De `detail` kan elke JSON-serialiseerbare waarde zijn (string, dict, list).

## Validatiefouten zijn automatisch (422)

```text
When request data fails Pydantic validation, FastAPI AUTOMATICALLY returns a 422
with a structured list of exactly which fields are wrong — you write nothing.
```

## Aangepaste exception handlers (globale formattering)

```python
from fastapi import Request
from fastapi.responses import JSONResponse

class ItemNotFound(Exception):
    def __init__(self, item_id: int): self.item_id = item_id

@app.exception_handler(ItemNotFound)         # handle a custom exception type globally
def handle_not_found(request: Request, exc: ItemNotFound):
    return JSONResponse(status_code=404, content={"error": f"Item {exc.item_id} not found"})

@app.get("/items/{id}")
def get(id: int):
    raise ItemNotFound(id)        # raise your domain exception; the handler formats it
```

Aangepaste exception handlers laten je je eigen (domein)exceptions toewijzen aan responses, waardoor foutformattering centraal wordt en handler-code schoon blijft.

## Standaardhandlers overschrijven

```python
from fastapi.exceptions import RequestValidationError

@app.exception_handler(RequestValidationError)   # customize the 422 validation-error format
def validation_handler(request, exc):
    return JSONResponse(status_code=422, content={"errors": exc.errors()})
```

## Waarom het belangrijk is

Juiste foutafhandeling is essentieel voor het bouwen van betrouwbare, professionele API's, en FastAPI's aanpak is schoon en consistent.

De idomatische `HTTPException` maakt het gemakkelijk om juiste foutresponses terug te geven met de passende statuscodes en berichten — fundamenteel voor elk endpoint dat kan mislukken (niet gevonden, verboden, slechte staat).

Evenredig waardevol is dat **validatiefouten automatisch worden afgehandeld** (Pydantic-fouten produceren gestructureerde 422-responses zonder code van jou), en dat **aangepaste exception handlers** je eigen domeinexceptions toewijzen aan responses en een consistent foutformaat afdwingen over de hele API — verbeterend zowel onderhoudbaarheid (gecentraliseerde foutlogica) als clientervaring (voorspelbare foutvormen).

Het begrijpen van `HTTPException`, automatische validatiefouten en aangepaste handlers dekt het praktische spectrum van foutafhandeling, wat het belangrijke kennis maakt voor het bouwen van robuuste API's.

HTTPException opwerpen

Validatiefouten zijn automatisch (422)

Aangepaste exception handlers (globale formattering)

Standaardhandlers overschrijven

Waarom het belangrijk is

Gerelateerde vragen