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

巴特西

drf从入门到飞升仙界 06

模型类准备

9个视图子类

视图集

通过ModelViewSet编写5个接口

通过ReadOnlyModelViewSet编写两个只读接口

ViewSetMixin源码分析

from rest_framework.viewsets包下的类

视图层总结

路由系统

自动生成路由

action装饰器

最新文章

热门文章