Apa itu serializers dalam Django REST Framework?

Question

Accepted Answer

**Django REST Framework (DRF)** adalah standar de facto untuk membangun REST API dengan Django, dan **serializers** adalah konsep intinya. Sebuah serializer mengonversi data kompleks (instance model, querysets) **ke** JSON untuk respons API, dan mengonversi JSON yang masuk **kembali** ke objek Python yang telah divalidasi — menangani serialisasi dan validasi, mirip dengan cara forms menangani HTML.

## ModelSerializer — kasus umum

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

Sebuah `ModelSerializer` secara otomatis menghasilkan field dari model (seperti ModelForm) — kode minimal untuk serialisasi dan validasi model.

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

## Deserialisasi + validasi: JSON → objek yang divalidasi

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

Pola ini mencerminkan forms: `is_valid()` memvalidasi data yang masuk terhadap aturan field dan model, dan `save()` menyimpannya. Data yang tidak valid menghasilkan pesan error terstruktur.

## Validasi kustom dan field

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

## Serializers bersarang (data terkait)

```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 dapat **bersarang** untuk merepresentasikan objek terkait (menyematkan data penulis dalam JSON artikel) — dan Anda mengontrol bentuk API secara independen dari database.

## Mengapa ini penting

Serializer adalah fondasi untuk membangun REST API dengan Django REST Framework, yang merupakan alat standar untuk API Django — jadi memahaminya sangat penting bagi siapa pun yang mengembangkan backend Django modern yang melayani JSON ke frontend, aplikasi mobile, atau layanan lain.

Serializer menyelesaikan dua kebutuhan fundamental API: mengonversi data Python/model **ke JSON** untuk respons (serialisasi) dan mengonversi **JSON ke objek Python yang divalidasi** untuk membuat/memperbarui data (deserialisasi + validasi).

Aspek validasi sangat penting untuk **keamanan dan ketahanan** — seperti forms untuk HTML, serializers memastikan Anda tidak pernah mempercayai input API mentah, memvalidasinya terhadap aturan field sebelum mencapai database Anda. **ModelSerializer** memberikan keuntungan produktivitas besar dengan secara otomatis menghasilkan field dari model (DRY, seperti ModelForm), membuat menjadi mudah untuk mengekspos model sebagai resource API, sementara pola `is_valid()`/`save()` menangani lifecycle create/update penuh dengan bersih.

Memahami cara serialisasi object dan querysets, deserialisasi dan validasi input, menambahkan validasi kustom dan computed field, serta menggunakan **serializers bersarang** untuk data terkait (mengontrol bentuk API secara independen dari skema database) adalah fundamental untuk membangun API.

Serializer adalah tempat DRF menangani core concern API tentang transformasi dan validasi data, menjadikannya pengetahuan pusat yang harus diketahui — analog dalam pentingnya dengan forms untuk Django tradisional, tetapi untuk aplikasi berbasis API yang mendominasi pengembangan web modern.