Какие плюсы и минусы Django REST?

Django REST Framework — плюсы и минусы

Django REST Framework (DRF) — это мощная и популярная библиотека для создания REST API на Django. Я использовал её в нескольких production проектах и знаю как сильные, так и слабые стороны.

Плюсы Django REST Framework

1. Встроенная сериализация

Отличная поддержка преобразования моделей Django в JSON и обратно:

from rest_framework import serializers
from django.contrib.auth.models import User

class UserSerializer(serializers.ModelSerializer):
    class Meta:
        model = User
        fields = ['id', 'username', 'email', 'first_name', 'last_name']
        read_only_fields = ['id']
    
    def validate_email(self, value):
        """Кастомная валидация email."""
        if User.objects.filter(email=value).exists():
            raise serializers.ValidationError("Email уже используется.")
        return value

# Автоматическая сериализация
user = User.objects.get(id=1)
serializer = UserSerializer(user)
print(serializer.data)  # {'id': 1, 'username': 'john', 'email': 'john@example.com', ...}

2. Встроенная аутентификация и права доступа

from rest_framework import permissions
from rest_framework.views import APIView

class IsOwner(permissions.BasePermission):
    """Только владелец может редактировать."""
    def has_object_permission(self, request, view, obj):
        return obj.owner == request.user

class UserDetailView(APIView):
    permission_classes = [permissions.IsAuthenticated, IsOwner]
    
    def get(self, request, pk):
        user = User.objects.get(id=pk)
        serializer = UserSerializer(user)
        return Response(serializer.data)
    
    def put(self, request, pk):
        user = User.objects.get(id=pk)
        self.check_object_permissions(request, user)
        serializer = UserSerializer(user, data=request.data, partial=True)
        if serializer.is_valid():
            serializer.save()
            return Response(serializer.data)
        return Response(serializer.errors, status=400)

3. ViewSets и Роутеры

Автоматическое генерирование CRUD операций:

from rest_framework import viewsets
from rest_framework.routers import DefaultRouter

class UserViewSet(viewsets.ModelViewSet):
    queryset = User.objects.all()
    serializer_class = UserSerializer
    permission_classes = [permissions.IsAuthenticated]
    
    def get_queryset(self):
        """Фильтрация по текущему пользователю."""
        return self.queryset.filter(owner=self.request.user)

# Автоматические маршруты
router = DefaultRouter()
router.register(r'users', UserViewSet)

urlpatterns = [
    path('api/', include(router.urls)),
]

# Генерирует:
# GET    /api/users/          — list
# POST   /api/users/          — create
# GET    /api/users/{id}/     — retrieve
# PUT    /api/users/{id}/     — update
# PATCH  /api/users/{id}/     — partial_update
# DELETE /api/users/{id}/     — destroy

4. Встроенная документация и автоматический API

from rest_framework.decorators import api_view, permission_classes
from rest_framework.response import Response

@api_view(['GET', 'POST'])
@permission_classes([permissions.IsAuthenticated])
def user_list(request):
    """
    GET: Получить список пользователей
    POST: Создать нового пользователя
    """
    if request.method == 'GET':
        users = User.objects.all()
        serializer = UserSerializer(users, many=True)
        return Response(serializer.data)
    
    elif request.method == 'POST':
        serializer = UserSerializer(data=request.data)
        if serializer.is_valid():
            serializer.save()
            return Response(serializer.data, status=201)
        return Response(serializer.errors, status=400)

5. Гибкая фильтрация и пагинация

from rest_framework import filters
from django_filters.rest_framework import DjangoFilterBackend

class UserViewSet(viewsets.ModelViewSet):
    queryset = User.objects.all()
    serializer_class = UserSerializer
    filter_backends = [DjangoFilterBackend, filters.SearchFilter, filters.OrderingFilter]
    filterset_fields = ['is_active', 'date_joined']
    search_fields = ['username', 'email']
    ordering_fields = ['date_joined', 'username']
    ordering = ['-date_joined']
    pagination_class = PageNumberPagination

# Использование:
# GET /api/users/?is_active=true&search=john&ordering=-date_joined

6. Встроенное тестирование

from rest_framework.test import APITestCase, APIClient

class UserAPITestCase(APITestCase):
    def setUp(self):
        self.client = APIClient()
        self.user = User.objects.create_user(
            username='testuser',
            email='test@example.com',
            password='testpass123'
        )
    
    def test_list_users(self):
        response = self.client.get('/api/users/')
        self.assertEqual(response.status_code, 200)
        self.assertIsInstance(response.data, list)
    
    def test_create_user_authenticated(self):
        self.client.force_authenticate(user=self.user)
        response = self.client.post('/api/users/', {
            'username': 'newuser',
            'email': 'new@example.com',
            'password': 'pass123'
        })
        self.assertEqual(response.status_code, 201)

Минусы Django REST Framework

1. Избыточность для простых проектов

Для простого API может быть слишком много кода:

# FastAPI — минималистичнее
from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

class User(BaseModel):
    username: str
    email: str

@app.get("/users")
async def list_users():
    return [{"username": "john", "email": "john@example.com"}]

@app.post("/users")
async def create_user(user: User):
    return user

# DRF требует больше бойлерплейта

2. Производительность

DRF добавляет overhead слоев абстракции:

# DRF медленнее чем raw Django queries
# Причины:
# - Множественные слои (View → Serializer → QuerySet)
# - Автоматическое форматирование ошибок
# - Проверки прав доступа на каждый запрос

# Для высоконагруженных систем лучше использовать:
# - raw SQL queries
# - кеширование
# - асинхронные фреймворки (FastAPI, Starlette)

3. Сложность множественного наследования

# Сложные иерархии ViewSet'ов
class CreateListMixin:
    def list(self, request):
        pass
    def create(self, request):
        pass

class RetrieveUpdateDestroyMixin:
    def retrieve(self, request, pk):
        pass
    def update(self, request, pk):
        pass
    def destroy(self, request, pk):
        pass

class UserViewSet(
    CreateListMixin,
    RetrieveUpdateDestroyMixin,
    viewsets.GenericViewSet
):
    # Сложно отследить поведение
    pass

4. Излишняя магия

# Много неявного поведения
class UserSerializer(serializers.ModelSerializer):
    class Meta:
        model = User
        fields = '__all__'  # Что войдет сюда? Магия!

# Сложно понять what goes in and what comes out

5. Проблемы с версионированием API

# DRF версионирование добавляет сложность
from rest_framework.versioning import AcceptHeaderVersioning

class UserViewSet(viewsets.ModelViewSet):
    versioning_class = AcceptHeaderVersioning
    
    def get_serializer_class(self):
        if self.request.version == '1.0':
            return UserSerializerV1
        return UserSerializerV2

# Требует отслеживания множественных версий

6. Слабая поддержка асинхронности

# Django долго не поддерживал async
# DRF async поддержка пришла не сразу
# FastAPI лучше для асинхронного кода

from fastapi import FastAPI

app = FastAPI()

@app.get("/users")
async def get_users():  # Native async
    return await db.fetch_users()

7. Над-инжиниринг для CRUD операций

# Для простого CRUD много кода
class UserViewSet(viewsets.ModelViewSet):
    queryset = User.objects.all()
    serializer_class = UserSerializer
    permission_classes = [permissions.IsAuthenticated]
    filter_backends = [filters.SearchFilter]
    search_fields = ['username']
    pagination_class = PageNumberPagination
    # ... еще код

# Можно было бы сделать проще

Когда использовать Django REST Framework

✅ Используй DRF когда:

• Есть сложная бизнес-логика
• Нужна встроенная аутентификация
• Требуется версионирование API
• Есть сложные права доступа
• Нужна документация
• Интегрируешь существующий Django проект

❌ Не используй DRF когда:

• Нужна максимальная производительность
• Асинхронность — критична
• Простой CRUD без сложной логики
• Новый greenfield проект (рассмотри FastAPI)
• Микросервис, который не нужна вся мощь Django

Альтернативы

# FastAPI — более современный выбор
from fastapi import FastAPI, Depends

app = FastAPI()

@app.get("/users/{user_id}")
async def get_user(user_id: int):
    return {"id": user_id, "name": "John"}

# Graphene — для GraphQL
# Tortoise ORM + REST — альтернатива

Вывод: Django REST Framework — это промышленный стандарт для REST API на Django с отличной документацией, но добавляет overhead и может быть избыточным для простых случаев. Для новых проектов с требованиями к производительности и асинхронности рассмотри FastAPI.