Bài 5.4: Advanced Patterns & Performance - Phần 4

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

Mục Tiêu Bài 5.4

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

✅ Implement dynamic field selection
✅ Master serializer context patterns
✅ Use serializer inheritance effectively
✅ Create reusable generic serializers
✅ Optimize serializer performance
✅ Apply real-world patterns
✅ Test serializers properly
✅ Handle edge cases and errors

Dynamic Field Selection

Why Dynamic Fields?

Problem: Different clients need different fields.

Examples:

Mobile app: minimal fields (save bandwidth)
Web dashboard: full fields
Public API: hide sensitive fields
Admin API: show all fields including internal

Pattern 1: Query Parameter Based

Allow clients to specify fields:

class DynamicFieldsSerializer(serializers.ModelSerializer):    """    A serializer that takes an additional `fields` argument to    dynamically limit the fields returned.    """        def __init__(self, *args, **kwargs):        # Don't pass 'fields' arg to parent        fields = kwargs.pop('fields', None)                # Instantiate parent normally        super().__init__(*args, **kwargs)                if fields is not None:            # Drop fields not specified            allowed = set(fields)            existing = set(self.fields)                        for field_name in existing - allowed:                self.fields.pop(field_name) class ArticleSerializer(DynamicFieldsSerializer):    class Meta:        model = Article        fields = ['id', 'title', 'content', 'author', 'created_at', 'updated_at'] # Usage in view:def get(self, request):    articles = Article.objects.all()        # Get requested fields from query params    fields = request.query_params.get('fields')    if fields:        fields = fields.split(',')        serializer = ArticleSerializer(articles, many=True, fields=fields)    else:        serializer = ArticleSerializer(articles, many=True)        return Response(serializer.data) # API Usage:# GET /api/articles/                      → All fields# GET /api/articles/?fields=id,title      → Only id and title# GET /api/articles/?fields=id,title,author → id, title, author

Pattern 2: Context-Based Field Selection

Determine fields based on user or action:

class ArticleSerializer(serializers.ModelSerializer):    class Meta:        model = Article        fields = ['id', 'title', 'content', 'author', 'status', 'internal_notes']        def __init__(self, *args, **kwargs):        super().__init__(*args, **kwargs)                # Get user from context        request = self.context.get('request')                if request and request.user:            # Hide internal fields from non-staff            if not request.user.is_staff:                self.fields.pop('internal_notes', None)                self.fields.pop('status', None)

Pattern 3: Include/Exclude Parameters

Flexible field control:

class FlexibleFieldsSerializer(serializers.ModelSerializer):    """    Supports both 'include' and 'exclude' parameters    """        def __init__(self, *args, **kwargs):        include = kwargs.pop('include', None)        exclude = kwargs.pop('exclude', None)                super().__init__(*args, **kwargs)                if include is not None:            # Only include specified fields            allowed = set(include)            existing = set(self.fields)                        for field_name in existing - allowed:                self.fields.pop(field_name)                elif exclude is not None:            # Exclude specified fields            for field_name in exclude:                self.fields.pop(field_name, None) class UserSerializer(FlexibleFieldsSerializer):    class Meta:        model = User        fields = ['id', 'username', 'email', 'first_name', 'last_name', 'password'] # Usage:# Show only public fieldsserializer = UserSerializer(user, exclude=['password', 'email']) # Show only basic infoserializer = UserSerializer(user, include=['id', 'username'])

Pattern 4: Expandable Fields

Allow clients to request nested data:

class ExpandableFieldsSerializer(serializers.ModelSerializer):    """    Supports 'expand' parameter to include nested data    """        expandable_fields = {}        def __init__(self, *args, **kwargs):        expand = kwargs.pop('expand', None)                super().__init__(*args, **kwargs)                if expand:            expand_fields = expand.split(',') if isinstance(expand, str) else expand                        for field_name in expand_fields:                if field_name in self.expandable_fields:                    serializer_class = self.expandable_fields[field_name]                    self.fields[field_name] = serializer_class(read_only=True) class AuthorSerializer(serializers.ModelSerializer):    class Meta:        model = Author        fields = ['id', 'name', 'bio'] class CommentSerializer(serializers.ModelSerializer):    class Meta:        model = Comment        fields = ['id', 'author', 'text'] class ArticleSerializer(ExpandableFieldsSerializer):    # Define which fields can be expanded    expandable_fields = {        'author': AuthorSerializer,        'comments': CommentSerializer(many=True)    }        class Meta:        model = Article        fields = ['id', 'title', 'content', 'author', 'comments'] # Usage in view:def get(self, request, pk):    article = Article.objects.get(pk=pk)        expand = request.query_params.get('expand')    serializer = ArticleSerializer(article, expand=expand, context={'request': request})        return Response(serializer.data) # API Usage:# GET /api/articles/1/                    → author: 5 (ID only)# GET /api/articles/1/?expand=author      → author: {id: 5, name: "John", bio: "..."}# GET /api/articles/1/?expand=author,comments → Both expanded

Serializer Context Patterns

What is Context?

Context = Dictionary passed to serializer with additional information.

Common context data:

request - Current HTTP request
view - Current view instance
format - Response format
Custom data

Accessing Context

In serializer:

class ArticleSerializer(serializers.ModelSerializer):    can_edit = serializers.SerializerMethodField()        def get_can_edit(self, obj):        # Access request from context        request = self.context.get('request')                if not request or not request.user.is_authenticated:            return False                # Check if user is author or staff        return obj.author == request.user or request.user.is_staff        class Meta:        model = Article        fields = ['id', 'title', 'can_edit']

Passing Context from View

Automatic context (Generic Views):

class ArticleDetail(generics.RetrieveAPIView):    serializer_class = ArticleSerializer    queryset = Article.objects.all()    # Context automatically includes: request, view, format

Manual context (APIView):

class ArticleDetail(APIView):    def get(self, request, pk):        article = Article.objects.get(pk=pk)                # Pass context manually        serializer = ArticleSerializer(            article,            context={                'request': request,                'view': self,                'custom_data': 'some value'            }        )                return Response(serializer.data)

Context in Nested Serializers

Context automatically propagates:

class CommentSerializer(serializers.ModelSerializer):    can_delete = serializers.SerializerMethodField()        def get_can_delete(self, obj):        # Context is available in nested serializer!        request = self.context.get('request')        return request and obj.author == request.user        class Meta:        model = Comment        fields = ['id', 'text', 'can_delete'] class ArticleSerializer(serializers.ModelSerializer):    comments = CommentSerializer(many=True, read_only=True)    # Context automatically passed to CommentSerializer        class Meta:        model = Article        fields = ['id', 'title', 'comments']

Custom Context Patterns

Pattern 1: User Permissions:

class ArticleSerializer(serializers.ModelSerializer):    permissions = serializers.SerializerMethodField()        def get_permissions(self, obj):        request = self.context.get('request')                if not request or not request.user.is_authenticated:            return {                'can_edit': False,                'can_delete': False,                'can_publish': False            }                user = request.user        return {            'can_edit': obj.author == user or user.is_staff,            'can_delete': obj.author == user or user.is_staff,            'can_publish': user.is_staff        }        class Meta:        model = Article        fields = ['id', 'title', 'permissions']

Pattern 2: Conditional Fields:

class UserSerializer(serializers.ModelSerializer):    class Meta:        model = User        fields = ['id', 'username', 'email', 'phone']        def __init__(self, *args, **kwargs):        super().__init__(*args, **kwargs)                request = self.context.get('request')                # Hide email/phone from others        if request and hasattr(self, 'instance'):            if self.instance != request.user and not request.user.is_staff:                self.fields.pop('email', None)                self.fields.pop('phone', None)

Pattern 3: Additional Data:

class ArticleSerializer(serializers.ModelSerializer):    stats = serializers.SerializerMethodField()        def get_stats(self, obj):        # Use precomputed stats from context        stats_cache = self.context.get('stats_cache', {})                if obj.id in stats_cache:            return stats_cache[obj.id]                # Fallback: compute on the fly        return {            'views': obj.views,            'likes': obj.likes.count()        } # In view:class ArticleList(generics.ListAPIView):    serializer_class = ArticleSerializer        def get_serializer_context(self):        context = super().get_serializer_context()                # Precompute stats for all articles        articles = self.get_queryset()        stats_cache = {}                for article in articles:            stats_cache[article.id] = {                'views': article.views,                'likes': article.likes.count()            }                context['stats_cache'] = stats_cache        return context

Serializer Inheritance

Basic Inheritance

Extend existing serializers:

class BaseArticleSerializer(serializers.ModelSerializer):    """Base serializer with common fields"""    author_name = serializers.CharField(source='author.name', read_only=True)        class Meta:        model = Article        fields = ['id', 'title', 'author_name', 'created_at'] class ArticleListSerializer(BaseArticleSerializer):    """Minimal fields for list views"""    class Meta(BaseArticleSerializer.Meta):        fields = BaseArticleSerializer.Meta.fields + ['status'] class ArticleDetailSerializer(BaseArticleSerializer):    """Full fields for detail views"""    comments = CommentSerializer(many=True, read_only=True)        class Meta(BaseArticleSerializer.Meta):        fields = BaseArticleSerializer.Meta.fields + ['content', 'comments', 'tags']

Abstract Base Serializers

Create reusable base classes:

class TimestampedSerializer(serializers.ModelSerializer):    """Add timestamp fields to any serializer"""    created_at = serializers.DateTimeField(read_only=True)    updated_at = serializers.DateTimeField(read_only=True)        class Meta:        abstract = True        fields = ['created_at', 'updated_at'] class UserTrackingSerializer(serializers.ModelSerializer):    """Add user tracking fields"""    created_by = serializers.StringRelatedField(read_only=True)    updated_by = serializers.StringRelatedField(read_only=True)        class Meta:        abstract = True        fields = ['created_by', 'updated_by'] class ArticleSerializer(TimestampedSerializer, UserTrackingSerializer):    """Inherits timestamp and user tracking"""    class Meta:        model = Article        fields = ['id', 'title', 'content'] + \                 TimestampedSerializer.Meta.fields + \                 UserTrackingSerializer.Meta.fields

Mixin Pattern

Reusable functionality:

class PermissionSerializerMixin:    """Add permission fields to any serializer"""    permissions = serializers.SerializerMethodField()        def get_permissions(self, obj):        request = self.context.get('request')                if not request or not request.user.is_authenticated:            return {'can_edit': False, 'can_delete': False}                return {            'can_edit': self._can_edit(obj, request.user),            'can_delete': self._can_delete(obj, request.user)        }        def _can_edit(self, obj, user):        # Override in subclass        return False        def _can_delete(self, obj, user):        # Override in subclass        return False class ArticleSerializer(PermissionSerializerMixin, serializers.ModelSerializer):    class Meta:        model = Article        fields = ['id', 'title', 'permissions']        def _can_edit(self, obj, user):        return obj.author == user or user.is_staff        def _can_delete(self, obj, user):        return obj.author == user

Overriding Fields

Customize inherited fields:

class BaseSerializer(serializers.ModelSerializer):    author = serializers.PrimaryKeyRelatedField(queryset=Author.objects.all())        class Meta:        model = Article        fields = ['id', 'title', 'author'] class DetailSerializer(BaseSerializer):    # Override author field to be nested    author = AuthorSerializer(read_only=True)        # Also provide author_id for writes    author_id = serializers.PrimaryKeyRelatedField(        queryset=Author.objects.all(),        source='author',        write_only=True    )        class Meta(BaseSerializer.Meta):        fields = BaseSerializer.Meta.fields + ['author_id', 'content']

Generic Serializers

Polymorphic Serializer

Handle multiple model types:

class ContentSerializer(serializers.Serializer):    """Serialize different content types"""        def to_representation(self, instance):        # Determine type and use appropriate serializer        if isinstance(instance, Article):            return ArticleSerializer(instance, context=self.context).data        elif isinstance(instance, Video):            return VideoSerializer(instance, context=self.context).data        elif isinstance(instance, Podcast):            return PodcastSerializer(instance, context=self.context).data                raise Exception(f'Unexpected type: {type(instance)}') # Usage:class FeedView(APIView):    def get(self, request):        # Mixed content types        articles = Article.objects.all()[:5]        videos = Video.objects.all()[:5]                content = list(articles) + list(videos)                serializer = ContentSerializer(content, many=True, context={'request': request})        return Response(serializer.data)

Generic Field Serializer

Serialize any model with generic fields:

class GenericObjectSerializer(serializers.Serializer):    """Generic serializer for any model"""    id = serializers.IntegerField(read_only=True)    type = serializers.SerializerMethodField()    data = serializers.SerializerMethodField()        def get_type(self, obj):        return obj.__class__.__name__        def get_data(self, obj):        # Get serializer for this type        serializer_class = self.context.get('serializers', {}).get(            obj.__class__.__name__        )                if serializer_class:            return serializer_class(obj, context=self.context).data                # Fallback: basic fields        return {            'str': str(obj),            'pk': obj.pk        } # Usage:serializer = GenericObjectSerializer(    objects,    many=True,    context={        'request': request,        'serializers': {            'Article': ArticleSerializer,            'Video': VideoSerializer        }    })

Activity Feed Pattern

Generic activity serializer:

class ActivitySerializer(serializers.ModelSerializer):    actor = serializers.SerializerMethodField()    target = serializers.SerializerMethodField()    action_object = serializers.SerializerMethodField()        class Meta:        model = Activity        fields = ['id', 'actor', 'verb', 'target', 'action_object', 'timestamp']        def _serialize_object(self, obj):        """Serialize any object based on its type"""        if obj is None:            return None                serializers_map = {            'User': UserSerializer,            'Article': ArticleSerializer,            'Comment': CommentSerializer        }                serializer_class = serializers_map.get(obj.__class__.__name__)                if serializer_class:            return serializer_class(obj, context=self.context).data                return {'id': obj.id, 'type': obj.__class__.__name__}        def get_actor(self, obj):        return self._serialize_object(obj.actor)        def get_target(self, obj):        return self._serialize_object(obj.target)        def get_action_object(self, obj):        return self._serialize_object(obj.action_object) # Output:# {#     "id": 1,#     "actor": {"id": 5, "username": "john"},#     "verb": "commented on",#     "target": {"id": 10, "title": "Django Tutorial"},#     "action_object": {"id": 20, "text": "Great article!"},#     "timestamp": "2024-01-01T12:00:00Z"# }

Performance Optimization

1. Only() and Defer()

Reduce database column fetching:

# In view querysetclass ArticleList(generics.ListAPIView):    serializer_class = ArticleListSerializer        def get_queryset(self):        # Only fetch needed columns        return Article.objects.only('id', 'title', 'created_at') # Or use defer() to exclude columnsclass ArticleList(generics.ListAPIView):    def get_queryset(self):        # Exclude heavy columns        return Article.objects.defer('content', 'html_content')

2. Selective Field Loading

Load fields based on context:

class ArticleSerializer(serializers.ModelSerializer):    content = serializers.CharField()        class Meta:        model = Article        fields = ['id', 'title', 'content']        def __init__(self, *args, **kwargs):        super().__init__(*args, **kwargs)                # Remove content field for list views        view = self.context.get('view')        if view and view.action == 'list':            self.fields.pop('content', None)

3. Prefetch Optimization

Optimize nested serializers:

class ArticleSerializer(serializers.ModelSerializer):    author = AuthorSerializer(read_only=True)    comments = CommentSerializer(many=True, read_only=True)    tags = TagSerializer(many=True, read_only=True)        class Meta:        model = Article        fields = ['id', 'title', 'author', 'comments', 'tags'] # In view:class ArticleList(generics.ListAPIView):    serializer_class = ArticleSerializer        def get_queryset(self):        return Article.objects.all() \            .select_related('author') \            .prefetch_related('comments', 'tags')

4. Cached Properties

Cache expensive computations:

from django.utils.functional import cached_property class Article(models.Model):    title = models.CharField(max_length=200)    content = models.TextField()        @cached_property    def read_time(self):        """Expensive calculation - cache it"""        words = len(self.content.split())        return max(1, words // 200) class ArticleSerializer(serializers.ModelSerializer):    read_time = serializers.IntegerField(read_only=True)    # Uses cached_property, computed once        class Meta:        model = Article        fields = ['id', 'title', 'read_time']

5. Batch Processing

Optimize bulk operations:

class ArticleSerializer(serializers.ModelSerializer):    view_count = serializers.SerializerMethodField()        def get_view_count(self, obj):        # Bad: N queries        # return obj.views.count()                # Good: Use annotated value        return getattr(obj, '_view_count', 0)        class Meta:        model = Article        fields = ['id', 'title', 'view_count'] # In view:class ArticleList(generics.ListAPIView):    serializer_class = ArticleSerializer        def get_queryset(self):        from django.db.models import Count        return Article.objects.annotate(            _view_count=Count('views')        ).all()

6. Pagination

Always paginate large datasets:

# settings.pyREST_FRAMEWORK = {    'DEFAULT_PAGINATION_CLASS': 'rest_framework.pagination.PageNumberPagination',    'PAGE_SIZE': 20} # Or custom paginationclass ArticleList(generics.ListAPIView):    serializer_class = ArticleSerializer    pagination_class = PageNumberPagination

7. Response Caching

Cache serialized responses:

from django.views.decorators.cache import cache_pagefrom django.utils.decorators import method_decorator class ArticleList(generics.ListAPIView):    serializer_class = ArticleSerializer        @method_decorator(cache_page(60 * 15))  # Cache 15 minutes    def list(self, request, *args, **kwargs):        return super().list(request, *args, **kwargs)

8. Lazy Evaluation

Defer expensive operations:

class ArticleSerializer(serializers.ModelSerializer):    related_articles = serializers.SerializerMethodField()        def get_related_articles(self, obj):        # Only compute if explicitly requested        if not self.context.get('include_related'):            return None                related = Article.objects.filter(            category=obj.category        ).exclude(pk=obj.pk)[:5]                return ArticleSerializer(related, many=True).data # Usage:# Without related: serializer = ArticleSerializer(article)# With related: serializer = ArticleSerializer(article, context={'include_related': True})

Real-World Patterns

Pattern 1: Versioned Serializers

Support multiple API versions:

# serializers/v1.pyclass ArticleSerializerV1(serializers.ModelSerializer):    class Meta:        model = Article        fields = ['id', 'title', 'content', 'author'] # serializers/v2.pyclass ArticleSerializerV2(serializers.ModelSerializer):    author_details = AuthorSerializer(source='author', read_only=True)    tags = TagSerializer(many=True, read_only=True)        class Meta:        model = Article        fields = ['id', 'title', 'content', 'author_details', 'tags', 'created_at'] # views.pyclass ArticleList(generics.ListAPIView):    def get_serializer_class(self):        if self.request.version == 'v1':            return ArticleSerializerV1        return ArticleSerializerV2

Pattern 2: Localized Serializers

Multi-language support:

class ArticleSerializer(serializers.ModelSerializer):    title = serializers.SerializerMethodField()    content = serializers.SerializerMethodField()        def get_title(self, obj):        lang = self.context.get('request').LANGUAGE_CODE        return getattr(obj, f'title_{lang}', obj.title)        def get_content(self, obj):        lang = self.context.get('request').LANGUAGE_CODE        return getattr(obj, f'content_{lang}', obj.content)        class Meta:        model = Article        fields = ['id', 'title', 'content']

Pattern 3: Audit Trail

Track changes with serializers:

class AuditMixin:    """Mixin to track serializer changes"""        def create(self, validated_data):        instance = super().create(validated_data)                # Log creation        AuditLog.objects.create(            action='CREATE',            model_name=instance.__class__.__name__,            object_id=instance.pk,            user=self.context['request'].user,            data=validated_data        )                return instance        def update(self, instance, validated_data):        # Track changes        old_data = {            field: getattr(instance, field)            for field in validated_data.keys()        }                instance = super().update(instance, validated_data)                # Log update        AuditLog.objects.create(            action='UPDATE',            model_name=instance.__class__.__name__,            object_id=instance.pk,            user=self.context['request'].user,            old_data=old_data,            new_data=validated_data        )                return instance class ArticleSerializer(AuditMixin, serializers.ModelSerializer):    class Meta:        model = Article        fields = ['id', 'title', 'content']

Pattern 4: Soft Delete

Handle soft-deleted objects:

class ArticleSerializer(serializers.ModelSerializer):    is_deleted = serializers.BooleanField(read_only=True)        class Meta:        model = Article        fields = ['id', 'title', 'is_deleted']        def update(self, instance, validated_data):        # Check if trying to restore        if 'is_deleted' in validated_data:            if not validated_data['is_deleted'] and instance.is_deleted:                instance.deleted_at = None                instance.is_deleted = False                return super().update(instance, validated_data) # In view:class ArticleList(generics.ListAPIView):    def get_queryset(self):        # Only show non-deleted by default        qs = Article.objects.filter(is_deleted=False)                # Allow staff to see deleted        if self.request.user.is_staff and self.request.query_params.get('show_deleted'):            qs = Article.objects.all()                return qs

Pattern 5: Bulk Operations

Create/update multiple objects:

class BulkArticleSerializer(serializers.ListSerializer):    """Custom list serializer for bulk operations"""        def create(self, validated_data):        # Bulk create        articles = [Article(**item) for item in validated_data]        return Article.objects.bulk_create(articles)        def update(self, instance, validated_data):        # Bulk update        article_mapping = {article.id: article for article in instance}                updated_articles = []        for item in validated_data:            article = article_mapping.get(item['id'])            if article:                article.title = item.get('title', article.title)                article.content = item.get('content', article.content)                updated_articles.append(article)                Article.objects.bulk_update(updated_articles, ['title', 'content'])        return updated_articles class ArticleSerializer(serializers.ModelSerializer):    class Meta:        model = Article        fields = ['id', 'title', 'content']        list_serializer_class = BulkArticleSerializer # Usage:data = [    {'title': 'Article 1', 'content': 'Content 1'},    {'title': 'Article 2', 'content': 'Content 2'},] serializer = ArticleSerializer(data=data, many=True)if serializer.is_valid():    serializer.save()  # Bulk creates all articles

Testing Serializers

Unit Tests

Test serialization:

from django.test import TestCasefrom rest_framework.test import APITestCase class ArticleSerializerTestCase(TestCase):    def setUp(self):        self.author = Author.objects.create(name='John Doe')        self.article = Article.objects.create(            title='Test Article',            content='Test content',            author=self.author        )        def test_serialization(self):        """Test model to JSON"""        serializer = ArticleSerializer(self.article)                self.assertEqual(serializer.data['id'], self.article.id)        self.assertEqual(serializer.data['title'], 'Test Article')        self.assertEqual(serializer.data['content'], 'Test content')        def test_deserialization(self):        """Test JSON to model"""        data = {            'title': 'New Article',            'content': 'New content',            'author': self.author.id        }                serializer = ArticleSerializer(data=data)        self.assertTrue(serializer.is_valid())                article = serializer.save()        self.assertEqual(article.title, 'New Article')        self.assertEqual(article.author, self.author)        def test_validation_error(self):        """Test validation"""        data = {            'title': '',  # Empty title            'content': 'Content'        }                serializer = ArticleSerializer(data=data)        self.assertFalse(serializer.is_valid())        self.assertIn('title', serializer.errors)        def test_nested_serialization(self):        """Test nested objects"""        serializer = ArticleSerializer(self.article)                # Assuming author is nested        self.assertIn('author', serializer.data)        self.assertEqual(serializer.data['author']['name'], 'John Doe')        def test_read_only_fields(self):        """Test read-only fields can't be set"""        data = {            'title': 'Title',            'content': 'Content',            'created_at': '2024-01-01T00:00:00Z'  # read-only        }                serializer = ArticleSerializer(data=data)        self.assertTrue(serializer.is_valid())                # created_at should be ignored        article = serializer.save(author=self.author)        self.assertNotEqual(            article.created_at.isoformat(),            '2024-01-01T00:00:00Z'        )

Integration Tests

Test with views:

class ArticleAPITestCase(APITestCase):    def setUp(self):        self.user = User.objects.create_user(username='test', password='test123')        self.author = Author.objects.create(user=self.user, name='Test Author')        self.client.force_authenticate(user=self.user)        def test_create_article(self):        """Test creating article via API"""        data = {            'title': 'New Article',            'content': 'Article content here...',            'author': self.author.id        }                response = self.client.post('/api/articles/', data, format='json')                self.assertEqual(response.status_code, 201)        self.assertEqual(response.data['title'], 'New Article')        self.assertEqual(Article.objects.count(), 1)        def test_update_article(self):        """Test updating article via API"""        article = Article.objects.create(            title='Original',            content='Original content',            author=self.author        )                data = {'title': 'Updated Title'}                response = self.client.patch(            f'/api/articles/{article.id}/',            data,            format='json'        )                self.assertEqual(response.status_code, 200)        self.assertEqual(response.data['title'], 'Updated Title')                article.refresh_from_db()        self.assertEqual(article.title, 'Updated Title')        def test_nested_creation(self):        """Test creating with nested objects"""        data = {            'title': 'Article with Tags',            'content': 'Content',            'author': self.author.id,            'tags': [                {'name': 'Python'},                {'name': 'Django'}            ]        }                response = self.client.post('/api/articles/', data, format='json')                self.assertEqual(response.status_code, 201)                article = Article.objects.get(pk=response.data['id'])        self.assertEqual(article.tags.count(), 2)

Performance Tests

Test query counts:

from django.test.utils import override_settingsfrom django.test import TestCase class SerializerPerformanceTestCase(TestCase):    def setUp(self):        # Create test data        authors = [Author.objects.create(name=f'Author {i}') for i in range(10)]                for i in range(100):            article = Article.objects.create(                title=f'Article {i}',                content='Content',                author=authors[i % 10]            )        def test_list_query_count(self):        """Test N+1 queries are avoided"""        from django.test.utils import override_settings        from django.db import connection        from django.test.utils import CaptureQueriesContext                articles = Article.objects.all()                with CaptureQueriesContext(connection) as context:            serializer = ArticleSerializer(articles, many=True)            data = serializer.data                        # Should be constant queries regardless of number of articles            self.assertLessEqual(len(context.captured_queries), 5)

Tóm Tắt Bài 5.4

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

✅ Dynamic Field Selection:

Query parameter based fields
Context-based field selection
Include/exclude parameters
Expandable fields pattern

✅ Serializer Context:

What is context and how to use it
Accessing context in serializers
Context propagation to nested serializers
Custom context patterns (permissions, conditional fields, additional data)

✅ Serializer Inheritance:

Basic inheritance patterns
Abstract base serializers
Mixin pattern for reusable functionality
Overriding inherited fields

✅ Generic Serializers:

Polymorphic serializers for multiple types
Generic field serializers
Activity feed pattern
Handling dynamic content types

✅ Performance Optimization:

only() and defer() for columns
Selective field loading
Prefetch optimization
Cached properties
Batch processing
Pagination
Response caching
Lazy evaluation

✅ Real-World Patterns:

Versioned serializers
Localized serializers
Audit trail implementation
Soft delete handling
Bulk operations

✅ Testing:

Unit tests for serialization/deserialization
Validation testing
Integration tests with views
Performance tests for N+1 queries

Exercises

Exercise 1: Dynamic Fields API

Create flexible article API:

Support ?fields=id,title,author parameter
Support ?exclude=content,internal_notes parameter
Support ?expand=author,comments parameter
Allow combining all three parameters
Test with different combinations

Exercise 2: Multi-Version Serializers

Create versioned user API:

V1: Basic fields (id, username, email)
V2: Add profile fields (bio, avatar)
V3: Add stats (follower_count, post_count)

Requirements:

Single view supporting all versions
Use Accept header or query param for version
Ensure backward compatibility
Test all versions

Exercise 3: Performance Optimization

Given slow article list API:

class Article(models.Model):    title = models.CharField(max_length=200)    author = models.ForeignKey(User)    category = models.ForeignKey(Category)    tags = models.ManyToManyField(Tag)

Tasks:

Identify N+1 query problems
Optimize with select_related/prefetch_related
Add annotations for counts
Implement caching
Test: reduce queries from 200+ to < 10

Exercise 4: Bulk Operations Serializer

Create bulk article manager:

Support bulk create (array of articles)
Support bulk update (array of id + fields)
Support bulk delete (array of ids)
Add validation for max 100 items per request
Return success/failure for each item

Exercise 5: Advanced Context Pattern

Create context-aware serializer:

Different fields for owner vs others
Different fields for mobile vs web
Permission-based field visibility
Rate limiting info (remaining requests)
Include related objects based on query depth

Navigation:

← Bài 5.3: Nested Serializers & Relationships
Bài 5.4: Advanced Patterns & Performance (current)
Bài 6: Generic Views & ViewSets →

🎉 Congratulations! Bạn đã hoàn thành Bài 5 (Serializers Advanced) - một trong những bài học quan trọng nhất của Django REST Framework!

Next Steps:

Practice building complex serializers
Implement dynamic field selection in your projects
Optimize serializer performance
Write comprehensive tests
Study DRF source code for advanced patterns

Recommended Reading:

DRF Documentation: Serializers
"Two Scoops of Django" - Serializer patterns
DRF GitHub issues for advanced use cases

#advanced-patterns

Advanced Patterns & Performance - Phần 4