9个视图子类

两个视图基类
5个视图扩展类
9个视图子类----》视图类，不需要额外继承GenericAPIView，只需要继承9个中其中某个，就会有某个或某几个接口

* 路由
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

2 视图集

2.1 通过ModelViewSet编写5个接口

路由 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个只读接口

路由 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源码分析

请求来了，路由匹配成功---》get请求，匹配成功books，会执行 views.BookView.as_view({'get': 'list', 'post': 'create'})()------>读as_view【这个as_view是ViewSetMixin的as_view】

@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 以后视图类类中的方法名，可以任意命名，只要在路由中做好映射即可【重要】

2.4 from rest_framework.viewsets包下的类

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






## 2.5 视图层大总结
    * 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 路由系统

## 3.1 自动生成路由
    * drf 由于继承ViewSetMinxin类，路由写法变了
            -原生+drf，以后的路由写法，可能会有如下情况(三种情况)
            -path('books/', views.BookView.as_view()
            -path('books/', views.BookView.as_view({'get': 'list', 'post': 'create'}))
            -自动生成


    * drf提供了两个路由类，继承ModelViewSet后，路由可以自动生成

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




    * 底层实现：自动生成路由器
           -本质是自动做映射，能够自动成的前提是，视图类中要有 5个方法的某要给或多个
               get--->list
               get---->retrieve
               put---->update
               post---->create
               delete---->destory
           -ModelViewSet，ReadOnlyModelViewSet可以自动生成

       -9个试图子类+配合ViewSetMixin   才可以自动生成
       -GenericAPIView+5个试图扩展类+配合ViewSetMixin   才能自动生成

## 3.2 action 装饰器

    * action 写在视图类的方法上，可以自动生成路由

    * 使用步骤
            - 1 写在视图类方法上
        class SendView(ViewSet):
            # methods指定请求方法，可以传多个
            # detail：只能传True和False
                    -False,不带id的路径：send/send_sms/
                -True，带id的路径：send/2/send_sms/
            #url_path：生成send后路径的名字，默认以方法名命名 
            # url_name：别名，反向解析使用，了解即可
            @action(methods=['POST'], detail=False)
            def send_sms(self, request):


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






    * 补充：
            -1 不同请求方式可以使用不同序列化类
        -2 不同action使用不同序列化类
    class SendView(GenericViewSet):
        queryset = None
        serializer_class = '序列化类'

    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

# 4 认证组件
    * 访问某个接口，需要登陆后才能访问

    * 第一步：写个登录功能，用户表
            -User表
        -UserToken表：存储用户登录状态 [这个表可以没有，如果没有，把字段直接写在User表上也可以]
## 4.1 登录接口

    * 表模型

    class User(models.Model):
        username = models.CharField(max_length=32)
        password = models.CharField(max_length=32)



    class UserToken(models.Model):  # 跟User是一对一
        token = models.CharField(max_length=32)
        user = models.OneToOneField(to='User', on_delete=models.CASCADE, null=True)
        # user :反向，表名小写，所有有user字段

    * 路由
    router.register('user', views.UserView, 'user')  # /api/v1/user/login     post 请求

    * 视图类
    登录接口  自动生成路由+由于登录功能，不用序列化，继承ViewSet
    from .models import User, UserToken
    import uuid


    class UserView(ViewSet):
        @action(methods=['POST'], detail=False)
        def login(self, request):
            username = request.data.get('username')
            password = request.data.get('password')
            user = User.objects.filter(username=username, password=password).first()
            if user:
                # 用户存在，登录成功
                # 生成一个随机字符串--uuid
                token = str(uuid.uuid4())  # 生成一个永不重复的随机字符串
                # 在userToken表中存储一下：1 从来没有登录过，插入一条，     2 登录过，修改记录
                # 如果有就修改，如果没有就新增  (if 自己写)
                # kwargs 传入的东西查找，能找到，使用defaults的更新，否则新增一条
                UserToken.objects.update_or_create(user=user, defaults={'token': token})
                return Response({'code': '100', 'msg': '登录成功', 'token': token})
            else:
                return Response({'code': '101', 'msg': '用户名或密码错误'})

drf--day6