视图

视图  View

    两个视图基类：APIView   GenericAPIView
    APIView
        执行流程：新的reqeust，三大认证，全局异常
        重写了as_view，dispatch
        类属性：parser_class，xxx

    GenericAPIView---》继承了APIView----》以后，如果是跟数据库打交道，尽量用它
        1 queryset:要序列化或反序列化的表模型数据
        2 serializer_class：使用的序列化类
        3 lookup_field ：查询单条的路由分组分出来的字段名
        4 filter_backends：过滤类的配置(了解)
        5 pagination_class：分页类的配置(了解)

        方法
        1 get_queryset   ：获取要序列化的对象
        2 get_object  ：获取单个对象
        3 get_serializer ：获取序列化类  ，跟它差不多的get_serializer_class，一般重写它，不调用它
        4 filter_queryset  ：过滤有关系(了解)


    补充，根据请求方式，定制序列化类
     def get_serializer(self, *args, **kwargs):
        if self.request.method=='GET':
            return 序列化单条的序列化类
        else:
            return 新增的序列化类

5个视图扩展类----》不是视图类----》必须配合GenericAPIView
     每个类自己写了一个方法，写的不是【请求方式，不是put，get。。。】的方法，写的是list，destroy。。。
     mixins 混入，通过多继承来实现多个功能
     from rest_framework.mixins import CreateModelMixin, UpdateModelMixin, DestroyModelMixin, RetrieveModelMixin,
    ListModelMixin
    
    
     继承GenericAPIView+某个视图扩展类+请求方式的方法

9个视图子类

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

路由
urlpatterns = [
    path('books/', views.BookView.as_view()),
    path('books/<int:pk>/', views.BookView.as_view()),
]

视图类
from rest_framework.generics import ListAPIView, ListCreateAPIView, CreateAPIView, \
    RetrieveAPIView, RetrieveUpdateDestroyAPIView, UpdateAPIView, DestroyAPIView
from .models import Book
from .serializer import BookSerializer

class BookView(ListCreateAPIView):  # 查询所有，新增一个
    queryset = Book.objects.all()
    serializer_class = BookSerializer

# 新增一个，修改一个，删除一个
class BookDetailView(RetrieveUpdateDestroyAPIView):
    queryset = Book.objects.all()
    serializer_class = BookSerializer

因为这5个接口在不同的场景可能不需要全部都写 所以按照需求可以通过继承的父类的不同进行代码编写
eg：写一个查询所有   
   class BookView(ListAPIView):
        queryset = Book.objects.all()
        serializer_class = BookSerializer

    再写一个修改
    class BookDetailView(UpdateAPIView):
        queryset = Book.objects.all()
        serializer_class = BookSerializer

视图集

通过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'})),
]

视图类
from .models import Book
from .serializer import BookSerializer
from rest_framework.viewsets import ModelViewSet
class BookView(ModelViewSet):  
    queryset = Book.objects.all()
    serializer_class = BookSerializer

通过ReadOnlyModelViewSet编写2个只读接口

路由
urlpatterns = [
    path('books/', views.BookView.as_view({'get': 'list'})),
    path('books/<int:pk>/', views.BookView.as_view({'get': 'retrieve'})),
]

视图类
from .models import Book
from .serializer import BookSerializer
from rest_framework.viewsets import ReadOnlyModelViewSet
class BookView(ReadOnlyModelViewSet): 
    queryset = Book.objects.all()
    serializer_class = BookSerializer

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

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

视图层大总结

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):

链接https://www.processon.com/embed/60dec4091e085359888e3e72

路由系统

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

drf提供了两个路由类 继承ModelViewSet后，路由可以自动生成
from django.urls import path, include
from app01 import views
from rest_framework.routers import SimpleRouter, DefaultRouter

使用步骤：
     第一步：导入路由类
     第二步：实例化得到对象（两个类，一般使用SimpleRouter）
         router = SimpleRouter() # 生成少用的多
         # router = DefaultRouter() # 生成多 用的少
   根  Api root ：访问根 可以看到有哪些地址比如 book publish

     第三步：注册：router.register('books', views.BookView, 'books')  # 第一个参数是路径 注意不带/ 第二个参数是视图类，第三个参数是别名 一般跟路径相同
     第四步：在urlpatterns中注册,两种方式
        1. urlpatterns += router.urls
        2. 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   才能自动生成

action装饰器

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

使用步骤
     1.写在视图类方法上
     from rest_framework.viewsets import ViewSet


     from rest_framework.decorators import action
     # class SendView(ViewSetMixin,APIView):
     class SendView(ViewSet):
        @action(methods=['GET','POST'],detail=False,url_path='send_sms',url_name='send_sms')
        # methods 指定请求方法，可以传多个
        # detail：只能传True和False
            False，不带id的路径：send/send_sms
            True，带id的路径：send/pk/send_sms 参数要带pk
            #url_path：生成send后路径的名字，默认以方法名命名 
            # url_name：别名，反向解析使用，了解即可
        def send_sms(self, request):
            # 手机号 从哪去 假设get请求 携带了参数
            phone = request.query_params.get('phone')
            print('发送成功,%s' % phone)
            return Response({'code': 100, 'msg': '发送成功'})


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


补充：
    1.不同请求方式可以使用不同序列化类
    2.不同action使用不同序列化类
from rest_framework.viewsets import ViewSet,GenericViewSet
from rest_framework.decorators import action
# class SendView(ViewSetMixin,APIView):
class SendView(GenericViewSet,):
    queryset = None
    serializer_class = '序列化类'

    def get_serializer(self,*args,**kwargs):
        if self.action == 'lqz':
            return '某个序列化类'
        else:
            return '另一个序列化类'
    @action(methods=['GET','POST'],detail=True)
    def send_sms(self, request,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
        # 序列化类
        ...

    @action(methods=['GET'],detail=True)
    def login(self,request):   # get
        #序列化类
        ...

认证组件

访问某个接口，需要登录后才能访问

第一步：写个登录功能 用户表
    User表
    UserToken表：存储用户登录状态【这个表可以没有，如果没有，把字段直接写在User表上也可以】

登录接口

表模型

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': '用户名或密码错误'})