03. Django REST framework - 视图组件
视图继承关系
详图见文章末尾
视图
REST framework 提供了众多的通用视图基类与扩展类，以简化视图的编写。
2个视图基类
APIView
APIView 是REST framework提供的所有视图的基类，继承自Django的View父类。
from rest_framework.views import APIView APIView与View的不同之处在于： 传入到视图方法中的是REST framework的Request对象，而不是Django的HttpRequeset对象； 视图方法可以返回REST framework的Response对象，视图会为响应数据设置（render）符合前端要求的格式； 任何APIException异常都会被捕获到，并且处理成合适的响应信息； 在进行dispatch()分发前，会对请求进行身份认证、权限检查、流量控制。 支持定义的类属性 authentication_classes 列表或元祖，身份认证类 permissoin_classes 列表或元祖，权限检查类 throttle_classes 列表或元祖，流量控制类 在APIView中仍以常规的类视图定义方法来实现get() 、post() 或者其他请求方式的方法 ********示例在下方*******
GenericAPIView[通用视图类]
继承自APIVIew，主要增加了操作序列化器和数据库查询的方法，作用是为下面Mixin扩展类的执行提供方法支持。通常在使用时，可搭配一个或多个Mixin扩展类。
from rest_framework.generics import GenericAPIView
GenericAPIView(APIView):做了一些封装
-属性：
queryset # 要序列化的数据
serializer_class # 指明视图使用的序列化器
-方法：
get_queryset：获取qs数据(返回视图使用的查询集，主要用来提供给Mixin扩展类使用，
是列表视图与详情视图获取数据的基础，默认返回queryset属性)
get_object：获取一条数据的对象(返回详情视图所需的模型类数据对象，主要用来
提供给Mixin扩展类使用。在试图中可以调用该方法获取详情信息的模型类对象)
get_serializer：以后使用它来实例化得到ser对象(返回序列化器对象，主要用来
提供给Mixin扩展类使用，如果我们在视图中想要获取序列化器对象，也可以直接调用此方法)
get_serializer_class：获取序列化类，注意跟上面区分
作用：
提供了几种后端视图（对数据资源进行曾删改查）处理流程的实现，如果需要编写的视图属于这五种，则视图可以通过继承相应的扩展类来复用代码，减少自己编写的代码量。
这五个扩展类需要搭配GenericAPIView父类，因为五个扩展类的实现需要调用GenericAPIView提供的序列化器与数据库查询的方法。
1 查所有：ListModelMixin
列表视图扩展类，提供list(request, *args, **kwargs)方法快速实现列表视图，返回200状态码。
该Mixin的list方法会对数据进行过滤和分页。
2 查一个：RetrieveModelMixin
创建视图扩展类，提供create(request, *args, **kwargs)方法快速实现创建资源的视图，成功返回201状态码。
如果序列化器对前端发送的数据验证失败，返回400错误。
3 增一个：CreateModelMixin
详情视图扩展类，提供retrieve(request, *args, **kwargs)方法，可以快速实现返回一个存在的数据对象。
如果存在，返回200， 否则返回404
4 改一个：UpdateModelMixin
更新视图扩展类，提供update(request, *args, **kwargs)方法，可以快速实现更新一个存在的数据对象。
同时也提供partial_update(request, *args, **kwargs)方法，可以实现局部更新。
成功返回200，序列化器校验数据失败时，返回400错误。
5 删一个：DestroyModelMixin
删除视图扩展类，提供destroy(request, *args, **kwargs)方法，可以快速实现删除一个存在的数据对象
成功返回204，不存在返回404。
1）查所有：ListAPIView 提供 get 方法 继承自：GenericAPIView、ListModelMixin 2）增一个：CreateAPIView 提供 post 方法 继承自： GenericAPIView、CreateModelMixin 3）查所有+增一个：ListCreateAPIView 提供 get 和 post 方法 继承自： GenericAPIView、ListModelMixin、CreateModelMixin 4）查一个：RetrieveAPIView 提供 get 方法 继承自: GenericAPIView、RetrieveModelMixin 5）改一个：UpdateAPIView 提供 put 和 patch 方法 继承自：GenericAPIView、UpdateModelMixin 6）删一个：DestoryAPIView 提供 delete 方法 继承自：GenericAPIView、DestoryModelMixin 7）查一个+改一个：RetrieveUpdateAPIView 提供 get、put、patch方法 继承自： GenericAPIView、RetrieveModelMixin、UpdateModelMixin 8）查一个+删一个：RetrieveDestroyAPIView 提供 get 和 delete 方法 继承自： GenericAPIView、RetrieveModelMixin、DestoryModelMixin 9） 查一个+改一个+删一个：RetrieveUpdateDestoryAPIView 提供 get、put、patch、delete方法 继承自：GenericAPIView、RetrieveModelMixin、UpdateModelMixin、DestoryModelMixin
视图类的使用
下面把APIView 、GenericAPIView、5个视图扩展类、9个视图子类分四层来做演示
from django.db import models
class Book(models.Model):
nid = models.AutoField(primary_key=True)
name = models.CharField(max_length=32, verbose_name='书名')
price = models.DecimalField(max_digits=5, decimal_places=2, verbose_name='价格')
publish_date = models.DateField(verbose_name='出版时间')
publish = models.ForeignKey(to='Publish',to_field='nid',on_delete=models.CASCADE)
authors=models.ManyToManyField(to='Author')
class Meta:
verbose_name_plural = '书籍表'
def __str__(self):
return self.name
class Author(models.Model):
nid = models.AutoField(primary_key=True)
name = models.CharField(max_length=32, verbose_name='名字')
age = models.IntegerField(verbose_name='年龄')
author_detail = models.OneToOneField(to='AuthorDetail',to_field='nid',unique=True,on_delete=models.CASCADE)
class Meta:
verbose_name_plural = '作者表'
def __str__(self):
return self.name
class AuthorDetail(models.Model):
nid = models.AutoField(primary_key=True)
telephone = models.BigIntegerField(verbose_name='电话')
birthday = models.DateField(verbose_name='生日')
addr = models.CharField(max_length=64, verbose_name='地址')
class Meta:
verbose_name_plural = '作者详情表'
class Publish(models.Model):
nid = models.AutoField(primary_key=True)
name = models.CharField(max_length=32, verbose_name='社名')
city = models.CharField(max_length=32, verbose_name='地址')
email = models.EmailField(verbose_name='邮箱')
class Meta:
verbose_name_plural = '出版社表'
def __str__(self):
return self.name
from django.contrib import admin
from django.urls import path
from app01 import views
urlpatterns = [
path('admin/', admin.site.urls),
# 查询所有书籍，新增一本书籍
path('book/', views.BookView.as_view()),
# 查询，修改，删除单本书籍
path('book/<int:pk>/', views.BookSingleView.as_view()),
# 查询所有作者，增加一个作者
path('author/', views.AuthorView.as_view()),
# 查询，修改，删除单个作者
path('author/<int:pk>/', views.AuthorSingleView.as_view()),
# 查询所有作者详情，新增一个作者详情
path('authordetail/', views.AuthorDetailView.as_view()),
# 查询，修改，删除单个作者详情
path('authordetail/<int:pk>/', views.AuthorDetailSingleView.as_view()),
# 查询所有出版社，新增一个出版社
path('publish/', views.PublishView.as_view()),
# 查询，修改，删除单个出版社
path('publish/<int:pk>/', views.PublishSingleView.as_view()),
]
from rest_framework.response import Response
from app01 import serializer
from app01 import models
****** 第一层：继承APIview ******
from rest_framework.views import APIView
# 查询所有书籍，增加书籍
class BookView(APIView):
def get(self, request):
books = models.Book.objects.all()
ser = serializer.BookModelSerializer(instance=books, many=True)
return Response(ser.data)
def post(self, request):
ser = serializer.BookModelSerializer(data=request.data)
if ser.is_valid():
# 直接保存，保存到哪个表里？需要重写save
ser.save()
return Response(ser.data)
return Response(ser.errors)
# 查询，修改，删除单本书籍
class BookSingleView(APIView):
def get(self, request, *args, **kwargs):
book = models.Book.objects.filter(pk=kwargs.get('pk')).first()
ser = serializer.BookModelSerializer(instance=book)
print(ser.instance)
return Response(ser.data)
def put(self, request, *args, **kwargs):
book = models.Book.objects.filter(pk=kwargs.get('pk')).first()
ser = serializer.BookModelSerializer(instance=book, data=request.data)
if ser.is_valid():
ser.save()
return Response(ser.data)
else:
return Response('数据校验有误')
def delete(self, request, *args, **kwargs):
book = models.Book.objects.filter(pk=kwargs.get('pk')).delete()
print(book)
if book[0] > 0:
return Response('')
else:
return Response('要删的不存在')
# 查询所有作者，增加作者
class AuthorView(APIView):
def get(self,request):
author = models.Author.objects.all()
ser = serializer.AuthorModelSerializer(instance=author,many=True)
return Response(ser.data)
def post(self,request):
ser = serializer.AuthorModelSerializer(data=request.data)
if ser.is_valid():
ser.save()
return Response(ser.data)
return Response(ser.errors)
# 查询，修改，删除单个作者
class AuthorSingleView(APIView):
def get(self,request, *args, **kwargs):
author = models.Author.objects.filter(pk=kwargs.get('pk')).first()
ser = serializer.AuthorModelSerializer(instance=author)
return Response(ser.data)
def put(self, request, *args, **kwargs):
author = models.Author.objects.filter(pk=kwargs.get('pk')).first()
ser = serializer.AuthorModelSerializer(instance=author, data=request.data)
if ser.is_valid():
ser.save()
return Response(ser.data)
return Response(ser.errors)
def delete(self, request, *args, **kwargs):
author = models.Author.objects.filter(pk=kwargs.get('pk')).delete()
if author[0] > 0:
return Response('')
return Response('要删的不存在')
# 查询所有作者详情，增加作者详情
class AuthorDetailView(APIView):
def get(self, request):
author_detail = models.AuthorDetail.objects.all()
ser = serializer.AuthorDatailModelserializer(instance=author_detail, many=True)
return Response(ser.data)
def post(self,request):
ser = serializer.AuthorDatailModelserializer(data=request.data)
if ser.is_valid():
ser.save()
return Response(ser.data)
return Response(ser.errors)
# 查询，修改，删除，单个作者详情
class AuthorDetailSingleView(APIView):
def get(self, request, *args, **kwargs):
author_detail = models.AuthorDetail.objects.filter(pk=kwargs.get('pk')).first()
ser = serializer.AuthorDatailModelserializer(instance=author_detail)
return Response(ser.data)
def put(self, request, *args, **kwargs):
author_detail = models.AuthorDetail.objects.filter(pk=kwargs.get('pk')).first()
ser = serializer.AuthorDatailModelserializer(instance=author_detail, data=request.data)
if ser.is_valid():
ser.save()
return Response(ser.data)
return Response('数据校验有误')
def delete(self, request,*args,**kwargs):
author_detail = models.AuthorDetail.objects.filter(pk=kwargs.get('pk')).delete()
if author_detail[0] > 0:
return Response('')
return Response('要删的数据不存在')
# 查询所有出版社，增加出版社
class PublishView(APIView):
def get(self, request):
publish = models.Publish.objects.all()
ser = serializer.PublishModelSerializer(instance=publish, many=True)
return Response(ser.data)
def post(self, request):
ser = serializer.PublishModelSerializer(data=request.data)
if ser.is_valid():
# 直接保存，保存到哪个表里？需要重写save
ser.save()
return Response(ser.data)
return Response(ser.errors)
# 查询，修改，删除单个出版社
class PublishSingleView(APIView):
def get(self, request, *args, **kwargs):
publish = models.Publish.objects.filter(pk=kwargs.get('pk')).first()
ser = serializer.PublishModelSerializer(instance=publish)
print(ser.instance)
return Response(ser.data)
def put(self, request, *args, **kwargs):
publish = models.Publish.objects.filter(pk=kwargs.get('pk')).first()
ser = serializer.PublishModelSerializer(instance=publish, data=request.data)
if ser.is_valid():
ser.save()
return Response(ser.data)
else:
return Response('数据校验有误')
def delete(self, request, *args, **kwargs):
publish = models.Publish.objects.filter(pk=kwargs.get('pk')).delete()
if publish[0] > 0:
return Response('')
else:
return Response('要删的不存在')
************************* 第二层：继承GenericAPIView **************************
from rest_framework.generics import GenericAPIView
# 查询所有书籍，增加书籍
class BookView(GenericAPIView):
queryset = models.Book.objects.all() # 要序列化的数据
serializer_class = serializer.BookModelSerializer # 要序列化的类
def get(self, request):
qs = self.get_queryset() # 推荐用self.get_queryset来获取要序列化的数据
ser = self.get_serializer(qs, many=True) # 推荐使用self.get_serializer获取实例化后并且传入数据的对象
return Response(ser.data)
def post(self, request):
ser = self.get_serializer(data=request.data)
if ser.is_valid():
ser.save()
return Response(ser.data)
return Response(ser.errors)
# 查询，修改，删除单本书籍
class BookSingleView(GenericAPIView):
queryset = models.Book.objects.all() # 要序列化的数据
serializer_class = serializer.BookModelSerializer # 要序列化的类
def get(self, request, *args, **kwargs):
obj = self.get_object() # 获取单条self.get_object要序列化的数据
ser = self.get_serializer(obj) # 第一个参数是instance=obj，可以直接写obj
return Response(ser.data)
def put(self, request, *args, **kwargs):
obj = self.get_object()
ser = self.get_serializer(instance=obj, data=request.data)
if ser.is_valid():
ser.save()
return Response(ser.data)
else:
return Response(ser.errors)
def delete(self, request, *args, **kwargs):
res = self.get_object().delete() # get_object()拿到对象直接删除了
if res[0] > 0:
return Response('')
else:
return Response('要删的不存在')
# 查询所有作者，新增作者
class AuthorView(GenericAPIView):
queryset = models.Author.objects.all() # 要序列化的数据
serializer_class = serializer.AuthorModelSerializer # 要序列化的类
def get(self, request):
qs = self.get_queryset() # 推荐用self.get_queryset来获取要序列化的数据
ser = self.get_serializer(qs, many=True) # 推荐使用self.get_serializer获取实例化后并且传入数据的对象
return Response(ser.data)
def post(self, request):
ser = self.get_serializer(data=request.data)
if ser.is_valid():
ser.save()
return Response(ser.data)
return Response(ser.errors)
# 查询，修改，删除单个作者
class AuthorSingleView(GenericAPIView):
queryset = models.Author.objects.all() # 要序列化的数据
serializer_class = serializer.AuthorModelSerializer # 要序列化的类
def get(self, request, *args, **kwargs):
obj = self.get_object() # 获取单条self.get_object要序列化的数据
ser = self.get_serializer(obj) # 第一个参数是instance=obj，可以直接写obj
return Response(ser.data)
def put(self, request, *args, **kwargs):
obj = self.get_object()
ser = self.get_serializer(instance=obj, data=request.data)
if ser.is_valid():
ser.save()
return Response(ser.data)
else:
return Response(ser.errors)
def delete(self, request, *args, **kwargs):
res = self.get_object().delete() # get_object()拿到对象直接删除了
if res[0] > 0:
return Response('')
else:
return Response('要删的不存在')
# 查询所有作者详情，增加作者详情
class AuthorDetailView(GenericAPIView):
queryset = models.AuthorDetail.objects.all() # 要序列化的数据
serializer_class = serializer.AuthorDatailModelserializer # 要序列化的类
def get(self, request) :
qs = self.get_queryset() # 推荐用self.get_queryset来获取要序列化的数据
ser = self.get_serializer(qs, many=True) # 推荐使用self.get_serializer获取实例化后并且传入数据的对象
return Response(ser.data)
def post(self, request) :
ser = self.get_serializer(data=request.data)
if ser.is_valid() :
ser.save()
return Response(ser.data)
return Response(ser.errors)
# 查询，修改，删除，单个作者详情
class AuthorDetailSingleView(GenericAPIView):
queryset = models.AuthorDetail.objects.all() # 要序列化的数据
serializer_class = serializer.AuthorDatailModelserializer # 要序列化的类
def get(self, request, *args, **kwargs) :
obj = self.get_object() # 获取单条self.get_object要序列化的数据
ser = self.get_serializer(obj) # 第一个参数是instance=obj，可以直接写obj
return Response(ser.data)
def put(self, request, *args, **kwargs) :
obj = self.get_object()
ser = self.get_serializer(instance=obj, data=request.data)
if ser.is_valid():
ser.save()
return Response(ser.data)
else :
return Response(ser.errors)
def delete(self, request, *args, **kwargs) :
res = self.get_object().delete() # get_object()拿到对象直接删除了
if res[0] > 0 :
return Response('')
else :
return Response('要删的不存在')
# 查询所有出版社，增加出版社
class PublishView(GenericAPIView) :
queryset = models.Publish.objects.all() # 要序列化的数据
serializer_class = serializer.PublishModelSerializer # 要序列化的类
def get(self, request):
qs = self.get_queryset() # 推荐用self.get_queryset来获取要序列化的数据
ser = self.get_serializer(qs, many=True) # 推荐使用self.get_serializer获取实例化后并且传入数据的对象
return Response(ser.data)
def post(self, request):
ser = self.get_serializer(data=request.data)
if ser.is_valid():
ser.save()
return Response(ser.data)
return Response(ser.errors)
# 查询，修改，删除，单个作者详情
class PublishSingleView(GenericAPIView):
queryset = models.Publish.objects.all() # 要序列化的数据
serializer_class = serializer.PublishModelSerializer # 要序列化的类
def get(self, request, *args, **kwargs) :
obj = self.get_object() # 获取单条self.get_object要序列化的数据
ser = self.get_serializer(obj) # 第一个参数是instance=obj，可以直接写obj
return Response(ser.data)
def put(self, request, *args, **kwargs) :
obj = self.get_object()
ser = self.get_serializer(instance=obj, data=request.data)
if ser.is_valid():
ser.save()
return Response(ser.data)
else :
return Response(ser.errors)
def delete(self, request, *args, **kwargs) :
res = self.get_object().delete() # get_object()拿到对象直接删除了
if res[0] > 0 :
return Response('')
else :
return Response('要删的不存在')
******************* 第三层：继承GenericAPIView+5个视图扩展类 *******************
# 5个视图扩展类：每个类内部只有一个方法，一个类只完成一个事
from rest_framework.generics import GenericAPIView
from rest_framework.mixins import CreateModelMixin,RetrieveModelMixin,UpdateModelMixin,DestroyModelMixin,ListModelMixin
# 查询所有书籍，增加一本书籍
class BookView(GenericAPIView, ListModelMixin, CreateModelMixin):
queryset = models.Book.objects.all() # 要序列化的数据
serializer_class = serializer.BookModelSerializer # 要序列化的类
def get(self, request, *args, **kwargs): # 不管有值无值最好都把 *args, **kwargs传过来
return self.list(request, *args, **kwargs)
def post(self, request):
return self.create(request)
# 查询，修改，删除单本书籍
class BookSingleView(GenericAPIView, RetrieveModelMixin, UpdateModelMixin, DestroyModelMixin):
queryset = models.Book.objects.all() # 要序列化的数据
serializer_class = serializer.BookModelSerializer # 要序列化的类
def get(self, request, *args, **kwargs):
return self.retrieve(request, *args, **kwargs)
def put(self, request, *args, **kwargs):
return self.update(request, *args, **kwargs)
def delete(self, request, *args, **kwargs):
return self.destroy(request, *args, **kwargs)
# 查询所有作者，新增作者
class AuthorView(GenericAPIView, ListModelMixin, CreateModelMixin):
queryset = models.Author.objects.all() # 要序列化的数据
serializer_class = serializer.AuthorModelSerializer # 要序列化的类
def get(self, request, *args, **kwargs):
return self.list(request, *args, **kwargs)
def post(self, request):
return self.create(request)
# 查询，修改，删除单个作者
class AuthorSingleView(GenericAPIView, RetrieveModelMixin, UpdateModelMixin, DestroyModelMixin):
queryset = models.Author.objects.all() # 要序列化的数据
serializer_class = serializer.AuthorModelSerializer # 要序列化的类
def get(self, request, *args, **kwargs):
return self.retrieve(request, *args, **kwargs)
def put(self, request, *args, **kwargs):
return self.update(request, *args, **kwargs)
def delete(self, request, *args, **kwargs):
return self.destroy(request, *args, **kwargs)
# 查询所有作者详情，增加作者详情
class AuthorDetailView(GenericAPIView, ListModelMixin, CreateModelMixin):
queryset = models.AuthorDetail.objects.all() # 要序列化的数据
serializer_class = serializer.AuthorDatailModelserializer # 要序列化的类
def get(self, request, *args, **kwargs):
return self.list(request, *args, **kwargs)
def post(self, request):
return self.create(request)
# 查询，修改，删除，单个作者详情
class AuthorDetailSingleView(GenericAPIView, RetrieveModelMixin, UpdateModelMixin, DestroyModelMixin):
queryset = models.AuthorDetail.objects.all() # 要序列化的数据
serializer_class = serializer.AuthorDatailModelserializer # 要序列化的类
def get(self, request, *args, **kwargs):
return self.retrieve(request, *args, **kwargs)
def put(self, request, *args, **kwargs):
return self.update(request, *args, **kwargs)
def delete(self, request, *args, **kwargs):
return self.destroy(request, *args, **kwargs)
# 查询所有出版社，增加出版社
class PublishView(GenericAPIView, ListModelMixin, CreateModelMixin):
queryset = models.Publish.objects.all() # 要序列化的数据
serializer_class = serializer.PublishModelSerializer # 要序列化的类
def get(self, request, *args, **kwargs):
return self.list(request, *args, **kwargs)
def post(self, request):
return self.create(request)
# 查询，修改，删除，单个作者详情
class PublishSingleView(GenericAPIView, RetrieveModelMixin, UpdateModelMixin, DestroyModelMixin):
queryset = models.Publish.objects.all() # 要序列化的数据
serializer_class = serializer.PublishModelSerializer # 要序列化的类
def get(self, request, *args, **kwargs):
return self.retrieve(request, *args, **kwargs)
def put(self, request, *args, **kwargs):
return self.update(request, *args, **kwargs)
def delete(self, request, *args, **kwargs):
return self.destroy(request, *args, **kwargs)
*************** 第四层：9个视图子类 GenericAPIView+5个视图扩展类之一，之二，或之三 ****************
from rest_framework.generics import CreateAPIView, ListAPIView, ListCreateAPIView
from rest_framework.generics import RetrieveAPIView, UpdateAPIView, DestroyAPIView, RetrieveUpdateAPIView, RetrieveDestroyAPIView, RetrieveUpdateDestroyAPIView
# 查询所有书籍，增加一本书籍
class BookView(ListCreateAPIView):
queryset = models.Book.objects.all() # 要序列化的数据
serializer_class = serializer.BookModelSerializer # 要序列化的类
# 查询，修改，删除单本书籍
class BookSingleView(RetrieveUpdateDestroyAPIView):
queryset = models.Book.objects.all() # 要序列化的数据
serializer_class = serializer.BookModelSerializer # 要序列化的类
# 查询所有作者，新增一个作者
class AuthorView(ListAPIView, CreateAPIView):
queryset = models.Author.objects.all() # 要序列化的数据
serializer_class = serializer.AuthorModelSerializer # 要序列化的类
# 查询，修改，删除单个作者
class AuthorSingleView(RetrieveAPIView, UpdateAPIView, DestroyAPIView):
queryset = models.Author.objects.all() # 要序列化的数据
serializer_class = serializer.AuthorModelSerializer # 要序列化的类
# 查询所有作者详情，增加作者详情
class AuthorDetailView(ListCreateAPIView):
queryset = models.AuthorDetail.objects.all() # 要序列化的数据
serializer_class = serializer.AuthorDatailModelserializer # 要序列化的类
# 查询，修改，删除，单个作者详情
class AuthorDetailSingleView(RetrieveUpdateAPIView, DestroyAPIView):
queryset = models.AuthorDetail.objects.all() # 要序列化的数据
serializer_class = serializer.AuthorDatailModelserializer # 要序列化的类
# 查询所有出版社，增加一个出版社
class PublishView(ListAPIView, CreateAPIView):
queryset = models.Publish.objects.all() # 要序列化的数据
serializer_class = serializer.PublishModelSerializer # 要序列化的类
# 查询，删除，修改单个作者详情
class PublishSingleView(RetrieveDestroyAPIView, UpdateAPIView):
queryset = models.Publish.objects.all() # 要序列化的数据
serializer_class = serializer.PublishModelSerializer # 要序列化的类
使用视图集ViewSet，可以将一系列逻辑相关的动作放到一个类中：
-
list() 提供一组数据
-
retrieve() 提供单个数据
-
create() 创建数据
-
update() 保存数据
-
destory() 删除数据
ViewSet视图集类不再实现get()、post()等方法，而是实现动作 action 如 list() 、create() 等。
视图集只在使用as_view()方法的时候，才会将action动作与具体请求方式对应上。
常用的视图集父类
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。
# 模型层models.py 和序列化类层 serializer.py参照上面即可
# 路由层 urls.py
from django.contrib import admin
from django.urls import path
from app01 import views
urlpatterns = [
path('admin/', admin.site.urls),
# 查询所有书籍，增加书籍
path('book/', views.BookView.as_view({'get': 'list', 'post': 'create'})),
# 查询，修改，删除单本书籍
path('book/<int:pk>/', views.BookView.as_view({'get': 'retrieve', 'put': 'update', 'delete': 'destroy'})),
path('publish/', views.PublishView.as_view({'get': 'lqz'})),
]
# 视图层 views.py
###目标：只写一个视图类，实现5个接口，最大的问题是，俩接口，都是get
####第五层：视图集
# ModelViewSet 5个接口都有
# ModelViewSet 继承了GenericViewSet和五个视图扩展类
# ReadOnlyModelViewSet：只有读的两个接口
from rest_framework.viewsets import ModelViewSet, ReadOnlyModelViewSet
from rest_framework.viewsets import ViewSet, GenericViewSet, ViewSetMixin
#ViewSet是：ViewSetMixin, views.APIView
#GenericViewSet是：ViewSetMixin, GenericAPIView
# ViewSetMixin:魔法
### 如果视图类继承了ViewSetMixin这个类，路由写法就需要path('book/', views.BookView.as_view({'get': 'list', 'post': 'create'})
'''
源码映射关系
{'get': 'list', 'post': 'create'}
'get' 'list'
for method, action in actions.items():
handler = getattr(self, action)
setattr(self, method, handler)
'''
###如果视图类继承了ViewSetMixin这个类，路由的as_view执行的是ViewSetMixin的as_view
# 查询所有书籍，增加一本书籍,查询、修改、删除单本书籍
class BookView(ModelViewSet):
queryset = models.Book.objects.all() # 要序列化的数据
serializer_class = serializer.BookModelSerializer # 要序列化的类
class PublishView(GenericViewSet): # 路由变了，其它都没变（注意继承的类，不要混淆了）
queryset = models.Publish.objects.all() # 要序列化的数据
serializer_class = serializer.PublishModelSerializer # 要序列化的类
def lqz(self,request): # 自定义lqz就是获取所有
qs = self.get_queryset()
ser = self.get_serializer(qs, many=True)
return Response(ser.data)
#两个基类 APIView GenericAPIView：有关数据库操作，queryset 和serializer_class #5个视图扩展类(rest_framework.mixins) CreateModelMixin：create方法创建一条 DestroyModelMixin：destory方法删除一条 ListModelMixin：list方法获取所有 RetrieveModelMixin：retrieve获取一条 UpdateModelMixin：update修改一条 #9个子类视图(rest_framework.generics) CreateAPIView:继承CreateModelMixin,GenericAPIView，有post方法，新增数据 DestroyAPIView：继承DestroyModelMixin,GenericAPIView，有delete方法，删除数据 ListAPIView：继承ListModelMixin,GenericAPIView,有get方法获取所有 UpdateAPIView：继承UpdateModelMixin,GenericAPIView，有put和patch方法，修改数据 RetrieveAPIView：继承RetrieveModelMixin,GenericAPIView，有get方法，获取一条 ListCreateAPIView：继承ListModelMixin,CreateModelMixin,GenericAPIView，有get获取所有，post方法新增 RetrieveDestroyAPIView：继承RetrieveModelMixin,DestroyModelMixin,GenericAPIView，有get方法获取一条，delete方法删除 RetrieveUpdateAPIView：继承RetrieveModelMixin,UpdateModelMixin,GenericAPIView，有get获取一条，put，patch修改 RetrieveUpdateDestroyAPIView：继承RetrieveModelMixin,UpdateModelMixin,DestroyModelMixin,GenericAPIView，有get获取一条，put，patch修改，delete删除 #视图集 ViewSetMixin：重写了as_view ViewSet： 继承ViewSetMixin和APIView GenericViewSet：继承ViewSetMixin, generics.GenericAPIView ModelViewSet：继承mixins.CreateModelMixin,mixins.RetrieveModelMixin,mixins.UpdateModelMixin,mixins.DestroyModelMixin,mixins.ListModelMixin,GenericViewSet ReadOnlyModelViewSet：继承mixins.RetrieveModelMixin,mixins.ListModelMixin,GenericViewSet
本篇知识回顾
1 序列化器源码
-many参数控制，在__new__中控制了对象的生成
-局部和全局钩子源码：is_valid--》找self.方法一定要从根上找
-source参数是如何执行的：‘publish.name’,'方法'
2 视图：
-2个视图基类
-5个视图扩展类
-9个视图子类
-视图集
-ViewSetMixin
-ViewSet, GenericViewSet
-ModelViewSet, ReadOnlyModelViewSet
3 视图类的继承原则
-如果不涉及数据库操作：继承APIView
-如果想让路由可以映射：继承ViewSetMixin
-如果不涉及数据库操作，又要让路由可以映射：继承ViewSet
-比如发邮件接口，发短信接口
-如果涉及到数据库操作：继承GenericAPIView
-如果想让路由可以映射：继承ViewSetMixin
-如果涉及数据库操作，又要让路由可以映射：继承GenericViewSet
-如果涉及数据库操作，又要让路由可以映射，还要能新增：继承GenericViewSet+CreateModelMixin或者继承ViewSetMixin+CreateAPIView
-如果只涉及到数据库操作和新增：继承CreateAPIView
-路由有映射，数据库操作，3个接口（查一个，删一个改一个）
4 ViewSetMixin：路由的写法就特殊了
5 类实例化，先执行了元类的__call__:调用了这个类的__new__,生成一个空对象，调用了类的__init__,完成了对象的初始化
6 对象()---->会触发类的 __call__
7 类()----->会触发类的类（元类）的__call__
如果顶上的图你还觉得不够清晰，那么这张绝对会让你眼花缭乱
