Kas yra serializatoriai Django REST Framework?

Question

Accepted Answer

**Django REST Framework (DRF)** yra de facto standartas REST API kūrimui su Django, o **serializatoriai** yra jo pagrindinė koncepcija. Serializatorius konvertuoja sudėtingus duomenis (modelio egzempliorius, querysets) **į** JSON API atsakymams ir konvertuoja gautą JSON **atgal** į patvirtintus Python objektus — tvarkydami tiek serializavimą, tiek validavimą, panašiai kaip HTML formos.

## ModelSerializer — dažniausias atvejis

```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` automatiškai generuoja laukus iš modelio (kaip ModelForm) — minimalus kodas modeliui serializuoti ir validuoti.

## Serializavimas: objektas → 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
```

## Deserializavimas + validavimas: JSON → patvirtintas objektas

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

Šablonai atitinka formas: `is_valid()` patvirtina gautus duomenis pagal lauko taisykles ir modelį, o `save()` juos išsaugoja. Neteisingi duomenys grąžina struktūrizuotus klaidos pranešimus.

## Pasitinkintasis validavimas ir laukai

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

## Įdėti serializatoriai (susiję duomenys)

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

Serializatoriai gali **įdėti** susietus objektus (į straipsnio JSON įterpdami autoriaus duomenis) — ir jūs nepriklausomai nuo duomenų bazės kontroliuojate API formą.

## Kodėl tai svarbu

Serializatoriai yra REST API kūrimo su Django REST Framework pagrindas, kuris yra standartinis Django API įrankis — todėl jų supratimas yra būtinas bet kuriam moderniam Django backend'ui, teikiančiam JSON frontendams, mobiliosioms programoms ar kitoms paslaugoms.

Serializatoriai sprendžia dvi pagrindines API poreikius: Python/modelio duomenų konvertavimą **į JSON** atsakymams (serializavimas) ir gautų **JSON konvertavimą į patvirtintus Python objektus** duomenims kurti/atnaujinti (deserializavimas + validavimas).

Validavimo aspektas yra svarbus **saugumui ir patikimumui** — panašiai kaip formos HTML, serializatoriai užtikrina, kad niekada nepasitikite neapdorotomis API įvestimis, jas validuodami pagal lauko taisykles prieš pasiekiant duomenų bazę. **ModelSerializer** suteikia didelį produktyvumo padidėjimą automatiškai generuodamas laukus iš modelių (DRY, kaip ModelForm), todėl trivialiai pristatyti modelius kaip API išteklius, o `is_valid()`/`save()` šablonai švariausiai tvarkosi su visa sukūrimo/atnaujinimo ciklu.

Supratimas, kaip serializuoti objektus ir querysets, deserializuoti ir validuoti įvestis, pridėti pasitinkintąjį validavimą ir apskaičiuotus laukus, ir naudoti **įdėtus serializatorius** susijem duomenims (kontroliuojant API formą nepriklausomai nuo duomenų bazės schemos) yra esminis API kūrimui.

Serializatoriai yra vieta, kur DRF tvarkosi pagrindiniais API susirūpinimais — duomenų transformacija ir validavimas, todėl jie yra centralizuoti, būtini žinoti — svarbumą ekvivalentiški formoms tradiciniam Django, bet API paremtoms aplikacijoms, kurios dominuoja šiuolaikinėje interneto plėtroje.