drf 檢視使用及原始碼分析

前言

　　 drf檢視的原始碼非常的繞，但是實現的功能卻非常的神奇。

　　 它能夠幫你快速的解決ORM增刪改查的重複程式碼，非常的方便好用。

　　 下面是它原始碼中的一句話：

class ViewSetMixin:
    """
    This is the magic.
    """

　　 好了，屁話不多說，直接看看drf檢視中的功能吧。

準備工作

　　 此次的Django採用3版本，所以相對於1版本來說有一些差異。

模型表

　　 下面是模型表：

from django.db import models

# Create your models here.
class User(models.Model):
    user_id = models.AutoField(primary_key=True)
    user_name = models.CharField(max_length=50)
    user_gender = models.BooleanField(
        [(0,"male"),(1,"female")],
        default = 0,
    )
    user_age = models.IntegerField()

    def __str__(self):
        return self.user_name

    class Meta:
        db_table = ''
        managed = True
        verbose_name = 'User'
        verbose_name_plural = 'Users'

　　 資料如下：

INSERT INTO app01_user(user_name,user_age,user_gender) VALUES
    ("使用者1",18,0),
    ("使用者2",19,1),
    ("使用者3",19,1);

序列類

　　 序列類採用ModelSerializer：

from rest_framework import serializers
from . import models

class UserModelSerializers(serializers.ModelSerializer):
    
    class Meta:
        model = models.User
        fields = "__all__"

url路由

　　 下面是url路由的設定：

re_path('^api/users/(?P<uid>\d+)?',views.UserAPI.as_view())

封裝Rsponse

　　 由於不需要返回原生的Response，所以我們封裝了一個類，用於更加方便的返回Response：

class ResponseMeta(type):
    # 對Response類做封裝
    def __call__(cls, *args, **kwargs):
        obj = cls.__new__(cls, *args, **kwargs)
        cls.__init__(obj, *args, **kwargs)
        return Response(data=obj.__dict__)


class CommonResponse(object, metaclass=ResponseMeta):
    # 返回的資訊
    def __init__(self, status, data=None, errors=None):
        self.status = status
        self.data = data
        self.errors = errors

APIView

繼承關係

　　 APIView的匯入如下：

from rest_framework.views import APIView

　　 APIView繼承了原生的DjangoView，在其之上做了一些封裝，使操作更加簡單。

　　

封裝特性

　　 在APIView中對原生的request物件進行封裝，最常用的兩個屬性如下，它彌補了Django原生View對JSON請求格式的資料沒有處理的缺陷。

　　 同時，APIView認為對於GET請求的資源引數，不應該使用GET獲取，而是應該使用query_params進行獲取。

屬性	描述
request.data	當請求資料為Json格式時，將以dict形式儲存，主要針對request.POST請求
request.query_params	當請求方式為GET時，可獲取url中的請求資料

介面書寫

　　 以下是使用APIView對User表進行增刪改查的介面書寫。

from rest_framework.views import APIView
from rest_framework.response import Response
from rest_framework.request import Request
from . import models
from . import ser


class ResponseMeta(type):
    # 對Response類做封裝
    def __call__(cls, *args, **kwargs):
        obj = cls.__new__(cls, *args, **kwargs)
        cls.__init__(obj, *args, **kwargs)
        return Response(data=obj.__dict__)


class CommonResponse(object, metaclass=ResponseMeta):
    # 返回的資訊
    def __init__(self, status, data=None, errors=None):
        self.status = status
        self.data = data
        self.errors = errors


class UserAPI(APIView):
    def get(self, request, uid=None):
        if not uid:
            # 獲取所有
            user_queryset = models.User.objects.all()
            if user_queryset.exists():
                serialization = ser.UserModelSerializers(instance=user_queryset, many=True)
                return CommonResponse(status=100, data=serialization.data, errors=None)
            return CommonResponse(status=200, errors="暫時沒有任何學生")
        else:
            user_obj = models.User.objects.filter(pk=uid).first()
            if user_obj:
                serialization = ser.UserModelSerializers(instance=user_obj)
                return CommonResponse(status=100, data=serialization.data, errors=None)
            return CommonResponse(status=200, errors="沒有該學生")

    def post(self, request):

        serialization = ser.UserModelSerializers(data=request.data)
        if serialization.is_valid():
            serialization.save()
            return CommonResponse(status=100, data=serialization.data, errors=None)
        return CommonResponse(status=200, errors=serialization.errors)

    def patch(self, request, uid):
        user_obj = models.User.objects.filter(pk=uid).first()
        if user_obj:
            serialization = ser.UserModelSerializers(instance=user_obj, data=request.data)
            if serialization.is_valid():
                serialization.save()
                return CommonResponse(status=100, data=serialization.data, errors=None)
            else:
                return CommonResponse(status=200, errors="修改失敗，請檢查欄位是否一直")
        else:
            return CommonResponse(status=200, errors="修改失敗，請檢查該使用者是否存在")

    def delete(self,request,uid):
        models.User.objects.get(pk=uid).delete()
        return CommonResponse(status=100,data="刪除成功",errors=None)

問題發現

　　 在上述程式碼中，問題有以下幾點：

1. 重複程式碼多，在每個介面中都需要書寫ORM查詢
2. 每個介面都需要針對同一個序列類做出不同的例項化

GenericAPIView

繼承關係

　　 GenericAPIView的匯入如下：

from rest_framework.generics import GenericAPIView

　　 以下是它的繼承關係：

　　

　　 可以發現它是對APIView的繼承，所以理論上來說應該又多了一些東西。

原始碼閱讀

　　 下面來看一下GenericAPIView的原始碼，首先你可以發現大概有4個類屬性：

class GenericAPIView(views.APIView):

    queryset = None  # 要查詢的資料表
    serializer_class = None  # 執行序列化的序列化類

    lookup_field = 'pk'  # 查詢時的查詢條件，預設按主鍵查詢
    lookup_url_kwarg = None  # 如果在檢視中，url捕獲的查詢資料表過濾引數不是pk，你應該進行宣告

　　 接著往下看，其實它的方法很少，對外暴露的方法就更少了。

　　

　　 我們這裡就先看最常用的，即對外暴露的方法，首先是get_queryset()。

    def get_queryset(self):

        assert self.queryset is not None, (
            "'%s' should either include a `queryset` attribute, "
            "or override the `get_queryset()` method."
            % self.__class__.__name__
        )  # 做驗證，即例項屬性queryset不能是空，代表這個類屬性你必須要宣告，你可以選擇將它做成類屬性也可以做成例項屬性

        queryset = self.queryset  # 進行賦值，將self.queryset賦值為類屬性。先在UserAPI的例項中找，找不到再到UserAPI的類中找
        if isinstance(queryset, QuerySet):
            queryset = queryset.all()  # 如果它是一個QuerySET物件，就獲取全部，得到一個QuerySetDict物件
        return queryset  # 進行返回

　　 看到這裡發現了一個點，即queryset這個屬性必須要進行賦值，由於屬性查詢順序是先查詢例項，而後查詢類本身，所以我們直接在UserAPI中宣告queryset為類屬性即可。

　　 接下來繼續繼續看，get_object()，見明知意，它可以從資料表中獲取單個物件：

    def get_object(self):
        queryset = self.filter_queryset(self.get_queryset())  # 首先會執行get_queryset()，獲取一個所有物件的列表，然後進行filter過濾
        lookup_url_kwarg = self.lookup_url_kwarg or self.lookup_field  # 這裡是對url中獲取到的變數進行對映

        assert lookup_url_kwarg in self.kwargs, (  # 比如，url中獲取到的名為uid，如果uid沒有在kwargs中，即是{uid:4}中，則丟擲異常
            'Expected view %s to be called with a URL keyword argument '
            'named "%s". Fix your URL conf, or set the `.lookup_field` '
            'attribute on the view correctly.' %
            (self.__class__.__name__, lookup_url_kwarg)
        )

        filter_kwargs = {self.lookup_field: self.kwargs[lookup_url_kwarg]}  # 進行查詢替換，預設的self.lookup_field是pk，將uid替換為pk。那麼這裡就是{pk:4}
        obj = get_object_or_404(queryset, **filter_kwargs) # 獲取物件
        self.check_object_permissions(self.request, obj)  # 進行驗證許可權

        return obj  # 返回單個物件

　　 看到這裡就發現了，預設查詢條件是用pk，也就是說你的url中必須要用pk這個形參名進行分組捕獲。否則就需要宣告lookup_url_kwarg，即lokup_url_kwarg="uid"，然後進行替換組建filter_kwargs。當然如果你的查詢條件不是用的pk，就需要修改lookup_field為欄位名，如我不是按照pk進行查詢，而是按照name，就修改lookup_field為name。

re_path('^api/users/(?P<uid>\d+)?',views.UserAPI.as_view())

　　 接下來再看另一個方法get_serializer()：

   def get_serializer(self, *args, **kwargs):
        serializer_class = self.get_serializer_class()  # 內部調get_serializer_class
        kwargs.setdefault('context', self.get_serializer_context())  # 獲取context屬性
        return serializer_class(*args, **kwargs)  # 呼叫serializer_class並返回

　　 接下來是get_serializer_class()方法：

    def get_serializer_class(self):
    
        assert self.serializer_class is not None, (  # 傳入的必須不能是None
            "'%s' should either include a `serializer_class` attribute, "
            "or override the `get_serializer_class()` method."
            % self.__class__.__name__
        )

        return self.serializer_class  # 返回設定的屬性，serializer_class，即序列化類

　　 OK，其實原始碼讀到這裡就行了。

封裝特性

　　 通過上面的原始碼分析，總結出如下方法的使用：

方法/屬性	描述
queryset	將要查詢的資料表，型別應該是QuerySet
serializer_class	將要執行的序列化類，型別不能為None
lookup_field	查詢時的查詢條件，預設為pk
lookup_url_kwarg	檢視中url捕獲的查詢條件變數名如果不是pk，則應該進行指定
get_queryset()	查詢獲取所有記錄
get_object()	查詢獲取單條記錄
get_serializer()	執行序列化物件

　　 關於最常用的呼叫方法就三個，常用屬性四個。

　　 其他的方法基本上都是內部呼叫，所以暫時不深究。

介面書寫

　　 接下來使用GenericAPIView進行介面書寫。

from rest_framework.response import Response
from rest_framework.generics import GenericAPIView
from . import models
from . import ser


class ResponseMeta(type):
    # 對Response類做封裝
    def __call__(cls, *args, **kwargs):
        obj = cls.__new__(cls, *args, **kwargs)
        cls.__init__(obj, *args, **kwargs)
        return Response(data=obj.__dict__)


class CommonResponse(object, metaclass=ResponseMeta):
    # 返回的資訊
    def __init__(self, status, data=None, errors=None):
        self.status = status
        self.data = data
        self.errors = errors


class UserAPI(GenericAPIView):
    queryset = models.User.objects  # 傳入物件即可
    serializer_class = ser.UserModelSerializers  # 序列化類
    lookup_field = "pk"
    lookup_url_kwarg = "uid"  # 由於捕獲的是uid，需要宣告

    def get(self, request, uid=None):
        if not uid:
            # 獲取所有
            user_queryset = self.get_queryset()  # 獲取所有
            if user_queryset.exists():
                serialization = self.get_serializer(instance=user_queryset,many=True)  # 獲取序列化類，序列化多條
                return CommonResponse(status=100, data=serialization.data, errors=None)
            return CommonResponse(status=200, errors="暫時沒有任何學生")

        else:
            user_obj = self.get_object()
            if user_obj:
                serialization = self.get_serializer(instance=user_obj)
                return CommonResponse(status=100, data=serialization.data, errors=None)
            return CommonResponse(status=200, errors="沒有該學生")

    def post(self, request):

        serialization = self.get_serializer(data=request.data)
        if serialization.is_valid():
            serialization.save()
            return CommonResponse(status=100, data=serialization.data, errors=None)
        return CommonResponse(status=200, errors=serialization.errors)

    def patch(self, request, uid):
        user_obj = self.get_object()
        if user_obj:
            serialization = self.get_serializer(instance=user_obj,data=request.data)
            if serialization.is_valid():
                serialization.save()
                return CommonResponse(status=100, data=serialization.data, errors=None)
            else:
                return CommonResponse(status=200, errors="修改失敗，請檢查欄位是否一直")
        else:
            return CommonResponse(status=200, errors="修改失敗，請檢查該使用者是否存在")

    def delete(self,request,uid):
        self.get_object().delete()
        return CommonResponse(status=100,data="刪除成功",errors=None)

問題發現

　　 相對於使用APIView來說，它不必再手動去寫ORM語句。

　　 但是對於返回資訊、對於驗證操作還是要自己寫。

mixins中擴充套件類

五個擴充套件類

　　 下面是rest_framework.mixins中的五個擴充套件類，它們做了更高階別的封裝，配合GenericAPIView使用有奇效。

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

類	描述
ListModelMixin	該類主要負責查詢所有記錄
RetrieveModelMixin	該類主要負責查詢單條記錄
CreateModelMixin	該類主要負責建立記錄
UpdateModelMixin	該類主要負責對記錄做更新操作
DestroyModelMixin	該類主要負責刪除記錄

繼承關係

　　 這五個類都繼承於object，是獨立的子類。

　　

原始碼閱讀

　　 下面是ListModelMixin的原始碼，不難發現，它就是配合GenericAPIView使用的，因為它會使用get_queryset()方法，並且，它會自動的返回Response物件，並把驗證結果新增進去：

class ListModelMixin:

    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)

　　 至於其他幾個類，其實都差不多，這裡摘出兩個比較特別的類來看一下，分別是CreateModelMixin與DestroyModelMixin這兩個類。

　　 下面是CreateModelMixin類的原始碼：

class CreateModelMixin:

    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)  # 返回一個location請求頭
        return Response(serializer.data, status=status.HTTP_201_CREATED, headers=headers)  # 注意返回結果，狀態碼是201

    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 {}

　　 下面是DestroyModelMixin類的原始碼：

class DestroyModelMixin:
    def destroy(self, request, *args, **kwargs):
        instance = self.get_object()
        self.perform_destroy(instance)  # 內部執行刪除
        return Response(status=status.HTTP_204_NO_CONTENT)  # 返回狀態碼204

    def perform_destroy(self, instance):
        instance.delete()

　　 那麼讀這兩個類的原始碼，就是想要讓你知道，建立成功後的返回狀態碼是201，而刪除成功的返回狀態碼是204。這在REST規範中寫的很清楚，可以看見這裡也是這麼做的。

類與方法

　　 下面是不同的五個擴充套件類中不同的五個方法，功能與類一樣。

類	方法	描述
ListModelMixin	list()	查詢所有，並返回Response物件
RetrieveModelMixin	retrieve()	查詢單條，並返回Response物件
CreateModelMixin	create()	建立記錄，並返回Response物件
UpdateModelMixin	update()	更新記錄，並返回Response物件
DestroyModelMixin	destroy()	刪除記錄，並返回Response物件

　　 由於它會自動進行return Response()，所以我們就不用再對返回物件進行包裝了。

介面書寫

　　 下面是利用GenericAPIView與mixins中的五個擴充套件類進行介面書寫。

from . import models
from . import ser
from rest_framework.generics import GenericAPIView
from rest_framework.mixins import ListModelMixin,RetrieveModelMixin,CreateModelMixin,UpdateModelMixin,DestroyModelMixin

class UserAPI(GenericAPIView,ListModelMixin,RetrieveModelMixin,CreateModelMixin,UpdateModelMixin,DestroyModelMixin):

    queryset = models.User.objects  # 傳入物件即可
    serializer_class = ser.UserModelSerializers  # 序列化類
    lookup_field = "pk"
    lookup_url_kwarg = "uid"  # 由於捕獲的是uid，需要宣告

    def get(self, request, uid=None):
        if not uid:
            # 獲取所有
            return self.list(request)

        else:
            return self.retrieve(request,uid)

    def post(self, request):
        return self.create(request)

    def patch(self, request, uid):
        return self.update(request,uid)

    def delete(self,request,uid):
        return self.destroy(request,uid)

問題發現

　　 可以看見，程式碼相比於前兩個少了非常非常多。但是還是存在一些問題。

　　 第一個問題就是這個檢視UserAPI繼承的類太多了，太長了，其次就是每次都需要在檢視中return，它能不能幫我們自己return呢？那這個就非常舒服了。

modelViewSet

基本使用

　　 modelViewSet是針對GenericAPIView與mixins中擴充套件類的結合使用做了一些優化，它可以根據不同的請求自動的做出回應。

　　 同時也不再需要你在檢視中進行return。以下是基本使用方法，但是使用它時我們需要對路由做一些改進，具體的情況等下面的原始碼分析後你就明白了：

urlpatterns = [
    path('admin/', admin.site.urls),
    path('api/users/', views.UserAPI.as_view(actions={"get":"list","post":"create"})),
    re_path('^api/users/(?P<uid>\d+)?',views.UserAPI.as_view(actions={"get":"retrieve","patch":"update","delete":"destroy"}))
]

　　 那麼在views.py中，書寫的話很簡單：

from . import models
from . import ser
from rest_framework.viewsets import ModelViewSet
class UserAPI(ModelViewSet):
    queryset = models.User.objects  # 傳入物件即可
    serializer_class = ser.UserModelSerializers  # 序列化類
    lookup_field = "pk"
    lookup_url_kwarg = "uid"  # 由於捕獲的是uid，需要宣告

繼承關係

　　 ModelViewSet的匯入如下：

from rest_framework.viewsets import ModelViewSet

　　 你可看它的原始碼，它其實也沒什麼特別之處，就是針對上面第一個問題做了改進。但是你會發現，它會繼承一個新的類，即GenericViewSet這個類。

class ModelViewSet(mixins.CreateModelMixin,
                   mixins.RetrieveModelMixin,
                   mixins.UpdateModelMixin,
                   mixins.DestroyModelMixin,
                   mixins.ListModelMixin,
                   GenericViewSet):
    """
    A viewset that provides default `create()`, `retrieve()`, `update()`,
    `partial_update()`, `destroy()` and `list()` actions.
    """
    pass

　　 下面是它的繼承圖：

　　

　　 那麼GenericViewSet中又會有什麼新的發現呢？我們先看一看它。

GenericViewSet

　　 開啟GenericViewSet中發現什麼都沒有。但是它繼承了ViewSetMixin。

class GenericViewSet(ViewSetMixin, generics.GenericAPIView):
    """
    The GenericViewSet class does not provide any actions by default,
    but does include the base set of generic view behavior, such as
    the `get_object` and `get_queryset` methods.
    """
    pass

ViewSetMixin

　　 我們可以在上面基本使用時對url中as_view()傳參發現了一點不一樣的地方，我們傳遞進了一個關鍵字引數actions，這個引數非常的蹊蹺，因為在APIView中的as_view()方法中並沒有為該引數預留位置。

def as_view(cls, **initkwargs):

　　 我們再接著看看GenericAPIView中的as_view()方法有沒有為該引數預留位置，非常遺憾的是在GenericAPIView中根本就沒有as_view()方法，說明它用了父類也就是APIView的as_view()方法

　　 那麼只有一個可能，就是ViewSetMixin覆寫了as_view()方法，那麼到底是不是這麼回事？我們看一下就知道了：

class ViewSetMixin:

    @classonlymethod
    def as_view(cls, actions=None, **initkwargs):

　　 是的，那麼它內部是怎麼做的呢？實際上它的核心程式碼就是那個for迴圈，它會根據不同的請求方式來執行不同的mixins中五個擴充套件類的方法，因此我們需要兩條url來放入不同的actions。由於modelsViewSet繼承了mixins五個擴充套件類，所以才能夠呼叫擴充套件類下的方法。

    @classonlymethod 
    def as_view(cls, actions=None, **initkwargs):  # cls即為UserAPI這個類
        cls.name = None
        cls.description = None
        cls.suffix = None
        cls.detail = None
        cls.basename = None
        if not actions:  # 必須傳入actions，否則丟擲異常
            raise TypeError("The `actions` argument must be provided when "
                            "calling `.as_view()` on a ViewSet. For example "
                            "`.as_view({'get': 'list'})`")
        for key in initkwargs:  # 構造字典，不用管
            if key in cls.http_method_names:
                raise TypeError("You tried to pass in the %s method name as a "
                                "keyword argument to %s(). Don't do that."
                                % (key, cls.__name__))
            if not hasattr(cls, key):
                raise TypeError("%s() received an invalid keyword %r" % (
                    cls.__name__, key))

        if 'name' in initkwargs and 'suffix' in initkwargs:  # 不用管，這個也是構造字典
            raise TypeError("%s() received both `name` and `suffix`, which are "
                            "mutually exclusive arguments." % (cls.__name__))

        def view(request, *args, **kwargs):  # 閉包函式view
            self = cls(**initkwargs)

            if 'get' in actions and 'head' not in actions:
                actions['head'] = actions['get']

            self.action_map = actions

            for method, action in actions.items():  # 其實這裡是核心程式碼，  actions={"get":"retrieve","patch":"update","delete":"destroy"}，或者等於{"get":"list","post":"create"}
                handler = getattr(self, action)  # 根據請求方式，來執行list、create、retrieve、update、destroy這幾個方法
                setattr(self, method, handler)

            self.request = request
            self.args = args
            self.kwargs = kwargs

            return self.dispatch(request, *args, **kwargs)
 
        update_wrapper(view, cls, updated=())  # 傳入執行update_wrapper()，不用管

        update_wrapper(view, cls.dispatch, assigned=())   # 不用管


        view.cls = cls
        view.initkwargs = initkwargs
        view.actions = actions
        return csrf_exempt(view)

　　 根據不同的請求方式來執行不同的函式方法，可以說這個設計非常的巧妙，所以你可以像下面這樣做：

# views.py
from rest_framework.viewsets import ViewSetMixin
class Book6View(ViewSetMixin,APIView): # 一定要放在APIVIew前，因為as_view()的查詢順序一定要先是ViewSetMixin
    def get_all_book(self,request):
        print("xxxx")
        book_list = Book.objects.all()
        book_ser = BookSerializer(book_list, many=True)
        return Response(book_ser.data)
    
# urls.py
    #繼承ViewSetMixin的檢視類，路由可以改寫成這樣
    path('books6/', views.Book6View.as_view(actions={'get': 'get_all_book'})),