Django API接口开发：CBV与Functional View哪个更适合JsonResponse？

Hey there! As someone who’s built Django APIs from tiny one-off endpoints to large-scale systems, I totally get where you’re coming from. It’s easy to look at CBVs and think “that’s overkill for just returning JSON”—but let’s break down the core differences, use cases, and when each shines.

Core Differences Between CBVs and FBVs #

Let’s start with the key distinctions that matter most for API development:

1. HTTP Method Organization #

• FBVs: You’ll end up writing conditional checks for request.method (e.g., if request.method == 'GET', elif request.method == 'POST'). For simple endpoints this is fine, but as you add more methods (PUT, DELETE), the function can quickly turn into a messy block of conditionals.
• CBVs: You define separate methods for each HTTP verb (get(), post(), put()), which keeps logic clean and compartmentalized. No more scrolling through a giant function to find the POST handling code.

2. Code Reusability #

• FBVs: Reusing logic (like authentication, permission checks, or response formatting) means copying decorators or code snippets across multiple functions. This violates the DRY (Don’t Repeat Yourself) principle.
• CBVs: Use mixins and inheritance to reuse code. For example, if 10 of your APIs need login authentication, you can create a LoginRequiredMixin once and have all those views inherit it. Django’s built-in APIView (from Django REST Framework, or even the core View class) already handles boilerplate like method validation.

3. Scalability & Maintainability #

• FBVs: Great for small, single-purpose endpoints, but as your API grows, adding new features (like pagination, filtering, or error handling) requires rewriting parts of the function.
• CBVs: Built for scalability. If you later decide to add pagination to a list endpoint, you can just inherit PaginationMixin instead of rewriting pagination logic from scratch. Each component (authentication, validation, response) is a separate part of the class, making changes easier.

4. Learning Curve #

• FBVs: Perfect for beginners—they’re straightforward, just like any Python function. You can get a JSON response up and running in minutes.
• CBVs: Have a steeper initial learning curve. You’ll need to understand class inheritance, Django’s view lifecycle, and mixins. But once you grasp the pattern, it speeds up development for anything beyond trivial APIs.

When to Use Which? #

Go with FBV if: #

• You’re building a super simple, single-method endpoint (e.g., a static JSON status check).
• You’re still getting comfortable with Django and want to avoid the complexity of classes/inheritance.
• The endpoint is a one-off and won’t need future expansion or reuse.

Go with CBV if: #

• Your endpoint needs to handle multiple HTTP methods (e.g., GET to fetch data, POST to create it).
• You plan to reuse logic (authentication, permissions, response formatting) across multiple views.
• You’re building standard CRUD operations—Django’s generic CBVs (like ListAPIView, RetrieveUpdateDestroyAPIView) cut down on boilerplate drastically.
• You anticipate expanding the endpoint later (adding filtering, pagination, etc.).

Example Comparison #

Let’s look at a simple JSON endpoint in both styles to see the difference:

FBV Version #

from django.http import JsonResponse
from django.contrib.auth.decorators import login_required

@login_required
def user_profile(request):
    if request.method == 'GET':
        data = {
            'username': request.user.username,
            'email': request.user.email
        }
        return JsonResponse(data)
    elif request.method == 'PUT':
        # Handle update logic
        request.user.email = request.POST.get('email')
        request.user.save()
        return JsonResponse({'status': 'updated'}, status=200)
    else:
        return JsonResponse({'error': 'Method not allowed'}, status=405)

CBV Version #

from django.http import JsonResponse
from django.views import View
from django.contrib.auth.mixins import LoginRequiredMixin

class UserProfileView(LoginRequiredMixin, View):
    def get(self, request):
        data = {
            'username': request.user.username,
            'email': request.user.email
        }
        return JsonResponse(data)
    
    def put(self, request):
        request.user.email = request.POST.get('email')
        request.user.save()
        return JsonResponse({'status': 'updated'}, status=200)
    
    def http_method_not_allowed(self, request, *args, **kwargs):
        return JsonResponse({'error': 'Method not allowed'}, status=405)

Notice how the CBV separates each method’s logic, and adding authentication is as simple as inheriting LoginRequiredMixin (no need for decorators on every view).

Final Verdict #

There’s no absolute “better” choice—it depends on your use case. If you’re just starting out, FBVs are a great way to get comfortable with Django’s request/response cycle. But as you build more APIs, CBVs will save you time, reduce code duplication, and make your codebase easier to maintain.

Don’t dismiss CBVs as “overkill” for JSON responses—even simple CBVs lay the groundwork for future expansion, and once you’re familiar with them, they’ll feel just as intuitive as FBVs.

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