django框架向DRF框架演变过程详解

一、Django框架实现项目查询接口

主要知识点：

• Django框架
• 视图函数

1、在 Django 项目中创建一个应用（如果还没有创建）：

python manage.py startapp projects

2、在项目的 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/<int:pk>/update/', update_project),
    path('projects/<int:pk>/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 djangorestframework

2、在你的项目的 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.response

dispatch()方法是Django Rest Framework中APIView类的一个重要方法，它负责将传入的HTTP请求分派到适当的处理方法上。该方法在处理请求之前被调用。

在APIView中，dispatch()方法执行以下主要任务：

1. 确定要调用的具体处理方法：dispatch()方法会根据请求的HTTP方法（例如GET、POST、PUT等）和URL中的路径参数，确定应该调用哪个具体的处理方法来处理请求。
2. 调用前置钩子方法：在实际执行处理方法之前，dispatch()方法会调用一些前置钩子方法，如initial()和get_serializer()，这些钩子方法用于进行准备工作，例如对请求进行验证、获取序列化器等。
3. 执行处理方法：一旦确定了要调用的处理方法，并完成了必要的准备工作，dispatch()方法将执行相应的处理方法，例如get()、post()、put()等，来处理请求。
4. 处理异常：如果在执行处理方法时出现异常，dispatch()方法会捕获异常并调用相应的异常处理方法，例如handle_exception()，来处理异常情况。
5. 调用后置钩子方法：在请求处理完毕后，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 视图类 需要手动实现

文章来源地址https://www.toymoban.com/news/detail-565627.html

到了这里，关于django框架向DRF框架演变过程详解的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！