Kaj so serializerji v Django REST Framework?

Question

Accepted Answer

**Django REST Framework (DRF)** je de facto standard za gradnjo REST API-jev z Django-om, **serializerji** pa so njegov osrednji koncept. Serializator pretvori kompleksne podatke (primerke modelov, querysets) **v** JSON za odgovore API-ja in pretvori prihajajoči JSON **nazaj** v potrjene Python objekte — upravlja tako serializacijo kot tudi validacijo, podobno kot obrazci za HTML.

## ModelSerializer — običajni primer

```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` samodejno ustvari polja iz modela (kot ModelForm) — minimalna koda za serializacijo in validacijo modela.

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

## Deserializacija + validacija: JSON → potrjen 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
```

Vzorec se zrcali z obrazci: `is_valid()` preveri prihajajoče podatke glede na pravila polj in modela, `save()` pa ga shrani. Neveljavni podatki povzročijo strukturirane sporočila o napakah.

## Prilagojena validacija in 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
```

## Ugniezdeni serializerji (povezani podatki)

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

Serializerji se lahko **ugniezdijo** za predstavitev povezanih objektov (vstavljanje podatkov avtorja v JSON članka) — in vi neodvisno od baze podatkov nadzorite obliko API-ja.

## Zakaj je to pomembno

Serializerji so temelj gradnje REST API-jev z Django REST Framework-om, ki je standardno orodje za Django API-je — zato je njihovo razumevanje bistveno za katerega koli modernega Django vmesnika zaledja, ki služi JSON spletnim aplikacijam, mobilnim aplikacijam ali drugim storitvam.

Serializerji rešavajo dve temeljni potrebi API-ja: pretvarjanje Python/podatkov modela **v JSON** za odgovore (serializacija) in pretvarjanje prihajajočega **JSON-a v potrjene Python objekte** za ustvarjanje/posodabljanje podatkov (deserializacija + validacija).

Aspekt validacije je kritičen za **varnost in zanesljivost** — kot obrazci za HTML tudi serializerji zagotavljajo, da nikoli ne zaupate surovinskim podatkom API-ja, preverjate jih glede na pravila polj, preden dosežejo vašo bazo podatkov. **ModelSerializer** zagotavlja važno produktivnostno zmago s samodejnim ustvarjanjem polj iz modelov (DRY, kot ModelForm), kar naredi trivialno izpostavljanje modelov kot virov API-ja, medtem ko vzorec `is_valid()`/`save()` čisto upravlja polni cikel ustvarjanja/posodobljanja.

Razumevanje, kako serializirati objekte in querysets, deserializirati in preveriti vnos, dodati prilagojeno validacijo in izračunana polja ter uporabiti **ugniezdene serializerje** za povezane podatke (nadzorovanje oblike API-ja neodvisno od sheme baze podatkov) je temeljno za gradnjo API-jev.

Serializerji so mesto, kjer DRF upravlja temeljne API skrbi transformacije podatkov in validacije, kar jih naredi osrednje, nujno znane izkušnje — podobne po pomenu obrazcem za tradicionalni Django, vendar za vodeče s API aplikacije, ki prevladujejo sodobni razvoj spletnih strani.