[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__

如果頂上的圖你還覺得不夠清晰，那么這張絕對會讓你眼花繚亂