django框架向DRF框架演变过程详解
一、Django框架实现项目查询接口
主要知识点：
- Django框架
- 视图函数
1、在 Django 项目中创建一个应用（如果还没有创建）：
python manage.py startapp projects2、在项目的 models.py 文件中定义项目模型
from django.db import models
class Project(models.Model):
name = models.CharField(max_length=100)
description = models.TextField()
# 添加其他字段按需求
3、运行数据库迁移命令，以创建项目表：
python manage.py makemigrations
python manage.py migrate
4、在应用的 views.py 文件中编写视图函数来处理查询项目列表的请求：
from django.http import JsonResponse
from django.views.decorators.csrf import csrf_exempt
from .models import Project
@csrf_exempt
def project_list(request):
projects = Project.objects.all()
data = [{'id': project.id, 'name': project.name} for project in projects]
return JsonResponse(data, safe=False)
@csrf_exempt
def create_project(request):
if request.method == 'POST':
name = request.POST.get('name')
leader = request.POST.get('leader')
# 获取其他字段的值
project = Project(name=name, leader=leader)
project.save()
return JsonResponse({'message': 'Project created successfully'})
return JsonResponse({'message': 'Invalid request'})
@csrf_exempt
def update_project(request, pk):
project = Project.objects.get(pk=pk)
if request.method == 'PUT':
name = request.PUT.get('name')
leader = request.PUT.get('leader')
# 获取其他字段的值
project.name = name
project.leader = leader
# 更新其他字段的值
project.save()
return JsonResponse({'message': 'Project updated successfully'})
return JsonResponse({'message': 'Invalid request'})
@csrf_exempt
def delete_project(request, pk):
project = Project.objects.get(pk=pk)
project.delete()
return JsonResponse({'message': 'Project deleted successfully'})
5、在项目的 urls.py 文件中配置 URL 映射：
from django.urls import path
from .views import project_list, create_project, update_project, delete_project
urlpatterns = [
path('projects/', project_list),
path('projects/create/', create_project),
path('projects//update/', update_project),
path('projects//delete/', delete_project),
]
6、运行开发服务器，并访问 /projects/ 路径即可获取项目列表：
python manage.py runserver访问 http://localhost:8000/projects/
我们实现了哪些功能点：
- 在视图文件中，手写处理数据的方法，并与请求方法做匹配
- 在路由文件中，将路由映射到视图函数中具体某个方法上。
二、引入DRF中的序列化器serializers
主要知识点：
- DRF框架
- 列化器serializers
- @api_view(['GET']) 装饰器
2.1 序列化器的作用
在视图中，将从表里取出来的数据，组装成接口返回数据，我们是手动一个一个写的。
使用序列化器serializers，直接将从表中取出的对象，转成我们需要的json的数据格式。
2.2 应用序列化器serializers
1、首先，确保你已经在 Django 项目中安装了 djangorestframework 库：
pip install djangorestframework2、在你的项目的 settings.py 文件中，将 rest_framework 添加到 INSTALLED_APPS 列表中：
INSTALLED_APPS = [
# 其他已存在的应用
'rest_framework',
]
3、在项目的 serializers.py 文件中创建一个项目序列化器类：
from rest_framework import serializers
from .models import Project
class ProjectSerializer(serializers.ModelSerializer):
class Meta:
model = Project
fields = '__all__' # 或者指定你想要序列化的字段
4、在应用的 views.py 文件中编写视图函数来处理查询项目列表的请求，并使用序列化器来序列化数据：
from rest_framework.decorators import api_view
from rest_framework.response import Response
from .models import Project
from .serializers import ProjectSerializer
@api_view(['GET'])
def project_list(request):
projects = Project.objects.all()
serializer = ProjectSerializer(projects, many=True)
return Response(serializer.data)
注意：
@api_view(['GET']) 是 Django REST Framework 的装饰器，用于标识视图函数可以处理哪种类型的 HTTP 请求。
在这个例子中，@api_view(['GET']) 装饰器将 project_list 视图函数标记为只能处理 GET 请求。这样，当客户端发送一个 GET 请求到 /projects/ 路径时，Django 将调用 project_list 视图函数来处理该请求。
使用 @api_view(['GET']) 装饰器是为了确保视图函数只接受 GET 请求，并且提供了一些附加功能，例如自动返回适当的响应和错误处理。
另外，@api_view 装饰器还支持其他 HTTP 方法，如 POST、PUT、DELETE 等。只需根据需要将其放入列表中即可，例如 @api_view(['GET', 'POST']) 可以处理 GET 和 POST 请求。这样，你可以轻松处理不同类型的请求，并编写相应的逻辑来处理每个类型的请求。
5、在项目的 urls.py 文件中配置 URL 映射：
from django.urls import path
from projects.views import project_list
urlpatterns = [
path('projects/', project_list, name='project-list'),
# 添加其他 URL 映射按需求
]
6、运行开发服务器，并访问 /projects/ 路径即可获取项目列表：
python manage.py runserver访问 http://localhost:8000/projects/
我们实现了哪些功能点：
- 使用序列化器类代替了手动组装返回数据
三、引入视图类 APIView
主要知识点：
- APIView视图类
3.1 引入视图类 APIView
1、在应用的 views.py 文件中创建一个继承自 Django REST Framework 的 APIView 的视图类：
from rest_framework.views import APIView
from rest_framework.response import Response
from .models import Project
from .serializers import ProjectSerializer
class ProjectListAPIView(APIView):
def get(self, request, *args, **kwargs):
# 处理 GET 请求，返回项目列表
projects = Project.objects.all()
serializer = ProjectSerializer(projects, many=True)
return Response(serializer.data)
def post(self, request, *args, **kwargs):
# 处理 POST 请求，创建新的项目
serializer = ProjectSerializer(data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=201)
return Response(serializer.errors, status=400)
def put(self, request, *args, **kwargs):
# 处理 PUT 请求，更新整个项目列表
project_data = request.data
# 对项目列表进行处理
return Response(...)
def patch(self, request, *args, **kwargs):
# 处理 PATCH 请求，部分更新项目列表
project_data = request.data
# 对项目列表进行处理
return Response(...)
def delete(self, request, *args, **kwargs):
# 处理 DELETE 请求，删除项目列表
# 删除项目列表的逻辑
return Response(...)
在这个示例中，我们定义了一个 ProjectListAPIView 类，继承自 APIView。我们在其中定义了一个 get 方法来处理 GET 请求。
注意：
1、继承APIView 视图类
2、需要手写get post 等方法实现的具体逻辑
- get(self, request, *args, **kwargs)：处理 GET 请求，用于获取项目列表。
- post(self, request, *args, **kwargs)：处理 POST 请求，用于创建新的项目。
- put(self, request, *args, **kwargs)：处理 PUT 请求，用户更新某个项目下的所有字段（资源）
- patch(self, request, *args, **kwargs)：处理 PATCH 请求，用户更新某个项目下的部分字段（资源）
- delete(self, request, *args, **kwargs)：处理 DELETE 请求，用于删除项目列表。
2、在项目的 urls.py 文件中配置 URL 映射来使用视图类：
from django.urls import path
from projects.views import ProjectListAPIView
urlpatterns = [
path('projects/', ProjectListAPIView.as_view(), name='project-list'),
# 添加其他 URL 映射按需求
]
这里使用 .as_view() 方法将视图类转换为可用于 URL 映射的可调用对象。
现在，当你访问 http://localhost:8000/projects/，你应该能够看到以 JSON 格式返回的项目列表。这是通过调用 ProjectListAPIView 类的 get 方法来实现的。
使用视图类可以更好地组织代码，提供更多灵活性，并且可以通过覆盖不同的 HTTP 方法（如 get()、post() 等）来处理不同类型的请求。
我们实现了哪些功能点：
- 继承视图类 APIView，手动实现get post put等数据处理逻辑
- 路由自动生成
四、引入视图类 viewsets.ViewSet
主要知识点：
- viewsets.ViewSet视图类
4.1 引入视图类 viewsets.ViewSet
1、在 views.py 文件中导入 viewsets 和相应的模块：
from rest_framework import viewsets
from .models import Project
from .serializers import ProjectSerializer
2、创建一个继承自 viewsets.ViewSet 的类，并编写对应的方法和逻辑：
from .models import Project
from .serializers import ProjectSerializer
from rest_framework import viewsets
from rest_framework.response import Response
class ProjectViewSet(viewsets.ViewSet):
def list(self, request):
# 列出所有项目的列表
projects = Project.objects.all()
serializer = ProjectSerializer(projects, many=True)
return Response(serializer.data)
def retrieve(self, request, pk=None):
# 检索某一个项目的详细信息
project = Project.objects.get(pk=pk)
serializer = ProjectSerializer(project)
return Response(serializer.data)
def create(self, request):
# 创建一条数据
serializer = ProjectSerializer(data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=201)
return Response(serializer.errors, status=400)
def update(self, request, pk=None):
# 更新列表
project = Project.objects.get(pk=pk)
serializer = ProjectSerializer(project, data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
return Response(serializer.errors, status=400)
def partial_update(self, request, pk=None):
# 更新一条数据
project = Project.objects.get(pk=pk)
serializer = ProjectSerializer(project, data=request.data, partial=True)
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
return Response(serializer.errors, status=400)
def destroy(self, request, pk=None):
# 删除数据
project = Project.objects.get(pk=pk)
project.delete()
return Response(status=204)
在这个示例中，我们创建了一个名为 ProjectViewSet 的视图集，继承自 viewsets.ViewSet。
- .list()：列出所有项目的列表 -> get
- .retrieve()：检索某一个项目的详细信息 -> get
- .create() : 创建一条数据 -> post
- update(): 更新列表 -> put
- .partial_update():更新一条数据 -> patch
- .destroy()：删除数据 -> delete
3、在 urls.py 文件中配置 URL 映射来使用视图集：
为了将 ProjectViewSet 的方法与 URL 关联起来，你可以使用 DefaultRouter 进行自动路由配置。
from rest_framework.routers import DefaultRouter
router = DefaultRouter()
router.register(r'projects', ProjectViewSet, basename='project')
urlpatterns = router.urls
通过上述代码，我们将 ProjectViewSet 的方法自动关联到了 /projects 路径上，并为每个方法生成了对应的 URL。
发送 GET 请求到 /projects 路径时，将会调用 list 方法；
当你发送 POST 请求到 /projects 路径时，将会调用 create 方法。
你可以根据需要进一步扩展该视图集。
我们实现了哪些功能点：
- 继承视图类 ViewSet，手动实现list create 等action
- 路由自动生成
4.1.1 扩展：update() 与 partial_update()
update() 方法和 partial_update() 方法是继承自 viewsets.ViewSet 类的两个操作方法，用于更新资源。
update() 方法：
update() 方法用于完整更新一个资源。它接收一个完整的请求数据，并将该数据应用于指定的资源对象。任何未提供的字段都将被设置为默认值或空值。如果资源不存在，则会创建一个新的资源。这意味着在执行 update() 方法时，需要提供完整的数据来替换现有的资源。
partial_update() 方法：
partial_update() 方法用于部分更新一个资源。它接收一个部分请求数据，并将该数据部分地应用于指定的资源对象。只提供的字段将被更新，而未提供的字段将保持原样。这使得可以只更新资源对象的部分属性，而不必提供完整的数据。这对于只想更新资源的特定字段或属性非常有用。
使用场景：
- 使用 update() 方法时，适合在客户端有所有的资源属性信息，并且要求完全替换已有资源的情况下使用。例如，当用户填写一个包含所有资源字段的表单时，可以使用 update() 方法将表单数据直接应用于资源对象。
- 使用 partial_update() 方法时，适合在客户端只有要更新的部分资源属性信息的情况下使用。例如，当用户只更改了资源的部分字段时，可以使用 partial_update() 方法仅更新这些字段，而不影响其他字段。
举个例子，有一个学生列表，学生属性包含id、姓名、年龄、性别四个字段。
update() 方法，会更新id为1的学生信息，所有的字段（id、姓名、年龄、性别）
partial_update() 方法，只会新id为1的学生信息其中的部分字段（可能只更新年龄这个字段）
总之，update() 方法用于完整替换资源，而 partial_update() 方法用于部分更新资源。根据客户端提供的数据以及是否需要更新全部字段或仅部分字段，选择使用适当的方法。
4.2 list()方法如何实现关联GET请求
继承视图类viewsets.ViewSet，实现list等action，是如何与get请求做自动关联的。
父类APIView，dispatch 方法实现的。
源码：
def dispatch(self, request, *args, **kwargs):
"""
`.dispatch()` is pretty much the same as Django's regular dispatch,
but with extra hooks for startup, finalize, and exception handling.
"""
self.args = args
self.kwargs = kwargs
request = self.initialize_request(request, *args, **kwargs)
self.request = request
self.headers = self.default_response_headers # deprecate?
try:
self.initial(request, *args, **kwargs)
# Get the appropriate handler method
if request.method.lower() in self.http_method_names:
handler = getattr(self, request.method.lower(),
self.http_method_not_allowed)
else:
handler = self.http_method_not_allowed
response = handler(request, *args, **kwargs)
except Exception as exc:
response = self.handle_exception(exc)
self.response = self.finalize_response(request, response, *args, **kwargs)
return self.responsedispatch()方法是Django Rest Framework中APIView类的一个重要方法，它负责将传入的HTTP请求分派到适当的处理方法上。该方法在处理请求之前被调用。
在APIView中，dispatch()方法执行以下主要任务：
- 确定要调用的具体处理方法：dispatch()方法会根据请求的HTTP方法（例如GET、POST、PUT等）和URL中的路径参数，确定应该调用哪个具体的处理方法来处理请求。
- 调用前置钩子方法：在实际执行处理方法之前，dispatch()方法会调用一些前置钩子方法，如initial()和get_serializer()，这些钩子方法用于进行准备工作，例如对请求进行验证、获取序列化器等。
- 执行处理方法：一旦确定了要调用的处理方法，并完成了必要的准备工作，dispatch()方法将执行相应的处理方法，例如get()、post()、put()等，来处理请求。
- 处理异常：如果在执行处理方法时出现异常，dispatch()方法会捕获异常并调用相应的异常处理方法，例如handle_exception()，来处理异常情况。
- 调用后置钩子方法：在请求处理完毕后，dispatch()方法会调用一些后置钩子方法，如finalize_response()和get_renderers()，用于进行清理工作，例如生成响应、选择渲染器等。
通过重写dispatch()方法，您可以自定义请求的处理过程。例如，您可以添加额外的前置或后置处理逻辑，或者修改请求调度的方式。
from rest_framework.views import APIView
class MyAPIView(APIView):
def dispatch(self, request, *args, **kwargs):
# 在调用具体处理方法之前的自定义处理逻辑
# ...
response = super().dispatch(request, *args, **kwargs)
# 在调用具体处理方法之后的自定义处理逻辑
# ...
return response
请注意，一旦调用了super().dispatch(request, *args, **kwargs)，实际的处理方法将被调用，并且返回响应对象。您可以在返回响应之前或之后执行自定义处理逻辑。
总之，dispatch()方法在DRF的APIView类中起着关键的作用，负责将请求分派到相应的处理方法，并提供了一个扩展点，使您能够自定义请求的处理过程。
五、viewsets.ViewSet与APIView对比
5.1 对比
viewsets.ViewSet和APIView是Django Rest Framework（DRF）中用于处理API请求的两个不同的类。下面是它们的对比：
功能：
- viewsets.ViewSet：ViewSet是一个更高级的抽象，它结合了多个相关的API操作（如列表、创建、检索、更新、删除等）到一个类中。ViewSet内置了一些常见的操作方法，如list()、create()、retrieve()、update()等。同时，您可以使用@action装饰器添加自定义的额外操作。
- APIView：APIView是一个基于类的视图，它提供了在处理不同HTTP方法时需要实现的单个方法（如get()、post()、put()等）。您需要手动编写每个HTTP方法的处理逻辑。
代码组织：
- viewsets.ViewSet：通过将相关的操作组织到一个类中，ViewSet提供了更好的代码组织性和可读性。它可以更清晰地表示与某个实体或资源相关的多个操作，并且使代码更易于维护和扩展。
- APIView：APIView将每个HTTP方法的处理逻辑拆分为独立的方法，因此代码组织可能相对分散。但是，这也使得在每个方法中可以更灵活地处理请求。
URL配置：
- viewsets.ViewSet：ViewSet通常与Router一起使用，以自动为ViewSet中的操作方法生成URL配置。这样，您无需手动定义每个URL，并且可以遵循一种统一的URL命名约定。
- APIView：由于APIView是基于类的视图，您需要手动在URL配置中指定每个具体的HTTP方法所对应的URL。
程序复杂性：
- viewsets.ViewSet：ViewSet提供了一种简化和高级的方式来处理多个相关操作。它抽象了常见的API操作，并提供了默认实现的操作方法，减少了开发者编写重复代码的工作量。
- APIView：APIView更加灵活，允许您完全控制请求的处理方式。它适合对每个HTTP方法都有精确处理逻辑或者对请求做出高度定制的情况。
5.2 应用场景
5.2.1 viewsets.ViewSet：
- 当需要处理与某个特定实体或资源相关的多种不同API操作（如列表、创建、检索、更新、删除等）时，可以使用viewsets.ViewSet。它能够将这些相关的操作集中到一个类中，提高代码的组织性和可读性。
- 当需要为实体或资源定义自定义的额外操作时，可以使用@action装饰器将自定义操作添加到viewsets.ViewSet中。
例如，假设我们有一个Book模型，我们可以使用ViewSet来处理与图书相关的各种操作：
from rest_framework import viewsets
class BookViewSet(viewsets.ViewSet):
def list(self, request):
# 返回图书列表
def create(self, request):
# 创建新图书
def retrieve(self, request, pk=None):
# 检索单个图书
def update(self, request, pk=None):
# 更新图书
def destroy(self, request, pk=None):
# 删除图书
@action(detail=True, methods=['post'])
def borrow(self, request, pk=None):
# 自定义操作：借阅图书
@action(detail=True, methods=['post'])
def return_book(self, request, pk=None):
# 自定义操作：归还图书
5.2.2 APIView：
- 当需要对每个HTTP方法（如GET、POST、PUT等）都有具体的处理逻辑时，可以使用APIView。对于每个HTTP方法，您需要手动在APIView的子类中实现相应的方法。
- 当需要对请求进行更精细的控制和自定义处理逻辑时，可以使用APIView。通过重写dispatch()方法和其他相关方法，可以实现对请求的高度定制。
例如，如果我们需要对一个特定的API端点进行精细的控制和自定义处理逻辑，我们可以使用APIView：
from rest_framework.views import APIView
class MyView(APIView):
def get(self, request):
# GET请求处理逻辑
def post(self, request):
# POST请求处理逻辑
def put(self, request):
# PUT请求处理逻辑
def delete(self, request):
# DELETE请求处理逻辑
def dispatch(self, request, *args, **kwargs):
# 自定义请求调度逻辑
return super().dispatch(request, *args, **kwargs)
总之，viewsets.ViewSet适用于处理与某个实体或资源相关的多个操作，并且需要提供默认操作方法和自定义操作。而APIView适用于对每个HTTP方法都有具体处理逻辑或者对请求进行更精细的控制和定制的情况。根据具体的业务需求和开发需求，可以选择使用适合的类来处理API请求。
六、viewsets.ModelViewSet
1、视图
from rest_framework import viewsets
from .models import Project
from .serializers import ProjectSerializer
class ProjectViewSet(viewsets.ModelViewSet):
queryset = Project.objects.all()
serializer_class = ProjectSerializer重启项目，查看接口文档。
注意
- viewsets.ModelViewSet 视图类与 viewsets.ViewSet 视图类，实现的接口是一模一样的。
- viewsets.ModelViewSet 视图类 是自动实现的
- viewsets.ViewSet 视图类 需要手动实现
