drf从入门到飞升仙界 06

模型类准备

from django.db import models


# 图书跟作者：多对多，需要建立中间表，但是我们可以通过ManyToManyField自动生成，写在哪里都行
# 图书跟出版社：一对多，一个出版社，出版多本书，关联字段写在多的一方，写在Book
class Book(models.Model):
    name = models.CharField(max_length=32, default='xx')
    price = models.CharField(max_length=32)

    publish = models.ForeignKey(to='Publish', on_delete=models.CASCADE)  # 留住，还有很多
    authors = models.ManyToManyField(to='Author')

    def publish_detail(self):
        return {'name': self.publish.name, 'addr': self.publish.addr}

    def author_list(self):
        l = []
        for author in self.authors.all():
            l.append({'name': author.name, 'phone': author.phone})
        return l


class Publish(models.Model):
    name = models.CharField(max_length=32)
    addr = models.CharField(max_length=32)

    # 指定在book中现实publish的名字方案一，用的不多
    # def __str__(self):
    #     return self.name


class Author(models.Model):
    name = models.CharField(max_length=32)
    phone = models.CharField(max_length=11)


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字段

9个视图子类

# 2个视图基类
   APIView, GenericAPIView
# 5个视图扩展类
   ListModelMixin    （列表视图扩展类）
   CreateModelMixin  （创建视图扩展类）
   RetrieveModelMixin（详情视图扩展类）
   UpdateModelMixin  （更新视图扩展类）
   DestroyModelMixin （删除视图扩展类）

# 9个视图子类
   ListAPIView, CreateAPIView, RetrieveAPIView, 
   DestroyAPIView, UpdateAPIView, ListCreateAPIView,
   RetrieveDestroyAPIView, RetrieveUpdateAPIView,
   RetrieveUpdateDestroyAPIView

"""
    视图类不需要额外继承GenericAPIView。
    只需要继承9个视图子类中的某几个，就会有相对应的接口
"""


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


## 2.视图类 views.py
from .models import Book
from .serializer import BookSerializer
from rest_framework.generics import ListAPIView,CreateAPIView,RetrieveAPIView,\
    DestroyAPIView,UpdateAPIView,ListCreateAPIView,RetrieveDestroyAPIView,RetrieveUpdateAPIView,\
    RetrieveUpdateDestroyAPIView

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

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


##3.serizlizer.py
from rest_framework import serializers
from .models import Book

class BookSerializer(serializers.ModelSerializer):
    class Meta:
        model = Book
        fields = ['name','price','publish_detail','author_list','publish','authors']
        extra_kwargs = {'name':{'max_length': 8},
                        'publish_detail': {'read_only':True},
                        'author_list': {'read_only':True},
                        'publish': {'write_only': True},
                        'authors': {'write_only': True},}

视图集

通过ModelViewSet编写5个接口

# 路由 urls.py
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'})),
]

# 视图类 views.py
from rest_framework.viewsets import ModelViewSet
class BookView(ModelViewSet):  # 查询所有，新增一个
    queryset = Book.objects.all()
    serializer_class = BookSerializer

通过ReadOnlyModelViewSet编写两个只读接口

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

# 视图类
from rest_framework.viewsets import ReadOnlyModelViewSet

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

ViewSetMixin源码分析

# 1.ViewSetMixin位置：
ModelViewSet ---->  GenericViewSet ----> ViewSetMixin

# 2.ViewSetMixin源码分析：
"""
当请求来了之后，路由匹配成功：
  -1.get请求，匹配成功books
  -2.执行views.BookView.as_view({'get': 'list', 'post': 'create'})()
  -3.读到的as_view是ViewSetMixin的a  
"""
# # 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)


"""
当路由匹配成功执行:
  -1.views.BookView.as_view({'get': 'list', 'post': 'create'})()
  -2.本质执行ViewSetMixin里面的as_view内的view()
"""   
##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)
    #dispatch是APIView的
    return self.dispatch(request, *args, **kwargs) 

# 3.总结
 - 1.只要继承了ViewSetMixin的视图类，路由写法就改变了(重写了as_view)
 - 2.路由的写法变为了需要传入字典映射的方法：{'get': 'list', 'post': 'create'}
 - 3.只要传入时传入actions参数，所有的映射就会生效，访问get就是访问list
 - 4.其他执行与之前一致
 - 5.后期写代码视图类中的方法名，可以任意命名，但是需要在路由中做好映射关系【重要】

from rest_framework.viewsets包下的类

# from rest_framework.viewsets有如下几个类：
- 1.ModelViewSet：              
     5个试图扩展类+ViewSetMixin+GenericAPIView
- 2.ReadOnlyModelViewSet：
     2个试图扩展类(查单个,查所有)+ViewSetMixin+GenericAPIView   
- 3.ViewSetMixin：
     使用魔法方法，重写了as_view，只要继承ViewSetMixin，以后路由写法变成了映射方法
- 4.ViewSet：
     ViewSetMixin+ APIView
- 5.GenericViewSet：
     ViewSetMixin+ GenericAPIView


# 重点
"""
1.想继承APIView，也想改变路由写法，必须继承ViewSet【视图类中方法名任意命名】
2.想继承GenericAPIView，也想变路由写法，要继承GenericViewSet【视图类中方法名任意命名】
"""

视图层总结

# 1.两个试图基类
# 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):
            

路由系统

自动生成路由

# drf 由于继承了ViewSetMixin，路由写法改变
  对于原生django+drf，路由写法可能会有三种情况：
    - 1. path('books/', views.BookView.as_view()
    - 2. path('books/', views.BookView.as_view({'get': 'list', 'post': 'create'}))
    - 3. 自动生成
# drf提供两个路由类，继承ModelViewSet后，路由可以自动生成
  使用步骤：
    - 第一步:导入路由类
    - 第二步,实例化得到对象（两个类，一般使用SimpleRouter）
    - 第三步:注册：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装饰器

# 1.action 写在视图类的方法上，可以自动生成路由
# 2.使用步骤：
-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 加入路由了
"""

# 3.补充
  - 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