九个视图子类、视图集、路由系统

目录
  • 一、九个视图子类
  • 二、视图集
  • 三、路由系统

  • 一、九个视图子类

    python
    # 两个视图基类
    # 5个视图扩展类
    # 9个视图子类----》视图类,不需要额外继承GenericAPIView(源码中可以看到已经继承了),只需要继承9个中其中某个,就会有某个或某几个接口

    视图子类详细介绍见上期博客:https://www.cnblogs.com/zhihuanzzh/p/17089531.html

    视图子类使用:

    相比之前的APIView就十分简洁

    python
    ## 路由
    urlpatterns = [
        path('books/', views.BookView.as_view()),
        path('books/<int:pk>/', views.BookView.as_view()),
    ]
    
    # 视图类
    class BookView(ListCreateAPIView):  # 查询所有,新增一个
        queryset = Book.objects.all()
        serializer_class = BookSerializer
    
    
    # 新增一个,修改一个,删除一个
    class BookDetailView(RetrieveUpdateDestroyAPIView):
        queryset = Book.objects.all()
        serializer_class = BookSerializer

    二、视图集

    最开始的视图拓展类,是依赖GenericAPIView才能实现功能的,接着我们的视图子类则是内部继承了拓展类和GenericAPIView类,因此我们只需要继承子类即可使用。

    这时候我们有出现了一个需求,比如我们想把所有的接口都塞到一个视图类中,这时候就引进了ModelViewSet这个类

    但是ModelViewSet虽然使用的时候很方便,他的路由格式有所变化,需要写上一个字典,对方法和请求方式进行映射

    2.1 通过ModelViewSet编写5个接口

    ModelViewSet中继承了五个拓展类

    python
    # 路由
    urlpatterns = [
        path('books/', views.BookView.as_view({'get': 'list', 'post': 'create'})),
        path('books/<int:pk>/', views.BookView.as_view({'get': 'retrieve', 'put': 'update', 'delete': 'destroy'})),
    ]
    
    # 视图类
    class BookView(ModelViewSet):  # 查询所有,新增一个
        queryset = Book.objects.all()
        serializer_class = BookSerializer

    2.2 通过ReadOnlyModelViewSet编写2个只读接口

    ReadOnlyModelViewSet中继承了获取所有和获取单挑的拓展类

    python
    # 路由
    urlpatterns = [
        path('books/', views.BookView.as_view({'get': 'list'})),
        path('books/<int:pk>/', views.BookView.as_view({'get': 'retrieve'})),
    ]
    
    # 视图类
    class BookView(ReadOnlyModelViewSet):  # 查询所有,新增一个
        queryset = Book.objects.all()
        serializer_class = BookSerializer

    2.3 ViewSetMixin源码分析

    前置条件分析:当我们编写了前面的两个视图类的代码后,我们点击源码,发现内部主要的玄机在父类中,除了拓展类,别的部分只有GenericViewSet是我们没有看过的,代码如下:

    python
    class ViewSet(ViewSetMixin, views.APIView):
        pass
    
    
    class GenericViewSet(ViewSetMixin, generics.GenericAPIView):
        pass
    
    
    class ReadOnlyModelViewSet(mixins.RetrieveModelMixin,
                               mixins.ListModelMixin,
                               GenericViewSet):
        pass
    
    
    class ModelViewSet(mixins.CreateModelMixin,
                       mixins.RetrieveModelMixin,
                       mixins.UpdateModelMixin,
                       mixins.DestroyModelMixin,
                       mixins.ListModelMixin,
                       GenericViewSet):
        pass

    个人理解:

    通过他的源码我们发现这个GenericViewSet就在ModelViewSet的上面,同时他的内部也十分的简单,GenericAPIView是我们学过的东西,视图基类之一,因此研究的关键点就是ViewSetMixin,查看他的源码我们发现他的内部有一个as_view()方法,而我们想到as_view()是用在视图层中的,我们使用ModelViewSet和ReadOnlyModelViewSet的时候需要在as_view()中传入请求方式跟方法的映射关系,因此这个actions就是接受我们传的字典的,接着就是跟之前的APIView中的as_view()一样的作用:取出csrf校验,然后返回view方法,当执行路由的时候通过传入参数,用for循环获取映射关系,再执行dispatch方法。

    老师讲解(附源码):

    python
    # 请求来了,路由匹配成功---》get请求,匹配成功books,会执行  views.BookView.as_view({'get': 'list', 'post': 'create'})()------>读as_view【这个as_view是ViewSetMixin的as_view】
    class ViewSetMixin:
        @classonlymethod
        def as_view(cls, actions=None, **initkwargs):
            # 如果没有传actions,直接抛异常,路由写法变了后,as_view中不传字典,直接报错
            if not actions:
                raise TypeError("The `actions` argument must be provided when "
                                "calling `.as_view()` on a ViewSet. For example "
                                "`.as_view({'get': 'list'})`")
    		# 。。。。其他代码不用看
            def view(request, *args, **kwargs):
                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():
                    handler = getattr(self, action)
                    setattr(self, method, handler)
    
                return self.dispatch(request, *args, **kwargs)
            # 去除了csrf校验
            return csrf_exempt(view)
        
        
    # 路由匹配成功执行views.BookView.as_view({'get': 'list', 'post': 'create'})()----》本质执
    行ViewSetMixin----》as_view----》内的view()---》代码贴过来
        def view(request, *args, **kwargs):
                #actions 是传入的字典--->{'get': 'list', 'post': 'create'}
                self.action_map = actions
                # 第一次循环:method:get,action:list
                # 第一次循环:method:post,action:create
                for method, action in actions.items():
                    # 反射:去视图类中反射,action对应的方法,action第一次是list,去视图类中反射list方法
                    # handler就是视图类中的list方法
                    handler = getattr(self, action)
                    # 反射修改:把method:get请求方法,handler:list
                    # 视图类的对象的get方法,变成了list
                    setattr(self, method, handler)
    
                return self.dispatch(request, *args, **kwargs) #dispatch是APIView的

    总结:

    • 1 只要继承ViewSetMixin的视图类,路由写法就变了(关键就是重写了as_veiw)
    • 2 变成需要需要传入字典映射方法:{'get': 'list', 'post': 'create'}
      -只要传入actions,以后访问get就是访问list,访问post,就是访问create
    • 3 其他执行跟之前一样
    • 4 以后视图类类中的方法名,可以任意命名,只要在路由中做好映射即可【重要】
    • 5 ViewSetMixin用于自动生成路由的时候,需要写在GenericAPIView和APIView的前面,否则就不回用到内部重写的as_view方法

    2.4 from rest_framework.viewsets包下的类

    python
    '''
    from rest_framework.viewsets下有这几个类
    ModelViewSet:5个试图扩展类+ViewSetMixin+GenericAPIView
    ReadOnlyModelViewSet::2个试图扩展类+ViewSetMixin+GenericAPIView   只读的两个
    ViewSetMixin:魔法,重新了as_view,只要继承他,以后路由写法变成了映射方法
    
    下面两个类则相当于进行了封装:
    ViewSet:ViewSetMixin+ APIView
    GenericViewSet:ViewSetMixin+ GenericAPIView
    '''
    
    
    

    重点:

    • 以后,你想继承APIView,但是想变路由写法【视图类中方法名任意命名】,要继承ViewSet
    • 以后,你想继承GenericAPIView,但是想变路由写法【视图类中方法名任意命名】,要继承GenericViewSet(跟数据库相关的时候建议用GenericViewSet,不然他的queryset不太好写)

    2.5常用视图集父类(概念整理)

    1) ViewSet

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

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

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

    2)GenericViewSet

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

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

    3)ModelViewSet

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

    4)ReadOnlyModelViewSet

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

    2.6action属性

    在视图集中,我们可以通过action对象属性来获取当前请求视图集时的action动作是哪个。

    例如:

    python
    from rest_framework.viewsets import ModelViewSet
    from students.models import Student
    from .serializers import StudentModelSerializer
    from rest_framework.response import Response
    class StudentModelViewSet(ModelViewSet):
        queryset = Student.objects.all()
        serializer_class = StudentModelSerializer
    
        def get_new_5(self,request):
            """获取最近添加的5个学生信息"""
            # 操作数据库
            print(self.action) # 获取本次请求的视图方法名
            
            
    通过路由访问到当前方法中.可以看到本次的action就是请求的方法名

    2.7 视图层大总结

    python
    # 1 两个试图基类
    	-APIView,GenericAPIView
    # 2 5个试图扩展类,不是视图类,必须配合GenericAPIView
    
    # 3 9 个视图子类,是视图类,只需要继承其中某一个即可
    
    # 4 视图集 
    	-ModelViewSet:路由写法变了,只需要写两行,5个接口都有了
        -ReadOnlyModelViewSet:路由写法变了,只需要写两行,2个只读接口都有了
        -ViewSetMixin:不是视图类,魔法,重写了as_view,路由写法变了,变成映射了
        	views.BookView.as_view({'get': 'list', 'post': 'create'})
        -ViewSet:ViewSetMixin+ APIView
    	-GenericViewSet:ViewSetMixin+ GenericAPIView
    
        
        
    # 举例子:发送短信接口,视图类叫SendView,方法叫send_sms,路由配置变了
    	get--->send_sms
    	class SendView(ViewSet):
            def send_sms(self,request):
                

    三、路由系统

    3.1 自动生成路由

    drf 由于继承ViewSetMixin类,路由写法变了,原生django+drf,以后的路由写法,可能会有如下情况(三种情况)

    python
    -path('books/', views.BookView.as_view()
    -path('books/', views.BookView.as_view({'get': 'list', 'post': 'create'}))
    -自动生成

    drf提供了两个路由类,继承ModelViewSet后,路由可以自动生成,使用步骤如下:

    python
        # 第一步:导入路由类
        # 第二步,实例化得到对象(两个类,一般使用SimpleRouter)
        # 第三步:注册:router.register('books', views.BookView, 'books')
        # 第四步:在urlpatterns中注册,两种方式
            -urlpatterns += router.urls
            -include:path('/api/v1/', include(router.urls))  方式多一些

    代码如下:

    urls.py

    python
    # 第一步:导入路由类
    from rest_framework.routers import SimpleRouter, DefaultRouter
    
    # 第二步,实例化得到对象
    router = SimpleRouter()  # 后面这个生成路由少的用的多
    # router = DefaultRouter()
    # 生成多个路由,到底多了几个:
    # 1 Api Root :访问根(/),可以看到有那些地址,比如book的,比如publish的
    # 2 会给别的路由自动起别名,后期一般都用SimpleRouter
    'SimpleRouter()与DefaultRouter()的区别'
    # DefaultRouter与SimpleRouter的区别是,DefaultRouter会多附带一个默认的API根视图(就是访问根),返回一个包含所有列表视图的超链接响应数据
    
    
    # 第三步:注册
    # 第一个参数是路径,不要带 /
    # 第二个参数是视图类
    # 第三个参数是别名,一般跟路径相同
    router.register('books', views.BookView, 'books')  # 路径和视图类建立关系  有几个视图类就要写几次
    
    # 第四步:在urlpatterns中注册,两种方式
    # 方式一:
    urlpatterns += router.urls
    print(router.urls)  # [<URLPattern '^books/$' [name='books-list']>, <URLPattern '^books/(?P<pk>[^/.]+)/$' [name='books-detail']>]
    

    第四步方式二:

    python
    # 第一步:导入路由类
    from rest_framework.routers import SimpleRouter, DefaultRouter
    
    # 第二步,实例化得到对象
    router = SimpleRouter()
    
    # 第三步:注册
    router.register('books', views.BookView, 'books')
    
    # 第四步:在urlpatterns中注册
    '在上方导入模块'
    from django.urls import path, include
    
    urlpatterns = [
        path('admin/', admin.site.urls),
        path('api/v1/', include(router.urls)),
    ]
    '我们可以发现,这里的第二种注册方式我们可以进行一定程度的自定义,最终的路由就是:自定义部分+自动生成部分,因此将来使用第二种方式的情况居多'

    底层实现:自动生成路由

    python
           -本质是自动做映射,能够自动成的前提是,视图类中要用到5个方法中的某个或多个,并且用上了ViewSetMixin类(它的as_view方法就是做映射)
               get--->list
               get---->retrieve
               put---->update
               post---->create
               delete---->destory
           -因此ModelViewSet,ReadOnlyModelViewSet可以自动生成路由
                  
           -9个试图子类+配合ViewSetMixin   才可以自动生成
           -GenericAPIView+5个试图扩展类+配合ViewSetMixin才能自动生成。同时GenericAPIView和ViewSetMixin可以替换成GenericViewSet

    3.2 action 装饰器

    当我们想对视图类中的get、post等方法,自定义方法名称或同意名称的方法有多个请求方式的时候,我们需要使用action装饰器,这样才能使用自动生成路由。

    python
    def action(methods=None, detail=None, url_path=None, url_name=None, **kwargs):

    通过action装饰器的源码我们发现他内部主要有四个参数,作用如下:

    • method:声明该action对应的请求方式,以列表的方式存入,可以写多个请求方式
    • detail:默认是False(只能传True和False),控制生成的路由是什么样子,如果是True则会加上PK,必须是数字。
    python
        -False,不带id的路径:send/send_sms/
        -True,带id的路径:send/2/send_sms/
    • ulr_path: 控制生成的路由后面的路径名称是什么,如果不写默认以被装饰的方法名为路径名称
    • url_name: 别名 用于反向解析

    使用步骤:

    python
    	- 1 写在视图类方法上
        from rest_framework.decorators import action
        class SendView(ViewSet):
    
            @action(methods=['POST'], detail=False)
            def send_sms(self, request):

    ps:以后看到的drf路由写法,都是自动生成,一般不在urlpatterns 加入路由了

    补充

    • 1 不同请求方式可以使用不同序列化类
    • 2 不同action使用不同序列化类
    python
    class SendView(GenericViewSet):
        queryset = None
        serializer_class = '序列化类'
    	
        '这里我们通过重写get_serializer方法来根据请求方式选择不同的序列化类'
        def get_serializer(self, *args, **kwargs):
            if self.action=='lqz':
                return '某个序列化类'
            else:
                return '另一个序列化列'
            
        @action(methods=['GET'], detail=True)
        def send_sms(self, request,pk):
            print(pk)
            # 手机号,从哪去,假设get请求,携带了参数
            phone = request.query_params.get('phone')
            print('发送成功,%s' % phone)
            return Response({'code': 100, 'msg': '发送成功'})
    
        @action(methods=['GET'], detail=True)
        def lqz(self,request):  # get
            # 序列化类
            pass
    
        @action(methods=['GET'], detail=True)
        def login(self,request):  # get
            # 序列化类
            pass

posted @ 2023-02-07 20:24  dear丹  阅读(19)  评论(0编辑  收藏  举报