Hur hanterar du fel och höjer HTTP-undantag?

Question

Accepted Answer

FastAPI hanterar fel genom att **höja undantag** som det konverterar till korrekta HTTP-svar. `HTTPException` täcker de flesta fall; anpassade undantagshanterare låter dig styra felformatering globalt.

## Höja 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=...)` är det idiomatiska sättet att returnera ett fel — FastAPI producerar ett JSON-svar `{"detail": "..."}` med den givna statusen. `detail` kan vara vilket JSON-serialiserbart värde som helst (sträng, dict, lista).

## Valideringsfel är automatiska (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.
```

## Anpassade undantagshanterare (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
```

Anpassade undantagshanterare låter dig mappa dina egna (domän)undantag till svar, centralisera felformatering och hålla handlerarkod ren.

## Åsidosätta standardhanterare

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

## Varför det är viktigt

Korrekt felhantering är väsentlig för att bygga tillförlitliga, professionella API:er, och FastAPI:s tillvägagångssätt är rent och konsekvent.

Det idiomatiska `HTTPException` gör det enkelt att returnera korrekta felsvar med lämpliga statuskoder och meddelanden — fundamental för alla slutpunkter som kan misslyckas (inte hittad, förbjuden, dåligt tillstånd).

Lika värdefullt är att **valideringsfel hanteras automatiskt** (Pydantic-fel producerar strukturerade 422-svar utan kod från dig), och att **anpassade undantagshanterare** låter dig mappa dina egna domänundantag till svar och tillämpa ett konsekvent felformat över hela API:et — vilket förbättrar både underhållbarhet (centraliserad fellogik) och klientupplevelse (förutsägbara felformer).

Att förstå `HTTPException`, automatiska valideringsfel och anpassade hanterare täcker det praktiska spektrumet av felhantering, vilket gör det till viktig kunskap för att bygga robusta API:er.