Hvordan håndterer du fejl og rejser HTTP-undtagelser?

Question

Accepted Answer

FastAPI håndterer fejl ved at **rejse undtagelser**, som den konverterer til korrekte HTTP-svar. `HTTPException` dækker de fleste tilfælde; brugerdefinerede undtagelseshåndtere lader dig styre fejlformatering globalt.

## Rejsning af HTTPException

```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=...)` er den idiomatiske måde at returnere en fejl på — FastAPI producerer et JSON-svar `{"detail": "..."}` med den givne status. `detail` kan være enhver JSON-serialiserbar værdi (streng, dict, liste).

## Valideringsfejl er automatiske (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.
```

## Brugerdefinerede undtagelseshåndtere (global formatering)

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

Brugerdefinerede undtagelseshåndtere lader dig kortlægge dine egne (domæne-)undtagelser til svar, centralisere fejlformatering og holde håndterkode ren.

## Tilsidesætte standardhåndtere

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

## Hvorfor det er vigtigt

Korrekt fejlhåndtering er afgørende for at bygge pålidelige, professionelle API'er, og FastAPI's tilgang er ren og konsistent.

Den idiomatiske `HTTPException` gør det nemt at returnere korrekte fejlsvar med passende statuskoder og beskeder — fundamentalt for enhver endepunkt, der kan fejle (ikke fundet, forbudt, dårlig tilstand).

Ligeså værdifuldt er, at **valideringsfejl håndteres automatisk** (Pydantic-fejl producerer strukturerede 422-svar uden kode fra dig), og at **brugerdefinerede undtagelseshåndtere** lader dig kortlægge dine egne domæneundtagelser til svar og gennemtvinge et konsistent fejlformat på tværs af hele API'en — forbedrer både vedligeholdelse (centraliseret fejllogik) og klientoplevelse (forudsigelige fejlformer).

Forståelse af `HTTPException`, automatiske valideringsfejl og brugerdefinerede håndtere dækker det praktiske spektrum af fejlhåndtering, hvilket gør det vigtig viden for at bygge robuste API'er.