在Django Rest Framework中执行CRUD操作的正确位置该如何选择？

Hey there! Let me break this down based on how I've worked with DRF over the years—this is such a common question when you're getting started, so don't feel stuck on it!

优先用Serializer处理CRUD的场景 #

When your logic is directly tied to the model instance's creation/update or data validation, serializers are the right place. They're designed to handle the translation between request data and model instances, so keeping model-related logic here keeps your code reusable and focused.

For example, if you need to auto-populate a field (like setting the current user as the author of a post) whenever an instance is created:

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

class PostSerializer(serializers.ModelSerializer):
    class Meta:
        model = Post
        fields = ["title", "content"]

    def create(self, validated_data):
        # Pull the user from the request context (passed by the view)
        validated_data["author"] = self.context["request"].user
        return super().create(validated_data)

This logic will work across any view that uses this serializer—whether it's a plain APIView or a ModelViewSet—so you don't have to repeat it in multiple places.

优先用View处理CRUD的场景 #

When your logic is tied to request context, business workflows, or one-off actions, keep it in the view. Views handle the request/response cycle, so they're the right spot for things that don't belong to the model instance itself.

Say you need to send a confirmation email right after an order is created—this is a business workflow step, not part of the order model's core creation logic:

# views.py
from rest_framework import viewsets
from .models import Order
from .serializers import OrderSerializer
from django.core.mail import send_mail

class OrderViewSet(viewsets.ModelViewSet):
    queryset = Order.objects.all()
    serializer_class = OrderSerializer

    def create(self, request, *args, **kwargs):
        # Let the serializer handle creating the order instance
        response = super().create(request, *args, **kwargs)
        # Add the business logic: send confirmation email
        send_mail(
            "Your Order Is Confirmed!",
            f"Order ID: {response.data['id']} has been processed.",
            "no-reply@yourapp.com",
            [request.user.email],
            fail_silently=False,
        )
        return response

This keeps your serializer clean (focused only on the order data) and your view responsible for the full workflow.

Quick Rule of Thumb #

• Single Responsibility Principle: Serializers manage data validation and model instance operations; Views manage request handling and business workflows.
• If the logic needs to be reused across multiple views → put it in the serializer.
• If the logic depends on request-specific data (like user permissions, query params) or triggers external actions (emails, webhooks) → put it in the view.

The docs you looked at ("saving instances" for serializers, "viewset actions" for views) are pointing you exactly to this split—serializers handle the instance saving logic, while views let you hook into the action lifecycle for workflow stuff.

内容的提问来源于stack exchange，提问作者Salad.Guyo