როგორ ხდება შეცდომების დამუშავება და HTTP გამონაკლისების გამოწვევა?

Question

Accepted Answer

FastAPI ხელახლა დამუშავებს შეცდომებს **გამონაკლისების წაყენებით**, რომელსაც ის სწორ HTTP პასუხებად აქცევს. `HTTPException` უმეტეს შემთხვევას მოიცავს; მომხმარებლის შეცდომის დამამუშავებლები საშუალებას გაძლევთ შეცდომის ფორმატირება გლობალურად კონტროლი გაკეთოთ.

## 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=...)` არის იდიომატური გზა შეცდომის დასაბრუნებლად — FastAPI აქმნის JSON პასუხს `{"detail": "..."}` მოცემული სტატუსით. `detail` შეიძლება იყოს ნებისმიერი JSON-სერიალიზირებული მნიშვნელობა (სტრიქონი, ლექსიკონი, სია).

## ვალიდაციის შეცდომები ავტომატური (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.
```

## მომხმარებლის შეცდომის დამამუშავებლები (გლობალური ფორმატირება)

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

მომხმარებლის შეცდომის დამამუშავებლები საშუალებას გაძლევთ დაკავშიროთ თქვენი საკუთარი (დომენის) გამონაკლისები პასუხებთან, რაც ცენტრალიზებს შეცდომის ფორმატირებას და ხელმძღვანელის კოდს ნაკლებ დაცემულს ხდის.

## ნაგულისხმები დამამუშავებლების გადახაზვა

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

## რატომ მნიშვნელოვანია ეს

შეცდომების სწორი დამუშავება აუცილებელია საიმედო, პროფესიონალური API-ების შესაქმნელად, ხოლო FastAPI-ის მიდგომა 깔끔하고 თანმიმდევრული.

იდიომატური `HTTPException` აადვილებს სწორი შეცდომის პასუხების დაბრუნებას მეტი სტატუსის კოდებით და შეტყობინებებით — ფუნდამენტური ნებისმიერი ბოლო წერტილი, რომელიც შეიძლება ვერ გაკოთრდეს (ვერ მოიძებნა, აკრძალული, ცუდი მდგომარეობა).

თანაბრად ღირებული არის, რომ **ვალიდაციის შეცდომები ავტომატურად დამუშავებულია** (Pydantic აგავსებს სტრუქტურირებულ 422 პასუხებს თქვენი კოდის გარეშე), და რომ **მომხმარებლის შეცდომის დამამუშავებლები** საშუალებას გაძლევთ დაკავშიროთ თქვენი საკუთარი დომენის გამონაკლისები პასუხებთან და აკმაყოფილოთ თანმიმდევრული შეცდომის ფორმატი მთელ API-ში — ამჯობინებს როგორც შენარჩუნებას (ცენტრალიზებული შეცდომის ლოგიკა) ისე კლიენტის გამოცდილებას (პროგნოზირებული შეცდომის ფორმები).

`HTTPException`-ის, ავტომატური ვალიდაციის შეცდომების და მომხმარებლის დამამუშავებლების გაგება ფარავს შეცდომის დამუშავების პრაქტიკულ სპექტრს, რაც მნიშვნელოვანი ცოდნაა მყარი API-ების შესაქმნელად.