drf-day6——九个视图子类、视图集、路由系统、认证组件

目录

• 一、九个视图子类
• 二、视图集
  • 2.1 通过ModelViewSet编写5个接口
  • 2.2 通过ReadOnlyModelViewSet编写2个只读接口
  • 2.3 ViewSetMixin源码分析
    • 总结：
  • 2.4 from rest_framework.viewsets包下的类
  • 2.5常用视图集父类（概念整理）
    • 1） ViewSet
    • 2）GenericViewSet
    • 3）ModelViewSet
    • 4）ReadOnlyModelViewSet
  • 2.6action属性
  • 2.7 视图层大总结
• 三、路由系统
  • 3.1 自动生成路由
  • 3.2 action 装饰器
• 四、认证组件
  • 4.1 登录接口
• 五、作业
  • 登录接口写完（if,我写的方式）

一、九个视图子类

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

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

视图子类使用：

相比之前的APIView就十分简洁

## 路由
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中继承了五个拓展类

# 路由
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中继承了获取所有和获取单挑的拓展类

# 路由
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是我们没有看过的，代码如下：

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方法。

老师讲解（附源码）：

# 请求来了，路由匹配成功---》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包下的类

'''
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

继承自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。

2.6action属性

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

例如：

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 视图层大总结

# 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，以后的路由写法，可能会有如下情况(三种情况)

-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))  方式多一些

代码如下：

urls.py

# 第一步:导入路由类
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']>]

第四步方式二：

# 第一步:导入路由类
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)),
]
'我们可以发现，这里的第二种注册方式我们可以进行一定程度的自定义，最终的路由就是：自定义部分+自动生成部分，因此将来使用第二种方式的情况居多'

底层实现：自动生成路由

       -本质是自动做映射，能够自动成的前提是，视图类中要用到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装饰器，这样才能使用自动生成路由。

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

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

• method：声明该action对应的请求方式，以列表的方式存入，可以写多个请求方式
• detail：默认是False（只能传True和False），控制生成的路由是什么样子，如果是True则会加上PK，必须是数字。

    -False,不带id的路径：send/send_sms/
    -True，带id的路径：send/2/send_sms/

• ulr_path: 控制生成的路由后面的路径名称是什么，如果不写默认以被装饰的方法名为路径名称
• url_name: 别名 用于反向解析

使用步骤：

	- 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使用不同序列化类

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

四、认证组件

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

4.1 登录接口

# 认证是基于登录的接口上面操作的 所以前戏编写一个简单的登录接口

models.py
class User(models.Model):  # 简易的用户信息账号密码
    username = models.CharField(max_length=32)
    password = models.CharField(max_length=32)

    def __str__(self):
        return self.username

	'跟User表是一对一外键关联，存储用户登录状态用的 [这个表可以没有，如果没有，把字段直接写在User表上也可以]'
	class UserToken(models.Model):  # 用户信息登录记录表
	    user = models.OneToOneField(to='User', on_delete=models.CASCADE)  # 一对一关联
	    token = models.CharField(max_length=32, null=True)  # 如果用户没有登录则没有值 如果登录则有值

views.py
	'登录接口功能:自动生成路由+登录功能，不用序列化，因此继承ViewSet即可'
class UserView(ViewSet):
    @action(methods=['POST'], detail=False, url_path='login', url_name='login')
    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:
            token = str(uuid.uuid4())
            # uuid4 随机获得永不重复的字符串 机制跟Cookie中的验证码一样
            # 在userToken表中存储一下：1 从来没有登录过，插入一条，     2 登录过，修改记录

            UserToken.objects.update_or_create(defaults={'token': token}, user=user)
            # 通过user去UserToken表中查数据，如果能查到，使用defaults的数据更新，如果查不到，直接通过user和defaults的数据新增
            # kwargs 传入的东西查找，能找到，使用defaults的更新，否则新增一条
            return Response({'code': 100, 'msg': '登录成功', 'token': token})
        else:
            return Response({'code': 101, 'msg': '用户名或密码错误'})

urls.py
	from rest_framework.routers import SimpleRouter, DefaultRouter
	router = SimpleRouter()
	router.register('users', views.UserView, 'users')
	urlpatterns += router.urls

'''这个时候一个简单的登录接口就写好了 每次登录都会更新Token 相当于登录了之前的设备就无效了 '''

update_or_create源码如下

    def update_or_create(self, defaults=None, **kwargs):
        defaults = defaults or {}
        self._for_write = True
        with transaction.atomic(using=self.db):
            try:
                obj = self.select_for_update().get(**kwargs)
            except self.model.DoesNotExist:
                params = self._extract_model_params(defaults, **kwargs)
                obj, created = self._create_object_from_params(kwargs, params, lock=True)
                if created:
                    return obj, created
            for k, v in defaults.items():
                setattr(obj, k, v() if callable(v) else v)
            obj.save(using=self.db)
        return obj, False

五、作业

登录接口写完（if,我写的方式）

---扩展
# 4 登录认证功能，没写，登录功能写完了
	-实现了图书5个接口
    -图书的查询所有和新增不需要登录访问
    -图书的查询一个，修改，删除，登录访问