視圖類視圖集

時間 2020-05-19

標籤視圖圖集简体版

原文原文鏈接

view層

from rest_framework.views import APIView
from rest_framework.response import Response
from .response import APIResponse
from . import models, serializers


class CarAPIView(APIView):
    # 羣查
    def get(self, request, *args, **kwargs):
        car_query = models.Car.objects.filter(is_delete=False).all()
        car_ser = serializers.CarModelSerializer(instance=car_query, many=True)
        return APIResponse(results=car_ser.data)


""" 視圖家族
from rest_framework import views, mixins, generics, viewsets

views：視圖類 - APIView，GenericAPIView(generics中)
mixins：視圖工具類 - CreateModelMixin，ListModelMixin，RetrieveModelMixin，UpdateModelMixin，DestroyModelMixin
generics：工具視圖類 - 九個類
viewsets：視圖集 - 兩個視圖集基類，兩個視圖集子類，一個工具類
"""

# 回顧APIView類：1)擁有View的全部  2)重寫as_view  3)重寫dispatch  4)一系列類屬性
# GenericAPIView類
# 1)擁有APIView的全部

from rest_framework.generics import GenericAPIView
class CarGenericAPIView(GenericAPIView):
    # 不能直接寫到objects結束，由於objects結束時，不是QuerySet對象，而是Manager對象，但 .all() 和 .filter() 後必定是QuerySet對象
    queryset = models.Car.objects.filter(is_delete=False).all()
    serializer_class = serializers.CarModelSerializer
    lookup_url_kwarg = 'pk'
    # 羣查
    """
    def get(self, request, *args, **kwargs):
        # car_query = models.Car.objects.filter(is_delete=False).all()
        car_query = self.get_queryset()

        # car_ser = serializers.CarModelSerializer(instance=car_query, many=True)
        car_ser = self.get_serializer(car_query, many=True)

        return APIResponse(results=car_ser.data)
    """

    # 單查
    def get(self, request, *args, **kwargs):
        # pk = kwargs.get('pk')
        # car_obj = models.Car.objects.filter(is_delete=False).filter(pk=pk).first()
        car_obj = self.get_object()

        # car_ser = serializers.CarModelSerializer(car_obj)
        car_ser = self.get_serializer(car_obj)

        return APIResponse(results=car_ser.data)


# mixins視圖工具類
from rest_framework.mixins import RetrieveModelMixin, ListModelMixin, CreateModelMixin
class CarReadCreateGenericAPIView(ListModelMixin, RetrieveModelMixin, CreateModelMixin, GenericAPIView):
    queryset = models.Car.objects.filter(is_delete=False).all()
    serializer_class = serializers.CarModelSerializer
    lookup_url_kwarg = 'pk'
    # 羣查
    # """
    def get(self, request, *args, **kwargs):
        # car_query = self.get_queryset()
        # car_ser = self.get_serializer(car_query, many=True)
        # return APIResponse(results=car_ser.data)
        return self.list(request, *args, **kwargs)
    # """

    # 單查
    """
    def get(self, request, *args, **kwargs):
        # car_obj = self.get_object()
        # car_ser = self.get_serializer(car_obj)
        # return APIResponse(results=car_ser.data)
        response = self.retrieve(request, *args, **kwargs)
        return APIResponse(results=response.data)
    """

    # 單增
    def post(self, request, *args, **kwargs):
        return self.create(request, *args, **kwargs)


# Generics工具視圖類

# 單獨完成單查接口
from rest_framework.generics import RetrieveAPIView
class CarRetrieveAPIView(RetrieveAPIView):
    queryset = models.Car.objects.filter(is_delete=False).all()
    serializer_class = serializers.CarModelSerializer
    lookup_url_kwarg = 'pk'

# 單獨完成羣查接口
from rest_framework.generics import ListAPIView
class CarListAPIView(ListAPIView):
    queryset = models.Car.objects.filter(is_delete=False).all()
    serializer_class = serializers.CarModelSerializer


# 單查(get)、單總體改(put)、單局部改(patch)、單刪接口(delete)
from rest_framework.generics import RetrieveUpdateDestroyAPIView
class CarRetrieveUpdateDestroyAPIView(RetrieveUpdateDestroyAPIView):
    queryset = models.Car.objects.filter(is_delete=False).all()
    serializer_class = serializers.CarModelSerializer





"""
一、APIView:
1)擁有View的全部  2)重寫as_view  3)重寫dispatch  4)一系列類屬性


二、GenericAPIView
1)繼承APIView，因此擁有APIView的全部
2)get_queryset方法，配置queryset類屬性，提供視圖類相關的Models
3)在第二條基礎上，get_object方法，配置lookup_url_kwarg類屬性，提供視圖類相關的具體Model
4)get_serializer方法，配置serializer_class類屬性，提供視圖類相關的序列化對象

總結：GenericAPIView就是在APIView基礎上額外提供了三個方法，三個類屬性，若是不配合視圖工具類，體現不出優點
目的：視圖中的增刪改查邏輯類似，但操做的資源不一致，操做資源就是操做 資源對象們、資源對象以及資源相關的序列化類，
將這三者造成配置，那操做邏輯就一致，就能夠進行封裝

三、mixins視圖工具類們：五個類，六個方法
1)要配合GenericAPIView類使用，將單查、羣查、單增，單總體改，單局部改，單刪六個接口
封裝成retrieve、list、create、update、partial_update、destroy六個方法
緣由：六個方法的實現體，調用的方法就是GenericAPIView提供的，因此要配合GenericAPIView類使用

四、generics工具視圖類們：九種組合
1)幫咱們將不一樣個數不一樣種類的mixins與GenericAPIView進行組合
2)不一樣的組合幫咱們實現好對應的get、post、put、patch、delete方法
3)須要咱們本身配置三個類屬性便可：queryset、serializer_class、lookup_url_kwarg
"""
"""
class CarView(APIView):
    def get(self):
        obj,
        ser,
        response,
        
class CarView(GenericAPIView):  # 不會出現，中間產物
    queryset,
    serializer_class,
    lookup_url_kwarg,
    def get(self):
        obj,
        ser,
        response,

class CarView(RetrieveModelMixin, GenericAPIView):  # 自定義組合，能夠超過九種
    queryset,
    serializer_class,
    lookup_url_kwarg,
    def get(self):
        self.retrieve()
        
class CarView(RetrieveAPIView):  # 最終產物，系統只提供了九種組合，RetrieveAPIView是其中一種
    queryset,
    serializer_class,
    lookup_url_kwarg,
"""


# 視圖集
from rest_framework.viewsets import ViewSetMixin, GenericViewSet, ViewSet, ModelViewSet
class CarReadOnlyAPIView(RetrieveModelMixin, ListModelMixin, GenericViewSet):
    # def many_get(self, request, *args, **kwargs):
    #     return self.list(request, *args, **kwargs)
    #
    # def single_get(self, request, *args, **kwargs):
    #     return self.retrieve(request, *args, **kwargs)

    queryset = models.Car.objects.filter(is_delete=False).all()
    serializer_class = serializers.CarModelSerializer


# 六大接口
class CarModelViewSet(ModelViewSet):
    queryset = models.Car.objects.filter(is_delete=False).all()
    serializer_class = serializers.CarModelSerializer
    # 分析：從實際開發角度分析不合理點
    # 1）沒有羣增，羣總體改，羣局部改，羣刪四個接口
    # 2）刪除操做視圖集默認走的destroy方法是將資源從數據庫中刪除，一般一個作字段is_delete字段修改表示刪除
    # 3）響應的結果只有數據，沒有數據狀態碼和狀態信息

    # 解決1,
    # 羣總體改，羣局部改，全刪三個接口能夠獨立成三個方法
    def many_update(self, request, *args, **kwargs):
        return APIResponse(msg='這個地方是羣總體改，你會寫！')
    def many_partial_update(self, request, *args, **kwargs):
        return APIResponse(msg='這個地方是羣局部改，你會寫！')
    def many_destroy(self, request, *args, **kwargs):
        return APIResponse(msg='這個地方是羣刪，你會寫！')
    # 羣增與單增必須公用一個接口，都要走create方法 - 重寫create方法，用邏輯進行拆分
    def create(self, request, *args, **kwargs):
        request_data = request.data
        if isinstance(request_data, list):
            car_ser = self.get_serializer(data=request_data, many=True)
            car_ser.is_valid(raise_exception=True)
            car_obj = car_ser.save()
            return APIResponse(msg='羣增成功', results=self.get_serializer(car_obj, many=True).data)

        return super().create(request, *args, **kwargs)


    # 解決2，destroy方法是完成is_delete字段值修改 - 重寫destroy方法，自定義實現體
    def destroy(self, request, *args, **kwargs):
        car_obj = self.get_object()
        car_obj.is_delete = True
        car_obj.save()
        return APIResponse(msg='刪除成功')


    # 解決3，讓羣查有狀態碼和狀態信息 - 重寫list方法
    def list(self, request, *args, **kwargs):
        response = super().list(request, *args, **kwargs)
        return APIResponse(results=response.data)




""" 視圖集總結
核心：視圖集都繼承了 ViewSetMixin類，該類重寫了as_view方法，相比APIView的as_view方法，額外多出了一個參數actions
    as_view({'get': 'list'}) 傳入的{'get': 'list'}就被actions介紹，原理是將get請求映射給視圖類的list函數進行處理

1）爲何有GenericViewSet和ViewSet兩個視圖集基類
    GenericViewSet(ViewSetMixin, GenericAPIView)，該分支嚴格知足資源接口
    ViewSet(ViewSetMixin, APIView)，該分支知足的接口與資源Model類關係不是特別密切：登陸接口、短信驗證碼接口

2）ReadOnlyModelViewSet，ModelViewSet兩個視圖集子類，就是作個一堆mixin與GenericViewSet相結合，
    本身在urls文件中配置as_view設置映射關係
"""

路由層

from django.conf.urls import url, include

from . import views


# 路由層：外面會遇到這種寫法，看到了要認識
from rest_framework.routers import SimpleRouter
router = SimpleRouter()
router.register('v7/cars', views.CarModelViewSet, basename='car')
# router.register('books', views.BookModelViewSet, basename='book')
# router.register('users', views.UserModelViewSet, basename='user')

urlpatterns = [
    # 基礎
    url(r'^v1/cars/$', views.CarAPIView.as_view()),
    # url(r'^v1/cars/(?P<pk>\d+)/$', views.CarAPIView.as_view()),

    # Generic
    url(r'^v2/cars/$', views.CarGenericAPIView.as_view()),
    url(r'^v2/cars/(?P<pk>\d+)/$', views.CarGenericAPIView.as_view()),

    # Generic過渡
    url(r'^v3/cars/$', views.CarReadCreateGenericAPIView.as_view()),
    url(r'^v3/cars/(?P<pk>\d+)/$', views.CarReadCreateGenericAPIView.as_view()),

    # 工具視圖類
    url(r'^v4/cars/$', views.CarListAPIView.as_view()),
    # url(r'^v4/cars/(?P<pk>\d+)/$', views.CarListAPIView.as_view()),

    url(r'^v5/cars/$', views.CarRetrieveUpdateDestroyAPIView.as_view()),
    url(r'^v5/cars/(?P<pk>\d+)/$', views.CarRetrieveUpdateDestroyAPIView.as_view()),

    # 視圖集
    url(r'^v6/cars/$', views.CarReadOnlyAPIView.as_view({'get': 'list'})),
    url(r'^v6/cars/(?P<pk>\d+)/$', views.CarReadOnlyAPIView.as_view({'get': 'retrieve'})),

    # url(r'^v7/cars/$', views.CarModelViewSet.as_view({
    #     'get': 'list',
    #     'post': 'create',
    #     'put': 'many_update',
    #     'patch': 'many_partial_update',
    #     'delete': 'many_destroy',
    # })),
    # url(r'^v7/cars/(?P<pk>\d+)/$', views.CarModelViewSet.as_view({
    #     'get': 'retrieve',
    #     'put': 'update',
    #     'patch': 'partial_update',
    #     'delete': 'destroy',
    # })),
    url(r'', include(router.urls))
]
# urlpatterns.extend(router.urls)
print(router.urls)

模型層

from django.db import models

# 汽車表、汽車商家表、贊助商表、贊助商詳情表
class BaseModel(models.Model):
    is_delete = models.BooleanField(default=False)
    createdTime = models.DateTimeField(auto_now_add=True)
    class Meta:
        abstract = True

class Car(BaseModel):
    name = models.CharField(max_length=64)
    price = models.DecimalField(max_digits=10, decimal_places=2)
    brand = models.ForeignKey(to='Brand', db_constraint=False, null=True, on_delete=models.SET_NULL, related_name='cars')
    sponsors = models.ManyToManyField(to='Sponsor', db_constraint=False, related_name='cars')

    @property
    def brand_name(self):
        return self.brand.name

    @property
    def sponsor_list(self):
        sponsor_list_temp = []
        for sponsor in self.sponsors.all():
            sponsor_dic = {
                'name': sponsor.name
            }
            try:
                sponsor_dic['phone'] = sponsor.detail.phone
            except:
                sponsor_dic['phone'] = '未知'
            sponsor_list_temp.append(sponsor_dic)
        return sponsor_list_temp

    class Meta:
        verbose_name_plural = '汽車'

    def __str__(self):
        return self.name

class Brand(BaseModel):
    name = models.CharField(max_length=64)

    class Meta:
        verbose_name_plural = '品牌'

    def __str__(self):
        return self.name

class Sponsor(BaseModel):
    name = models.CharField(max_length=64)

    @property
    def phone(self):
        try:
            return self.detail.phone
        except:
            return "無"

    class Meta:
        verbose_name_plural = '贊助商'

    def __str__(self):
        return self.name

class SponsorDetail(BaseModel):
    phone = models.CharField(max_length=11)
    sponsor = models.OneToOneField(to=Sponsor, db_constraint=False, on_delete=models.CASCADE, related_name='detail')

    class Meta:
        verbose_name_plural = '贊助商詳情'

    def __str__(self):
        try:  # 連表可能會出現問題，因此要異常處理
            return self.sponsor.name + '的詳情'
        except:
            return super().__str__()