一. 前言
Django REST framwork 提供的视图的主要作用
1. 控制序列化器的执行（检验、保存、转换数据）
2. 控制数据库查询的执行
二. 两个视图基类
两个视图基类: APIView, GenericAPIView
1. APIView
继承django原生View,重写方法，去掉csrf验证，用自己的dispatch
models.py
class Book(models.Model): title = models.CharField(max_length=32) price = models.DecimalField(max_digits=6, decimal_places=2) publish = models.CharField(max_length=32) def __str__(self): return self.title
ser.py
from rest_framework import serializers from app01.models import Book class BookSerializer(serializers.ModelSerializer): class Meta: model = Book fields = '__all__'
urls.py
# 基于APIView path('books/', views.BooksView.as_view()), path('book/<int:pk>/', views.BookView.as_view()),
views.py
class BooksView(APIView): # 查询多条数据 def get(self, request): my_dic = MyDic() query_books = models.Book.objects.all() books_ser = BookSerializer(query_books, many=True) my_dic.data = books_ser.data return Response(my_dic.get_dic) # 新增多条数据 def post(self, request): my_dic = MyDic() books_ser = BookSerializer(data=request.data) if books_ser.is_valid(): # 继承的ModelSerializers,不需要重写create方法 books_ser.save() my_dic.data = books_ser.data print(books_ser.data) else: my_dic.status = 300 my_dic.msg = '校验不通过' my_dic.data = books_ser.errors return Response(my_dic.get_dic) class BookView(APIView): # 获取一条数据 def get(self, request, pk): my_dic = MyDic() book_obj = models.Book.objects.filter(pk=pk).first() book_ser = BookSerializer(book_obj) my_dic.data = book_ser.data return Response(my_dic.get_dic) # 修改数据 def put(self, request, pk): my_dic = MyDic() book_obj = models.Book.objects.filter(pk=pk).first() book_ser = BookSerializer(instance=book_obj, data=request.data) if book_ser.is_valid(): # 序列化器继承ModelSerializer,不用重写update方法 book_ser.save() my_dic.data = book_ser.data else: my_dic.status = 200 my_dic.msg = '校验未通过' my_dic.data = book_ser.errors return Response(my_dic.get_dic) def delete(self,pk): my_dic = MyDic() models.Book.objects.filter(pk=pk).first() my_dic.msg = '删除成功' return Response(my_dic.get_dic)
总结
1. 继承关系: APIView继承View 2. APIView基于View的拓展: APIView重写了View的dispatch方法, 在该方法中实现了实现了一下功能: 1) 对来的原生请求对象request进行了封装. 2) 提供了对包装过后的请求对象的三段认证: 认证, 权限控制, 频率控制 3) 重写了View中通过本次请求的方式动态的反射到自定义继承APIView类实例化的对象中定义的请求方法 4) 使用异常处理处理2,3步骤中的异常 5) 处理完毕异常以后使用drf的response对象对请求响应 3. 针对路由配置 路由中的有名分组必须指定pk, 视图中使用必须使用相同的关键字参数接受
2. GenericAPIView
GenericAPIView是继承APIView，解决不同的序列化器 ，重复写相同代码的问题，比如有两个序列化器BookSerializer和PublishSerializer,
只需要改动queryset = models.Book.objects.all()和serializer_class = BookSerializer，其他都可以复制。
models.py
from django.db import models # Create your models here. class Book(models.Model): name = models.CharField(max_length=32, null=True) price = models.DecimalField(max_digits=8, decimal_places=2, null=True) author = models.CharField(max_length=32, null=True) publish = models.CharField(max_length=32, null=True) publish_time = models.DateTimeField(auto_now_add=True)
serializer.py 自定义序列化.py文件
from rest_framework import serializers from .models import Book class BookModelSerializer(serializers.ModelSerializer): class Meta: model = Book fields = '__all__' # exclude = ('id', ) # exclude = ['id'] extra_kwargs = { # 'price': {'write_only': True} } read_only_fields = ['id', ] # 该方式在drf3.2版本以后就被弃用了, 使用ModelSerializer现在使用的的extra_kwargs # write_only_fields = []
views.py
# 基于GenericaAPIView from rest_framework.generics import GenericAPIView class Books1View(GenericAPIView): # queryset要传query对象，查询了所有的图书 queryset = models.Book.objects.all() # serializer_class使用那个序列化类序列化这堆数据 serializer_class = BookSerializer def get(self, request): my_dic = MyDic() query_books = self.get_queryset() books_ser = self.get_serializer(query_books, many=True) my_dic.data = books_ser.data return Response(my_dic.get_dic) # 新增多条数据 def post(self, request): my_dic = MyDic() books_ser = self.get_serializer(data=request.data) if books_ser.is_valid(): # 继承的ModelSerializers,不需要重写create方法 books_ser.save() my_dic.data = books_ser.data print(books_ser.data) else: my_dic.status = 300 my_dic.msg = '校验不通过' my_dic.data = books_ser.errors return Response(my_dic.get_dic) class Book1View(GenericAPIView): queryset = models.Book.objects.all() serializer_class = BookSerializer # 获取一条数据 def get(self, request, pk): my_dic = MyDic() book_obj = self.get_object() book_ser = self.get_serializer(book_obj) my_dic.data = book_ser.data return Response(my_dic.get_dic) # 修改数据 def put(self, request, pk): my_dic = MyDic() book_obj = self.get_object() book_ser = self.get_serializer(instance=book_obj, data=request.data) if book_ser.is_valid(): # 序列化器继承ModelSerializer,不用重写update方法 book_ser.save() my_dic.data = book_ser.data else: my_dic.status = 200 my_dic.msg = '校验未通过' my_dic.data = book_ser.errors return Response(my_dic.get_dic) def delete(self, request, pk): my_dic = MyDic() self.get_object().delete() my_dic.msg = '删除成功' return Response(my_dic.get_dic)
urls.py
# 基于GenericaAPIView path('books1/', views.Books1View.as_view()), path('book1/<int:pk>/', views.Book1View.as_view()),
GenericAPIView提供的三种方法的源码分析
# 1. self.get_queryset def get_queryset(self): # 1) 断言继承GenericAPIView的视图类实例化的对象时候有queryset对象 ''' 如果没有: 那么断言成功抛出异常 如果有: 那么将会继续往下执行 因此为什么视图类中要为类新增一个queryset属性的原因就明白了 ''' assert self.queryset is not None, ( "'%s' should either include a `queryset` attribute, " "or override the `get_queryset()` method." % self.__class__.__name__ ) # 2) 由自定义视图类实例化出来的对象获取类中定义的queryset对象. 进行判断 '''' 如果我们自定义视图类中书写的属性是queryset对象, 那么就会帮我们自动.all(). 因此我们可以不用点all了. 如果不是, 那么就直接返回数据对象 ''' queryset = self.queryset if isinstance(queryset, QuerySet): # Ensure queryset is re-evaluated on each request. queryset = queryset.all() return queryset # 2. self.get_serializer def get_serializer(self, *args, **kwargs): # 1) 获取继承GenericAPIView视图类实例化对象中找get_serializer_class ''' def get_serializer_class(self): # ① 断言继承GenericAPIVIew的自定义视图类实例化出来的对象中serializer_class时候为None ''' 为None断言成功, 抛出指定异常 不为None断言失败, 继续往下执行 ''' assert self.serializer_class is not None, ( "'%s' should either include a `serializer_class` attribute, " "or override the `get_serializer_class()` method." % self.__class__.__name__ ) # ② 发现本质就是获取视图类中定义的serializer_class序列化器类, 因此从这里我们就明白为什么视图类中要写序列化器类了. return self.serializer_class ''' # 2) get_serializer_class方法就是获取到了我们自定义视图类中定义的serializer_classes属性 serializer_class = self.get_serializer_class() # 3) 内部就是return, 获取我们自定义视图类中的上下文一些信息 ''' def get_serializer_context(self): return { 'request': self.request, 'format': self.format_kwarg, 'view': self } ''' kwargs['context'] = self.get_serializer_context() # 4) 这里的serializer_class就是自定义视图类中的类属性, 通过类属性调用传值 return serializer_class(*args, **kwargs) # 3. self.get_object def get_object(self): # 1) 执行过滤操作, 默认没有配置过滤类. 因此queryset还是queryset queryset = self.filter_queryset(self.get_queryset()) # 2) 运用短路运算, lookup_url_kwarg默认就是None, lookup_field默认就是pk, 因此返回值就是pk ''' 提示: 继承GenericAPIView的自定义视图类中没有定义以下参数. 默认使用的是GenericAPIView类中配置的 lookup_field = 'pk' lookup_url_kwarg = None ''' lookup_url_kwarg = self.lookup_url_kwarg or self.lookup_field # 3) 断言刚刚的pk时候在self.kwargs中 ''' 查找顺序: 视图对象 -> 视图类 -> GenericAPIView -> APIView -> dispatch. kwargs就是路由匹配来了, 走到APIVIew中的dispatch方法中将传入的关键字参数形式的key:value对到kwargs字典中, 再存到的对象当中, 直至此刻拿出来进行判断. 本质就是必须安装关键字pk=xxx的形式传参, 路由中必须指定又名分组pk, 视图中必须指定接受的关键字参数是pk ''' assert lookup_url_kwarg in self.kwargs, ( 'Expected view %s to be called with a URL keyword argument ' 'named "%s". Fix your URL conf, or set the `.lookup_field` ' 'attribute on the view correctly.' % (self.__class__.__name__, lookup_url_kwarg) ) # 4) 这里就是获取默认定义lookup_field充当字典的key, 又从self.kwargs这个dispatch方法就赋值的字典中, 将通过key取值, lookup_url_kwarg就是第2步分析出来的值 filter_kwargs = {self.lookup_field: self.kwargs[lookup_url_kwarg]} # 5) get_object_or_404的功能就是获取对象 或者 抛出抛出404异常 ''' **filter_kwargs就是步骤4的字典. 字典的结构{'pk': value}, **就将字典拆散, 以关键字的形式传参, 传给了get_object_or_404方法 def get_object_or_404(queryset, *filter_args, **filter_kwargs): try: # _get_object_or_404内部就是从闯传进来的queryset对象中使用get以关键字的形式查询,但是get方法会在2种情况下, 会抛出异常, 因此内部也做了异常处理 return _get_object_or_404(queryset, *filter_args, **filter_kwargs) except (TypeError, ValueError, ValidationError): # 这里就获取到了_get_object_or_404中抛出异常, 由Http404实例化类实例化出来的对象返回到上一层 raise Http404 拓展: 修改必须使用pk作为有名分组!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! 本质就是通过get将传过来的字段拆散, 以关键字的形式获取对应的数据对象 因此在自定义的视图类中重写 lookup_url_kwarg 就可以实现, 修改路由中, 对应的又名分组必须取名是pk了. 例如: 有名分组是(?P<num>), 关键字必须num接受 那么self.kwargs在给视图对象中方法传参的时候就是{'num': param}而, self.kwargs[lookup_url_kwarg]这一步操作直接获取到的就是param了. ''' obj = get_object_or_404(queryset, **filter_kwargs) # 5) 这一步是APIView中dispatch方法中定义的三段认证中的权限认证. 在drf的认证中会讲到 self.check_object_permissions(self.request, obj) return obj
总结
1. 继承GenericAPIView的视图类, 当需要修改接口指定操作的模型类, 以及序列化的模型类直接在视图类中修改即可了.其他都不用动就可以实现偷换模型类以及序列化类 2. GenericAPIView提供了3个主要的方法 self.get_object() 获取单条数据 self.get_queryset() 获取多条数据 self.serializer_classes(参数同原来即可) 执行自定义视图类中定义的序列化类进行序列化, 将ORM对象的数据转换成python的对象 3. GenericAPIView提供了可修改路由又名分组的指定不再是默认的pk 自定义的视图类
三. 五个视图扩展类
这五个扩展类需要搭配GenericAPIView父类，因为五个扩展类的实现需要调用GenericAPIView提供的序列化器与数据库查询的方法。
models.py
from django.db import models # Create your models here. class Book(models.Model): name = models.CharField(max_length=32) price = models.DecimalField(max_digits=8, decimal_places=2) author = models.CharField(max_length=32) # 这里的定义可以让序列化类中当作序列化字段来处理, return的结果是什么就是什么. @property def current_time(self): import time return time.strftime("%Y-%m-%d %X") publish = models.ForeignKey(to='Publish') class Publish(models.Model): name = models.CharField(max_length=32) email = models.EmailField()
serializer.py 自定义序列化.py文件
from rest_framework import serializers from .models import Book from .models import Publish class PublishModelSerializer(serializers.ModelSerializer): class Meta: model = Publish fields = '__all__' class BookModelSerializer(serializers.ModelSerializer): publish = PublishModelSerializer() ''' publish = serializers.SerializerMethodField(read_only=True, source='publish') # publish = serializers.CharField() def get_publish(self, instance): print('instance:', instance) fields_list = ['name', 'email'] fields_dict = {} for field in fields_list: if hasattr(instance.publish, field): fields_dict[field] = getattr(instance.publish, field) return fields_dict ''' # 这里不做任何格外的校验处理, 只是看看校验成功以后的结果 def validated_price(self, data): # print('data:', data) return data # 这里也是 def validate(self, validate_data): # print('validate validate_data:', validate_data) return validate_data class Meta: model = Book # fields = ['id', 'name', ...] # exclude = ['id'] fields = '__all__' extra_kwargs = { 'price': {'max_value': 10000, 'min_value': 0} } def create(self, validated_data): publish_dict = validated_data.pop('publish') publish_obj = Publish.objects.create(**dict(publish_dict)) Book.objects.create(**validated_data, publish=publish_obj) validated_data.update({'publish': publish_dict}) return validated_data def update(self, instance, validated_data): print('validated_data:', validated_data) publish_dict = validated_data.pop('publish') Publish.objects.filter(book__pk=instance.pk).update(**publish_dict) Book.objects.filter(pk=instance.pk).update(**validated_data) validated_data.update({'publish': publish_dict}) return validated_data
urls.py
# 基于mixins的视图类 path('books2/', views.Books2View.as_view()), path('book2/<int:pk>/', views.Book2View.as_view()),
views.py
from rest_framework.generics import GenericAPIView from rest_framework.mixins import CreateModelMixin, DestroyModelMixin, ListModelMixin, RetrieveModelMixin, \ UpdateModelMixin class Books2View(GenericAPIView, ListModelMixin, CreateModelMixin): # queryset要传query对象，查询了所有的图书 queryset = models.Book.objects.all() # serializer_class使用那个序列化类序列化这堆数据 serializer_class = BookSerializer def get(self, request): return self.list(request) # 新增多条数据 def post(self, request): return self.create(request) class Book2View(GenericAPIView, RetrieveModelMixin, UpdateModelMixin, DestroyModelMixin): queryset = models.Book.objects.all() serializer_class = BookSerializer # 获取一条数据 def get(self, request, pk): return self.retrieve(request, pk) # 修改数据 def put(self, request, pk): return self.update(request, pk) def delete(self, request, pk): return self.destroy(request, pk)
总结
提示: 以下的5种视图扩展类必须和GenericAPIView连用
ListModelMixin 内部封装了list方法, 实现了查询所有数据
CreateModelMixin 内部封装了create方法, 实现了新增数据
RetrieveModelMixin 内部封装了retrieve方法, 实现了查询一条数据
UpdateModelMixin 内部封装了update方法, 实现了更新一条数据
DestroyModelMixin 内部封装
四. GenericAPIView的9个视图子类
ListAPIView源码
9个GenericAPIView的视图子类快速介绍
提示: 以下都是基与对应的5种不同的视图扩展类ModelMixin和GenericAPiView. 在原来的基础之上剔除了对应的上一个节需要定义的重复的方法
CreateAPIView
DestroyAPIView
UpdateAPIView
ListAPIView
RetrieveAPIView
ListCreateAPIView
RetrieveDestroyAPIView
RetrieveUpdateDestroyAPIView
RetrieveUpdateAPIView
ListAPIView源码
class ListAPIView(mixins.ListModelMixin, GenericAPIView): """ Concrete view for listing a queryset. """ def get(self, request, *args, **kwargs): return self.list(request, *args, **kwargs) # 继承了GenericAPIView和mixins
urls.py
# GenericAPIView和mixins的视图之类 9个 path('books3/', views.Books3View.as_view()), path('book3/<int:pk>/', views.Book3View.as_view()),
views.py
# 基于GenericAPIView的视图之类 9个 from rest_framework.generics import CreateAPIView, ListAPIView, UpdateAPIView, RetrieveAPIView, DestroyAPIView, \ ListCreateAPIView, RetrieveDestroyAPIView, RetrieveUpdateAPIView, RetrieveUpdateDestroyAPIView # 后面四个是两两组合 class Books3View(CreateAPIView, ListAPIView): # 获取所有，新增一个 queryset = models.Book.objects.all() serializer_class = BookSerializer class Book3View(RetrieveAPIView, UpdateAPIView, DestroyAPIView): # 获取一条，修改一条，删除一条 queryset = models.Book.objects.all() serializer_class = BookSerializer
ModelViewSet继承GenericViewSet，GenericViewSet继承ViewSetMixin，重写了as_view方法，
通过循环路由字典，传给dispatch方法，从而实现一个写一个视图类，实现五个方法。
ViewSetMixin的源码
class ModelViewSet(mixins.CreateModelMixin, mixins.RetrieveModelMixin, mixins.UpdateModelMixin, mixins.DestroyModelMixin, mixins.ListModelMixin, GenericViewSet): class GenericViewSet(ViewSetMixin, generics.GenericAPIView): # ViewSetMixin的源码 @classonlymethod # 重写了as_view方法 def as_view(cls, actions=None, **initkwargs): def view(request, *args, **kwargs): self = cls(**initkwargs) if 'get' in actions and 'head' not in actions: actions['head'] = actions['get'] # actions视图路由的方法字典 # actions={'get': 'list', 'post': 'create'} self.action_map = actions for method, action in actions.items(): # 取出字典中value的值 handler = getattr(self, action) # 字典中value的值设置成key的值，比如get请求来了，就执行list方法 setattr(self, method, handler) self.request = request # And continue as usual return self.dispatch(request, *args, **kwargs)
urls.py
# 基于ModelViewSet编写的5个接口 path('books4/', views.Book4View.as_view(actions={'get': 'list', 'post': 'create'})), path('book4/<int:pk>/', views.Book4View.as_view(actions={'get': 'retrieve', 'put': 'update', 'delete': 'destroy'})),
views.py
# 基于ModelViewSet编写的5个接口 from rest_framework.viewsets import ModelViewSet class Book4View(ModelViewSet): queryset = models.Book.objects.all() serializer_class = BookSerializer
视图集补充一个ReadOnlyModelViewSet，获取一条或多条，ModelViewSet的一个子集。
class ReadOnlyModelViewSet(mixins.RetrieveModelMixin, mixins.ListModelMixin, GenericViewSet):
iewSetMixin类只重写了路由关系，没有继承序列化器的类,所有要配合使用
APIView类，ViewSetMixin也是视图集的一个类，其他都是继承ViewSetMixin
urls.py
# 继承ViewSerMixin的视图类,通过改变视图的路由，直接执行自定义方法get_all_book path('books5/', views.Book5View.as_view(actions={'get': 'get_all_book'})),
views.py
# 继承ViewSerMixin的视图类 from rest_framework.viewsets import ViewSetMixin class Book5View(ViewSetMixin, APIView): # 就是视图集ViewSet，一定要写在APIView之前，两个继承类，都用共同的方法，需调用第一个的方法。 # ViewSetMixin重写了as_view方法，APIView也是重写了了as_view方法，继承顺序查找关系，ViewSetMixin必须写第一个 def get_all_book(self, request): my_dic = MyDic() query_books = models.Book.objects.all() books_ser = BookSerializer(query_books, many=True) my_dic.data = books_ser.data return Response(my_dic.get_dic)
视图集再补充：
源码：
class ViewSet(ViewSetMixin, views.APIView): class GenericViewSet(ViewSetMixin, generics.GenericAPIView): class ReadOnlyModelViewSet(mixins.RetrieveModelMixin, mixins.ListModelMixin, GenericViewSet): class ModelViewSet(mixins.CreateModelMixin, mixins.RetrieveModelMixin, mixins.UpdateModelMixin, mixins.DestroyModelMixin, mixins.ListModelMixin, GenericViewSet):
七 总结
介绍: ModelViewSet继承关系非常多, 通过一层层的继承, 只需要很少的代码就能实现API的5中视图接口 它, 还可以和路由组件使用, 这样就直接使用路由直接生成对应功能的路由接口, 以及在不指定路由的基础之上默认帮我们书写了路由中在as_view()类方法中添加的actions参数了 庞大的继承可实现的功能: 1. APIView提供的 request封装 三段认证 全局异常处理 response响应格式 2. GenericAPIView提供的 视图类中声明queryset 和 serializer_classes 类属性 self.get_object () self.get_queryset() self.get_serializer() 3. 五个基本视图扩展类ModelMixin系列提供的 self.list() self.create() self.update() self.retrieve() self.destroy()
4. 九个子类，继承GenericAPIView和ModelMixin
进一步封住5个视图接口和数据库操作的方法
5. ViewSetMixin提供的 修改路由中ac_view()类方法的actions参数 如: 路由配置: url(r'index/', BookView.as_view(actions={'get': 'get_list'})) 视图使用: class BookView(ViewSetMixin, APIView): def get_list(self, request): ...