标签：return get self request 视图组件 serializer drf

一视图之两个视图基类
- 1.1 APIView
  - 使用APIView+序列化类+Response写接口
- 1.2 GenericAPIView[通用视图类]
二 5个视图扩展类
三 9个视图子类
- 3.1 介绍
- 3.2 具体使用
四视图集
六总结

一视图之两个视图基类

两个视图基类有：

# 视图类：
    -APIView：之前用过
    -GenericAPIView：GenericAPIView继承了APIView

1.1 APIView

rest_framework.views.APIView

APIView是REST framework提供的所有视图的基类，继承自Django的View父类。

APIView与View的不同之处在于：

去除了csrf的校验
包装了新的request
在执行视图类的方法之前，执行了三大认证(认证，权限，频率)
处理了全局异常

支持定义的类属性

authentication_classes 列表或元祖，身份认证类
permissoin_classes 列表或元祖，权限检查类
throttle_classes 列表或元祖，流量控制类

在APIView中仍以常规的类视图定义方法来实现get() 、post() 、put() 、 get() 、 delete()。

使用APIView+序列化类+Response写接口

from rest_framework.views import APIView
from .serializer import BookSerialzier
from rest_framework.response import Response
from .models import Book

class BookView(APIView):
    def get(self, request):
        qs = Book.objects.all()
        ser = BookSerialzier(qs, many=True)
        return Response({'code': 100, 'msg': '成功', 'results': ser.data})

    def post(self, request):
        ser = BookSerialzier(data=request.data)
        if ser.is_valid():
            ser.save()
            return Response({'code': 100, 'msg': '成功'})
        else:
            return Response({'code': 100, 'msg': ser.errors})


class BookDetailView(APIView):
    def get(self, request, pk):
        book = Book.objects.all().get(pk=pk)
        ser = BookSerialzier(book)
        return Response({'code': 100, 'msg': '成功', 'results': ser.data})

    def put(self, request, pk):
        book = Book.objects.get(pk=pk)
        ser = BookSerialzier(data=request.data, instance=book)
        if ser.is_valid():
            ser.save()
            return Response({'code': 100, 'msg': '更新成功'})
        else:
            return Response({'code': 100, 'msg': ser.errors})

1.2 GenericAPIView[通用视图类]

rest_framework.generics.GenericAPIView

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

1.2.1 主要的属性或方法

以后，如果涉及到数据库操作，尽量用GenericAPIView。

# GenericAPIView
    -类属性：
        queryset：要序列化的所有数据
        serializer_class：序列化类
        lookup_field = 'pk' ：获取单条数据的查询条件
        filter_backends：过滤类
        pagination_class：分页类，任意一个查询所有的条件都要带分页类，一条一条查询。

    -方法：
        -get_queryset：获取所有要序列化的数据【后期可以重写】
        -get_object ：根据pk，获取单个对象，没有返回404。路由必须：path('/<int:pk>/', PublishDetailView.as_view()),

        -get_serializer  : 真正的实例化得到序列化类【后期可以重写，指定要序列化的类是哪一个】
        -get_serializer_class:仅仅是返回序列化类，不能传任何参数


拓展:
get_queryset()：其实就是把queryset返回出去了。但为什么要写这个方法呢？
# 写成方法的目的：增加扩展性。
可以在自己的类中重写这个方法。可以根据某个条件返回不同的值，这样能够序列化的数据就变多了，是动态的，而不是写死的。
eg:
    def get_queryset(self):
        if 某种条件:
            return self.queryset
        elif 另一个条件:
            return Book.objects.all()

1.2.2 推导GenericAPIView的封装

# 咱们写的，伪代码
# 定义一个GenericAPIView类继承APIView
class GenericAPIView(APIView):
    query_set = None
    serialzier_class = None
    
    def get_queryset(self):
        return self.query_set
    
    def get_serializer(self):
        return self.serialzier_class
    
    def get_object(self):
        return self.query_set.filter(pk=pk)


class BookView(GenericAPIView):
    queryset = Book.objects.all()
    serializer_class = BookSerialzier
    
    def get(self, request):
        qs = self.get_queryset()
        ser = self.get_serializer(qs, many=True)
        return Response({'code': 100, 'msg': '成功', 'results': ser.data})

    def post(self, request):
        ser = self.get_serializer(data=request.data)
        if ser.is_valid():
            ser.save()
            return Response({'code': 100, 'msg': '成功'})
        else:
            return Response({'code': 100, 'msg': ser.errors})


class BookDetailView(GenericAPIView):
    queryset = Book.objects.all()
    serializer_class = BookSerialzier

    def get(self, request, pk):
        book = self.get_object()
        ser = self.get_serializer(book)
        return Response({'code': 100, 'msg': '成功', 'results': ser.data})


    def put(self, request, pk):
        book = self.get_object()
        ser = self.get_serializer(data=request.data, instance=book)
        if ser.is_valid():
            ser.save()
            return Response({'code': 100, 'msg': '更新成功'})
        else:
            return Response({'code': 100, 'msg': ser.errors})

1.2.3 写5个接口

使用GenericAPIView+序列化类+Response写5个接口

 # 总结：以后继承GenericAPIView写接口
    1 必须配置类属性
    	queryset
        serializer_class
     2 想获取要序列化的所有数据
    	get_queryset()
     3 想使用序列化类：
    	get_serializer
     4 想拿单条
    	get_object

代码：

from rest_framework.generics import GenericAPIView


class BookView(GenericAPIView):
    # queryset = Book.objects  # 可以不用加all()，源码中有，但最好自己加上
    queryset = Book.objects.all()  ## 
    serializer_class = BookSerialzier  ## 
    # lookup_field = 'id'

    def get(self, request):
        # qs = self.queryset  # 这个函数中也可以这么写
        qs = self.get_queryset()  ##
        ser = self.get_serializer(qs, many=True)  ##
        return Response({'code': 100, 'msg': '成功', 'results': ser.data})

    def post(self, request):
        ser = self.get_serializer(data=request.data)  ## 
        if ser.is_valid():
            ser.save()
            return Response({'code': 100, 'msg': '成功'})
        else:
            return Response({'code': 100, 'msg': ser.errors})


class BookDetailView(GenericAPIView):
    queryset = Book.objects.all()  ## 
    serializer_class = BookSerialzier  ##  

    def get(self, request, pk):
        book = self.get_object()  ## 
        ser = self.get_serializer(book)  ## 
        return Response({'code': 100, 'msg': '成功', 'results': ser.data})

    def put(self, request, pk):
        book = self.get_object()  ## 
        ser = self.get_serializer(data=request.data, instance=book)  ## 
        if ser.is_valid():
            ser.save()
            return Response({'code': 100, 'msg': '更新成功'})
        else:
            return Response({'code': 100, 'msg': ser.errors})
   
     
# 再写publish有关的，就可以复制上面的，改动两个类的名字，改动两个类属性就行
    queryset = Publish.objects.all()  
    serializer_class = PublishSerialzier  

"""如果涉及到数据库操作，尽量用GenericAPIView"""

二 5个视图扩展类

2.1 方法

5个类(不叫视图类，视图扩展类，需要配合GenericAPIView一起用)，每个类有一个方法，以后想写哪个接口，就继承哪个类即可。

from rest_framework.mixins import ListModelMixin, CreateModelMixin, UpdateModelMixin, DestroyModelMixin, RetrieveModelMixin
'''
    -查询所有 :ListModelMixin ---> list方法
    -新增一条：CreateModelMixin ---> create方法
    
    -查询单条：RetrieveModelMixin ---> retrieve方法
    -修改一条：UpdateModelMixin ---> update方法
    -删除一条：DestroyModelMixin ---> destroy方法
'''

2.2 自己封装

# 不需要继承类

class ListModelMixin:  # 查询所有
    def list(self, request, *args, **kwargs):
        qs = self.get_queryset()
        ser = self.get_serializer(qs, many=True)
        return Response({'code': 100, 'msg': '成功', 'results': ser.data})


class CreateModelMixin:  # 新增数据
    def create(self, request, *args, **kwargs):
        ser = self.get_serializer(data=request.data)
        if ser.is_valid():
            ser.save()
            return Response({'code': 100, 'msg': '成功'})
        else:
            return Response({'code': 100, 'msg': ser.errors})


class RetrieveModelMixin:  # 查询单条
    def retrieve(self, request, *args, **kwargs):
        book = self.get_object()
        ser = self.get_serializer(book)
        return Response({'code': 100, 'msg': '成功', 'results': ser.data})


class UpdateModelMixin:  # 修改一条
    def update(self, request, *args, **kwargs):
        book = self.get_object()
        ser = self.get_serializer(data=request.data, instance=book)
        if ser.is_valid():
            ser.save()
            return Response({'code': 100, 'msg': '更新成功'})
        else:
            return Response({'code': 100, 'msg': ser.errors})


class DestroyModelMixin:  # 删除一条
    def destroy(self, request, *args, **kwargs):
        self.get_object().delete()
        return Response({'code': 100, 'msg': '删除成功'})

2.3 源码

'''
    -查询所有 :ListModelMixin ---> list方法
    -新增一条：CreateModelMixin ---> create方法
    
    -查询单条：RetrieveModelMixin ---> retrieve方法
    -修改一条：UpdateModelMixin ---> update方法
    -删除一条：DestroyModelMixin ---> destroy方法
'''

ListModelMixin的源码：

class ListModelMixin:
    """
    List a queryset.查询所有
    快速实现列表视图，返回200状态码。
    """
    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的源码：

class CreateModelMixin:
    """
    新增一条
    Create a model instance.
    成功返回201状态码。

如果序列化器对前端发送的数据验证失败，返回400错误。
    """
    def create(self, request, *args, **kwargs):
        # 获取序列化器
        serializer = self.get_serializer(data=request.data)
        # 验证，不正确主动抛异常
        serializer.is_valid(raise_exception=True)
        # 保存，   也可以自己写perform_create方法，提高了扩展性
        self.perform_create(serializer)
        headers = self.get_success_headers(serializer.data)
        return Response(serializer.data, status=status.HTTP_201_CREATED, headers=headers)

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

RetrieveModelMixin的源码：

class RetrieveModelMixin:
    """
    查询一条
    Retrieve a model instance.
    如果存在，返回200， 否则返回404。
    """
    def retrieve(self, request, *args, **kwargs):
        # 获取对象，会检查对象的权限
        instance = self.get_object()
        # 序列化
        serializer = self.get_serializer(instance)
        return Response(serializer.data)

UpdateModelMixin的源码：

class UpdateModelMixin:
    """
    修改一条
    Update a model instance.
    成功返回200，序列化器校验数据失败时，返回400错误
    """
    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):
            # If 'prefetch_related' has been applied to a queryset, we need to
            # forcibly invalidate the prefetch cache on the instance.
            instance._prefetched_objects_cache = {}

        return Response(serializer.data)

    def perform_update(self, serializer):
        serializer.save()

    def partial_update(self, request, *args, **kwargs):
        kwargs['partial'] = True
        return self.update(request, *args, **kwargs)

DestroyModelMixin的源码：

class DestroyModelMixin:
    """
    删除一条
    Destroy a model instance.
    成功返回204，不存在返回404。
    """
    def destroy(self, request, *args, **kwargs):
        # 获取对象，会检查对象的权限
        instance = self.get_object()
        # 删除数据
        self.perform_destroy(instance)
        return Response(status=status.HTTP_204_NO_CONTENT)

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

2.4 具体使用，写5个接口

# 5 个视图扩展类--->不是视图类---> 必须配合GenericAPIView及其子类使用---> 不能配合APIView使用
# 5个视图扩展类，每一个类中只有一个方法，完成5个接口中的其中一个，想写多个接口，就要继承多个。这种思维方法叫mixin，混入


# 3 继承GenericAPIView+5个视图扩展类+序列化类+Response写接口
from .models import Book
from .serializer import BookSerializer
from rest_framework.response import Response
from rest_framework.generics import GenericAPIView
from rest_framework.mixins import ListModelMixin, CreateModelMixin, UpdateModelMixin, DestroyModelMixin, RetrieveModelMixin

class BookView(GenericAPIView, ListModelMixin, CreateModelMixin):
    queryset = Book.objects.all()
    serializer_class = BookSerializer

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

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



class BookDetailView(GenericAPIView, RetrieveModelMixin, UpdateModelMixin, DestroyModelMixin):
    queryset = Book.objects.all()
    serializer_class = BookSerializer

    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 delete(self, request, *args, **kwargs):
        return self.destroy(request, *args, **kwargs)

三 9个视图子类

3.1 介绍

# 9个视图子类--->视图类
from rest_framework.generics import ListAPIView, CreateAPIView, UpdateAPIView, DestroyAPIView, RetrieveAPIView
from rest_framework.generics import ListCreateAPIView
from rest_framework.generics import RetrieveUpdateDestroyAPIView
from rest_framework.generics import RetrieveUpdateAPIView
from rest_framework.generics import RetrieveDestroyAPIView
# 没有UpdateDestroyAPIView，写接口是为了配合前端使用，前端只有查到这个数据才能够修改，如果都不能查到，就不会有修改和删除方法了。

1）CreateAPIView

提供 post 方法

继承自： GenericAPIView、CreateModelMixin

2）ListAPIView

提供 get 方法

继承自：GenericAPIView、ListModelMixin

3）RetrieveAPIView

提供 get 方法

继承自: GenericAPIView、RetrieveModelMixin

4）DestoryAPIView

提供 delete 方法

继承自：GenericAPIView、DestoryModelMixin

5）UpdateAPIView

提供 put 和 patch 方法

继承自：GenericAPIView、UpdateModelMixin

6）RetrieveUpdateAPIView

提供 get、put、patch方法

继承自： GenericAPIView、RetrieveModelMixin、UpdateModelMixin

7）RetrieveUpdateDestoryAPIView

提供 get、put、patch、delete方法

继承自：GenericAPIView、RetrieveModelMixin、UpdateModelMixin、DestoryModelMixin

3.2 具体使用

# 4 基于视图子类写5 个接口：9个视图子类--->视图类
from .models import Book
from .serializer import BookSerializer
from rest_framework.generics import ListCreateAPIView, RetrieveUpdateDestroyAPIView

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


class BookDetailView(RetrieveUpdateDestroyAPIView):
    queryset = Book.objects.all()
    serializer_class = BookSerialzier

四视图集

4.1 ModelViewSet写5个接口

总结

# ModelViewSet：

    -继承它后，只需要在视图类中写两行
    	queryset = Book.objects.all()
    	serializer_class = BookSerialzier

    -配置路由，5个接口都有了
    	path('books/', BookView.as_view({'get': 'list', 'post': 'create'})),
    	path('books/<int:pk>/', BookView.as_view({'get': 'retrieve', 'put': 'update', 'delete': 'destroy'})),

视图函数

### 5 视图集 ---> 写5个接口
from .models import Book
from .serializer import BookSerializer
from rest_framework.viewsets import ModelViewSet


class BookView(ModelViewSet):
    queryset = Book.objects.all()
    serializer_class = BookSerialzier

路由

urlpatterns = [
    path('books/', BookView.as_view({'get': 'list', 'post': 'create'})),
    path('books/<int:pk>/', BookView.as_view({'get': 'retrieve', 'put': 'update', 'delete': 'destroy'})),
	]

4.2 为什么要使用视图集

# 具体使用时，就可以自己重写内部的方法，扩展性很高
from rest_framework.viewsets import ModelViewSet


class BookView(ModelViewSet):
    queryset = Book.objects.all()
    serializer_class = BookSerializer
	
    # 自己重写list方法
    def list(self, request, *args, **kwargs):
        # 继承父类的list方法，也就是真正的list方法
        res = super().list(request, *args, **kwargs)
        return Response({'code': 100, 'msg': '成功', 'data': res.data})
	
    # 重写create方法
    def create(self, request, *args, **kwargs):
        # 真正的新增数据方法
        res = super().create(request, *args, **kwargs)
        print('发送邮件。。。')
        return Response({'code': 100, 'msg': '新增成功'})
    
    # # 或者也可以重写perform_create方法，两个重写一个就行
    # def perform_create(self, serializer):
    #     # 在新增之前，加入逻辑
    #     print('发送邮件。。。。')
    #     super(BookView, self).perform_create(serializer)

4.3 ModelViewSet 源码分析

# ModelViewSet是个视图类，必须继承GenericAPIView或子类
# ModelViewSet 源码分析
	-继承了：      
    	     mixins.CreateModelMixin,
             mixins.RetrieveModelMixin,
             mixins.UpdateModelMixin,
             mixins.DestroyModelMixin,
             mixins.ListModelMixin  # 5个视图扩展类
             GenericViewSet
                -ViewSetMixin ：没有见过, 重写了 as_view
                -GenericAPIView
                
                
     -只要继承了ModelViewSet，路由写法变成映射的关系了，谁控制它变的：ViewSetMixin
   

# ViewSetMixin 如何控制路由写法变了？
	-BookView.as_view 是在执行，其实是ViewSetMixin的as_view
        @classonlymethod
        def as_view(cls, actions=None, **initkwargs):
            #我们传入的 actions={'get': 'list', 'post': 'create'}
            def view(request, *args, **kwargs):
                self = cls(**initkwargs)
                for method, action in actions.items():
                    # method:get
                    # action:list
                    # 通过反射，self是BookView的对象，取BookView对象中反射list
                    handler = getattr(self, action)
                    # 通过反射：setattr(BookView的对象,'get',list方法)
                    setattr(self, method, handler)
                # APIViwe的dispatch
                return self.dispatch(request, *args, **kwargs)
            return csrf_exempt(view)
	
    
    
# 总结：
'''
    1 只要继承了ViewSetMixin及其子类，路由写法就变了，必须传actions参数，没有传入action参数，会报错，主动抛异常
    2 变成映射关系了：
        path('books/', BookView.as_view({'get': 'list', 'post': 'create'})),
    3 以后，只要是books路由匹配成功，的get请求，就会执行视图类BookView的list方法
    
    4 以后视图类中的方法名，可以随意命名
    5 ViewSetMixin这个类，必须配合视图类使用(APIView，GenericAPIView，9个视图子类)，必须放在视图类之前(as_view()要先执行)
'''

4.4 视图集中的所有类

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


ViewSetMixin：魔法，不能单独使用，必须配合视图类用，重写了as_view，路由写法变了
ViewSet =ViewSetMixin+APIView
GenericViewSet = ViewSetMixin+GenericAPIView
ModelViewSet：继承了5个视图扩展类和GenericViewSet
ReadOnlyModelViewSet：只读视图类 ---> 只有两个，继承查询所有和查询单条+GenericViewSet

0) ViewSetMixin

只要继承了ViewSetMixin及其子类，路由写法就变了，变成映射关系。必须传actions参数，没有传入action参数，会报错，主动抛异常。

但它不能单独使用，必须配合视图类用

path('books/', BookView.as_view({'get': 'list', 'post': 'create'})),

1） ViewSet

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

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

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

2）GenericViewSet

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

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

3）ModelViewSet

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

4）ReadOnlyModelViewSet

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

4.5 视图中自定义的方法名

视图函数

from rest_framework.viewsets import ViewSetMixin
from rest_framework.views import APIView

class SmsView(ViewSetMixin, APIView):
    # 视图类中的方法可以随意命名
    def lqz(self, request):
        return Response('你好')

路由

path('lqz/', SmsView.as_view({'get':'lqz'})),

# http://127.0.0.1:8000/lqz/地址的get请求，就会执行SmsView视图类中自定义的lqz方法。

六总结

# 两个视图基类
    -APIView
    -GenericAPIView:有关数据库操作，queryset 和serializer_class


# 5 个视图扩展类(rest_framework.mixins)
不是视图类，需要配合GenericAPIView及其子类使用
    -CreateModelMixin：create方法创建一条
    -DestroyModelMixin：destory方法删除一条
    -ListModelMixin：list方法获取所有
    -RetrieveModelMixin：retrieve获取一条
    -UpdateModelMixin：update修改一条
	

# 9个视图子类(rest_framework.generics)
    -CreateAPIView:有post方法，新增数据
    -DestroyAPIView：有delete方法，删除数据
    -ListAPIView：有get方法获取所有
    -UpdateAPIView：有put方法，修改数据
    -RetrieveAPIView：有get方法，获取一条

    -ListCreateAPIView：有get获取所有，post方法新增
    -RetrieveDestroyAPIView：有get方法获取一条，delete方法删除
    -RetrieveUpdateAPIView：有get获取一条，put修改
    -RetrieveUpdateDestroyAPIView：有get获取一条，put修改，delete删除


# 视图集：
    -ModelViewSet：5个接口的
    -ReadOnlyModelViewSet：两个接口，list和retrieve
    -ViewSetMixin：魔法，不能单独使用，必须配合视图类用，路由写法变了，映射。
    -ViewSet：ViewSetMixin+APIView，以后想继承APIView，但是路由写法变化，视图类中方法可以任意命名
    -GenericViewSet：ViewSetMixin+GenericAPIView，以后想继承GenericAPIView，但是路由写法变化，视图类中方法可以任意命名

标签：return,get,self,request,视图,组件,serializer,drf
From： https://www.cnblogs.com/zjyao/p/17429705.html

drf-视图组件

一 视图之两个视图基类

1.1 APIView

使用APIView+序列化类+Response写接口

1.2 GenericAPIView[通用视图类]

1.2.1 主要的属性或方法

1.2.2 推导GenericAPIView的封装

1.2.3 写5个接口

二 5个视图扩展类

2.1 方法

2.2 自己封装

2.3 源码

2.4 具体使用，写5个接口

三 9个视图子类

3.1 介绍

1）CreateAPIView

2）ListAPIView

3）RetrieveAPIView

4）DestoryAPIView

5）UpdateAPIView

6）RetrieveUpdateAPIView

7）RetrieveUpdateDestoryAPIView

3.2 具体使用

四 视图集

4.1 ModelViewSet写5个接口

总结

视图函数

路由

4.2 为什么要使用视图集

4.3 ModelViewSet 源码分析

4.4 视图集中的所有类

0) ViewSetMixin

1） ViewSet

2）GenericViewSet

3）ModelViewSet

4）ReadOnlyModelViewSet

4.5 视图中自定义的方法名

视图函数

路由

六 总结

相关文章

赞助商

阅读排行

一视图之两个视图基类

四视图集

六总结