Co jsou serializátory v Django REST Framework?

Question

Accepted Answer

**Django REST Framework (DRF)** je de facto standard pro vytváření REST API s Django a **serializátory** jsou jeho klíčovým konceptem. Serializátor převádí komplexní data (instance modelů, querysets) **na** JSON pro API odpovědi a převádí příchozí JSON **zpět** na validované objekty Pythonu — pokrývá jak serializaci, tak validaci, podobně jako formuláře pro HTML.

## ModelSerializer — nejčastější případ

```python
from rest_framework import serializers
from .models import Article

class ArticleSerializer(serializers.ModelSerializer):
    class Meta:
        model = Article                              # build from a model (DRY)
        fields = ["id", "title", "body", "published", "created_at"]
        read_only_fields = ["id", "created_at"]
```

`ModelSerializer` automaticky generuje pole z modelu (jako ModelForm) — minimální kód k serializaci a validaci modelu.

## Serializace: objekt → JSON

```python
article = Article.objects.get(pk=1)
serializer = ArticleSerializer(article)
serializer.data        # {"id": 1, "title": "Hello", "body": "...", ...} → return as JSON

# serialize a queryset (many objects)
serializer = ArticleSerializer(Article.objects.all(), many=True)
serializer.data        # a list of dicts
```

## Deserializace + validace: JSON → validovaný objekt

```python
serializer = ArticleSerializer(data=request.data)   # incoming JSON
if serializer.is_valid():                            # VALIDATE (like a form)
    article = serializer.save()                       # create/update the model
else:
    return Response(serializer.errors, status=400)   # validation error details
```

Vzor zrcadlí formuláře: `is_valid()` validuje příchozí data podle pravidel pole a modelu a `save()` je uloží. Neplatná data vrací strukturované chybové zprávy.

## Vlastní validace a pole

```python
class ArticleSerializer(serializers.ModelSerializer):
    word_count = serializers.SerializerMethodField()   # a computed, read-only field

def get_word_count(self, obj):
        return len(obj.body.split())

def validate_title(self, value):                    # field-level validation
        if "spam" in value.lower():
            raise serializers.ValidationError("No spam")
        return value
```

## Vnořené serializátory (související data)

```python
class AuthorSerializer(serializers.ModelSerializer):
    class Meta: model = Author; fields = ["name"]

class ArticleSerializer(serializers.ModelSerializer):
    author = AuthorSerializer(read_only=True)          # embed related author data
    class Meta: model = Article; fields = ["title", "author"]
```

Serializátory mohou **vnořit** reprezentaci souvisejících objektů (vložení dat autora do JSON článku) — a vy kontrolujete tvar API nezávisle na databázi.

## Proč na tom záleží

Serializátory jsou základním kamenem vytváření REST API s Django REST Framework, což je standardní nástroj pro Django API — takže jejich pochopení je nezbytné pro jakéhokoliv moderního Django backendu obsluhujícího JSON pro frontendy, mobilní aplikace nebo další služby.

Serializátory řeší dvě základní potřeby API: převod dat Pythonu/modelu **na JSON** pro odpovědi (serializace) a převod příchozího **JSON na validované objekty Pythonu** pro vytváření/aktualizaci dat (deserializace + validace).

Aspekt validace je kritický pro **bezpečnost a robustnost** — podobně jako formuláře pro HTML, serializátory zajišťují, že nikdy nedůvěřujete surému vstupu API a validujete jej proti pravidlům pole předtím, než dosáhne vaší databáze. **ModelSerializer** přináší výrazný přínos v produktivitě automatickým generováním polí z modelů (DRY, jako ModelForm), takže je triviální vystavit modely jako API zdroje, zatímco vzor `is_valid()`/`save()` čistě řeší celý životní cyklus vytváření/aktualizace.

Pochopení, jak serializovat objekty a querysets, deserializovat a validovat vstup, přidat vlastní validaci a vypočítaná pole a používat **vnořené serializátory** pro související data (řízení tvaru API nezávisle na schématu databáze) je zásadní pro vytváření API.

Serializátory jsou místem, kde DRF řeší základní problémy API transformace a validace dat, což je činí centrální, nezbytnou znalostí — analogické co do důležitosti formulářům pro tradiční Django, ale pro aplikace řízené API, které dominují modernímu webovému vývoji.