[Django REST framework - 视图组件之视图基类、视图扩展类、视图子类、视图集]

视图继承关系

详图见文章末尾

视图组件可点我查看

两个视图基类：APIView、GenericAPIView

from rest_framework.views import APIView
APIView与View的不同之处在于：
传入到视图方法中的是REST framework的Request对象，而不是Django的HttpRequeset对象；
视图方法可以返回REST framework的Response对象，视图会为响应数据设置（render）符合前端要求的格式；
任何APIException异常都会被捕获到，并且处理成合适的响应信息；
在进行dispatch()分发前，会对请求进行身份认证、权限检查、流量控制。
支持定义的类属性
authentication_classes 列表或元祖，身份认证类
permission_classes 列表或元祖，权限检查类
throttle_classes 列表或元祖，流量控制类
在APIView中仍以常规的类视图定义方法来实现get() 、post() 或者其他请求方式的方法
********示例在下方*******

继承 APIView

导入模块: from rest_framework.views import APIView

from rest_framework.views import APIView    # 导入模块
class Books(APIView):  
    def get(self,request):   # get请求会执行此方法  用于查询全部信息
        book = Book.objects.all()  # 获取Book下全部字段信息
        obj = BookSerializer(book,many=True)  # 查询多条需要指定many=True
        return Response(obj.data)  #  obj.data将数据返回
    def post(self,request): # post请求执行此方法  用于创建新的信息
        obj = BookSerializer(data=request.data)  # 将数据传入序列化器（类）
        if obj.is_valid():   #  校验数据是否合法
            obj.save()  # .save保存数据
        return Response(obj.data)
class Bookss(APIView):
    def put(self,request,pk):
        book = Book.objects.filter(pk=pk).first()
        obj = BookSerializer(instance=book,data=request.data)
        if obj.is_valid():
            obj.save()
        return Response(obj.data)
    def get(self,request,pk):
        book = Book.objects.filter(pk=pk).first()
        obj = BookSerializer(instance=book)
        return Response(obj.data)
    def delete(self,request,pk):
        Book.objects.filter(pk=pk).delete()
        return Response()

继承 GenericAPIView

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

from rest_framework.generics import GenericAPIView
    
GenericAPIView(APIView):做了一些封装
    -属性：
         queryset  # 要序列化的数据
         serializer_class  # 指明视图使用的序列化器
    -方法：
          get_queryset：获取qs数据(返回视图使用的查询集，主要用来提供给Mixin扩展类使用，
                是列表视图与详情视图获取数据的基础，默认返回queryset属性)
        
        get_object：获取一条数据的对象(返回详情视图所需的模型类数据对象，主要用来
             提供给Mixin扩展类使用。在试图中可以调用该方法获取详情信息的模型类对象)
        
        get_serializer：以后使用它来实例化得到ser对象(返回序列化器对象，主要用来
                  提供给Mixin扩展类使用，如果我们在视图中想要获取序列化器对象，也可以直接调用此方法)
        
        get_serializer_class：获取序列化类，注意跟上面区分

导入模块: from rest_framework.views import GenericAPIView

-queryset = None  #查那个表，就把   表名.objects.all()
-serializer_class = None # 要使用那个序列化类序列化数据，把类名写上
---------------------------------------------------------------------------------------
from rest_framework.views import GenericAPIView  
from .serializer import BookSerializer  # 导入序列化器（类）
class Books(GenericAPIView):
     # 将数据和序列化提示为类属性，所有的请求方法都可以复用
    queryset = Book.objects.all()    # 要序列化的数据
    serializer_class = BookSerializer  # BookSerializer是导入的序列化类
    lookup_field = 'pk'  # 可以省略，默认是pk，与url有名分组对应的
    
    def get(self,request):
         # book = models.Book.objects.filter(is_delete=False).all()  # => 方法+属性两行代码
        book = self.get_queryset()
        
         # serializer = serializers.BookSerializer(instance=book, many=True)  # => 方法+属性两行代码
        obj = self.get_serializer(book,many=True)  # 多条需要指定many=True
        return Response(obj.data)
    
    def post(self,request):
        # obj = serializers.BookModelSerializer(data=request.data)  
        #  把前端传入的数据，完成实例化，得到序列化类的对象
        obj = self.get_serializer(data = request.data)  # 等同于上面的操作
        
        if obj.is_valid():
            obj.save()
            return Response(obj.data)
class Bookss(GenericAPIView):
    queryset = Book.objects.all()   # 同上~ 
    serializer_class = BookSerializer
    def get(self,request,pk):
        
        book = self.get_object()  # 不同的是获取单挑是用self.get_object() 
        obj = self.get_serializer(instance=book)
      
        return Response(obj.data)
    def put(self,request,pk):
        book = self.get_object()
        obj = self.get_serializer(instance=book,data=request.data)
        if obj.is_valid():
            obj.save()
            return Response(obj.data)
    def delete(self,request,pk):
        self.get_object().delete()
        return Response()

五个视图扩展类

视图扩展类：mixins包下的五个类（六个方法）

作用:

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

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

导入模块:

from rest_framework.mixins import CreateModelMixin,ListModelMixin,DestroyModelMixin,UpdateModelMixin,RetrieveModelMixin

CreateModelMixin #内部有create方法，就是新增

ListModelMixin #内部有list方法，就是查询所有

DestroyModelMixin # 内部有destory方法，就是删除单条

UpdateModelMixin # 内部有update方法，就是修改一条

RetrieveModelMixin # 内部有retrieve方法，就是查询单条

"""
视图基类：APIView、GenericAPIView
视图扩展类：mixins包下的五个类（六个方法）
"""
""" GenericAPIView基类（基本不会单独使用，了解即可，但是是高级视图类的依赖基础）
1）GenericAPIView继承APIView，所有APIView子类写法在继承GenericAPIView时可以保持一致
2）GenericAPIView给我们提供了三个属性 queryset、serializer_class、lookup_field
3）GenericAPIView给我们提供了三个方法 get_queryset、get_serializer、get_obj
"""
""" mixins包存放了视图工具类（不能单独使用，必须配合GenericAPIView使用）
1 查所有：ListModelMixin
    列表视图扩展类，提供list(request, *args, **kwargs)方法快速实现列表视图，返回200状态码。
     该Mixin的list方法会对数据进行过滤和分页。
    
2 查一个：RetrieveModelMixin
    创建视图扩展类，提供create(request, *args, **kwargs)方法快速实现创建资源的视图，成功返回201状态码。
     如果序列化器对前端发送的数据验证失败，返回400错误。
        
3 增一个：CreateModelMixin
    详情视图扩展类，提供retrieve(request, *args, **kwargs)方法，可以快速实现返回一个存在的数据对象。
     如果存在，返回200， 否则返回404
4 改一个：UpdateModelMixin
    更新视图扩展类，提供update(request, *args, **kwargs)方法，可以快速实现更新一个存在的数据对象。
    同时也提供partial_update(request, *args, **kwargs)方法，可以实现局部更新。
     成功返回200，序列化器校验数据失败时，返回400错误。
5 删一个：DestroyModelMixin
    删除视图扩展类，提供destroy(request, *args, **kwargs)方法，可以快速实现删除一个存在的数据对象
    成功返回204，不存在返回404。
"""
""" generics包下的所有GenericAPIView的子类（就是继承GenericAPIView和不同mixins下的工具类的组合）
1）定义的视图类，继承generics包下已有的特点的GenericAPIView子类，可以在只初始化queryset和serializer_class两个类属性后，就获得特定的功能
2）定义的视图类，自己手动继承GenericAPIView基类，再任意组合mixins包下的一个或多个工具类，可以实现自定义的工具视图类，获得特定的功能或功能们
注：
i）在这些模式下，不能实现单查群查共存（可以加逻辑区分，也可以用视图集知识）
ii）DestroyModelMixin工具类提供的destory方法默认是从数据库中删除数据，所以一般删除数据的需求需要自定义逻辑
"""

案例:

from rest_framework.generics import GenericAPIView
from rest_framework.mixins import CreateModelMixin,ListModelMixin,DestroyModelMixin,UpdateModelMixin,RetrieveModelMixin
class BookView(GenericAPIView,CreateModelMixin,ListModelMixin):
    queryset = Books.objects.all()
    serializer_class = BookSerializer
    def get(self,request):
        # # 拿到所有
        # obj_list=self.get_queryset()
        # # 得到序列化对象
        # ser=self.get_serializer(obj_list,many=True)
        # # 返回数据
        # return Response(ser.data)
        
        return self.list(request)   #  无需上面操作  直接self.list即可  都封装好了
    def post(self,request):
        # # 把前端传入的数据，完成实例化，得到序列化类的对象
        # ser = self.get_serializer(data=request.data)
        # # 校验数据
        # if ser.is_valid():
        #     ser.save()
        #     return Response(ser.data)
        return self.create(request)
    #
    # def perform_create(self, serializer):
    #     #逻辑
    #     super().perform_create()
class BookDetailView(GenericAPIView,RetrieveModelMixin,DestroyModelMixin,UpdateModelMixin):
    queryset = Books.objects.all()
    serializer_class = BookSerializer
    def get(self, request,pk):
        # 获取单条
        # obj=self.get_object()
        # # 得到单条的序列化对象
        # ser = self.get_serializer(obj)
        # return Response(ser.data)
        return self.retrieve(request, pk)
    def delete(self,request,pk):
        # # 获取单条，通过pk获取的
        # obj=self.get_object()
        # # 删除对象
        # obj.delete()
        # return Response()
        return self.destroy(request,pk)
    def put(self,request,pk):
        # # 获取单条
        # obj = self.get_object()
        # # 得到序列化类对象，传入单条对象和要修改的数据字典
        # ser=self.get_serializer(obj,data=request.data)
        # if ser.is_valid():
        #     ser.save()
        #     return Response(ser.data)
        return self.update(request,pk)

九个视图子类

ListAPIView, 
CreateAPIView,  
UpdateAPIView,
DestroyAPIView,
RetrieveAPIView,
ListCreateAPIView,
RetrieveUpdateDestroyAPIView,
RetrieveDestroyAPIView,
RetrieveUpdateAPIView

九个视图子类详解

1）查所有：ListAPIView  # 获取所有，视图类只需要继承它，写两个类属性，就有获取所有的功能了
提供 get 方法
继承自：GenericAPIView、ListModelMixin
例如:
         class Books(ListAPIView):   # 获取所有  
                queryset = Book.objects.all()  # 写两个类属性
                serializer_class = BookSerializer
2）增一个：CreateAPIView  
    # 创建1个，视图类只需要继承它，写两个类属性，就有创建一个所有的功能了
提供 post 方法
继承自： GenericAPIView、CreateModelMixin
3）查所有+增一个：ListCreateAPIView 
    # 查询所有与创建一个  视图类只需要继承它，写两个类属性，就有创建一个和查询所有的功能了
提供 get 和 post 方法
继承自： GenericAPIView、ListModelMixin、CreateModelMixin
4）查一个：RetrieveAPIView  
    # 查询1个，视图类只需要继承它，写两个类属性，就有查询一个的功能了
提供 get 方法
继承自: GenericAPIView、RetrieveModelMixin
   
5）改一个：UpdateAPIView
    # 修改1个，视图类只需要继承它，写两个类属性，就有修改一个的功能了
提供 put 和 patch 方法
继承自：GenericAPIView、UpdateModelMixin
6）删一个：DestoryAPIView
    # 删除1个，视图类只需要继承它，写两个类属性，就有删除一个的功能了
提供 delete 方法
继承自：GenericAPIView、DestoryModelMixin
7）查一个+改一个：RetrieveUpdateAPIView
    # 查1个+改1个，视图类只需要继承它，写两个类属性，就有查1个与改1个的功能了
提供 get、put、patch方法
继承自： GenericAPIView、RetrieveModelMixin、UpdateModelMixin
8）查一个+删一个：RetrieveDestroyAPIView
    # 查1个+删1个，视图类只需要继承它，写两个类属性，就有查1个与删1个的功能了
提供 get 和 delete 方法
继承自： GenericAPIView、RetrieveModelMixin、DestoryModelMixin
9） 查一个+改一个+删一个：RetrieveUpdateDestoryAPIView
    # 查1个+改1个+删1个，视图类只需要继承它，写两个类属性，就有查1个+改1个+删1个的功能了
提供 get、put、patch、delete方法
继承自：GenericAPIView、RetrieveModelMixin、UpdateModelMixin、DestoryModelMixin

案例:

from rest_framework.generics import ListAPIView,CreateAPIView,UpdateAPIView,RetrieveAPIView,DestroyAPIView,ListCreateAPIView,RetrieveDestroyAPIView,RetrieveUpdateAPIView,RetrieveUpdateDestroyAPIView
class Books(ListAPIView,CreateAPIView):  # 继承这两个类 写两个类属性
    # 查询所有与创建一个 写两个类属性，就有创建一个和查询所有的功能了
    #  也可以直接继承ListCreateAPIView  效果一样
    queryset = Book.objects.all()
    serializer_class = BookSerializer
class Bookss(RetrieveUpdateDestroyAPIView):
    # 继承RetrieveUpdateDestroyAPIView就有查1个+改1个+删1个的功能了
    queryset = Book.objects.all()  # 之后写两个类属性即可
    serializer_class = BookSerializer
    
    也可以单独继承你所需要的接口属性
    例如: 
        你只需要删除信息与修改信息  那么你只需要继承UpdateAPIView，DestroyAPIView即可

视图集ViewSet

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

• list() 提供一组数据

• retrieve() 提供单个数据

• create() 创建数据

• update() 保存数据

• destory() 删除数据

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

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

只要继承ViewSetMixin的视图类，以后路由写发特殊了

而视图集都直接或者间接的继承了ViewSetMixin

# ViewSetMixin类----》重写了as_view方法---》view跟之前（APIView的as_view）不一样了
-path('books/', views.BookView.as_view({'get':'list','post':'create'}))

常用的视图集父类

1） ViewSet

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

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

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

总结：如果路由想写成特殊的，如果要继承APIView----》直接继承ViewSet

2）GenericViewSet

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

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

总结：如果路由想写成特殊的，如果要继承GenericAPIView----》直接继承GenericViewSet

3）ModelViewSet

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

5个接口写好了、ModelViewSet继承了5个视图扩展类，GenericAPIView 和 ViewSetMixin

4）ReadOnlyModelViewSet

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

视图集案例:

# 模型层models.py 和序列化类层 serializer.py参照上面即可
# 路由层 urls.py
from django.contrib import admin
from django.urls import path
from app01 import views
urlpatterns = [
    path('admin/', admin.site.urls),
    # 查询所有书籍，增加书籍
    path('book/', views.BookView.as_view({'get': 'list', 'post': 'create'})),
    # 查询，修改，删除单本书籍
    path('book/<int:pk>/', views.BookView.as_view({'get': 'retrieve', 'put': 'update', 'delete': 'destroy'})),
    path('publish/', views.PublishView.as_view({'get': 'lqz'})),
]
# 视图层 views.py
###目标：只写一个视图类，实现5个接口，最大的问题是，俩接口，都是get
####第五层：视图集
# ModelViewSet 5个接口都有
# ModelViewSet 继承了GenericViewSet和五个视图扩展类
# ReadOnlyModelViewSet：只有读的两个接口
from rest_framework.viewsets import ModelViewSet, ReadOnlyModelViewSet
from rest_framework.viewsets import ViewSet, GenericViewSet, ViewSetMixin
#ViewSet是：ViewSetMixin, views.APIView
#GenericViewSet是：ViewSetMixin, GenericAPIView
# ViewSetMixin:魔法
### 如果视图类继承了ViewSetMixin这个类，路由写法就需要path('book/', views.BookView.as_view({'get': 'list', 'post': 'create'})
'''
源码映射关系
{'get': 'list', 'post': 'create'}
      'get'    'list'
for method, action in actions.items():
    handler = getattr(self, action)
    setattr(self, method, handler)
'''
###如果视图类继承了ViewSetMixin这个类，路由的as_view执行的是ViewSetMixin的as_view
# 查询所有书籍，增加一本书籍,查询、修改、删除单本书籍
class BookView(ModelViewSet):
    queryset = models.Book.objects.all()  # 要序列化的数据
    serializer_class = serializer.BookModelSerializer  # 要序列化的类
class PublishView(GenericViewSet): # 路由变了，其它都没变（注意继承的类，不要混淆了）
    queryset = models.Publish.objects.all()  # 要序列化的数据
    serializer_class = serializer.PublishModelSerializer  # 要序列化的类
    def lqz(self,request):   # 自定义lqz就是获取所有
        qs = self.get_queryset()  
        ser = self.get_serializer(qs, many=True)  
        return Response(ser.data)

总结

#两个基类
APIView
GenericAPIView：有关数据库操作，queryset 和serializer_class
#5个视图扩展类(rest_framework.mixins)
CreateModelMixin：create方法创建一条
DestroyModelMixin：destory方法删除一条
ListModelMixin：list方法获取所有
RetrieveModelMixin：retrieve获取一条
UpdateModelMixin：update修改一条
#9个子类视图(rest_framework.generics)
CreateAPIView:继承CreateModelMixin,GenericAPIView，有post方法，新增数据
DestroyAPIView：继承DestroyModelMixin,GenericAPIView，有delete方法，删除数据
ListAPIView：继承ListModelMixin,GenericAPIView,有get方法获取所有
UpdateAPIView：继承UpdateModelMixin,GenericAPIView，有put和patch方法，修改数据
RetrieveAPIView：继承RetrieveModelMixin,GenericAPIView，有get方法，获取一条
ListCreateAPIView：继承ListModelMixin,CreateModelMixin,GenericAPIView，有get获取所有,post方法新增
RetrieveDestroyAPIView：继承RetrieveModelMixin,DestroyModelMixin,GenericAPIView，有get方法获取一条，delete方法删除
RetrieveUpdateAPIView：继承RetrieveModelMixin,UpdateModelMixin,GenericAPIView，有get获取一条，put，patch修改
RetrieveUpdateDestroyAPIView：继承RetrieveModelMixin,UpdateModelMixin,DestroyModelMixin,GenericAPIView，有get获取一条，put，patch修改，delete删除
#视图集
ViewSetMixin：重写了as_view 
ViewSet：     继承ViewSetMixin和APIView
GenericViewSet：继承ViewSetMixin, generics.GenericAPIView
ModelViewSet：继承mixins.CreateModelMixin,mixins.RetrieveModelMixin,mixins.UpdateModelMixin,mixins.DestroyModelMixin,mixins.ListModelMixin,GenericViewSet
ReadOnlyModelViewSet：继承mixins.RetrieveModelMixin,mixins.ListModelMixin,GenericViewSet

本篇知识回顾

1 序列化器源码
    -many参数控制，在__new__中控制了对象的生成
    -局部和全局钩子源码：is_valid--》找self.方法一定要从根上找
    -source参数是如何执行的：‘publish.name’,'方法'
2 视图：
    -2个视图基类
    -5个视图扩展类
    -9个视图子类
    -视图集
        -ViewSetMixin
        -ViewSet, GenericViewSet
        -ModelViewSet, ReadOnlyModelViewSet
    
3 视图类的继承原则
    -如果不涉及数据库操作：继承APIView
    -如果想让路由可以映射：继承ViewSetMixin
    -如果不涉及数据库操作，又要让路由可以映射：继承ViewSet
    -比如发邮件接口，发短信接口
    
    
    -如果涉及到数据库操作：继承GenericAPIView
    -如果想让路由可以映射：继承ViewSetMixin
    -如果涉及数据库操作，又要让路由可以映射：继承GenericViewSet
    -如果涉及数据库操作，又要让路由可以映射，还要能新增：继承GenericViewSet+CreateModelMixin或者继承ViewSetMixin+CreateAPIView
    
    -如果只涉及到数据库操作和新增：继承CreateAPIView
    
    -路由有映射，数据库操作，3个接口（查一个，删一个改一个）
    
4 ViewSetMixin：路由的写法就特殊了
    
    
    
5 类实例化，先执行了元类的__call__:调用了这个类的__new__,生成一个空对象，调用了类的__init__,完成了对象的初始化
6 对象()---->会触发类的 __call__
7 类()----->会触发类的类（元类）的__call__

如果顶上的图你还觉得不够清晰，那么这张绝对会让你眼花缭乱

原文: https://www.cnblogs.com/liupengfei1123/p/14969816.html