Как обработать Many-to-Many поля в сериалайзерах Django REST Framework?

Many-to-Many в Django REST Framework сериалайзерах

Many-to-Many (M2M) отношения требуют специальной обработки в DRF сериалайзерах.

1. Модели с Many-to-Many

from django.db import models

class Author(models.Model):
    name = models.CharField(max_length=100)
    
    def __str__(self):
        return self.name

class Book(models.Model):
    title = models.CharField(max_length=200)
    description = models.TextField()
    authors = models.ManyToManyField(Author, related_name='books')
    published_date = models.DateField()
    
    def __str__(self):
        return self.title

2. Базовый сериалайзер для M2M

from rest_framework import serializers
from .models import Book, Author

class AuthorSerializer(serializers.ModelSerializer):
    class Meta:
        model = Author
        fields = ['id', 'name']

class BookSerializer(serializers.ModelSerializer):
    # Способ 1: Читать только (вложенная сериализация)
    authors = AuthorSerializer(many=True, read_only=True)
    
    class Meta:
        model = Book
        fields = ['id', 'title', 'description', 'authors', 'published_date']

3. Запись M2M полей (write_only)

class BookSerializer(serializers.ModelSerializer):
    # Для чтения — вложенный объект
    authors = AuthorSerializer(many=True, read_only=True)
    # Для записи — только ID
    author_ids = serializers.PrimaryKeyRelatedField(
        queryset=Author.objects.all(),
        many=True,
        write_only=True,
        source='authors'  # Соответствует полю authors в модели
    )
    
    class Meta:
        model = Book
        fields = ['id', 'title', 'description', 'authors', 'author_ids', 'published_date']

# Использование
data = {
    'title': 'Python Guide',
    'description': 'Learning Python',
    'author_ids': [1, 2, 3],  # Отправляем ID авторов
    'published_date': '2023-01-15'
}
serializer = BookSerializer(data=data)
if serializer.is_valid():
    book = serializer.save()
    print(book.authors.all())  # Авторы установлены

4. Разные представления для чтения и записи

class BookDetailSerializer(serializers.ModelSerializer):
    """Детальное представление с полной информацией об авторах"""
    authors = AuthorSerializer(many=True, read_only=True)
    
    class Meta:
        model = Book
        fields = ['id', 'title', 'description', 'authors', 'published_date']

class BookCreateUpdateSerializer(serializers.ModelSerializer):
    """Для создания и обновления — только ID авторов"""
    author_ids = serializers.PrimaryKeyRelatedField(
        queryset=Author.objects.all(),
        many=True,
        write_only=True,
        source='authors'
    )
    
    class Meta:
        model = Book
        fields = ['title', 'description', 'author_ids', 'published_date']

class BookViewSet(viewsets.ModelViewSet):
    queryset = Book.objects.all()
    
    def get_serializer_class(self):
        if self.action in ['create', 'update', 'partial_update']:
            return BookCreateUpdateSerializer
        return BookDetailSerializer

5. Кастомная обработка в create/update

class BookSerializer(serializers.ModelSerializer):
    authors = AuthorSerializer(many=True, read_only=True)
    author_ids = serializers.PrimaryKeyRelatedField(
        queryset=Author.objects.all(),
        many=True,
        write_only=True,
        required=False
    )
    
    class Meta:
        model = Book
        fields = ['id', 'title', 'description', 'authors', 'author_ids', 'published_date']
    
    def create(self, validated_data):
        authors = validated_data.pop('author_ids', [])
        book = Book.objects.create(**validated_data)
        if authors:
            book.authors.set(authors)  # Установить авторов
        return book
    
    def update(self, instance, validated_data):
        authors = validated_data.pop('author_ids', None)
        
        # Обновить основные поля
        for attr, value in validated_data.items():
            setattr(instance, attr, value)
        instance.save()
        
        # Обновить авторов, если переданы
        if authors is not None:
            instance.authors.set(authors)
        
        return instance

6. SlugRelatedField для M2M

class BookSerializer(serializers.ModelSerializer):
    # Читать/писать по slug вместо ID
    authors = serializers.SlugRelatedField(
        slug_field='name',
        many=True,
        queryset=Author.objects.all()
    )
    
    class Meta:
        model = Book
        fields = ['id', 'title', 'authors', 'published_date']

# Использование
data = {
    'title': 'Python Guide',
    'authors': ['John Doe', 'Jane Smith'],  # Используем имена
    'published_date': '2023-01-15'
}

7. Подробная сериализация с доступом к методам

class AuthorDetailSerializer(serializers.ModelSerializer):
    book_count = serializers.SerializerMethodField()
    
    class Meta:
        model = Author
        fields = ['id', 'name', 'book_count']
    
    def get_book_count(self, obj):
        return obj.books.count()

class BookDetailSerializer(serializers.ModelSerializer):
    authors = AuthorDetailSerializer(many=True, read_only=True)
    
    class Meta:
        model = Book
        fields = ['id', 'title', 'description', 'authors', 'published_date']

# Результат:
# {
#   "id": 1,
#   "title": "Python Guide",
#   "description": "...",
#   "authors": [
#     {"id": 1, "name": "John Doe", "book_count": 5},
#     {"id": 2, "name": "Jane Smith", "book_count": 3}
#   ]
# }

8. Оптимизация запросов (prefetch_related)

class BookViewSet(viewsets.ModelViewSet):
    def get_queryset(self):
        # Без оптимизации — N+1 проблема
        # queryset = Book.objects.all()
        
        # С оптимизацией
        queryset = Book.objects.prefetch_related('authors')
        
        if self.action == 'retrieve':
            queryset = queryset.prefetch_related(
                Prefetch(
                    'authors',
                    queryset=Author.objects.all().order_by('name')
                )
            )
        
        return queryset
    
    serializer_class = BookDetailSerializer

9. Валидация M2M полей

class BookSerializer(serializers.ModelSerializer):
    author_ids = serializers.PrimaryKeyRelatedField(
        queryset=Author.objects.all(),
        many=True,
        write_only=True,
        required=True
    )
    
    class Meta:
        model = Book
        fields = ['title', 'description', 'author_ids', 'published_date']
    
    def validate_author_ids(self, value):
        """Валидировать авторов"""
        if not value:
            raise serializers.ValidationError(
                "Книга должна иметь хотя бы одного автора."
            )
        
        if len(value) > 10:
            raise serializers.ValidationError(
                "Максимум 10 авторов на книгу."
            )
        
        return value

10. Работа с промежуточной моделью

class BookAuthor(models.Model):
    """Промежуточная таблица с дополнительными полями"""
    book = models.ForeignKey(Book, on_delete=models.CASCADE)
    author = models.ForeignKey(Author, on_delete=models.CASCADE)
    order = models.IntegerField()  # Порядок авторов
    role = models.CharField(max_length=50)  # главный автор, соавтор и т.д.

class Book(models.Model):
    title = models.CharField(max_length=200)
    authors = models.ManyToManyField(Author, through=BookAuthor)

class BookAuthorSerializer(serializers.ModelSerializer):
    author = AuthorSerializer(read_only=True)
    author_id = serializers.IntegerField(write_only=True)
    
    class Meta:
        model = BookAuthor
        fields = ['author', 'author_id', 'order', 'role']

class BookDetailSerializer(serializers.ModelSerializer):
    authors = BookAuthorSerializer(
        source='bookauthor_set',
        many=True,
        read_only=True
    )
    
    class Meta:
        model = Book
        fields = ['id', 'title', 'authors']

Ключевые моменты

• read_only=True — используй вложенную сериализацию
• write_only=True — принимай ID или slug для записи
• source='field_name' — соответствие с моделью
• set() vs add() — set() заменяет все, add() добавляет
• prefetch_related — оптимизация N+1 запросов
• through модели — для дополнительных данных в M2M связи
• Валидация — проверь бизнес-логику в validate_*

Праильная обработка M2M полей обеспечивает чистый, эффективный API.