Bài 5.1: Serializers Nâng Cao - Phần 1 - Serializer Fundamentals

**Series Navigation:** - **Bài 5.1 (bài này): Serializer Fundamentals** 👈 - [Bài 5.2: Field-Level & Object-Level Validation](/django-advance/serializers-advanced-phan-2) - [Bài 5.3: Nested Serializers](/django-advance/serializers-advanced-phan-3) - [Bài 5.4: Advanced Patterns & Performance](/django-advance/serializers-advanced-phan-4)

Mục Tiêu Bài 5.1

Sau khi hoàn thành Bài 5.1 này, bạn sẽ:

✅ Hiểu Serializer architecture trong DRF
✅ Phân biệt Serializer vs ModelSerializer
✅ Master các serializer field types
✅ Sử dụng field options (read_only, write_only, required)
✅ Implement SerializerMethodField
✅ Handle source attribute mapping
✅ Understand serialization vs deserialization flow

Giới Thiệu

What Are Serializers?

Serializers trong Django REST Framework = Translators between:

Python objects (models, querysets) ↔ JSON/XML/other formats
Request data → Python objects (deserialization)
Python objects → Response data (serialization)

Key Responsibilities:

Serialization: Convert complex data → JSON
Deserialization: Parse JSON → Python objects
Validation: Validate input data
Saving: Create/update model instances

Why Serializers Matter

Without Serializers (Manual JSON):

# ❌ Manual, error-prone, no validationdef article_detail(request, pk):    article = Article.objects.get(pk=pk)    data = {        'id': article.id,        'title': article.title,        'content': article.content,        'author': {            'id': article.author.id,            'name': article.author.name        }    }    return JsonResponse(data)

With Serializers (DRF):

# ✅ Clean, validated, maintainableclass ArticleSerializer(serializers.ModelSerializer):    class Meta:        model = Article        fields = ['id', 'title', 'content', 'author'] def article_detail(request, pk):    article = Article.objects.get(pk=pk)    serializer = ArticleSerializer(article)    return Response(serializer.data)

Benefits:

✅ Automatic validation
✅ Type conversion
✅ Error handling
✅ Reusable across views
✅ Easy testing

Serializer vs ModelSerializer

Basic Serializer

Use Case: Non-model data, custom logic, complete control.

Example:

from rest_framework import serializers class LoginSerializer(serializers.Serializer):    """Non-model serializer for login"""    email = serializers.EmailField()    password = serializers.CharField(write_only=True, min_length=8)    remember_me = serializers.BooleanField(default=False)        def validate_email(self, value):        # Custom validation        if not value.endswith('@company.com'):            raise serializers.ValidationError('Must use company email')        return value

Characteristics:

✅ Full control over fields
✅ No model required
✅ Must implement create()/update() manually
❌ More code to write

ModelSerializer

Use Case: Model-based APIs, CRUD operations, less boilerplate.

Example:

class ArticleSerializer(serializers.ModelSerializer):    """Model-based serializer"""    class Meta:        model = Article        fields = ['id', 'title', 'content', 'author', 'created_at']        # Or use '__all__' for all fields

Characteristics:

✅ Automatic field generation from model
✅ Automatic create()/update() implementation
✅ Less boilerplate code
✅ Model validation inherited

Generated Fields:

# ModelSerializer automatically creates:id = serializers.IntegerField(read_only=True)title = serializers.CharField(max_length=200)content = serializers.CharField()author = serializers.PrimaryKeyRelatedField(queryset=User.objects.all())created_at = serializers.DateTimeField(read_only=True)

Comparison Table

Feature	Serializer	ModelSerializer
Model Required	❌ No	✅ Yes
Field Generation	Manual	Automatic
create()/update()	Must implement	Auto-implemented
Boilerplate	More	Less
Flexibility	Full control	Model-constrained
Use Case	Non-model data	Model APIs

When to Use Each

Use Serializer When:

Non-model data (login, search, filters)
Complex custom logic
Data aggregation from multiple sources
Need complete control

Use ModelSerializer When:

Standard CRUD operations
Model-based APIs
Want to reduce boilerplate
Following REST conventions

Serializer Field Types

Common Field Types

1. String Fields:

from rest_framework import serializers class MySerializer(serializers.Serializer):    # Basic string    name = serializers.CharField(max_length=100)        # Email with validation    email = serializers.EmailField()        # URL with validation    website = serializers.URLField()        # Slug (lowercase alphanumeric + hyphens)    slug = serializers.SlugField()        # UUID    id = serializers.UUIDField()        # Choice field    STATUS_CHOICES = [('draft', 'Draft'), ('published', 'Published')]    status = serializers.ChoiceField(choices=STATUS_CHOICES)

2. Numeric Fields:

class ProductSerializer(serializers.Serializer):    # Integer    stock = serializers.IntegerField(min_value=0)        # Float    rating = serializers.FloatField(min_value=0, max_value=5)        # Decimal (for money)    price = serializers.DecimalField(max_digits=10, decimal_places=2)

3. Boolean Fields:

class ArticleSerializer(serializers.Serializer):    is_published = serializers.BooleanField()    is_featured = serializers.BooleanField(default=False)

4. Date/Time Fields:

class EventSerializer(serializers.Serializer):    # Date only    event_date = serializers.DateField()        # Time only    start_time = serializers.TimeField()        # DateTime    created_at = serializers.DateTimeField(read_only=True)        # Duration    duration = serializers.DurationField()

5. File Fields:

class ProfileSerializer(serializers.Serializer):    # File upload    document = serializers.FileField()        # Image upload with validation    avatar = serializers.ImageField(        max_length=None,        allow_empty_file=False,        use_url=True    )

6. Relationship Fields:

class ArticleSerializer(serializers.ModelSerializer):    # Primary key (default for ForeignKey)    author = serializers.PrimaryKeyRelatedField(        queryset=User.objects.all()    )        # String representation    author_name = serializers.StringRelatedField(source='author')        # Hyperlink    author_url = serializers.HyperlinkedRelatedField(        source='author',        view_name='user-detail',        read_only=True    )        # Nested serializer (covered in Part 3)    author_details = UserSerializer(source='author', read_only=True)

Field Options

1. read_only:

class ArticleSerializer(serializers.ModelSerializer):    # Cannot be set by client    id = serializers.IntegerField(read_only=True)    created_at = serializers.DateTimeField(read_only=True)    view_count = serializers.IntegerField(read_only=True)        class Meta:        model = Article        fields = ['id', 'title', 'created_at', 'view_count']

Use Cases:

Auto-generated fields (id, timestamps)
Computed fields
Server-controlled values

2. write_only:

class UserSerializer(serializers.ModelSerializer):    # Accepted in requests but not in responses    password = serializers.CharField(write_only=True, min_length=8)    password_confirm = serializers.CharField(write_only=True)        class Meta:        model = User        fields = ['id', 'username', 'email', 'password', 'password_confirm']

Use Cases:

Passwords
Confirmation fields
Sensitive input data

3. required:

class OrderSerializer(serializers.Serializer):    # Must be provided (default=True)    customer_email = serializers.EmailField(required=True)        # Optional field    discount_code = serializers.CharField(required=False)        # Optional with default    shipping_method = serializers.CharField(default='standard')

4. allow_null:

class ArticleSerializer(serializers.Serializer):    # Can be null    summary = serializers.CharField(allow_null=True)        # Cannot be null (default)    title = serializers.CharField(allow_null=False)

5. allow_blank:

class CommentSerializer(serializers.Serializer):    # Can be empty string    nickname = serializers.CharField(allow_blank=True)        # Cannot be empty string (default)    text = serializers.CharField(allow_blank=False)

6. default:

class ArticleSerializer(serializers.Serializer):    # Static default    status = serializers.CharField(default='draft')        # Callable default    created_at = serializers.DateTimeField(default=timezone.now)        # Default from context    author = serializers.HiddenField(default=serializers.CurrentUserDefault())

Field Validators

Built-in Validators:

from rest_framework.validators import UniqueValidator, UniqueTogetherValidator class ArticleSerializer(serializers.ModelSerializer):    # Unique slug    slug = serializers.SlugField(        validators=[UniqueValidator(queryset=Article.objects.all())]    )        # Min/max length    title = serializers.CharField(        min_length=10,        max_length=200    )        # Min/max value    rating = serializers.IntegerField(        min_value=1,        max_value=5    )        # Regex validator    phone = serializers.CharField(        validators=[            RegexValidator(                regex=r'^\+?1?\d{9,15}$',                message='Invalid phone number'            )        ]    )

Custom Validator Functions:

def validate_even_number(value):    """Ensure value is even"""    if value % 2 != 0:        raise serializers.ValidationError('Must be an even number')    return value def validate_future_date(value):    """Ensure date is in the future"""    from django.utils import timezone    if value <= timezone.now().date():        raise serializers.ValidationError('Date must be in the future')    return value class EventSerializer(serializers.Serializer):    capacity = serializers.IntegerField(validators=[validate_even_number])    event_date = serializers.DateField(validators=[validate_future_date])

SerializerMethodField

What is SerializerMethodField?

SerializerMethodField = Custom read-only field with computed value from a method.

Use Cases:

Computed properties
Aggregated data
Formatted output
Complex transformations

Basic Usage

Pattern:

class MySerializer(serializers.ModelSerializer):    # 1. Define field    custom_field = serializers.SerializerMethodField()        # 2. Define method (get_<field_name>)    def get_custom_field(self, obj):        return compute_value(obj)

Example - Full Name:

class UserSerializer(serializers.ModelSerializer):    full_name = serializers.SerializerMethodField()        def get_full_name(self, obj):        return f"{obj.first_name} {obj.last_name}".strip()        class Meta:        model = User        fields = ['id', 'username', 'full_name']

Output:

{    "id": 1,    "username": "john_doe",    "full_name": "John Doe"}

Examples

1. Computed Property:

class ArticleSerializer(serializers.ModelSerializer):    read_time = serializers.SerializerMethodField()        def get_read_time(self, obj):        """Calculate reading time in minutes"""        words = len(obj.content.split())        minutes = max(1, words // 200)  # Average 200 words/min        return f"{minutes} min read"        class Meta:        model = Article        fields = ['id', 'title', 'read_time']

2. Aggregated Data:

class AuthorSerializer(serializers.ModelSerializer):    article_count = serializers.SerializerMethodField()        def get_article_count(self, obj):        return obj.articles.count()        class Meta:        model = Author        fields = ['id', 'name', 'article_count']

3. Conditional Display:

class ProductSerializer(serializers.ModelSerializer):    availability = serializers.SerializerMethodField()        def get_availability(self, obj):        if obj.stock > 100:            return 'In Stock'        elif obj.stock > 0:            return f'Only {obj.stock} left'        else:            return 'Out of Stock'        class Meta:        model = Product        fields = ['id', 'name', 'availability']

4. Formatted Output:

class OrderSerializer(serializers.ModelSerializer):    total_formatted = serializers.SerializerMethodField()        def get_total_formatted(self, obj):        return f"${obj.total:,.2f}"        class Meta:        model = Order        fields = ['id', 'total_formatted']

5. Related Object Data:

class ArticleSerializer(serializers.ModelSerializer):    author_name = serializers.SerializerMethodField()    category_name = serializers.SerializerMethodField()        def get_author_name(self, obj):        return obj.author.get_full_name()        def get_category_name(self, obj):        return obj.category.name        class Meta:        model = Article        fields = ['id', 'title', 'author_name', 'category_name']

Performance Considerations

⚠️ Problem: N+1 Queries

class ArticleSerializer(serializers.ModelSerializer):    author_name = serializers.SerializerMethodField()        def get_author_name(self, obj):        return obj.author.name  # N+1 if author not prefetched!        class Meta:        model = Article        fields = ['id', 'title', 'author_name']

✅ Solution: Prefetch in View

class ArticleList(generics.ListAPIView):    queryset = Article.objects.select_related('author').all()    serializer_class = ArticleSerializer

Or Use Annotation:

from django.db.models import F class ArticleList(generics.ListAPIView):    queryset = Article.objects.annotate(author_name=F('author__name'))    serializer_class = ArticleSerializer class ArticleSerializer(serializers.ModelSerializer):    author_name = serializers.CharField()  # From annotation, not method        class Meta:        model = Article        fields = ['id', 'title', 'author_name']

Source Attribute

What is source?

source = Map serializer field to different model attribute.

Use Cases:

Rename fields in API
Access nested attributes
Call model methods
Map to related objects

Basic Usage

Rename Field:

class UserSerializer(serializers.ModelSerializer):    # API field 'name' maps to model field 'username'    name = serializers.CharField(source='username')        class Meta:        model = User        fields = ['id', 'name']  # API shows 'name', not 'username'

Output:

{    "id": 1,    "name": "john_doe"  // Actually from username field}

Nested Attributes

Access Related Object Fields:

class ArticleSerializer(serializers.ModelSerializer):    # Access author.username    author_username = serializers.CharField(source='author.username')        # Access author.profile.bio    author_bio = serializers.CharField(source='author.profile.bio')        class Meta:        model = Article        fields = ['id', 'title', 'author_username', 'author_bio']

⚠️ Remember to prefetch:

# In viewqueryset = Article.objects.select_related('author', 'author__profile')

Call Model Methods

Model:

class Article(models.Model):    title = models.CharField(max_length=200)    content = models.TextField()        def get_summary(self):        return self.content[:100] + '...'

Serializer:

class ArticleSerializer(serializers.ModelSerializer):    # Call model method    summary = serializers.CharField(source='get_summary')        class Meta:        model = Article        fields = ['id', 'title', 'summary']

Multiple Fields from Same Source

class UserSerializer(serializers.ModelSerializer):    # Both map to 'profile' related object    bio = serializers.CharField(source='profile.bio')    avatar = serializers.ImageField(source='profile.avatar')    location = serializers.CharField(source='profile.location')        class Meta:        model = User        fields = ['id', 'username', 'bio', 'avatar', 'location']

source with Write Operations

Read-Only (Common):

class ArticleSerializer(serializers.ModelSerializer):    author_name = serializers.CharField(source='author.username', read_only=True)

Writable (Careful!):

class ArticleSerializer(serializers.ModelSerializer):    author_username = serializers.CharField(source='author.username')    # Will try to set author.username on write    # Make sure related object exists!

Serialization vs Deserialization Flow

Serialization (Model → JSON)

Flow:

Model Instance    ↓Serializer(instance=obj)    ↓.data property    ↓JSON Response

Example:

# 1. Get model instancearticle = Article.objects.get(pk=1) # 2. Create serializer with instanceserializer = ArticleSerializer(article) # 3. Access .data (triggers serialization)data = serializer.data # 4. Return JSONreturn Response(data)

Behind the Scenes:

1. Field values extracted from model2. to_representation() called for each field3. SerializerMethodField methods called4. source mappings applied5. Final dict/OrderedDict created

Deserialization (JSON → Model)

Flow:

JSON Request Data    ↓Serializer(data=request.data)    ↓.is_valid()    ↓.validated_data    ↓.save()    ↓Model Instance

Example:

# 1. Get request datadata = {    'title': 'New Article',    'content': 'Article content...'} # 2. Create serializer with dataserializer = ArticleSerializer(data=data) # 3. Validateif serializer.is_valid():    # 4. Access validated data    validated = serializer.validated_data        # 5. Save (creates or updates model)    article = serializer.save()else:    # Handle errors    errors = serializer.errors

Behind the Scenes:

1. Run field validators2. Run field-level validation methods (validate_<field>)3. Run object-level validation (validate)4. If valid: create validated_data dict5. On save(): call create() or update()

Both (Update Existing)

Update Flow:

# Get existing instancearticle = Article.objects.get(pk=1) # Pass both instance and dataserializer = ArticleSerializer(article, data=request.data) if serializer.is_valid():    # Calls update() method    article = serializer.save()

Tóm Tắt Bài 5.1

Trong Bài 5.1 này, bạn đã học:

✅ Serializer Fundamentals:

Serializers = Translators between Python objects và JSON
Responsibilities: serialization, deserialization, validation, saving

✅ Serializer vs ModelSerializer:

Serializer: Full control, manual fields, custom logic
ModelSerializer: Auto-generation, less code, model-based

✅ Field Types:

String: CharField, EmailField, URLField, SlugField
Numeric: IntegerField, FloatField, DecimalField
Boolean, Date/Time, File fields
Relationship fields: PrimaryKey, StringRelated, Hyperlinked

✅ Field Options:

read_only, write_only, required
allow_null, allow_blank, default
Validators: built-in và custom

✅ SerializerMethodField:

Computed read-only fields
get_ method pattern
Use cases: aggregation, formatting, conditions
Performance: avoid N+1 with prefetch

✅ Source Attribute:

Map fields to different model attributes
Access nested attributes
Call model methods
Rename API fields

✅ Serialization Flow:

Serialization: Model → JSON
Deserialization: JSON → Model
Validation lifecycle

Exercises

Exercise 1: Book Serializer

Models:

class Author(models.Model):    first_name = models.CharField(max_length=50)    last_name = models.CharField(max_length=50)    birth_date = models.DateField() class Book(models.Model):    title = models.CharField(max_length=200)    isbn = models.CharField(max_length=13)    published_date = models.DateField()    pages = models.IntegerField()    author = models.ForeignKey(Author, related_name='books')

Task: Create BookSerializer with:

All book fields
author_name (SerializerMethodField showing "First Last")
age_years (SerializerMethodField: years since publication)
is_new (SerializerMethodField: True if published < 1 year ago)
isbn should be write_only
Validate pages must be > 0

Exercise 2: User Profile Serializer

Models:

class User(AbstractUser):    pass class Profile(models.Model):    user = models.OneToOneField(User, on_delete=models.CASCADE)    bio = models.TextField()    birth_date = models.DateField()    phone = models.CharField(max_length=20)    avatar = models.ImageField()

Task: Create UserProfileSerializer with:

username, email from User
bio, birth_date, phone, avatar from Profile (use source)
age (SerializerMethodField computed from birth_date)
email should be read_only
phone should validate format: +XX-XXX-XXX-XXXX

Exercise 3: Product API

Models:

class Category(models.Model):    name = models.CharField(max_length=100) class Product(models.Model):    name = models.CharField(max_length=200)    description = models.TextField()    price = models.DecimalField(max_digits=10, decimal_places=2)    stock = models.IntegerField()    category = models.ForeignKey(Category)    created_at = models.DateTimeField(auto_now_add=True)

Task: Create ProductSerializer with:

All fields except created_at
category_name (CharField from category.name)
availability (SerializerMethodField: "In Stock" / "Low Stock" / "Out of Stock")
price_formatted (SerializerMethodField: "$X,XXX.XX")
created_at as read_only field
Validate price > 0 and stock >= 0

Next Steps

Trong Bài 5.2, bạn sẽ học:

Field-level validation với validate_()
Object-level validation với validate()
Custom validators và validator classes
ValidationError handling
Multi-field validation
Conditional validation

Navigation:

← Bài 4: DRF Introduction
Bài 5.1: Serializer Fundamentals (current)
Bài 5.2: Field-Level & Object-Level Validation →

#modelserializer

Serializers Nâng Cao - Phần 1 - Serializer Fundamentals