Django REST Framework 시리얼라이저 심층 분석: 유효성 검사, 중첩 및 N+1 문제

# serializers.py
from rest_framework import serializers
from .models import Article, Author, Tag

class AuthorSerializer(serializers.ModelSerializer):
    """Author model serializer with computed field"""
    full_name = serializers.SerializerMethodField()
    
    class Meta:
        model = Author
        fields = ['id', 'first_name', 'last_name', 'full_name', 'email', 'bio']
        read_only_fields = ['id']
    
    def get_full_name(self, obj):
        return f"{obj.first_name} {obj.last_name}"


class TagSerializer(serializers.ModelSerializer):
    class Meta:
        model = Tag
        fields = ['id', 'name', 'slug']

# serializers.py
from rest_framework import serializers
from rest_framework.validators import UniqueTogetherValidator
from django.utils import timezone
from .models import Article

class ArticleSerializer(serializers.ModelSerializer):
    """Article serializer with multi-level validation"""
    
    class Meta:
        model = Article
        fields = ['id', 'title', 'slug', 'content', 'author', 'tags', 
                  'published_at', 'status', 'view_count']
        read_only_fields = ['id', 'view_count', 'slug']
        validators = [
            UniqueTogetherValidator(
                queryset=Article.objects.all(),
                fields=['author', 'title'],
                message="This author already has an article with this title."
            )
        ]
    
    # Field-level validation
    def validate_title(self, value):
        """Ensure title meets requirements"""
        if len(value) < 10:
            raise serializers.ValidationError(
                "Title must be at least 10 characters long."
            )
        if value.isupper():
            raise serializers.ValidationError(
                "Title cannot be all uppercase."
            )
        return value
    
    def validate_published_at(self, value):
        """Prevent publishing in the past"""
        if value and value < timezone.now():
            raise serializers.ValidationError(
                "Publication date cannot be in the past."
            )
        return value
    
    # Object-level validation
    def validate(self, attrs):
        """Cross-field validation"""
        status = attrs.get('status')
        published_at = attrs.get('published_at')
        content = attrs.get('content', '')
        
        # Published articles must have publication date
        if status == 'published' and not published_at:
            raise serializers.ValidationError({
                'published_at': 'Publication date is required for published articles.'
            })
        
        # Published articles need minimum content length
        if status == 'published' and len(content) < 100:
            raise serializers.ValidationError({
                'content': 'Published articles must have at least 100 characters.'
            })
        
        return attrs

# serializers.py
from rest_framework import serializers
from .models import Article, Author, Tag, Comment

class CommentSerializer(serializers.ModelSerializer):
    author_name = serializers.CharField(source='author.username', read_only=True)
    
    class Meta:
        model = Comment
        fields = ['id', 'content', 'author_name', 'created_at']


class ArticleDetailSerializer(serializers.ModelSerializer):
    """Detailed article serializer with nested relations"""
    author = AuthorSerializer(read_only=True)
    tags = TagSerializer(many=True, read_only=True)
    comments = CommentSerializer(many=True, read_only=True)
    comment_count = serializers.IntegerField(read_only=True)
    
    # Write-only fields for creating/updating
    author_id = serializers.PrimaryKeyRelatedField(
        queryset=Author.objects.all(),
        source='author',
        write_only=True
    )
    tag_ids = serializers.PrimaryKeyRelatedField(
        queryset=Tag.objects.all(),
        source='tags',
        many=True,
        write_only=True
    )
    
    class Meta:
        model = Article
        fields = [
            'id', 'title', 'slug', 'content', 
            'author', 'author_id',
            'tags', 'tag_ids',
            'comments', 'comment_count',
            'published_at', 'status'
        ]
        read_only_fields = ['id', 'slug']

# serializers.py
from django.db import transaction
from rest_framework import serializers
from .models import Order, OrderItem, Product

class OrderItemSerializer(serializers.ModelSerializer):
    product_name = serializers.CharField(source='product.name', read_only=True)
    subtotal = serializers.DecimalField(
        max_digits=10, decimal_places=2, read_only=True
    )
    
    class Meta:
        model = OrderItem
        fields = ['id', 'product', 'product_name', 'quantity', 'price', 'subtotal']
        read_only_fields = ['id', 'price', 'subtotal']


class OrderSerializer(serializers.ModelSerializer):
    """Order serializer with writable nested items"""
    items = OrderItemSerializer(many=True)
    total_amount = serializers.DecimalField(
        max_digits=10, decimal_places=2, read_only=True
    )
    
    class Meta:
        model = Order
        fields = ['id', 'customer', 'items', 'total_amount', 
                  'status', 'created_at', 'updated_at']
        read_only_fields = ['id', 'total_amount', 'created_at', 'updated_at']
    
    def validate_items(self, value):
        """Ensure order has at least one item"""
        if not value:
            raise serializers.ValidationError(
                "Order must have at least one item."
            )
        return value
    
    @transaction.atomic
    def create(self, validated_data):
        """Create order with nested items"""
        items_data = validated_data.pop('items')
        order = Order.objects.create(**validated_data)
        
        for item_data in items_data:
            product = item_data['product']
            item_data['price'] = product.price  # Set current price
            OrderItem.objects.create(order=order, **item_data)
        
        return order
    
    @transaction.atomic
    def update(self, instance, validated_data):
        """Update order and replace items"""
        items_data = validated_data.pop('items', None)
        
        # Update order fields
        for attr, value in validated_data.items():
            setattr(instance, attr, value)
        instance.save()
        
        # Replace items if provided
        if items_data is not None:
            instance.items.all().delete()
            for item_data in items_data:
                product = item_data['product']
                item_data['price'] = product.price
                OrderItem.objects.create(order=instance, **item_data)
        
        return instance

# views.py - N+1 problem example
from rest_framework import generics
from .models import Article
from .serializers import ArticleDetailSerializer

# BAD: This causes N+1 queries
class ArticleListView(generics.ListAPIView):
    queryset = Article.objects.all()  # N+1 problem!
    serializer_class = ArticleDetailSerializer

# views.py - Optimized queries
from rest_framework import generics
from django.db.models import Count, Prefetch
from .models import Article, Comment
from .serializers import ArticleDetailSerializer

class ArticleListView(generics.ListAPIView):
    serializer_class = ArticleDetailSerializer
    
    def get_queryset(self):
        return Article.objects.select_related(
            'author'  # ForeignKey - single JOIN
        ).prefetch_related(
            'tags',  # ManyToMany - separate query
            Prefetch(
                'comments',
                queryset=Comment.objects.select_related('author')
                    .order_by('-created_at')[:5]  # Latest 5 comments
            )
        ).annotate(
            comment_count=Count('comments')  # Computed in DB
        ).order_by('-published_at')

# models.py
from django.db import models
from django.db.models import Count, Prefetch

class ArticleQuerySet(models.QuerySet):
    def with_relations(self):
        """Eager load common relations"""
        return self.select_related(
            'author'
        ).prefetch_related(
            'tags'
        )
    
    def with_comments(self, limit=5):
        """Include latest comments"""
        from .models import Comment
        return self.prefetch_related(
            Prefetch(
                'comments',
                queryset=Comment.objects.select_related('author')
                    .order_by('-created_at')[:limit]
            )
        )
    
    def with_stats(self):
        """Include computed statistics"""
        return self.annotate(
            comment_count=Count('comments', distinct=True),
            tag_count=Count('tags', distinct=True)
        )
    
    def published(self):
        """Filter to published articles only"""
        return self.filter(status='published')


class ArticleManager(models.Manager):
    def get_queryset(self):
        return ArticleQuerySet(self.model, using=self._db)
    
    def with_relations(self):
        return self.get_queryset().with_relations()
    
    def published_with_details(self):
        """Common query for public article list"""
        return self.get_queryset().published().with_relations().with_stats()


class Article(models.Model):
    # ... fields ...
    objects = ArticleManager()

# serializers.py
from rest_framework import serializers
from .models import Article

class ArticleListSerializer(serializers.ModelSerializer):
    """Lightweight serializer for list views"""
    author_name = serializers.CharField(source='author.full_name', read_only=True)
    tag_names = serializers.SlugRelatedField(
        many=True, read_only=True, slug_field='name', source='tags'
    )
    
    class Meta:
        model = Article
        fields = ['id', 'title', 'slug', 'author_name', 'tag_names', 
                  'published_at', 'comment_count']


class ArticleDetailSerializer(serializers.ModelSerializer):
    """Full serializer for detail views"""
    author = AuthorSerializer(read_only=True)
    tags = TagSerializer(many=True, read_only=True)
    comments = CommentSerializer(many=True, read_only=True)
    
    class Meta:
        model = Article
        fields = ['id', 'title', 'slug', 'content', 'author', 'tags',
                  'comments', 'published_at', 'status', 'view_count']

# serializers.py
class DynamicFieldsSerializer(serializers.ModelSerializer):
    """Base serializer with dynamic field selection"""
    
    def __init__(self, *args, **kwargs):
        fields = kwargs.pop('fields', None)
        exclude = kwargs.pop('exclude', None)
        
        super().__init__(*args, **kwargs)
        
        if fields is not None:
            allowed = set(fields)
            existing = set(self.fields)
            for field_name in existing - allowed:
                self.fields.pop(field_name)
        
        if exclude is not None:
            for field_name in exclude:
                self.fields.pop(field_name, None)


class ArticleSerializer(DynamicFieldsSerializer):
    author = AuthorSerializer(read_only=True)
    tags = TagSerializer(many=True, read_only=True)
    
    class Meta:
        model = Article
        fields = ['id', 'title', 'slug', 'content', 'author', 'tags',
                  'published_at', 'status']


# views.py - Usage
class ArticleViewSet(viewsets.ModelViewSet):
    serializer_class = ArticleSerializer
    
    def get_serializer(self, *args, **kwargs):
        # Allow ?fields=id,title,author query param
        fields_param = self.request.query_params.get('fields')
        if fields_param:
            kwargs['fields'] = fields_param.split(',')
        return super().get_serializer(*args, **kwargs)

# serializers.py - Production patterns
from rest_framework import serializers
from django.core.cache import cache
from .models import Article

class CachedAuthorSerializer(serializers.ModelSerializer):
    """Serializer with caching for expensive computations"""
    article_count = serializers.SerializerMethodField()
    
    class Meta:
        model = Author
        fields = ['id', 'full_name', 'email', 'article_count']
    
    def get_article_count(self, obj):
        cache_key = f'author_{obj.id}_article_count'
        count = cache.get(cache_key)
        if count is None:
            count = obj.articles.filter(status='published').count()
            cache.set(cache_key, count, timeout=3600)  # 1 hour
        return count