Serializer ใน Django REST Framework คืออะไร?

Question

Accepted Answer

**Django REST Framework (DRF)** เป็นมาตรฐานโดยพฤตินัยสำหรับการสร้าง REST API ด้วย Django และ **serializer** คือแนวคิดหลักของมัน serializer แปลงข้อมูลที่ซับซ้อน (model instance, queryset) **ไปเป็น** JSON สำหรับ response ของ API และแปลง JSON ที่เข้ามา **กลับ** เป็น Python object ที่ผ่านการ validate แล้ว โดยจัดการทั้งการ serialize และการ validate คล้ายกับที่ form ทำกับ HTML

## ModelSerializer — กรณีที่พบบ่อย

```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` สร้างฟิลด์โดยอัตโนมัติจาก model (เหมือน ModelForm) — เขียนโค้ดน้อยที่สุดเพื่อ serialize และ validate model

## การ Serialize: 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
```

## การ Deserialize + validate: JSON → object ที่ validate แล้ว

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

รูปแบบนี้สะท้อนการทำงานของ form: `is_valid()` validate ข้อมูลที่เข้ามาเทียบกับกฎของฟิลด์และ model ส่วน `save()` บันทึกข้อมูลลงฐานข้อมูล ข้อมูลที่ไม่ถูกต้องจะให้ข้อความ error ที่มีโครงสร้าง

## การ validate และฟิลด์แบบกำหนดเอง

```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 serializer (ข้อมูลที่เกี่ยวข้องกัน)

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

serializer สามารถ **ซ้อนกัน** (nest) เพื่อแสดง object ที่เกี่ยวข้องกันได้ (ฝังข้อมูลของผู้เขียนไว้ภายใน JSON ของบทความ) — และคุณควบคุมรูปแบบของ API ได้อย่างอิสระจากฐานข้อมูล

## ทำไมจึงสำคัญ

serializer คือรากฐานของการสร้าง REST API ด้วย Django REST Framework ซึ่งเป็นเครื่องมือมาตรฐานสำหรับ Django API ดังนั้นการเข้าใจมันจึงจำเป็นอย่างยิ่งสำหรับ back-end ของ Django สมัยใหม่ที่ให้บริการ JSON แก่ frontend, mobile app หรือ service อื่น ๆ

serializer แก้ปัญหาความต้องการพื้นฐานสองอย่างของ API: การแปลงข้อมูล Python/model **ไปเป็น JSON** สำหรับ response (serialization) และการแปลง **JSON ที่เข้ามาให้เป็น Python object ที่ validate แล้ว** สำหรับการสร้าง/อัปเดตข้อมูล (deserialization + validation)

ด้านการ validate เป็นสิ่งสำคัญต่อ **ความปลอดภัยและความทนทาน** — เช่นเดียวกับ form ของ HTML serializer ทำให้คุณไม่เคยเชื่อ input ของ API แบบดิบ ๆ โดย validate มันเทียบกับกฎของฟิลด์ก่อนที่จะถึงฐานข้อมูล **ModelSerializer** ให้ประสิทธิภาพการทำงานที่เพิ่มขึ้นอย่างมากด้วยการสร้างฟิลด์อัตโนมัติจาก model (DRY เหมือน ModelForm) ทำให้การเปิดเผย model เป็น API resource เป็นเรื่องง่ายมาก ในขณะที่รูปแบบ `is_valid()`/`save()` จัดการวงจรการสร้าง/อัปเดตได้อย่างสะอาดครบถ้วน

การเข้าใจวิธี serialize object และ queryset, deserialize และ validate input, เพิ่มการ validate และฟิลด์แบบกำหนดเอง และใช้ **nested serializer** สำหรับข้อมูลที่เกี่ยวข้องกัน (ควบคุมรูปแบบของ API อย่างอิสระจาก schema ของฐานข้อมูล) คือพื้นฐานสำหรับการสร้าง API

serializer คือจุดที่ DRF จัดการประเด็นหลักของ API ทั้งการแปลงข้อมูลและการ validate ทำให้มันเป็นความรู้สำคัญที่ต้องรู้ — มีความสำคัญในระดับเดียวกับ form สำหรับ Django แบบดั้งเดิม แต่สำหรับแอปพลิเคชันที่ขับเคลื่อนด้วย API ซึ่งครองตลาดการพัฒนาเว็บสมัยใหม่