O que são serializadores no Django REST Framework?

Question

Accepted Answer

**Django REST Framework (DRF)** é o padrão de facto para construir APIs REST com Django, e **serializadores** são seu conceito central. Um serializador converte dados complexos (instâncias de modelos, querysets) **para** JSON para respostas da API, e converte JSON recebido **de volta** para objetos Python validados — tratando tanto serialização quanto validação, muito como formulários fazem para HTML.

## ModelSerializer — o caso comum

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

Um `ModelSerializer` gera campos automaticamente a partir do modelo (como um ModelForm) — código mínimo para serializar e validar um modelo.

## Serializando: objeto → 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
```

## Desserializando + validação: JSON → objeto validado

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

O padrão espelha formulários: `is_valid()` valida dados recebidos contra regras de campo e do modelo, e `save()` persiste isso. Dados inválidos geram mensagens de erro estruturadas.

## Validação e campos customizados

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

## Serializadores aninhados (dados relacionados)

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

Serializadores podem **aninhar** para representar objetos relacionados (incorporando dados do autor dentro do JSON de um artigo) — e você controla a forma da API independentemente do banco de dados.

## Por que isso importa

Serializadores são a pedra angular da construção de APIs REST com Django REST Framework, que é a ferramenta padrão para APIs Django — portanto, entendê-los é essencial para qualquer back-end Django moderno servindo JSON para front-ends, aplicativos móveis ou outros serviços.

Serializadores resolvem as duas necessidades fundamentais de uma API: converter dados Python/modelo **para JSON** para respostas (serialização) e converter JSON recebido **para objetos Python validados** para criar/atualizar dados (desserialização + validação).

O aspecto de validação é crítico para **segurança e robustez** — como formulários para HTML, serializadores garantem que você nunca confie em entrada bruta de API, validando-a contra regras de campo antes que chegue ao seu banco de dados. **ModelSerializer** oferece uma grande vitória de produtividade ao gerar campos automaticamente a partir de modelos (DRY, como ModelForm), tornando trivial expor modelos como recursos de API, enquanto o padrão `is_valid()`/`save()` trata o ciclo de vida completo de criar/atualizar de forma limpa.

Entender como serializar objetos e querysets, desserializar e validar entrada, adicionar validação customizada e campos computados, e usar **serializadores aninhados** para dados relacionados (controlando a forma da API independentemente do esquema do banco de dados) é fundamental para construir APIs.

Serializadores são onde o DRF trata as preocupações centrais da API de transformação de dados e validação, tornando-os conhecimento central e obrigatório — análogo em importância a formulários para Django tradicional, mas para as aplicações orientadas a API que dominam o desenvolvimento web moderno.