类视图（Class-Based Views，简称 CBV）是 Django 中构建视图的一种强大且灵活的方式。相比于函数视图（Function-Based Views，FBV），类视图提供了更好的可复用性和可扩展性，尤其在处理复杂逻辑和大型项目时尤为有用。本文将详细讲解 Django 中的类视图，包括内置类视图、自定义类视图的设计，以及如何在 Django REST framework 中使用类视图。

1. 类视图简介

1.1 函数视图 vs 类视图

函数视图（FBV） 是 Django 中最基本的视图类型，通过定义一个函数来处理请求并返回响应。例如：

# myapp/views.py
from django.http import HttpResponsedef hello_world(request):return HttpResponse("Hello, World!")

类视图（CBV） 则使用类来定义视图，通过继承 Django 提供的基类，实现不同的 HTTP 方法（如 GET、POST 等）。例如：

# myapp/views.py
from django.views import View
from django.http import HttpResponseclass HelloWorldView(View):def get(self, request):return HttpResponse("Hello, World!")

1.2 优势

• 可复用性：通过继承和组合，可以轻松复用代码。
• 组织性：将相关逻辑封装在一个类中，使代码结构更清晰。
• 扩展性：便于添加新的功能或修改现有功能。
• 内置功能丰富：Django 提供了许多内置的通用类视图，简化常见任务。

2. Django 内置类视图

Django 提供了许多内置的类视图，涵盖了常见的操作，如展示模板、处理表单、执行 CRUD 操作等。以下是一些常用的内置类视图及其用法。

2.1 基础类视图

2.1.1 View

django.views.View 是所有类视图的基类。它提供了处理不同 HTTP 方法的基本结构。

# myapp/views.py
from django.views import View
from django.http import HttpResponseclass MyView(View):def get(self, request):return HttpResponse('GET 请求')def post(self, request):return HttpResponse('POST 请求')

2.1.2 TemplateView

用于渲染模板并返回响应，适用于简单的页面展示。

# myapp/views.py
from django.views.generic import TemplateViewclass HomePageView(TemplateView):template_name = 'home.html'

# myapp/urls.py
from django.urls import path
from .views import HomePageViewurlpatterns = [path('', HomePageView.as_view(), name='home'),
]

2.1.3 RedirectView

用于重定向到其他 URL。

# myapp/views.py
from django.views.generic import RedirectViewclass OldHomePageRedirect(RedirectView):url = '/new-home/'

# myapp/urls.py
from django.urls import path
from .views import OldHomePageRedirecturlpatterns = [path('old-home/', OldHomePageRedirect.as_view(), name='old_home'),
]

2.2 通用类视图（Generic Views）

通用类视图提供了更高级别的抽象，适用于常见的数据库操作，如显示列表、创建、更新和删除对象。

2.2.1 ListView

显示对象的列表。

# myapp/views.py
from django.views.generic import ListView
from .models import Postclass PostListView(ListView):model = Posttemplate_name = 'post_list.html'context_object_name = 'posts'ordering = ['-created_at']

2.2.2 DetailView

显示单个对象的详细信息。

# myapp/views.py
from django.views.generic import DetailView
from .models import Postclass PostDetailView(DetailView):model = Posttemplate_name = 'post_detail.html'

2.2.3 CreateView

创建新对象的表单视图。

# myapp/views.py
from django.views.generic import CreateView
from .models import Post
from django.urls import reverse_lazyclass PostCreateView(CreateView):model = Postfields = ['title', 'content']template_name = 'post_form.html'success_url = reverse_lazy('post_list')

2.2.4 UpdateView

更新现有对象的表单视图。

# myapp/views.py
from django.views.generic import UpdateView
from .models import Post
from django.urls import reverse_lazyclass PostUpdateView(UpdateView):model = Postfields = ['title', 'content']template_name = 'post_form.html'success_url = reverse_lazy('post_list')

2.2.5 DeleteView

删除对象的确认视图。

# myapp/views.py
from django.views.generic import DeleteView
from .models import Post
from django.urls import reverse_lazyclass PostDeleteView(DeleteView):model = Posttemplate_name = 'post_confirm_delete.html'success_url = reverse_lazy('post_list')

2.3 组合使用通用视图

可以通过组合多个通用视图，快速实现复杂的功能。例如，使用 ListView 和 DetailView 实现一个博客的文章列表和详细页面。

# myapp/views.py
from django.views.generic import ListView, DetailView
from .models import Postclass PostListView(ListView):model = Posttemplate_name = 'post_list.html'context_object_name = 'posts'ordering = ['-created_at']class PostDetailView(DetailView):model = Posttemplate_name = 'post_detail.html'

# myapp/urls.py
from django.urls import path
from .views import PostListView, PostDetailViewurlpatterns = [path('', PostListView.as_view(), name='post_list'),path('post/<int:pk>/', PostDetailView.as_view(), name='post_detail'),
]

3. 自定义类视图

虽然 Django 提供了许多内置类视图，但在实际开发中，往往需要根据具体需求自定义类视图。下面介绍如何设计和实现自定义类视图。

3.1 设计思路

1. 继承自适当的基类：根据需要继承自 View、TemplateView、ListView 等。
2. 定义必要的方法：如 get、post 等，或者使用类视图提供的钩子方法（如 get_context_data）。
3. 封装通用逻辑：通过方法的重写或添加辅助方法，封装通用逻辑，提高代码复用性。

3.2 示例：自定义搜索视图

假设我们希望在 PostListView 中添加搜索功能，根据标题关键字过滤文章。

# myapp/views.py
from django.views.generic import ListView
from .models import Post
from django.db.models import Qclass PostListView(ListView):model = Posttemplate_name = 'post_list.html'context_object_name = 'posts'ordering = ['-created_at']paginate_by = 10def get_queryset(self):queryset = super().get_queryset()query = self.request.GET.get('q')if query:queryset = queryset.filter(Q(title__icontains=query) | Q(content__icontains=query))return querysetdef get_context_data(self, **kwargs):context = super().get_context_data(**kwargs)context['q'] = self.request.GET.get('q', '')return context

<!-- templates/post_list.html -->
<form method="get"><input type="text" name="q" placeholder="搜索..." value="{{ q }}"><button type="submit">搜索</button>
</form><ul>{% for post in posts %}<li><a href="{% url 'post_detail' post.pk %}">{{ post.title }}</a></li>{% endfor %}
</ul>{% if is_paginated %}<div>{% if page_obj.has_previous %}<a href="?q={{ q }}&page={{ page_obj.previous_page_number }}">上一页</a>{% endif %}<span>第 {{ page_obj.number }} 页，共 {{ page_obj.paginator.num_pages }} 页</span>{% if page_obj.has_next %}<a href="?q={{ q }}&page={{ page_obj.next_page_number }}">下一页</a>{% endif %}</div>
{% endif %}

3.3 使用 Mixins 增强类视图

Mixin 是一种通过多继承来复用代码的设计模式。在 Django 类视图中，Mixins 可以用来添加额外的功能，而不需要修改现有的视图类。

示例：添加登录验证

假设我们希望某些视图只能由登录用户访问，可以创建一个 Mixin 来实现这一功能。

# myapp/mixins.py
from django.contrib.auth.mixins import LoginRequiredMixin# Django 已经提供了 LoginRequiredMixin，无需自定义
# 如果需要自定义，可以这样做：from django.contrib.auth.decorators import login_required
from django.utils.decorators import method_decoratorclass CustomLoginRequiredMixin:@method_decorator(login_required)def dispatch(self, *args, **kwargs):return super().dispatch(*args, **kwargs)

然后在视图中使用该 Mixin：

# myapp/views.py
from django.views.generic import ListView
from .models import Post
from .mixins import CustomLoginRequiredMixin  # 如果使用自定义的 Mixin
from django.contrib.auth.mixins import LoginRequiredMixin  # 推荐使用 Django 内置的class ProtectedPostListView(LoginRequiredMixin, ListView):model = Posttemplate_name = 'protected_post_list.html'context_object_name = 'posts'login_url = '/login/'

3.4 自定义表单处理

假设我们需要一个自定义的表单视图，不仅处理表单提交，还需要在表单验证失败时执行特定逻辑。

# myapp/forms.py
from django import forms
from .models import Postclass PostForm(forms.ModelForm):class Meta:model = Postfields = ['title', 'content']

# myapp/views.py
from django.views.generic import View
from django.shortcuts import render, redirect
from .forms import PostFormclass CustomPostCreateView(View):form_class = PostFormtemplate_name = 'post_form.html'def get(self, request):form = self.form_class()return render(request, self.template_name, {'form': form})def post(self, request):form = self.form_class(request.POST)if form.is_valid():form.save()return redirect('post_list')else:# 自定义处理逻辑，例如记录错误日志return render(request, self.template_name, {'form': form})

4. 类视图在 Django REST framework 中的应用

Django REST framework（DRF）同样广泛使用类视图，提供了更高层次的抽象，简化 API 的开发。下面介绍 DRF 中常用的类视图及其使用方法。

4.1 基础类视图

4.1.1 APIView

APIView 是 DRF 中所有类视图的基类，类似于 Django 的 View。它提供了对 HTTP 方法的支持，并集成了 DRF 的功能，如认证、权限、序列化等。

# myapp/api_views.py
from rest_framework.views import APIView
from rest_framework.response import Response
from rest_framework import statusclass HelloWorldAPIView(APIView):def get(self, request):return Response({"message": "Hello, World!"}, status=status.HTTP_200_OK)def post(self, request):data = request.datareturn Response({"received_data": data}, status=status.HTTP_201_CREATED)

4.2 通用类视图

DRF 提供了许多通用类视图，简化了常见的 API 操作，如列表、创建、检索、更新和删除。

4.2.1 ListAPIView 和 CreateAPIView

分别用于列出对象和创建新对象。

# myapp/api_views.py
from rest_framework.generics import ListAPIView, CreateAPIView
from .models import Post
from .serializers import PostSerializerclass PostListAPIView(ListAPIView):queryset = Post.objects.all()serializer_class = PostSerializerclass PostCreateAPIView(CreateAPIView):queryset = Post.objects.all()serializer_class = PostSerializer

4.2.2 RetrieveAPIView, UpdateAPIView, DestroyAPIView

分别用于检索、更新和删除单个对象。

# myapp/api_views.py
from rest_framework.generics import RetrieveAPIView, UpdateAPIView, DestroyAPIViewclass PostRetrieveAPIView(RetrieveAPIView):queryset = Post.objects.all()serializer_class = PostSerializerclass PostUpdateAPIView(UpdateAPIView):queryset = Post.objects.all()serializer_class = PostSerializerclass PostDestroyAPIView(DestroyAPIView):queryset = Post.objects.all()serializer_class = PostSerializer

4.2.3 ListCreateAPIView 和 RetrieveUpdateDestroyAPIView

将多个操作组合在一起，减少代码重复。

# myapp/api_views.py
from rest_framework.generics import ListCreateAPIView, RetrieveUpdateDestroyAPIViewclass PostListCreateAPIView(ListCreateAPIView):queryset = Post.objects.all()serializer_class = PostSerializerclass PostRetrieveUpdateDestroyAPIView(RetrieveUpdateDestroyAPIView):queryset = Post.objects.all()serializer_class = PostSerializer

4.3 视图集（ViewSets）

视图集将多个相关的视图操作组合在一个类中，进一步简化代码。DRF 提供了 ModelViewSet、ReadOnlyModelViewSet 等。

# myapp/api_views.py
from rest_framework import viewsets
from .models import Post
from .serializers import PostSerializerclass PostViewSet(viewsets.ModelViewSet):queryset = Post.objects.all()serializer_class = PostSerializer

# myapp/urls.py
from django.urls import path, include
from rest_framework.routers import DefaultRouter
from .api_views import PostViewSetrouter = DefaultRouter()
router.register(r'posts', PostViewSet)urlpatterns = [path('api/', include(router.urls)),
]

4.4 自定义类视图

在 DRF 中，也可以根据需要自定义类视图，实现特定的逻辑。

示例：自定义权限和过滤

# myapp/api_views.py
from rest_framework import viewsets, permissions, filters
from django_filters.rest_framework import DjangoFilterBackend
from .models import Post
from .serializers import PostSerializerclass CustomPostViewSet(viewsets.ModelViewSet):queryset = Post.objects.all()serializer_class = PostSerializerpermission_classes = [permissions.IsAuthenticatedOrReadOnly]filter_backends = [DjangoFilterBackend, filters.SearchFilter, filters.OrderingFilter]filterset_fields = ['title', 'created_at']search_fields = ['title', 'content']ordering_fields = ['created_at', 'title']ordering = ['-created_at']def perform_create(self, serializer):serializer.save(author=self.request.user)

5. 类视图的最佳实践

为了确保类视图的优雅和高效，遵循以下最佳实践是非常重要的。

5.1 遵循单一职责原则

每个视图类应专注于一个特定的任务，避免在一个视图中处理过多的逻辑。这有助于提高代码的可维护性和可读性。

5.2 使用通用类视图和 Mixins

尽可能使用 Django 或 DRF 提供的通用类视图和 Mixins，避免重复造轮子。这不仅减少了代码量，还利用了框架的优化和最佳实践。

# 示例：使用 DRF 的 ListModelMixin 和 CreateModelMixin
from rest_framework import viewsets, mixinsclass PostViewSet(mixins.ListModelMixin,mixins.CreateModelMixin,viewsets.GenericViewSet):queryset = Post.objects.all()serializer_class = PostSerializer

5.3 合理组织代码结构

将视图类按照功能或模块组织在不同的文件中，避免单个文件过于庞大。例如，可以将 API 视图和前端视图分开存放。

myapp/
├── views/
│   ├── __init__.py
│   ├── frontend_views.py
│   └── api_views.py
├── models.py
├── serializers.py
├── urls.py
└── ...

5.4 使用装饰器和 Mixins 添加额外功能

如权限控制、缓存、速率限制等，可以通过装饰器或 Mixins 添加到类视图中，而不需要修改视图的核心逻辑。

# 示例：添加速率限制
from rest_framework.throttling import UserRateThrottle
from rest_framework import viewsetsclass PostViewSet(viewsets.ModelViewSet):queryset = Post.objects.all()serializer_class = PostSerializerthrottle_classes = [UserRateThrottle]

5.5 优化 get_queryset 和 get_serializer_class

根据请求的不同，动态调整查询集和序列化器类，提升性能和灵活性。

# 示例：根据用户角色使用不同的序列化器
class PostViewSet(viewsets.ModelViewSet):queryset = Post.objects.all()def get_serializer_class(self):if self.request.user.is_staff:return PostAdminSerializerreturn PostSerializer

5.6 处理异常和错误

在类视图中适当处理可能出现的异常，确保 API 的稳定性和用户体验。

# 示例：处理对象不存在的异常
from rest_framework.exceptions import NotFoundclass PostDetailAPIView(APIView):def get_object(self, pk):try:return Post.objects.get(pk=pk)except Post.DoesNotExist:raise NotFound(detail="Post not found", code=404)def get(self, request, pk):post = self.get_object(pk)serializer = PostSerializer(post)return Response(serializer.data)

6. 实战示例：构建一个完整的 CRUD API

通过一个完整的示例，展示如何使用类视图构建一个 CRUD（创建、读取、更新、删除）API。

6.1 定义模型

# myapp/models.py
from django.db import models
from django.contrib.auth.models import Userclass Post(models.Model):author = models.ForeignKey(User, on_delete=models.CASCADE, related_name='posts')title = models.CharField(max_length=200)content = models.TextField()created_at = models.DateTimeField(auto_now_add=True)def __str__(self):return self.title

6.2 创建序列化器

# myapp/serializers.py
from rest_framework import serializers
from .models import Postclass PostSerializer(serializers.ModelSerializer):author = serializers.ReadOnlyField(source='author.username')class Meta:model = Postfields = ['id', 'author', 'title', 'content', 'created_at']

6.3 实现视图集

# myapp/api_views.py
from rest_framework import viewsets, permissions
from .models import Post
from .serializers import PostSerializerclass PostViewSet(viewsets.ModelViewSet):"""一个完整的 Post CRUD API"""queryset = Post.objects.all().order_by('-created_at')serializer_class = PostSerializerpermission_classes = [permissions.IsAuthenticatedOrReadOnly]def perform_create(self, serializer):serializer.save(author=self.request.user)

6.4 配置路由

# myapp/urls.py
from django.urls import path, include
from rest_framework.routers import DefaultRouter
from .api_views import PostViewSetrouter = DefaultRouter()
router.register(r'posts', PostViewSet, basename='post')urlpatterns = [path('api/', include(router.urls)),
]

6.5 配置权限和认证

在 settings.py 中配置 DRF 的权限和认证机制。

# myproject/settings.py
REST_FRAMEWORK = {'DEFAULT_PERMISSION_CLASSES': ['rest_framework.permissions.IsAuthenticatedOrReadOnly',],'DEFAULT_AUTHENTICATION_CLASSES': ['rest_framework.authentication.SessionAuthentication','rest_framework.authentication.BasicAuthentication',],'DEFAULT_FILTER_BACKENDS': ['django_filters.rest_framework.DjangoFilterBackend','rest_framework.filters.SearchFilter','rest_framework.filters.OrderingFilter',],'DEFAULT_PAGINATION_CLASS': 'rest_framework.pagination.PageNumberPagination','PAGE_SIZE': 10,
}

确保安装并添加 django-filter：

pip install django-filter

在 INSTALLED_APPS 中添加 'django_filters'：

# myproject/settings.py
INSTALLED_APPS = [# 其他应用...'rest_framework','django_filters','myapp',
]

6.6 运行和测试 API

启动开发服务器：

python manage.py runserver

访问 /api/posts/ 可以查看所有帖子，支持 GET、POST 等方法。通过浏览器或工具（如 Postman）测试 API 的各项功能。

7. 总结

类视图（CBV）在 Django 和 Django REST framework 中提供了强大且灵活的方式来构建视图和 API。通过继承内置类视图、使用 Mixins 以及自定义视图类，可以大大提高代码的可复用性和可维护性。以下是关键点总结：

• 选择合适的基类：根据需求选择 View、TemplateView、ListView 等内置类视图。
• 利用通用类视图：使用 Django 和 DRF 提供的通用类视图和 Mixins，减少代码重复。
• 遵循单一职责原则：确保每个视图类只负责一个明确的任务。
• 组织良好的代码结构：将视图类按功能模块化，便于管理和维护。
• 处理权限和认证：合理配置权限和认证，确保应用的安全性。
• 编写测试：为类视图编写测试，确保其行为符合预期。