Cosa sono i serializers in Django REST Framework?

Question

Accepted Answer

**Django REST Framework (DRF)** è lo standard de facto per costruire REST API con Django, e i **serializers** sono il suo concetto fondamentale. Un serializer converte dati complessi (istanze di modello, querysets) **in** JSON per le risposte API, e converte il JSON in arrivo **indietro** in oggetti Python validati — gestendo sia la serializzazione che la validazione, proprio come i form fanno per l'HTML.

## ModelSerializer — il caso comune

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

Un `ModelSerializer` auto-genera i campi dal modello (come un ModelForm) — codice minimo per serializzare e validare un modello.

## Serializing: object → 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
```

## Deserializing + validation: JSON → oggetto validato

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

Il pattern specchia i form: `is_valid()` valida i dati in arrivo rispetto alle regole dei campi e del modello, e `save()` lo salva. I dati non validi producono messaggi di errore strutturati.

## Custom validation e campi

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

## Nested serializers (dati correlati)

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

I serializers possono **annidare** per rappresentare oggetti correlati (incorporando i dati di un autore nel JSON di un articolo) — e controlli la forma dell'API indipendentemente dal database.

## Perché è importante

I serializers sono la pietra angolare della costruzione di REST API con Django REST Framework, che è lo strumento standard per le API Django — quindi comprenderli è essenziale per chiunque sviluppi backend Django moderno che serve JSON a frontend, app mobili o altri servizi.

I serializers risolvono i due bisogni fondamentali di un'API: convertire dati Python/modello **in JSON** per le risposte (serialization) e convertire il JSON in arrivo **in oggetti Python validati** per creare/aggiornare dati (deserialization + validation).

L'aspetto della validazione è critico per **la sicurezza e la robustezza** — come i form per l'HTML, i serializers assicurano che tu non dia mai fiducia all'input API grezzo, validandolo rispetto alle regole dei campi prima che raggiunga il tuo database. **ModelSerializer** fornisce un grosso vantaggio di produttività auto-generando i campi dai modelli (DRY, come ModelForm), rendendo banale esporre i modelli come risorse API, mentre il pattern `is_valid()`/`save()` gestisce il ciclo di vita completo di creazione/aggiornamento in modo pulito.

Capire come serializzare oggetti e querysets, deserializzare e validare l'input, aggiungere validazione personalizzata e campi calcolati, e usare **serializers annidati** per dati correlati (controllando la forma dell'API indipendentemente dallo schema del database) è fondamentale per costruire API.

I serializers sono dove DRF gestisce i concernenti core dell'API di trasformazione e validazione dei dati, rendendoli conoscenza centrale, must-know — analoga in importanza ai form per il Django tradizionale, ma per le applicazioni API-driven che dominano lo sviluppo web moderno.