Bagaimana Anda menangani kesalahan dan memunculkan pengecualian HTTP?

Question

Accepted Answer

FastAPI menangani kesalahan dengan **memunculkan pengecualian** yang dikonversi menjadi respons HTTP yang tepat. `HTTPException` mencakup sebagian besar kasus; penanganan pengecualian kustom memungkinkan Anda mengontrol pemformatan kesalahan secara global.

## Memunculkan 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=...)` adalah cara idiomatik untuk mengembalikan kesalahan — FastAPI menghasilkan respons JSON `{"detail": "..."}` dengan status yang diberikan. `detail` dapat berupa nilai apa pun yang dapat diserialisasi JSON (string, dict, list).

## Kesalahan validasi bersifat otomatis (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.
```

## Penanganan pengecualian kustom (pemformatan global)

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

Penanganan pengecualian kustom memungkinkan Anda memetakan pengecualian (domain) Anda sendiri ke respons, memusatkan pemformatan kesalahan dan menjaga kode penanganan tetap bersih.

## Menimpa penanganan default

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

## Mengapa ini penting

Penanganan kesalahan yang tepat sangat penting untuk membangun API yang andal dan profesional, dan pendekatan FastAPI bersih dan konsisten.

`HTTPException` idiomatik membuat mudah untuk mengembalikan respons kesalahan yang benar dengan kode status dan pesan yang sesuai — fundamental untuk titik akhir apa pun yang dapat gagal (tidak ditemukan, terlarang, status buruk).

Sama berharganya adalah kenyataan bahwa **kesalahan validasi ditangani secara otomatis** (kegagalan Pydantic menghasilkan respons 422 terstruktur tanpa kode dari Anda), dan bahwa **penanganan pengecualian kustom** memungkinkan Anda memetakan pengecualian domain Anda sendiri ke respons dan memberlakukan format kesalahan yang konsisten di seluruh API — meningkatkan kemampuan pemeliharaan (logika kesalahan terpusat) dan pengalaman klien (bentuk kesalahan yang dapat diprediksi).

Memahami `HTTPException`, kesalahan validasi otomatis, dan penanganan kustom mencakup spektrum praktis penanganan kesalahan, menjadikannya pengetahuan penting untuk membangun API yang kuat.