是否可弃用Django原生Form改用DRF Serializer兼顾表单与API？

Absolutely! You can fully ditch Django's native Form class and use DRF's Serializer to handle both traditional web form submissions and API requests. This approach eliminates duplicate validation logic, centralizes your data handling, and leverages DRF's flexible features for both use cases. Here's how to make it work:

1. Centralize Validation & Logic in a Single Serializer #

Your serializer will hold all your validation rules, field definitions, and data processing logic—just like a Form, but with more flexibility for API use.

Example serializer:

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

class UserProfileSerializer(serializers.Serializer):
    email = serializers.EmailField(required=True)
    username = serializers.CharField(max_length=150, required=True)
    password = serializers.CharField(min_length=8, write_only=True)

    # Custom field-level validation (same as Form's clean_<field> methods)
    def validate_username(self, value):
        if User.objects.filter(username=value).exists():
            raise serializers.ValidationError("This username is already taken.")
        return value

    # Handle object creation/replacement (similar to Form's save() method)
    def create(self, validated_data):
        return User.objects.create_user(**validated_data)

2. Use the Serializer for Both Web Forms and APIs #

For Traditional Web Forms #

In your Django view, parse the form data using DRF's parsers, validate it with the serializer, and handle errors just like you would with a Form:

from django.shortcuts import render, redirect
from rest_framework.parsers import FormParser

def profile_create_view(request):
    if request.method == 'POST':
        # Parse form data using DRF's FormParser
        parser = FormParser()
        form_data = parser.parse(request)
        
        # Validate with your serializer
        serializer = UserProfileSerializer(data=form_data)
        if serializer.is_valid():
            serializer.save()
            return redirect('profile-success')
        
        # Pass errors to your template (works just like Form.errors)
        return render(request, 'profile_create.html', {'errors': serializer.errors})
    
    return render(request, 'profile_create.html')

In your template, display errors just as you would with a Form:

{% if errors %}
    <div class="alert alert-danger">
        {% for field, messages in errors.items %}
            <p><strong>{{ field|title }}:</strong> {{ messages|join:", " }}</p>
        {% endfor %}
    </div>
{% endif %}

<form method="POST">
    {% csrf_token %}
    <div>
        <label for="username">Username:</label>
        <input type="text" id="username" name="username" required>
    </div>
    <!-- Add other fields similarly -->
    <button type="submit">Create Profile</button>
</form>

For API Requests #

Use DRF's standard views (like APIView, GenericAPIView, or viewsets) with the same serializer:

from rest_framework.views import APIView
from rest_framework.response import Response
from rest_framework import status

class UserProfileAPIView(APIView):
    def post(self, request):
        serializer = UserProfileSerializer(data=request.data)
        if serializer.is_valid():
            serializer.save()
            return Response(serializer.data, status=status.HTTP_201_CREATED)
        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)

3. Handle Edge Cases #

• File Uploads: Use DRF's FileField/ImageField and the MultiPartParser in your form view to handle file submissions, just like you would for API multipart requests.
• CSRF Protection: Keep Django's CSRF middleware enabled for your web form views (DRF automatically exempts API views from CSRF checks, which is fine).
• Form Rendering: If you want to avoid manually writing HTML form fields, you can use packages like django-rest-framework-forms to generate form markup from your serializer, but manual rendering is straightforward for most use cases.

Final Thoughts #

This pattern keeps your validation logic centralized, reduces code duplication, and lets you take advantage of DRF's advanced features (like nested serializers, dynamic fields, and serialization for responses) across both your web and API layers. It's a clean, maintainable solution that works great for projects with both form and API requirements.

内容的提问来源于stack exchange，提问作者Santhosh