內容概要

• request 對象和 response 對象
• GenericAPIView 介紹
• 基于 GenericAPIView 的 5個視圖擴展類
• GenericAPIView 的9個視圖子類
• 視圖集
• ModelViewSet 的使用 ViewSetMixin 源碼分析

內容詳細

request 對象和 response 對象

請求之 request 對象

我們已經知道，drf 對原生的 request 請求數據對象做過封裝處理，原生 request 對象被保存在_request 中，通過 __getattr__【點攔截】魔法方法可以獲取 原生 request 對象所有方法和屬性，并且 drf 的 request 可以通過 request.data 取出包括 json 格式數據在內的所有編碼格式，使得數據處理更加方便。

創新互聯公司專注于沙雅企業網站建設,響應式網站建設,電子商務商城網站建設。沙雅網站建設公司,為沙雅等地區提供建站服務。全流程按需開發網站，專業設計，全程項目跟蹤，創新互聯公司專業和態度為您提供的服務

導入模塊 Request

from rest_framework.request import Request

request 對象需要記憶：

• __getattr__
• request.data
• request.query_parmas

request.query_parmas 源碼：接受原生 request 對象的GET 請求的數據，也就是過濾參數

@property
def query_params(self):
    """
    More semantically correct name for request.GET.
    """
    return self._request.GET

限制 request 能接收的數據格式

局部配置：

在視圖層的視圖類中配置，限制 request 對象只能處理json格式數據，只針對當前視圖類有效

from rest_framework.parsers import JSONParser,FormParser,MultiPartParser

class PublishView(APIView):
    # 局部使用，只針對當前視圖類有效，只想處理json格式
    parser_classes = [JSONParser]
    
    def get(self, request):
		pass

全局配置：

在項目文件夾下的 settings.py文件中配置

REST_FRAMEWORK = {
    'DEFAULT_PARSER_CLASSES': [
        'rest_framework.parsers.JSONParser',
    ],
}

解析順序：
視圖層類中的配置 > 項目文件夾下 settings.py 文件配置 > drf 原有的默認配置

drf的默認配置：from rest_framework import settings

響應之 response 對象

from rest_framework.response import Response

形參：

data=None,    # 字符串，字典，列表--》給http響應body體中內容-->response對象中取出處理
status=None,  # 響應狀態碼：1xx，2xx，3xx，默認是200
from rest_framework.status import HTTP_201_CREATED
Response(ser.data,status=HTTP_201_CREATED)

headers=None,      # 響應頭 字典

---了解---
template_name=None,  # 模板名字(不用)，用瀏覽器訪問時，可以改
exception=False,    # 異常處理
content_type=None   # 響應編碼格式

設置響應的數據格式：

局部設置：

from rest_framework.renderers import JSONRenderer,BrowsableAPIRenderer
class BookDetailView(APIView):
    renderer_classes = [JSONRenderer,]

全局設置：

REST_FRAMEWORK = {
    'DEFAULT_RENDERER_CLASSES': (  # 默認響應渲染類
        'rest_framework.renderers.JSONRenderer',  # json渲染器
        'rest_framework.renderers.BrowsableAPIRenderer',  # 瀏覽API渲染器
    )
}

GenericAPIView 介紹

GenericAPIView 繼承的是 APIView

前面我們已經知道 APIView 對原生 request 對象進行了處理，新的request對象多了 .data 屬性，并且有三大認證和全局異常處理。

APIView還擁有限制請求和響應數據的屬性 renderer_classes,parser_classes

那么，GenericAPIView 就是在 APIView 的基礎上，多了更多屬性和方法

from rest_framework.generics import GenericAPIView

更多屬性和方法可以查看 GenericAPIView 源碼

屬性：

class GenericAPIView(views.APIView):
    queryset = None
    serializer_class = None
    lookup_field = 'pk'
    lookup_url_kwarg = None
    filter_backends = api_settings.DEFAULT_FILTER_BACKENDS
    pagination_class = api_settings.DEFAULT_PAGINATION_CLASS

方法：

優先記憶：

屬性

• queryset = None ： 獲取模型類對象
• serializer_class = None ： 獲取序列化類的屬性
• lookup_field = 'pk' ： 獲取單個對象時需要用到改屬性

方法：

• get_queryset ：獲取模型類對象 queryset
• get_object ： 獲取單個模型類對象
• get_serializer ：獲取序列化類執行并返回一個序列化后的對象
• get_serializer_class ： 獲取序列化類

get_queryset
    def get_queryset(self):
        # 斷言 self.queryset 不為空，否則報錯后面信息，說明 queryset 屬性必須定義
        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
        if isinstance(queryset, QuerySet):
            queryset = queryset.all()
        return queryset

get_serializer
    def get_serializer(self, *args, **kwargs):
        serializer_class = self.get_serializer_class()
        kwargs.setdefault('context', self.get_serializer_context())
        return serializer_class(*args, **kwargs)

get_serializer_class
    def get_serializer_class(self):
        assert self.serializer_class is not None, (
            "'%s' should either include a `serializer_class` attribute, "
            "or override the `get_serializer_class()` method."
            % self.__class__.__name__
        )
        return self.serializer_class
    
get_object
    def get_object(self):
        queryset = self.filter_queryset(self.get_queryset())
        lookup_url_kwarg = self.lookup_url_kwarg or self.lookup_field
        assert lookup_url_kwarg in self.kwargs, (
            '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]}
        obj = get_object_or_404(queryset, **filter_kwargs)
        self.check_object_permissions(self.request, obj)
        return obj

基于 GenericAPIView 的 5個視圖擴展類

不是視圖類，沒有繼承APIView，需要配合GenericAPIView 使用，這五個類中提供了查找、新增、修改刪除模型類數據的方法，在GenericAPIView類的五個接口中可以直接調用

• CreateModelMixin
• ListModelMixin
• DestroyModelMixin
• RetrieveModelMixin
• UpdateModelMixin

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

使用 APIView 的視圖層類：

class BookAPIView(APIView):
    def get(self, request):
        book_list = models.Book.objects.all()
        ser = BookModelSerializer(instance=book_list, many=True)  # 獲取多個資源用 many=True
        print(ser.data)
        return Response(ser.data)

    def post(self, request):
        ser = BookModelSerializer(data=request.data)
        if ser.is_valid():
            ser.save()
            return Response({'code': 100, 'msg': '新增成功', 'data': ser.data})
        return Response({'code': 101, 'msg': '新增失敗', 'data': ser.errors})


class BookSetAPIView(APIView):
    def get(self, request, pk):
        book_obj = models.Book.objects.filter(pk=pk).first()
        ser = BookModelSerializer(instance=book_obj)
        return Response(ser.data)

    def put(self, request, pk):
        book_obj = models.Book.objects.filter(pk=pk).first()
        ser = BookModelSerializer(instance=book_obj, data=request.data)  # 修改是既有instance 也有data才行
        if ser.is_valid():
            ser.save()
            return Response({'status': 100, 'msg': '修改成功', 'data': ser.data})
        return Response({'status': 100, 'msg': '修改失敗', 'data': ser.errors})

    def delete(self, request, pk):
        Book.objects.filter(pk=pk).delete()
        return Response({'status': 100, 'msg': '刪除成功'})

使用 GenericAPIView 的視圖層類：

和繼承 APIView 的區別就是，多了queryset、serializer_class屬性，還有get_queryset等方法，而且無論換了什么模型表（Auth、Publish），只需要改變queryset、serializer_class屬性即可，五個接口方法均不需要改變

class BookGeneric(GenericAPIView):
    queryset = Book.objects
    serializer_class = BookModelSerializer

    def get(self, request):
        quertset = self.get_queryset()
        serializer_class = self.get_serializer(instance=quertset, many=True)
        print(serializer_class.data)
        return Response(serializer_class.data)

    def post(self, request):
        serializer_class = self.get_serializer(data=request.data)
        if serializer_class.is_valid():
            serializer_class.save()
            return Response({'code': 100, 'msg': '新增成功', 'data': serializer_class.data})
        return Response({'code': 101, 'msg': '新增失敗', 'data': serializer_class.errors})


class BookSetGeneric(GenericAPIView):
    queryset = Book.objects
    serializer_class = BookModelSerializer

    def get(self, request, pk):
        queryset = self.get_object()
        serializer_class = self.get_serializer(instance=queryset)
        return Response(serializer_class.data)

    def put(self, request, pk):
        queryset = self.get_object()
        serializer_class = self.get_serializer(instance=queryset, data=request.data)  # 修改是既有instance 也有data才行
        if serializer_class.is_valid():
            serializer_class.save()
            return Response({'status': 100, 'msg': '修改成功', 'data': serializer_class.data})
        return Response({'status': 100, 'msg': '修改失敗', 'data': serializer_class.errors})

    def delete(self, request, pk):
        self.get_object().delete()
        return Response({'status': 100, 'msg': '刪除成功'})

繼承 GenericAPIView 和5個視圖擴展類：

五個視圖擴展類封裝了原來 GeneriacAPIView 類所需要書寫的五個接口方法

獲取模型類所有數據對象（get方法）和修改數據（post方法），書寫的方法和原來 GeneriacAPIView 類中的五個接口幾乎一致：

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)

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)
        return Response(serializer.data, status=status.HTTP_201_CREATED, headers=headers)

獲取單個模型類數據對象、修改數據、刪除數據三個需要傳入pk值的視圖擴展類：

class RetrieveModelMixin:
    def retrieve(self, request, *args, **kwargs):
        instance = self.get_object()
        serializer = self.get_serializer(instance)
        return Response(serializer.data)

class UpdateModelMixin:
    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):
            instance._prefetched_objects_cache = {}
        return Response(serializer.data)

class DestroyModelMixin:
    def destroy(self, request, *args, **kwargs):
        instance = self.get_object()
        self.perform_destroy(instance)
        return Response(status=status.HTTP_204_NO_CONTENT)

---

視圖層類：

繼承了這些視圖擴展類，我們就可以使用類中封裝的接口函數，更進一步精簡視圖層類的接口代碼了

class BookGenericMinxin(GenericAPIView, ListModelMixin, CreateModelMixin):
    queryset = Book.objects
    serializer_class = BookModelSerializer

    def get(self, request):
        return self.list(request)

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


class BookGenericSetMinxin(GenericAPIView, RetrieveModelMixin, UpdateModelMixin, DestroyModelMixin):
    queryset = Book.objects
    serializer_class = BookModelSerializer

    def get(self, request, pk):
        return self.retrieve(request)

    def put(self, request, pk):
        return self.update(request)

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

---

序列化類：

class BookModelSerializer(ModelSerializer):  # 繼承的是 ModelSerializer
    class Meta:
        model = Book
        fields = ['id', 'name', 'price', 'publish', 'authors', 'author_list', 'publish_info']  # 注意別漏寫 fields

        extra_kwargs = {
            'publish': {'write_only': True},
            'authors': {'write_only': True}
        }

路由層：

urlpatterns = [
    path('admin/', admin.site.urls),
    path('book/', views.BookAPIView.as_view()),
    path('book/<int:pk>/', views.BookSetAPIView.as_view()),
    path('book1/', views.BookGeneric.as_view()),
    path('book1/<int:pk>/', views.BookSetGeneric.as_view()),
    path('book2/', views.BookGenericMinxin.as_view()),
    path('book2/<int:pk>/', views.BookGenericSetMinxin.as_view()),
]

封裝程度越來越高，代碼越來越精簡

GenericAPIView 的9個視圖子類

這九個視圖子類，連 get、post、put、get、delete 五個接口都幫我們寫完了，我們在書寫GenericAPIView視圖層類時，只需要導入這九個試圖子類來繼承，就可以不用書寫五個方法了，需要什么接口導入什么模塊。

單獨的類：

from rest_framework.generics import CreateAPIView, ListAPIView, RetrieveAPIView, UpdateAPIView, DestroyAPIView

組合：

from rest_framework.generics import ListCreateAPIView, RetrieveUpdateDestroyAPIView, RetrieveDestroyAPIView, RetrieveUpdateAPIView

• CreateAPIView

• ListAPIView

• RetrieveAPIView

• UpdateAPIView

• DestroyAPIView

• ListCreateAPIView

• RetrieveUpdateDestroyAPIView

• RetrieveDestroyAPIView

• RetrieveUpdateAPIView

其實，它們就是繼承了GenericAPIView類，并且與五個視圖擴展類進行了組合繼承，并把接口函數也添加上罷了。pk使用 *args 和 **kwargs 來取締了

class CreateAPIView(mixins.CreateModelMixin,
                    GenericAPIView):
    def post(self, request, *args, **kwargs):
        return self.create(request, *args, **kwargs)

class ListAPIView(mixins.ListModelMixin,
                  GenericAPIView):
    def get(self, request, *args, **kwargs):
        return self.list(request, *args, **kwargs)

class RetrieveAPIView(mixins.RetrieveModelMixin,
                      GenericAPIView):
    def get(self, request, *args, **kwargs):
        return self.retrieve(request, *args, **kwargs)

class UpdateAPIView(mixins.UpdateModelMixin,
                    GenericAPIView):
    def put(self, request, *args, **kwargs):
        return self.update(request, *args, **kwargs)
    def patch(self, request, *args, **kwargs):
        return self.partial_update(request, *args, **kwargs)

class DestroyAPIView(mixins.DestroyModelMixin,
                     GenericAPIView):
    def delete(self, request, *args, **kwargs):
        return self.destroy(request, *args, **kwargs)

# 組合的就不逐一列舉了，原理一樣
class RetrieveUpdateDestroyAPIView(mixins.RetrieveModelMixin,
                                   mixins.UpdateModelMixin,
                                   mixins.DestroyModelMixin,
                                   GenericAPIView):
    def get(self, request, *args, **kwargs):
        return self.retrieve(request, *args, **kwargs)
    def put(self, request, *args, **kwargs):
        return self.update(request, *args, **kwargs)
    def patch(self, request, *args, **kwargs):
        return self.partial_update(request, *args, **kwargs)
    def delete(self, request, *args, **kwargs):
        return self.destroy(request, *args, **kwargs)

這樣，我們在書寫視圖層類更加精簡了：

class BookView(ListCreateAPIView):
    queryset = Book.objects
    serializer_class = BookModelSerializer


class BookSetView(RetrieveUpdateDestroyAPIView):
    queryset = Book.objects
    serializer_class = BookModelSerializer

---

路由書寫：

urlpatterns = [
    path('book3/', views.BookView.as_view()),
    path('book3/<int:pk>/', views.BookSetView.as_view()),
]

ViewSetMixin 介紹

由ViewSetMixin的源碼可以看到，它把as_view方法進行了重寫，在路由層調用視圖類時，如果類第一個繼承的時ViewSetMixin，會優先調用它的as_view方法，需要傳入位置參數 （一個字典）actions，而且由actions.items(),actions是一個字典。

這樣一來我們不使用到 九個視圖子類給我們封裝的五個接口方法（get、post、put、delete、patch）,可以直接繼承 ViewSetMixin, ListModelMixin, CreateModelMixin, GenericAPIView。因為在路由中會傳進來 get 等五個字典key，賦值對象地址后可直接調用。

記?。豪^承ViewSetMixin 之后書寫路由時需要傳入 actions 參數

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

        def view(request, *args, **kwargs):
            self = cls(**initkwargs)
            # 例子 method = 'get',action='list'
            for method, action in actions.items():
                # 獲取 list() 方法的對象地址
                handler = getattr(self, action)
                # 相當于 self.get = list，把lsit方法賦值給了self.get，發送get請求時觸發，相當于觸發了 ListModelMixin 的 list() 方法
                setattr(self, method, handler)

            return self.dispatch(request, *args, **kwargs)
        view.actions = actions
        return csrf_exempt(view)

導入

from rest_framework.viewsets import ViewSetMixin

路由層：

as_view()需要傳入字典：{“請求方式”: “方法名”}

注意字典中分別是五個接口的請求方式和對應的五個視圖擴展類封裝好的方法

urlpatterns = [
    path('book4/', views.BookViewSet.as_view(actions={'get': 'list', 'post': 'create'})),
    path('book4/<int:pk>/', views.BookViewSetPk.as_view(actions={'get': 'retrieve', 'put': 'update', 'delete': 'delete'}))
]

視圖層類：

class BookViewSet(ViewSetMixin, ListCreateAPIView):
    queryset = Book.objects
    serializer_class = BookModelSerializer


class BookViewSetPk(ViewSetMixin, RetrieveUpdateDestroyAPIView):
    queryset = Book.objects
    serializer_class = BookModelSerializer

Viewset系列

from rest_framework.viewsets import ViewSetMixin, ViewSet, GenericViewSet, ModelViewSet

• ViewSetMixin
• ViewSet
• GenericViewSet
• ModelViewSet

ViewSet

繼承了 ViewSetMixin和APIView

class ViewSet(ViewSetMixin, views.APIView):
    """
    The base ViewSet class does not provide any actions by default.
    """
    pass

GenericViewSet

繼承了 ViewSetMixin和GenericAPIView

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

ModelViewsetMinx

包含了五個視圖擴展類和 GenericViewSet

這樣繼承了 ModelViewSet的試圖層類可以不用把五個接口分開兩個類來寫了

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

class BookViewSet(ModelViewSet):
    queryset = Book.objects
    serializer_class = BookModelSerializer

---

繼承了 ViewSetMixin 之后，路由就要都要寫成這樣：

urlpatterns = [
    path('book4/', views.BookViewSet.as_view(actions={'get': 'list', 'post': 'create'})),
    path('book4/<int:pk>/', views.BookViewSetPk.as_view(actions={'get': 'retrieve', 'put': 'update', 'delete': 'delete'}))
]

drf 提供了自動生成這樣兩條路由與視圖函數對應關系的功能模塊 routers

用法：

# 導入
from rest_framework.routers import DefaultRouter, SimpleRouter

# 實例化對象并注冊路由
router = DefaultRouter()
router.register('book4', views.BookViewSet, 'book4')

添加到路由列表中

1、路由分發

urlpatterns = [
    path('admin/', admin.site.urls),
    path('api/v1/', include(router.urls)),
]

2、直接列表相加

urlpatterns += router.urls

當前題目：drf 視圖組件
URL鏈接：http://m.kartarina.com/article44/dsoghee.html

成都網站建設公司_創新互聯，為您提供網站設計、自適應網站、移動網站建設、網站維護、服務器托管、品牌網站設計

廣告

聲明：本網站發布的內容（圖片、視頻和文字）以用戶投稿、用戶轉載內容為主，如果涉及侵權請盡快告知，我們將會在第一時間刪除。文章觀點不代表本網站立場，如需處理請聯系客服。電話：028-86922220；郵箱：631063699@qq.com。內容未經允許不得轉載，或轉載時需注明來源： 創新互聯