REST framework 提供了众多的通用视图基类与扩展类，以简化视图的编写。

1、2个视图基类

1.1、 APIView

  1. rest_framework.views.APIView

APIView是REST framework提供的所有视图的基类，继承自Django的View父类。

APIView与View的不同之处在于：

  • 传入到视图方法中的是REST framework的Request对象，而不是Django的HttpRequeset对象；

  • 视图方法可以返回REST framework的Response对象，视图会为响应数据设置（render）符合前端要求的格式；

  • 任何APIException异常都会被捕获到，并且处理成合适的响应信息；

  • 在进行dispatch()分发前，会对请求进行身份认证、权限检查、流量控制。

支持定义的类属性

  • authentication_classes 列表或元祖，身份认证类

  • permissoin_classes 列表或元祖，权限检查类

  • throttle_classes 列表或元祖，流量控制类

在APIView中仍以常规的类视图定义方法来实现get() 、post() 或者其他请求方式的方法。

举例：

  1. from rest_framework.views import APIView
    from rest_framework.response import Response
    ​
    # url(r'^students/$', views.StudentsAPIView.as_view()),
    class StudentsAPIView(APIView):
        def get(self, request):
            data_list = Student.objects.all()
            serializer = StudentModelSerializer(instance=data_list, many=True)
            return Response(serializer.data)

1.2、 GenericAPIView[通用视图类]

  1. rest_framework.generics.GenericAPIView

继承自APIVIew，主要增加了操作序列化器和数据库查询的方法，作用是为下面Mixin扩展类的执行提供方法支持。通常在使用时，可搭配一个或多个Mixin扩展类。

提供的关于序列化器使用的属性与方法

  • 属性：

    • serializer_class 指明视图使用的序列化器

  • 方法：

    • get_serializer_class(self)

      当出现一个视图类中调用多个序列化器时,那么可以通过条件判断在get_serializer_class方法中通过返回不同的序列化器类名就可以让视图方法执行不同的序列化器对象了。

      返回序列化器类，默认返回serializer_class，可以重写，例如：

      1. def get_serializer_class(self):
            if self.request.user.is_staff:
                return FullAccountSerializer
            return BasicAccountSerializer
    • get_serializer(self, args, *kwargs)

      返回序列化器对象，主要用来提供给Mixin扩展类使用，如果我们在视图中想要获取序列化器对象，也可以直接调用此方法。

      注意，该方法在提供序列化器对象的时候，会向序列化器对象的context属性补充三个数据：request、format、view，这三个数据对象可以在定义序列化器时使用。

      • request 当前视图的请求对象

      • view 当前请求的类视图对象

      • format 当前请求期望返回的数据格式

提供的关于数据库查询的属性与方法

  • 属性：

    • queryset 指明使用的数据查询集

  • 方法：

    • get_queryset(self)

      返回视图使用的查询集，主要用来提供给Mixin扩展类使用，是列表视图与详情视图获取数据的基础，默认返回queryset属性，可以重写，例如：

      1. def get_queryset(self):
            user = self.request.user
            return user.accounts.all()

    • get_object(self)

      返回详情视图所需的模型类数据对象，主要用来提供给Mixin扩展类使用。

      在试图中可以调用该方法获取详情信息的模型类对象。

      若详情访问的模型类对象不存在，会返回404。

      该方法会默认使用APIView提供的check_object_permissions方法检查当前对象是否有权限被访问。

      举例：

      1. # url(r'^books/(?P<pk>\d+)/$', views.BookDetailView.as_view()),
        class BookDetailView(GenericAPIView):
            queryset = BookInfo.objects.all()
            serializer_class = BookInfoSerializer
        ​
            def get(self, request, pk):
                book = self.get_object() # get_object()方法根据pk参数查找queryset中的数据对象
                serializer = self.get_serializer(book)
                return Response(serializer.data)

其他可以设置的属性

  • pagination_class 指明分页控制类

  • filter_backends 指明过滤控制后端

为了方便学习上面的GenericAPIView通用视图类，我们新建一个子应用。

  1. python manage.py startapp gen
  1. from rest_framework.generics import GenericAPIView
  2.  
  3. from students.models import Student
  4. from .serializers import StudentModelSerializer, StudentModel2Serializer
  5. from rest_framework.response import Response
  6.  
  7. class StudentsGenericAPIView(GenericAPIView):
  8.     # 本次视图类中要操作的数据[必填]
  9.     queryset = Student.objects.all()
  10.     # 本次视图类中要调用的默认序列化器[选填]
  11.     serializer_class = StudentModelSerializer
  12.  
  13.     def get(self, request):
  14.         """获取所有学生信息"""
  15.         serializer = self.get_serializer(instance=self.get_queryset(), many=True)
  16.  
  17.         return Response(serializer.data)
  18.  
  19.     def post(self,request):
  20.  
  21.         data = request.data
  22.  
  23.         serializer = self.get_serializer(data=data)
  24.  
  25.         serializer.is_valid(raise_exception=True)
  26.  
  27.         instance = serializer.save()
  28.  
  29.         serializer = self.get_serializer(instance=instance)
  30.  
  31.         return Response(serializer.data)
  32.  
  33. class StudentGenericAPIView(GenericAPIView):
  34.     queryset = Student.objects.all()
  35.  
  36.     serializer_class = StudentModelSerializer
  37.  
  38.     def get_serializer_class(self):
  39.         """重写获取序列化器类的方法"""
  40.         if self.request.method == "GET":
  41.             return StudentModel2Serializer
  42.         else:
  43.             return StudentModelSerializer
  44.  
  45.     # 在使用GenericAPIView视图获取或操作单个数据时,视图方法中的代表主键的参数最好是pk
  46.     def get(self,request,pk):
  47.         """获取一条数据"""
  48.         serializer = self.get_serializer(instance=self.get_object())
  49.  
  50.         return Response(serializer.data)
  51.  
  52.     def put(self,request,pk):
  53.  
  54.         data = request.data
  55.  
  56.         serializer = self.get_serializer(instance=self.get_object(),data=data)
  57.  
  58.         serializer.is_valid(raise_exception=True)
  59.  
  60.         serializer.save()
  61.  
  62.         serializer = self.get_serializer(instance=self.get_object())
  63.  
  64.         return Response(serializer.data)

gen/views.py

  1. from rest_framework import serializers
  2.  
  3. from students.models import Student
  4.  
  5. class StudentModelSerializer(serializers.ModelSerializer):
  6.     class Meta:
  7.         model= Student
  8.         fields = "__all__"
  9.  
  10. class StudentModel2Serializer(serializers.ModelSerializer):
  11.     class Meta:
  12.         model= Student
  13.         fields = ("name","class_null")

gen/serializers.py

  1. from django.urls import path, re_path
  2. from . import views
  3. urlpatterns = [
  4.     path(r"students/",views.StudentsGenericAPIView.as_view()),
  5.     re_path(r"students/(?P<pk>\d+)/",views.StudentGenericAPIView.as_view()),
  6. ]

gen/urls.py

  1. from django.contrib import admin
  2. from django.urls import path,include
  3.  
  4. urlpatterns = [
  5.     path('admin/', admin.site.urls),
  6.     path("stu/",include("students.urls"))
  7. ]

urls.py

  1. from django.db import models
  2.  
  3. # Create your models here.
  4. class Student(models.Model):
  5.     #以下模型字段默认时不能为空 null=False
  6.     name = models.CharField(max_length=100,verbose_name="姓名")
  7.     sex = models.BooleanField(default=1,verbose_name="性别")
  8.     age = models.IntegerField(verbose_name="年龄")
  9.     class_null = models.CharField(max_length=5,verbose_name="班级编号",null=True)
  10.     description = models.TextField(max_length=1000,verbose_name="个性签名",null=True)
  11.  
  12.     class Meta:
  13.         db_table="tb_student"
  14.         verbose_name ="学生"
  15.         verbose_name_plural = verbose_name

gen/models.py

2、 5个视图扩展类

作用：

提供了几种后端视图（对数据资源进行曾删改查）处理流程的实现，如果需要编写的视图属于这五种，则视图可以通过继承相应的扩展类来复用代码，减少自己编写的代码量。

这五个扩展类需要搭配GenericAPIView父类，因为五个扩展类的实现需要调用GenericAPIView提供的序列化器与数据库查询的方法。

1）ListModelMixin

列表视图扩展类，提供list(request, *args, **kwargs)方法快速实现列表视图，返回200状态码。

该Mixin的list方法会对数据进行过滤和分页。

源代码：

  1. class ListModelMixin(object):
        """
        List a queryset.
        """
        def list(self, request, *args, **kwargs):
            # 过滤
            queryset = self.filter_queryset(self.get_queryset())
            # 分页
            page = self.paginate_queryset(queryset)
            if page is not None:
                serializer = self.get_serializer(page, many=True)
                return self.get_paginated_response(serializer.data)
            # 序列化
            serializer = self.get_serializer(queryset, many=True)
            return Response(serializer.data)

举例：

  1. from rest_framework.mixins import ListModelMixin
    ​
    class BookListView(ListModelMixin, GenericAPIView):
        queryset = BookInfo.objects.all()
        serializer_class = BookInfoSerializer
    ​
        def get(self, request):
            return self.list(request)

2）CreateModelMixin

创建视图扩展类，提供create(request, *args, **kwargs)方法快速实现创建资源的视图，成功返回201状态码。

如果序列化器对前端发送的数据验证失败，返回400错误。

源代码：

  1. class CreateModelMixin(object):
        """
        Create a model instance.
        """
        def create(self, request, *args, **kwargs):
            # 获取序列化器
            serializer = self.get_serializer(data=request.data)
            # 验证
            serializer.is_valid(raise_exception=True)
            # 保存
            self.perform_create(serializer)
            headers = self.get_success_headers(serializer.data)
            return Response(serializer.data, status=status.HTTP_201_CREATED, headers=headers)
    ​
        def perform_create(self, serializer):
            serializer.save()
    ​
        def get_success_headers(self, data):
            try:
                return {'Location': str(data[api_settings.URL_FIELD_NAME])}
            except (TypeError, KeyError):
                return {}

3）RetrieveModelMixin

详情视图扩展类，提供retrieve(request, *args, **kwargs)方法，可以快速实现返回一个存在的数据对象。

如果存在，返回200， 否则返回404。

源代码：

  1. class RetrieveModelMixin(object):
        """
        Retrieve a model instance.
        """
        def retrieve(self, request, *args, **kwargs):
            # 获取对象，会检查对象的权限
            instance = self.get_object()
            # 序列化
            serializer = self.get_serializer(instance)
            return Response(serializer.data)

举例：

  1. class BookDetailView(RetrieveModelMixin, GenericAPIView):
        queryset = BookInfo.objects.all()
        serializer_class = BookInfoSerializer
    ​
        def get(self, request, pk):
            return self.retrieve(request)

4）UpdateModelMixin

更新视图扩展类，提供update(request, *args, **kwargs)方法，可以快速实现更新一个存在的数据对象。

同时也提供partial_update(request, *args, **kwargs)方法，可以实现局部更新。

成功返回200，序列化器校验数据失败时，返回400错误。

源代码：

  1. class UpdateModelMixin(object):
        """
        Update a model instance.
        """
        def update(self, request, *args, **kwargs):
            partial = kwargs.pop('partial', False)
            instance = self.get_object()
            serializer = self.get_serializer(instance, data=request.data, partial=partial)
            serializer.is_valid(raise_exception=True)
            self.perform_update(serializer)
    ​
            if getattr(instance, '_prefetched_objects_cache', None):
                # If 'prefetch_related' has been applied to a queryset, we need to
                # forcibly invalidate the prefetch cache on the instance.
                instance._prefetched_objects_cache = {}
    ​
            return Response(serializer.data)
    ​
        def perform_update(self, serializer):
            serializer.save()
    ​
        def partial_update(self, request, *args, **kwargs):
            kwargs['partial'] = True
            return self.update(request, *args, **kwargs)

5）DestroyModelMixin

删除视图扩展类，提供destroy(request, *args, **kwargs)方法，可以快速实现删除一个存在的数据对象。

成功返回204，不存在返回404。

源代码：

  1. class DestroyModelMixin(object):
        """
        Destroy a model instance.
        """
        def destroy(self, request, *args, **kwargs):
            instance = self.get_object()
            self.perform_destroy(instance)
            return Response(status=status.HTTP_204_NO_CONTENT)
    ​
        def perform_destroy(self, instance):
            instance.delete()

使用GenericAPIView和视图扩展类，实现api接口，代码：

  1. from rest_framework.generics import GenericAPIView
  2.  
  3. from students.models import Student
  4. from .serializers import StudentModelSerializer, StudentModel2Serializer
  5. from rest_framework.response import Response
  6.  
  7. """GenericAPIView结合视图扩展类实现api接口"""
  8. from rest_framework.mixins import ListModelMixin,CreateModelMixin
  9. class Students2GenericAPIView(GenericAPIView,ListModelMixin,CreateModelMixin):
  10.     # 本次视图类中要操作的数据[必填]
  11.     queryset = Student.objects.all()
  12.     # 本次视图类中要调用的默认序列化器[玄天]
  13.     serializer_class = StudentModelSerializer
  14.  
  15.     def get(self, request):
  16.         """获取多个学生信息"""
  17.         return self.list(request)
  18.  
  19.     def post(self,request):
  20.         """添加学生信息"""
  21.         return self.create(request)
  22.  
  23. from rest_framework.mixins import RetrieveModelMixin,UpdateModelMixin,DestroyModelMixin
  24. class Student2GenericAPIView(GenericAPIView,RetrieveModelMixin,UpdateModelMixin,DestroyModelMixin):
  25.     queryset = Student.objects.all()
  26.  
  27.     serializer_class = StudentModelSerializer
  28.  
  29.     # 在使用GenericAPIView视图获取或操作单个数据时,视图方法中的代表主键的参数最好是pk
  30.     def get(self,request,pk):
  31.         """获取一条数据"""
  32.         return self.retrieve(request,pk)
  33.  
  34.     def put(self,request,pk):
  35.         """更新一条数据"""
  36.         return self.update(request,pk)
  37.  
  38.     def delete(self,request,pk):
  39.         """删除一条数据"""
  40.         return self.destroy(request,pk)

gen/views.py

  1. 其它代码以上面的例子类似！
  2.  

3、 GenericAPIView的视图子类

1）CreateAPIView

提供 post 方法

继承自： GenericAPIView、CreateModelMixin

2）ListAPIView

提供 get 方法

继承自：GenericAPIView、ListModelMixin

3）RetrieveAPIView

提供 get 方法

继承自: GenericAPIView、RetrieveModelMixin

4）DestoryAPIView

提供 delete 方法

继承自：GenericAPIView、DestoryModelMixin

5）UpdateAPIView

提供 put 和 patch 方法

继承自：GenericAPIView、UpdateModelMixin

6）RetrieveUpdateAPIView

提供 get、put、patch方法

继承自： GenericAPIView、RetrieveModelMixin、UpdateModelMixin

7）RetrieveUpdateDestoryAPIView

提供 get、put、patch、delete方法

继承自：GenericAPIView、RetrieveModelMixin、UpdateModelMixin、DestoryModelMixin

  1. from rest_framework.generics import GenericAPIView
  2.  
  3. from students.models import Student
  4. from .serializers import StudentModelSerializer, StudentModel2Serializer
  5. from rest_framework.response import Response
  6.  
  7. """使用GenericAPIView的视图子类进一步简化开发api接口的代码"""
  8. from rest_framework.generics import ListAPIView,CreateAPIView
  9. class Students3GenericAPIView(ListAPIView,CreateAPIView):
  10.     queryset = Student.objects.all()
  11.     serializer_class = StudentModelSerializer
  12.  
  13. from rest_framework.generics import RetrieveAPIView,UpdateAPIView,DestroyAPIView
  14. from rest_framework.generics import RetrieveUpdateDestroyAPIView # 结合了上面三个子类的功能
  15. class Student3GenericAPIView(RetrieveUpdateDestroyAPIView):
  16.     queryset = Student.objects.all()
  17.     serializer_class = StudentModelSerializer

gen/views.py

  1. from django.urls import path, re_path
  2. from . import views
  3. urlpatterns = [
  4.     # 使用GenericAPIView的视图子类进一步简化开发api接口的代码
  5.     path("students3/", views.Students3GenericAPIView.as_view()),
  6.     re_path("students3/(?P<pk>\d+)/", views.Student3GenericAPIView.as_view()),
  7.  
  8. ]

gen/urls.py

  1. 其它代码以上面的例子类似！
  1.  

4、 常用视图集父类（ViewSet、 GenericViewSet、 ModelViewSet、 ReadOnlyModelViewSet）

1） ViewSet

继承自APIView与ViewSetMixin，作用也与APIView基本类似，提供了身份认证、权限校验、流量管理等。

ViewSet主要通过继承ViewSetMixin来实现在调用as_view()时传入字典（如{'get':'list'}）的映射处理工作。

在ViewSet中，没有提供任何动作action方法，需要我们自己实现action方法。

使用视图集ViewSet，可以将一系列逻辑相关的动作放到一个类中：

  • list() 提供一组数据

  • retrieve() 提供单个数据

  • create() 创建数据

  • update() 保存数据

  • destory() 删除数据

ViewSet视图集类不再实现get()、post()等方法，而是实现动作 action 如 list() 、create() 等。

视图集只在使用as_view()方法的时候，才会将action动作与具体请求方式对应上。如：

  1. from rest_framework.generics import GenericAPIView
  2.  
  3. from students.models import Student
  4. from .serializers import StudentModelSerializer, StudentModel2Serializer
  5. from rest_framework.response import Response
  6.  
  7. """使用视图集把上面的两个视图类组成一个视图类"""
  8. from rest_framework.viewsets import ViewSet
  9. class StudentViewSet(ViewSet):
  10.     def get_all(self,request):
  11.         """获取所有学生信息"""
  12.         data_list = Student.objects.all()
  13.         serializer = StudentModelSerializer(instance=data_list, many=True)
  14.         return Response(serializer.data)
  15.  
  16.     def add_student(self,request):
  17.  
  18.         return Response({"message":"添加成功!"})
  19.  
  20.     def get_one(self,request,pk):
  21.         """获取一个学生信息"""
  22.         instance = Student.objects.get(pk=pk)
  23.         serializer = StudentModelSerializer(instance=instance)
  24.         return Response(serializer.data)
  25.  
  26. """发挥下ViewSet的作用"""
  27. from rest_framework.viewsets import ViewSet
  28. from rest_framework.generics import ListAPIView,CreateAPIView,RetrieveAPIView
  29. class Student2ViewSet(ViewSet,ListAPIView,CreateAPIView,RetrieveAPIView):
  30.     queryset = Student.objects.all()
  31.     serializer_class = StudentModelSerializer
  32.     def get_all(self,request):
  33.         """获取所有学生信息"""
  34.         return self.list(request)
  35.  
  36.     def add_student(self,request):
  37.  
  38.         return self.create(request)
  39.  
  40.     def get_one(self,request,pk):
  41.         """获取一个学生信息"""
  42.         return self.retrieve(request)

gen/views.py

  1. from django.urls import path, re_path
  2. from . import views
  3. urlpatterns = [
  4.     # 使用视图集把上面的两个视图类组成一个视图类
  5.     # as_view中提供字典参数,允许我们把http和视图方法进行一对一的映射
  6.     path("students4/",views.StudentViewSet.as_view({"get":"get_all","post":"add_student"})),
  7.     re_path("students4/(?P<pk>\d+)/", views.StudentViewSet.as_view({"get":"get_one"})),
  8.  
  9.     # 发挥下ViewSet的作用
  10.     path("students5/", views.Student2ViewSet.as_view({"get": "list", "post": "add_student"})),
  11.     re_path("students5/(?P<pk>\d+)/", views.Student2ViewSet.as_view({"get":"get_one"})),
  12.  
  13. ]

gen/urls.py

2）GenericViewSet

使用ViewSet通常并不方便，因为list、retrieve、create、update、destory等方法都需要自己编写，而这些方法与前面讲过的Mixin扩展类提供的方法同名，所以我们可以通过继承Mixin扩展类来复用这些方法而无需自己编写。但是Mixin扩展类依赖与GenericAPIView，所以还需要继承GenericAPIView。

GenericViewSet就帮助我们完成了这样的继承工作，继承自GenericAPIView与ViewSetMixin，在实现了调用as_view()时传入字典（如{'get':'list'}）的映射处理工作的同时，还提供了GenericAPIView提供的基础方法，可以直接搭配Mixin扩展类使用。

举例：

  1. from rest_framework.viewsets import GenericViewSet
    from rest_framework.mixins import ListModelMixin,CreateModelMixin,RetrieveModelMixin,UpdateModelMixin,DestroyModelMixin
    class Student4ViewSet(GenericViewSet,ListModelMixin,CreateModelMixin,RetrieveModelMixin,UpdateModelMixin,DestroyModelMixin):
        queryset = Student.objects.all()
        serializer_class = StudentModelSerializer

url的定义

  1. urlpatterns = [
        path("students7/", views.Student4ViewSet.as_view({"get": "list", "post": "create"})),
        re_path("students7/(?P<pk>\d+)/", views.Student4ViewSet.as_view({"get": "retrieve","put":"update","delete":"destroy"})),
    ​
    ]

3）ModelViewSet

继承自GenericViewSet，同时包括了ListModelMixin、RetrieveModelMixin、CreateModelMixin、UpdateModelMixin、DestoryModelMixin。

4）ReadOnlyModelViewSet

继承自GenericViewSet，同时包括了ListModelMixin、RetrieveModelMixin。

1.3.2 视图集中定义附加action动作

在视图集中，除了上述默认的方法动作外，还可以添加自定义动作。

举例：

  1. from rest_framework.viewsets import ModelViewSet,ReadOnlyModelViewSet
    class StudentModelViewSet(ModelViewSet):
        queryset = Student.objects.all()
        serializer_class = StudentModelSerializer
    ​
        def login(self,request):
            """学生登录功能"""
            return Response({"message":"登录成功"})

url的定义

  1. urlpatterns = [
        path("students8/", views.StudentModelViewSet.as_view({"get": "list", "post": "create"})),
        re_path("students8/(?P<pk>\d+)/",
                views.StudentModelViewSet.as_view({"get": "retrieve", "put": "update", "delete": "destroy"})),
    ​
        path("stu/login/",views.StudentModelViewSet.as_view({"get":"login"}))
    ​
    ]

1.3.3 action属性

在视图集中，我们可以通过action对象属性来获取当前请求视图集时的action动作是哪个。

例如：

  1. from rest_framework.viewsets import ModelViewSet
    from students.models import Student
    from .serializers import StudentModelSerializer
    from rest_framework.response import Response
    class StudentModelViewSet(ModelViewSet):
        queryset = Student.objects.all()
        serializer_class = StudentModelSerializer
    ​
        def get_new_5(self,request):
            """获取最近添加的5个学生信息"""
            # 操作数据库
            print(self.action) # 获取本次请求的视图方法名
            
            
    通过路由访问到当前方法中.可以看到本次的action就是请求的方法名
    ​
  1. from rest_framework.generics import GenericAPIView
  2.  
  3. from students.models import Student
  4. from .serializers import StudentModelSerializer, StudentModel2Serializer
  5. from rest_framework.response import Response
  6.  
  7. class StudentsGenericAPIView(GenericAPIView):
  8.     # 本次视图类中要操作的数据[必填]
  9.     queryset = Student.objects.all()
  10.     # 本次视图类中要调用的默认序列化器[选填]
  11.     serializer_class = StudentModelSerializer
  12.  
  13.     def get(self, request):
  14.         """获取所有学生信息"""
  15.         serializer = self.get_serializer(instance=self.get_queryset(), many=True)
  16.  
  17.         return Response(serializer.data)
  18.  
  19.     def post(self,request):
  20.  
  21.         data = request.data
  22.  
  23.         serializer = self.get_serializer(data=data)
  24.  
  25.         serializer.is_valid(raise_exception=True)
  26.  
  27.         instance = serializer.save()
  28.  
  29.         serializer = self.get_serializer(instance=instance)
  30.  
  31.         return Response(serializer.data)
  32.  
  33. class StudentGenericAPIView(GenericAPIView):
  34.     queryset = Student.objects.all()
  35.  
  36.     serializer_class = StudentModelSerializer
  37.  
  38.     def get_serializer_class(self):
  39.         """重写获取序列化器类的方法"""
  40.         if self.request.method == "GET":
  41.             return StudentModel2Serializer
  42.         else:
  43.             return StudentModelSerializer
  44.  
  45.     # 在使用GenericAPIView视图获取或操作单个数据时,视图方法中的代表主键的参数最好是pk
  46.     def get(self,request,pk):
  47.         """获取一条数据"""
  48.         serializer = self.get_serializer(instance=self.get_object())
  49.  
  50.         return Response(serializer.data)
  51.  
  52.     def put(self,request,pk):
  53.  
  54.         data = request.data
  55.  
  56.         serializer = self.get_serializer(instance=self.get_object(),data=data)
  57.  
  58.         serializer.is_valid(raise_exception=True)
  59.  
  60.         serializer.save()
  61.  
  62.         serializer = self.get_serializer(instance=self.get_object())
  63.  
  64.         return Response(serializer.data)
  65.  
  66. """GenericAPIView结合视图扩展类实现api接口"""
  67. from rest_framework.mixins import ListModelMixin,CreateModelMixin
  68. class Students2GenericAPIView(GenericAPIView,ListModelMixin,CreateModelMixin):
  69.     # 本次视图类中要操作的数据[必填]
  70.     queryset = Student.objects.all()
  71.     # 本次视图类中要调用的默认序列化器[玄天]
  72.     serializer_class = StudentModelSerializer
  73.  
  74.     def get(self, request):
  75.         """获取多个学生信息"""
  76.         return self.list(request)
  77.  
  78.     def post(self,request):
  79.         """添加学生信息"""
  80.         return self.create(request)
  81.  
  82. from rest_framework.mixins import RetrieveModelMixin,UpdateModelMixin,DestroyModelMixin
  83. class Student2GenericAPIView(GenericAPIView,RetrieveModelMixin,UpdateModelMixin,DestroyModelMixin):
  84.     queryset = Student.objects.all()
  85.  
  86.     serializer_class = StudentModelSerializer
  87.  
  88.     # 在使用GenericAPIView视图获取或操作单个数据时,视图方法中的代表主键的参数最好是pk
  89.     def get(self,request,pk):
  90.         """获取一条数据"""
  91.         return self.retrieve(request,pk)
  92.  
  93.     def put(self,request,pk):
  94.         """更新一条数据"""
  95.         return self.update(request,pk)
  96.  
  97.     def delete(self,request,pk):
  98.         """删除一条数据"""
  99.         return self.destroy(request,pk)
  100.  
  101. """使用GenericAPIView的视图子类进一步简化开发api接口的代码"""
  102. from rest_framework.generics import ListAPIView,CreateAPIView
  103. class Students3GenericAPIView(ListAPIView,CreateAPIView):
  104.     queryset = Student.objects.all()
  105.     serializer_class = StudentModelSerializer
  106.  
  107. from rest_framework.generics import RetrieveAPIView,UpdateAPIView,DestroyAPIView
  108. from rest_framework.generics import RetrieveUpdateDestroyAPIView # 结合了上面三个子类的功能
  109. class Student3GenericAPIView(RetrieveUpdateDestroyAPIView):
  110.     queryset = Student.objects.all()
  111.     serializer_class = StudentModelSerializer
  112.  
  113. """使用视图集把上面的两个视图类组成一个视图类"""
  114. from rest_framework.viewsets import ViewSet
  115. class StudentViewSet(ViewSet):
  116.     def get_all(self,request):
  117.         """获取所有学生信息"""
  118.         data_list = Student.objects.all()
  119.         serializer = StudentModelSerializer(instance=data_list, many=True)
  120.         return Response(serializer.data)
  121.  
  122.     def add_student(self,request):
  123.  
  124.         return Response({"message":"添加成功!"})
  125.  
  126.     def get_one(self,request,pk):
  127.         """获取一个学生信息"""
  128.         instance = Student.objects.get(pk=pk)
  129.         serializer = StudentModelSerializer(instance=instance)
  130.         return Response(serializer.data)
  131.  
  132. """发挥下ViewSet的作用"""
  133. from rest_framework.viewsets import ViewSet
  134. from rest_framework.generics import ListAPIView,CreateAPIView,RetrieveAPIView
  135. class Student2ViewSet(ViewSet,ListAPIView,CreateAPIView,RetrieveAPIView):
  136.     queryset = Student.objects.all()
  137.     serializer_class = StudentModelSerializer
  138.     def get_all(self,request):
  139.         """获取所有学生信息"""
  140.         return self.list(request)
  141.  
  142.     def add_student(self,request):
  143.  
  144.         return self.create(request)
  145.  
  146.     def get_one(self,request,pk):
  147.         """获取一个学生信息"""
  148.         return self.retrieve(request)
  149.  
  150. """使用GenericViewSet通用视图集"""
  151. from rest_framework.viewsets import GenericViewSet
  152. from rest_framework.mixins import ListModelMixin,CreateModelMixin,RetrieveModelMixin
  153. class Student3ViewSet(GenericViewSet,ListModelMixin,CreateModelMixin,RetrieveModelMixin):
  154.     queryset = Student.objects.all()
  155.     serializer_class = StudentModelSerializer
  156.     def get_all(self,request):
  157.         """获取所有学生信息"""
  158.         return self.list(request)
  159.  
  160.     def add_student(self,request):
  161.  
  162.         return self.create(request)
  163.  
  164.     def get_one(self,request,pk):
  165.         """获取一个学生信息"""
  166.         return self.retrieve(request)
  167.  
  168. """简化上面的代码"""
  169. from rest_framework.viewsets import GenericViewSet
  170. from rest_framework.mixins import ListModelMixin,CreateModelMixin,RetrieveModelMixin,UpdateModelMixin,DestroyModelMixin
  171. class Student4ViewSet(GenericViewSet,ListModelMixin,CreateModelMixin,RetrieveModelMixin,UpdateModelMixin,DestroyModelMixin):
  172.     queryset = Student.objects.all()
  173.     serializer_class = StudentModelSerializer
  174.  
  175. """使用ModelViewSet简写上面的继承代码"""
  176. from rest_framework.viewsets import ModelViewSet,ReadOnlyModelViewSet
  177. from rest_framework.decorators import action
  178. class StudentModelViewSet(ModelViewSet):
  179.     queryset = Student.objects.all()
  180.     serializer_class = StudentModelSerializer
  181.  
  182.     @action(methods=["get","put"],detail=True)
  183.     # methods 设置当前方法允许哪些http请求访问当前视图方法
  184.     # detail 设置当前视图方法是否是操作一个数据
  185.     def login(self,request,pk):
  186.         """学生登录功能"""
  187.         print(self.action)
  188.         print(pk)
  189.         return Response({"message":"登录成功"})

gen/views.py 全部代码

  1. from rest_framework import serializers
  2.  
  3. from students.models import Student
  4.  
  5. class StudentModelSerializer(serializers.ModelSerializer):
  6.     class Meta:
  7.         model= Student
  8.         fields = "__all__"
  9.  
  10. class StudentModel2Serializer(serializers.ModelSerializer):
  11.     class Meta:
  12.         model= Student
  13.         fields = ("name","class_null")

gen/serializers.py

  1. from django.urls import path, re_path
  2. from . import views
  3. urlpatterns = [
  4.     path("students/",views.StudentsGenericAPIView.as_view()),
  5.     re_path("students/(?P<pk>\d+)/",views.StudentGenericAPIView.as_view()),
  6.  
  7.     # GenericAPIView结合视图扩展类实现api接口
  8.     path("students2/", views.Students2GenericAPIView.as_view()),
  9.     re_path("students2/(?P<pk>\d+)/",views.Student2GenericAPIView.as_view()),
  10.  
  11.     # 使用GenericAPIView的视图子类进一步简化开发api接口的代码
  12.     path("students3/", views.Students3GenericAPIView.as_view()),
  13.     re_path("students3/(?P<pk>\d+)/", views.Student3GenericAPIView.as_view()),
  14.  
  15.     # 使用视图集把上面的两个视图类组成一个视图类
  16.     # as_view中提供字典参数,允许我们把http和视图方法进行一对一的映射
  17.     path("students4/",views.StudentViewSet.as_view({"get":"get_all","post":"add_student"})),
  18.     re_path("students4/(?P<pk>\d+)/", views.StudentViewSet.as_view({"get":"get_one"})),
  19.  
  20.     # 发挥下ViewSet的作用
  21.     path("students5/", views.Student2ViewSet.as_view({"get": "list", "post": "add_student"})),
  22.     re_path("students5/(?P<pk>\d+)/", views.Student2ViewSet.as_view({"get":"get_one"})),
  23.  
  24.     # 使用GenericViewSet通用视图集
  25.     path("students6/", views.Student3ViewSet.as_view({"get": "get_all", "post": "add_student"})),
  26.     re_path("students6/(?P<pk>\d+)/", views.Student3ViewSet.as_view({"get": "get_one"})),
  27.  
  28.     # 简化上面student6的代码
  29.     path("students7/", views.Student4ViewSet.as_view({"get": "list", "post": "create"})),
  30.     re_path("students7/(?P<pk>\d+)/", views.Student4ViewSet.as_view({"get": "retrieve","put":"update","delete":"destroy"})),
  31.  
  32.     path("students8/", views.StudentModelViewSet.as_view({"get": "list", "post": "create"})),
  33.     re_path("students8/(?P<pk>\d+)/",
  34.             views.StudentModelViewSet.as_view({"get": "retrieve", "put": "update", "delete": "destroy"})),
  35.  
  36.     path("stu/login/",views.StudentModelViewSet.as_view({"get":"login"}))
  37.  
  38. ]
  39.  
  40. """使用drf提供路由类router给视图集生成路由列表"""
  41. # 实例化路由类
  42. # drf提供一共提供了两个路由类给我们使用,他们用法一致,功能几乎一样
  43. # DefaultRouter
  44. #  SimpleRouter
  45. from rest_framework.routers import DefaultRouter,SimpleRouter
  46. router = DefaultRouter()
  47.  
  48. # 注册视图集
  49. # router.register("路由前缀",视图集类)
  50. router.register("router_stu",views.StudentModelViewSet)
  51.  
  52. # 把生成的路由列表追加到urlpatterns
  53. print( router.urls )
  54. urlpatterns += router.urls

gen/urls.py 全部路由

  1.  

drf04 drf视图类的更多相关文章

  1. 067.Python框架Django之DRF视图类

    一 关于视图类的一下概念 drf除了在数据序列化部分简写代码以外,还在视图中提供了简写操作.所以在django原有的django.views.View类基础上,drf封装了多个子类出来提供给我们使用. ...

  2. drf视图类总结

    ![image](https://img2022.cnblogs.com/blog/2608149/202204/2608149-20220401194236430-447848842.png)

  3. DRF之视图类(mixin)源码解析

     同样的增删改查操作,如果我们还像之前序列化组件那样做,代码重复率过多,所以我们用视图表示: 具体源码实现:首先定义一个视图类,然后根据mixin点进去有五个封装好的方法,这五个方法共有的属性就是都需 ...

  4. drf03 drf视图中提供的请求类和响应类

    drf除了在数据序列化部分简写代码以外,还在视图中提供了简写操作.所以在django原有的django.views.View类基础上,drf封装了多个子类出来提供给我们使用. Django REST ...

  5. DRF介绍，DRF项目开发，DRF项目的视图类的dispatch源码解析

    目录 一.DRF介绍 1. 什么是DRF 2. 为什么要用DRF (1)使用DRF的原因 (2)站在开发者的角度来说用DRF的好处(暂时列举这么多) 二.用DRF开发后端项目 三.APIView请求生 ...

  6. DRF框架之视图类

    前后端分离的项目 >: pip3 install djangorestframework   一.视图类传递参数给序列化类 视图层:views.py 需求: (1)在视图类中实列化对象是,可以设 ...

  7. day73:drf:drf视图相关类&路由Routers&创建虚拟环境

    目录 1.APIView 2.GenericAPIView:通用视图类 3.5个视图扩展类:ListModelMixin,CreateModelMixin,RetrieveModelMixin,Upd ...

  8. drf之视图类与路由

    视图 Django REST framwork 提供的视图的主要作用: 控制序列化器的执行(检验.保存.转换数据) 控制数据库查询的执行 2个视图基类 APIView rest_framework.v ...

  9. DRF视图-5个扩展类以及GenericAPIView基类

    视图 5个视图扩展类 视图拓展类的作用: 提供了几种后端视图(对数据资源进行曾删改查)处理流程的实现,如果需要编写的视图属于这五种,则视图可以通过继承相应的扩展类来复用代码,减少自己编写的代码量. 这 ...

随机推荐

  1. 传染病控制（洛谷 1041 WA 90）

    题目背景 近来,一种新的传染病肆虐全球.蓬莱国也发现了零星感染者,为防止该病在蓬莱国大范围流行,该国政府决定不惜一切代价控制传染病的蔓延.不幸的是,由于人们尚未完全认识这种传染病,难以准确判别病毒携带 ...

  2. POJ 3252 Round Numbers 组合数学

    Time Limit: 2000MS   Memory Limit: 65536K Total Submissions: 13381   Accepted: 5208 Description The ...

  3. sqlyog

    https://github.com/webyog/sqlyog-community/wiki/Downloads

  4. 快速傅立叶变换&HDU 1402

    参考http://www.cnblogs.com/v-July-v/archive/2011/08/13/2214132.html <算导> 那么,更快速的多项式乘法就依赖于能否把一个系数 ...

  5. volatile非原子性的示例

    volatile非原子性的示例 package com.stono.thread2.page124; public class MyThread extends Thread { volatile p ...

  6. 我们的一个已投产项目的高可用数据库实战 - mongo 副本集的搭建具体过程

    我们的 mongo 副本集有三台 mongo 服务器:一台主库两台从库. 主库进行写操作,两台从库进行读操作(至于某次读操作到底路由给了哪台,仲裁决定).实现了读写分离.这还不止,假设主库宕掉,还能实 ...

  7. BEGINNING SHAREPOINT&#174; 2013 DEVELOPMENT 第9章节--client对象模型和REST APIs概览 介绍SP2013中远程APIs

    BEGINNING SHAREPOINT® 2013 DEVELOPMENT 第9章节--client对象模型和REST APIs概览  介绍SP2013中远程APIs         当SP首次開始 ...

  8. IOS7中动态计算UILable的高度

    .h文件 #import <UIKit/UIKit.h> @interface UILabel (ContentSize) - (CGSize)contentSize; @end .m文件 ...

  9. Android动态逆向分析工具ZjDroid--脱壳神器

    项目地址:https://github.com/BaiduSecurityLabs/ZjDroid 前提条件: 1.Root手机一部 2.须要通过Xposed installer( http://dl ...

  10. luogu1005 矩阵取数游戏

    题目大意 一个矩阵,每次从每一行的行首或行尾取一个数,每一行的价值为 取的数*2^当前取数的次数,每一次的价值为每一行的价值的和.求得到的价值的最大值. 思路 #include <cstdio& ...