Što su serializatori u Django REST Framework-u?

Question

Accepted Answer

**Django REST Framework (DRF)** je de facto standard za izgradnju REST API-ja s Django-om, a **serializatori** su njegov temeljni koncept. Serializator pretvara složene podatke (instance modela, querysets) **u** JSON za API odgovore, te pretvara dolazne JSON podatke **nazad** u validirane Python objekte — obrađujući i serijalizaciju i validaciju, slično kao što forme rade za HTML.

## ModelSerializer — česti slučaj

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

A `ModelSerializer` automatski genira polja iz modela (kao ModelForm) — minimalan kod za serijalizaciju i validaciju modela.

## Serijalizacija: 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
```

## Deserijalizacija + validacija: JSON → validirani 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
```

Obrazac odgovara formama: `is_valid()` validira dolazne podatke prema pravilima polja i modelu, a `save()` je čuva. Nevaljani podaci daju strukturirane poruke o greškama.

## Prilagođena validacija i polja

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

## Ugniježđeni serializatori (povezani podaci)

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

Serializatori mogu biti **ugniježđeni** da prikažu povezane objekte (ugrađivanjem podataka autora unutar JSON-a članka) — i vi kontrolirate oblik API-ja nezavisno od baze podataka.

## Zašto je važno

Serializatori su temelj izgradnje REST API-ja s Django REST Framework-om, koji je standardni alat za Django API-je — pa je razumijevanje njih bitno za svakog modernog Django back-end razvojnjaka koji servira JSON front-end-ima, mobilnim aplikacijama ili drugim servisima.

Serializatori rješavaju dvije temeljne potrebe API-ja: pretvaranje Python/model podataka **u JSON** za odgovore (serijalizacija) i pretvaranje dolaznih **JSON podataka u validirane Python objekte** za stvaranje/ažuriranje podataka (deserijalizacija + validacija).

Aspekt validacije je kritičan za **sigurnost i pouzdanost** — poput formi za HTML, serializatori osiguravaju da nikada ne vjerujete sirovom API ulazu, validirajući ga prema pravilima polja prije nego što dosegne vašu bazu podataka. **ModelSerializer** pruža veliku produktivnost jer automatski genira polja iz modela (DRY, kao ModelForm), čineći trivijalno izlaganje modela kao API resursa, dok uzorak `is_valid()`/`save()` čisto obrađuje cijeli ciklus stvaranja/ažuriranja.

Razumijevanje kako serijalizirati objekte i querysete, deserijalizirati i validirati ulaz, dodati prilagođenu validaciju i izračunata polja, te koristiti **ugniježđene serializatore** za povezane podatke (kontrolirajući oblik API-ja nezavisno od sheme baze podataka) je temeljno za izgradnju API-ja.

Serializatori su gdje DRF obrađuje osnovne API zadatke transformacije podataka i validacije, čineći ih centralnim, nezaobilaznim znanjem — analogno važnostima formi za tradicionalni Django, ali za API-vođene aplikacije koje dominiraju modernim web razvojem.