9 个视图子类、视图集、路由系统、认证组件

9 个视图子类、视图集、路由系统、认证组件

9 个视图子类

# 两个视图基类
APIView     GenericAPIView
1.APIView 
  执行流程：新的request,三大认证，全局异常
  重写了as_view()和dispatch方法
  类属性：parser_class
2.GenericAPIView
 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:过滤有关系
    

# 5个视图扩展类
5个视图扩展类，没有继承APIView及其子类，它不能单独使用，必须配合GenericAPIView一起用才行
from rest_framework.mixins import CreateModelMixin,UpdateModelMixin,DestroyModelMixin,RetrieveModelMixin,ListModelMixin

 CreateModelMixin:新增
 DestroyModelMixin：删除     destroy方法
 RetrieveModelMixin：查单条   retrieve方法
 ListModelMixin：查所有      list 方法
 UpdateModelMixin：更新      updata方法

# 基于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,RetrieveDestroyAPIView,DestroyAPIView,UpdateAPIView

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

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

# 9个视图子类的总结：
1.ListAPIView，CreateAPIView
2.ListAPIView + CreateAPIView = ListCreateAPIView
3.RetrieveAPIView ， DestroyAPIView ， UpdateAPIView
4.RetrieveDestroyAPIView,DestroyAPIView
5. RetrieveUpdateDestroyAPIView

# 简便记忆：
Listxxx----->>查所有
Retrievexxx---->>查单条
Createxxx---->>新增
Updatexxx---->>修改
Destroyxxx---->>删除

视图集

1 通过ModelViewSet编写5个接口

# 路由
urlpatterns = [
    path('admin/', admin.site.urls),
    # path('books/', views.BookView.as_view()),
    # path('books/<int:pk>/', views.BookDetailView.as_view())
    path('books/', views.BookView.as_view({'get':'list','post':'create'})),
    path('books/<int:pk>/', views.BookDetailView.as_view({'get':'retrieve','put':'update','delete':'destroy'}))
]

导致路由写法变了的原因----->ViewSetMixin 类--->注释中写了，以后配置路由变成了view = MyViewSet.as_view({'get': 'list', 'post': 'create'})

# 视图层
from rest_framework.viewsets import ModelViewSet,ReadOnlyModelViewSet

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

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

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

# 视图类
class BookDetailView(ReadOnlyModelViewSet):
    # 查询所有和查询单个
    queryset = Book.objects.all()
    serializer_class = BookSerializer

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对应的方法，反射list的方法
                # handler就是就是视图类中的list方法
                handler = getattr(self, action)
                # 反射修改：视图类的get方法变成了list方法
                setattr(self, method, handler)

            return self.dispatch(request, *args, **kwargs)

总结：
1.只要继承ViewSetMixin的视图类，路由的写法据变了(重写了as_view方法)
2.需要传入字典的映射方法：{'get':'list','post':'create'}
	只要传入actions,以后访问get就是访问list,访问post就是访问create
3.其他执行都一样
4.以后视图类中的方法名，可以任意命名，在路由中做好映射即可

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

5 视图层大总结

# 1 两个试图基类
	-APIView，GenericAPIView
# 2 5个试图扩展类，不是视图类，必须配合GenericAPIView
	-CreateModelMixin,UpdateModelMixin,DestroyModelMixin,RetrieveModelMixin,ListModelMixin

# 3 9 个视图子类，是视图类，只需要继承其中某一个即可

# 4 视图集 
	-ModelViewSet：路由写法变了，只需要写两行，5个接口都有了
    -ReadOnlyModelViewSet：路由写法变了，只需要写两行，2个只读接口都有了
    -ViewSetMixin：不是视图类，魔法，重写了as_view,路由写法变了，变成映射了
    	views.BookView.as_view({'get': 'list', 'post': 'create'})
    -ViewSet：ViewSetMixin+ APIView
	-GenericViewSet：ViewSetMixin+ GenericAPIView

路由系统

1 自动生成路由

from django.contrib import admin
from django.urls import path,include
from app01 import views

# 第一步：导入路由类
from rest_framework.routers import SimpleRouter,DefaultRouter
# 第二步：实例化得到对象
router = SimpleRouter()
# router = DefaultRouter()
# 第三步：注册
router.register('books',views.BookView,'books')


urlpatterns = [
    path('admin/', admin.site.urls),
    path('api/v1/',include(router.urls))
]
# 第四部:在urlpatterns中注册
 urlpatterns += router.urls
    
# 底层实现：自动生成路由就
       -本质是自动做映射，能够自动成的前提是，视图类中要有 5个方法的某要给或多个
           get--->list
           get---->retrieve
           put---->update
           post---->create
           delete---->destory
       -ModelViewSet，ReadOnlyModelViewSet可以自动生成
              
       -9个试图子类+配合ViewSetMixin   才可以自动生成
       -GenericAPIView+5个试图扩展类+配合ViewSetMixin   才能自动生成

2 action 装饰器

# 发送短信，生成路由
from rest_framework.viewsets import ViewSet,GenericViewSet
from rest_framework.decorators import action
class SendView(ViewSet):
    # @action(methods=['POST'],detail=True)
    def send_sms(self,request):
        # print(pk)
        phone = request.query_params.get('phone')
        print('发送成功,%s' % phone)
        return Response({'code':100,'msg':'发送成功'})

# 使用步骤
	- 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 

认证组件

登录接口

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

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

# 发送短信，生成路由
from rest_framework.viewsets import ViewSet,GenericViewSet
from rest_framework.decorators import action
from .models import UserToken,user
import uuid
class SendView(ViewSet):
    @action(methods=['POST'],detail=False)
    def send_sms(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': '用户名或密码错误'})

#表模型

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