Hvad er serializers i Django REST Framework?

Question

Accepted Answer

**Django REST Framework (DRF)** er de facto-standarden for at bygge REST API'er med Django, og **serializers** er dets kernekoncept. En serializer konverterer komplekse data (modelinstanser, querysets) **til** JSON for API-svar, og konverterer indkommende JSON **tilbage** til validerede Python-objekter — håndterer både serialisering og validering, meget ligesom formularer gør det for HTML.

## ModelSerializer — det almindelige tilfælde

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

En `ModelSerializer` genererer automatisk felter fra modellen (som en ModelForm) — minimal kode til at serialisere og validere en model.

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

## Deserialisering + validering: JSON → valideret 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
```

Mønsteret spejler formularer: `is_valid()` validerer indkommende data mod feltregler og modellen, og `save()` persisterer det. Ugyldige data giver strukturerede fejlmeddelelser.

## Brugerdefineret validering og felter

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

## Indlejrede serializers (relaterede 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"]
```

Serializers kan **indlejres** for at repræsentere relaterede objekter (indlejring af en forfatters data inden for en artikels JSON) — og du kontrollerer API'ets form uafhængigt af databasen.

## Hvorfor det betyder noget

Serializers er hjørnestenen i at bygge REST API'er med Django REST Framework, som er standardværktøjet for Django API'er — så at forstå dem er væsentligt for enhver moderne Django back-end, der serverer JSON til frontends, mobilapps eller andre tjenester.

Serializers løser de to grundlæggende behov for en API: at konvertere Python/model-data **til JSON** for svar (serialisering) og at konvertere indkommende **JSON til validerede Python-objekter** til oprettelse/opdatering af data (deserialisering + validering).

Valideringsaspektet er kritisk for **sikkerhed og robusthed** — som formularer for HTML sikrer serializers, at du aldrig stoler på raw API-input, validerer det mod feltregler, før det når din database. **ModelSerializer** giver en stor produktivitetsgevinst ved at automatisk generere felter fra modeller (DRY, som ModelForm), hvilket gør det trivielt at eksponere modeller som API-ressourcer, mens `is_valid()`/`save()`-mønsteret håndterer hele opret/opdater-livscyklussen rent.

At forstå, hvordan man serialiserer objekter og querysets, deserialiserer og validerer input, tilføjer brugerdefineret validering og beregnede felter, og bruger **indlejrede serializers** til relaterede data (kontrollerer API'ets form uafhængigt af databaseskemaet) er grundlæggende for at bygge API'er.

Serializers er hvor DRF håndterer de centrale API-bekymringer om datatransformation og validering, hvilket gør dem centrale, skal-kende-viden — analogt i betydning med formularer for traditionel Django, men for de API-drevne applikationer, der dominerer moderne webudvikling.