一.mixins泛型视图类

一般自定义视图类在使用mixins泛型类时也就是继承该类，还需要再继承一个GenericAPIView类搭配使用

1.1mixins源码介绍：

DRF框架的介绍与理解 - 图1

1.1.1 CreateModelMixin源码

  1. class CreateModelMixin:
  2.     """
  3.     Create a model instance.
  4.     """
  5.     def create(self, request, *args, **kwargs):
  6.           #get_serializer方法得到属性序列化类serializer_class()视图函数中你需要指定该属性
  7.         #serializer_class=你自定义的序列化类，这里没有使用many参数，不用一般默认False，
  8.         #也就是适合单对象的序列化        
  9.         serializer = self.get_serializer(data=request.data)
  10.         #raise_exception=True验证当有异常时抛出异常
  11.         serializer.is_valid(raise_exception=True)
  12.         #调用下方perform_create方法进行保存对象
  13.         self.perform_create(serializer)
  14.         headers = self.get_success_headers(serializer.data)
  15.         return Response(serializer.data, status=status.HTTP_201_CREATED, headers=headers)
  17.     def perform_create(self, serializer):
  18.         serializer.save()
  20.     def get_success_headers(self, data):
  21.         try:
  22.             return {'Location': str(data[api_settings.URL_FIELD_NAME])}
  23.         except (TypeError, KeyError):
  24.             return {}

1.1.2 ListModelMixin源码

  1. class ListModelMixin:
  2.     """
  3.     List a queryset.
  4.     """
  5.     def list(self, request, *args, **kwargs):
  6.         #get_queryset在GenericAPIView类，返回的是GenericAPIView视图类中queryset属性
  7.            #filter_queryset()得到的是后端过滤后的查询集（搭配过滤器使用）后面会讲
  8.         queryset = self.filter_queryset(self.get_queryset())
  9.         #paginate_queryset返回结果的单个页面，如果分页被禁用，则返回“None”。
  10.         page = self.paginate_queryset(queryset)
  11.         if page is not None:
  12.             serializer = self.get_serializer(page, many=True)
  13.             return self.get_paginated_response(serializer.data)
  15.         serializer = self.get_serializer(queryset, many=True)
  16.         return Response(serializer.data)

1.1.3 RetrieveModelMixin源码

  1. class RetrieveModelMixin:
  2.     """
  3.     Retrieve a model instance.
  4.     """
  5.     #该方法使用场景为url位置参数:类似于url(r'^books/(?P<pk>\d+)/$'
  6.     def retrieve(self, request, *args, **kwargs):
  7.         #GenericAPIView类中的get_object通过url位置参数返回一个单对象
  8.         instance = self.get_object()
  9.         serializer = self.get_serializer(instance)
  10.         return Response(serializer.data)

1.1.4 UpdateModelMixin源码

  1. class UpdateModelMixin:
  2.     """
  3.     单实例更新：
  4.     1. 获取 kwargs 字典中 partial 的值，如果没有，则返回False，有，则返回值
  5.     2. 获取单个对象
  6.     3. 通过序列化，获取单个对象的序列化对象
  7.     4. 判断序列化对象的有效性
  8.     5. 更新数据
  9.     """
  10.     def update(self, request, *args, **kwargs):      
  11.         partial = kwargs.pop('partial', False)
  12.         instance = self.get_object()
  13.         serializer = self.get_serializer(instance, data=request.data, partial=partial)
  14.         serializer.is_valid(raise_exception=True)
  15.         self.perform_update(serializer)
  17.         if getattr(instance, '_prefetched_objects_cache', None):
  18.             # If 'prefetch_related' has been applied to a queryset, we need to
  19.             # forcibly invalidate the prefetch cache on the instance.
  20.             instance._prefetched_objects_cache = {}
  22.         return Response(serializer.data)
  24.     def perform_update(self, serializer):
  25.         serializer.save()
  27.     def partial_update(self, request, *args, **kwargs):
  28.         #这里给了一个partial为Ture,然后调用update()
  29.         kwargs['partial'] = True
  30.         return self.update(request, *args, **kwargs)

1.1.4 DestroyModelMixin源码

  1. class DestroyModelMixin:
  2.     """
  3.     删除单对象数据
  4.     """
  5.     def destroy(self, request, *args, **kwargs):
  6.         instance = self.get_object()
  7.         self.perform_destroy(instance)
  8.         return Response(status=status.HTTP_204_NO_CONTENT)
  10.     def perform_destroy(self, instance):
  11.         instance.delete()

1.2 视图集viewset的源码：

  1. class GenericViewSet(ViewSetMixin, generics.GenericAPIView):
  2.     """
  3.     默认情况下，GenericViewSet类不提供任何操作，
  4.     但包含通用视图行为的基本集，如
  5.     ' get_object '和' get_queryset '方法。
  6.     """
  7.     pass
  10. class ReadOnlyModelViewSet(mixins.RetrieveModelMixin,
  11.                            mixins.ListModelMixin,
  12.                            GenericViewSet):
  13.     """
  14.     提供默认的' list() '和' retrieve() '动作的视图集.
  15.     """
  16.     pass
  19. class ModelViewSet(mixins.CreateModelMixin,
  20.                    mixins.RetrieveModelMixin,
  21.                    mixins.UpdateModelMixin,
  22.                    mixins.DestroyModelMixin,
  23.                    mixins.ListModelMixin,
  24.                    GenericViewSet):
  25.     """
  26.     一个视图集提供了默认的' create() '， ' retrieve() '， ' update() '，
  27.     ' partial_update() '， ' destroy() '和' list() '操作。
  28.     """
  29.     pass

1.3 generic相关视图的介绍：

1.3.1 视图架构图

DRF框架的介绍与理解 - 图2

1.3.1 视图源码

  1. class CreateAPIView(mixins.CreateModelMixin,
  2.                     GenericAPIView):
  3.     """
  4.     Concrete view for creating a model instance.
  5.     """
  6.     def post(self, request, *args, **kwargs):
  7.         return self.create(request, *args, **kwargs)
  10. class ListAPIView(mixins.ListModelMixin,
  11.                   GenericAPIView):
  12.     """
  13.     Concrete view for listing a queryset.
  14.     """
  15.     def get(self, request, *args, **kwargs):
  16.         return self.list(request, *args, **kwargs)
  19. class RetrieveAPIView(mixins.RetrieveModelMixin,
  20.                       GenericAPIView):
  21.     """
  22.     Concrete view for retrieving a model instance.
  23.     """
  24.     def get(self, request, *args, **kwargs):
  25.         return self.retrieve(request, *args, **kwargs)
  28. class DestroyAPIView(mixins.DestroyModelMixin,
  29.                      GenericAPIView):
  30.     """
  31.     Concrete view for deleting a model instance.
  32.     """
  33.     def delete(self, request, *args, **kwargs):
  34.         return self.destroy(request, *args, **kwargs)
  37. class UpdateAPIView(mixins.UpdateModelMixin,
  38.                     GenericAPIView):
  39.     """
  40.     Concrete view for updating a model instance.
  41.     """
  42.     def put(self, request, *args, **kwargs):
  43.         return self.update(request, *args, **kwargs)
  45.     def patch(self, request, *args, **kwargs):
  46.         return self.partial_update(request, *args, **kwargs)
  49. class ListCreateAPIView(mixins.ListModelMixin,
  50.                         mixins.CreateModelMixin,
  51.                         GenericAPIView):
  52.     """
  53.     Concrete view for listing a queryset or creating a model instance.
  54.     """
  55.     def get(self, request, *args, **kwargs):
  56.         return self.list(request, *args, **kwargs)
  58.     def post(self, request, *args, **kwargs):
  59.         return self.create(request, *args, **kwargs)
  62. class RetrieveUpdateAPIView(mixins.RetrieveModelMixin,
  63.                             mixins.UpdateModelMixin,
  64.                             GenericAPIView):
  65.     """
  66.     Concrete view for retrieving, updating a model instance.
  67.     """
  68.     def get(self, request, *args, **kwargs):
  69.         return self.retrieve(request, *args, **kwargs)
  71.     def put(self, request, *args, **kwargs):
  72.         return self.update(request, *args, **kwargs)
  74.     def patch(self, request, *args, **kwargs):
  75.         return self.partial_update(request, *args, **kwargs)
  78. class RetrieveDestroyAPIView(mixins.RetrieveModelMixin,
  79.                              mixins.DestroyModelMixin,
  80.                              GenericAPIView):
  81.     """
  82.     Concrete view for retrieving or deleting a model instance.
  83.     """
  84.     def get(self, request, *args, **kwargs):
  85.         return self.retrieve(request, *args, **kwargs)
  87.     def delete(self, request, *args, **kwargs):
  88.         return self.destroy(request, *args, **kwargs)
  91. class RetrieveUpdateDestroyAPIView(mixins.RetrieveModelMixin,
  92.                                    mixins.UpdateModelMixin,
  93.                                    mixins.DestroyModelMixin,
  94.                                    GenericAPIView):
  95.     """
  96.     Concrete view for retrieving, updating or deleting a model instance.
  97.     """
  98.     def get(self, request, *args, **kwargs):
  99.         return self.retrieve(request, *args, **kwargs)
  101.     def put(self, request, *args, **kwargs):
  102.         return self.update(request, *args, **kwargs)
  104.     def patch(self, request, *args, **kwargs):
  105.         return self.partial_update(request, *args, **kwargs)
  107.     def delete(self, request, *args, **kwargs):
  108.         return self.destroy(request, *args, **kwargs)

二.视图中所涉及的重要的源码

2.1 GenericAPIView：

  1. class GenericAPIView(views.APIView):
  2.     """
  3.     Base class for all other generic views.
  4.     """
  5.     #你需要设置这些属性，
  6.     #或重写' get_queryset() ' / ' get_serializer_class() '。
  7.     #如果你重写一个视图方法，它是重要的调用
  8.     # ' get_queryset() '而不是直接访问' queryset '属性，
  9.     # as ' queryset '只会被求值一次，并且这些结果会被缓存
  10.     #对于所有后续请求。
  11.     queryset = None
  12.     serializer_class = None
  13.     #如果你想使用对象查找而不是pk，设置'lookup_field'。
  14.     #对于更复杂的查找需求，需重写' get_object() '。
  15.     lookup_field = 'pk'  #默认为pk也就是主键
  16.     lookup_url_kwarg = None   #url中的位置参数
  18.     #用于查询集过滤的过滤后端类(往往这里常用的就是结合django的settings中配置REST_FRAMEWORK = {
  19.     #'DEFAULT_FILTER_BACKENDS': ['django_filters.rest_framework.DjangoFilterBackend']},属于
  20.     #全局变量,你也可以不选择全局配置，在自己的视图集类下给该属性赋值:filter_backends = [DjangoFi
  21.     #lterBackend]
  23.     filter_backends = api_settings.DEFAULT_FILTER_BACKENDS
  25.     # 用于查询集分页的样式。
  26.     pagination_class = api_settings.DEFAULT_PAGINATION_CLASS
  28.     def get_queryset(self):
  29.         """
  30.         获取此视图的项目列表。
  31.         这必须是一个可迭代对象，并且是一个查询集。
  32.         默认使用' self.queryset '。
  33.         应该一直使用这个方法而不是访问self.queryset
  34.         直接self.queryset '只求值一次，这些结果
  35.         为所有后续请求缓存。
  36.         如果需要提供不同的服务，您可能希望重写此选项
  37.         查询集，取决于传入的请求。
  38.         (如。返回特定于用户的项目列表)
  39.         """
  40.         assert self.queryset is not None, (
  41.             "'%s' should either include a `queryset` attribute, "
  42.             "or override the `get_queryset()` method."
  43.             % self.__class__.__name__
  44.         )
  46.         queryset = self.queryset
  47.         if isinstance(queryset, QuerySet):
  48.             # 确保对每个请求重新评估queryset.
  49.             queryset = queryset.all()
  50.             return queryset
  53.     def get_object(self):
  54.         """
  55.         返回视图显示的对象。
  56.         如果您需要提供非标准的，您可能需要重写它
  57.         queryset查找。例如，如果对象使用multiple引用
  58.         url conf中的关键字参数。
  59.         """
  60.         #得到过滤后查询集赋值给queryset
  61.         queryset = self.filter_queryset(self.get_queryset())
  63.         # Perform the lookup filtering.
  64.         lookup_url_kwarg = self.lookup_url_kwarg or self.lookup_field
  65.         #断言位置参数有没有在kwargs
  66.         assert lookup_url_kwarg in self.kwargs, (
  67.             'Expected view %s to be called with a URL keyword argument '
  68.             'named "%s". Fix your URL conf, or set the `.lookup_field` '
  69.             'attribute on the view correctly.' %
  70.             (self.__class__.__name__, lookup_url_kwarg)
  71.         )
  73.         filter_kwargs = {self.lookup_field: self.kwargs[lookup_url_kwarg]}
  74.         obj = get_object_or_404(queryset, **filter_kwargs)
  76.         # 权限的验证函数
  77.         self.check_object_permissions(self.request, obj)
  78.         return obj
  80.     def get_serializer(self, *args, **kwargs):
  81.         """
  82.         返回应该用于验证和的序列化器实例，反序列化输入和序列化输出。
  83.         例如如果想要序列化list多对象的创建入库，可以重写该方法，在其中进行request.data
  84.         为列表时，返回serializer_class(many=True, *args, **kwargs)加入many参数
  85.         """
  86.         #从下方get_serializer_class看出最后得到了self.serializer_class
  87.         #相当于serializer_class=self.serializer_class，把类属性serializer_class赋给了serializer_class
  88.         serializer_class = self.get_serializer_class()
  89.         #kwargs设置默认值,也就是需要序列化的额外内容context
  90.         kwargs.setdefault('context', self.get_serializer_context())
  91.         #大家可以看到此时返回的序列化类的实例
  92.         return serializer_class(*args, **kwargs)
  94.     def get_serializer_class(self):
  95.         """
  96.         断言不为空时返回序列化类名,反之就返回类型应该包含serializer_class属性
  97.         或者重写get_serializer_class方法的异常字样
  98.         """
  100.         assert self.serializer_class is not None, (
  101.             "'%s' should either include a `serializer_class` attribute, "
  102.             "or override the `get_serializer_class()` method."
  103.             % self.__class__.__name__
  104.         )
  106.         return self.serializer_class
  108.     def get_serializer_context(self):
  109.         """
  110.         Extra context provided to the serializer class.
  111.         序列化类提供额外的序列参数context上下文
  112.         """
  114.         return {
  115.             'request': self.request,
  116.             'format': self.format_kwarg,
  117.             'view': self
  118.         }
  120.     def filter_queryset(self, queryset):
  121.         '''
  122.         给定一个查询集，使用过滤后端类及其下方法过滤它。返回得到过滤后的查询集，如filter_backends
  123.         指定的是DjangoFilterBackend,其实它调用了原本属于源码DjangoFilterBackend类下的filter_qu
  124.         eryset，其中backend代表我自定义的filterset类，filter_backends属性代表我们自定义的filter
  125.         set类的列表，然后使用backend()也就是自定义的过滤集类的对象调用filter_queryset，返回过滤后
  126.         的查询集赋值给了queryset
  127.         '''
  128.         for backend in list(self.filter_backends):
  129.             queryset = backend().filter_queryset(self.request, queryset, self)
  130.         return queryset
  131.     #此装饰器的作用就是将函数转变成属性
  132.     @property
  133.     def paginator(self):
  134.         """
  135.         返回与视图关联的分页器实例，或者“None”。
  136.         """
  137.         if not hasattr(self, '_paginator'):
  138.             if self.pagination_class is None:
  139.                 self._paginator = None
  140.             else:
  141.                 self._paginator = self.pagination_class()
  142.         return self._paginator
  144.     def paginate_queryset(self, queryset):
  145.         """
  146.         返回结果的单个页面，如果分页被禁用，则返回“None”。
  147.         其中的self.paginator代表的是分页类的实例，然后调用分页类源码下paginate_queryset()
  148.         返回的是页面对象的列表
  149.         """
  150.         if self.paginator is None:
  151.             return None
  152.         return self.paginator.paginate_queryset(queryset, self.request, view=self)
  154.     def get_paginated_response(self, data):
  155.         """
  156.         返回给定输出数据的分页样式' Response '对象。
  157.         """
  158.         assert self.paginator is not None
  159.         return self.paginator.get_paginated_response(data)

2.3 PageNumberPagination：

  1. class PageNumberPagination(BasePagination):
  2.     """
  3.     一个简单的基于页码的样式，它支持如下的页码
  4.     查询参数。例如:
  5.     http://api.example.org/accounts/?page=4
  6.     http://api.example.org/accounts/?page=4&page_size=100
  7.     """
  8.     # The default page size.
  9.     # 默认为 `None`, 意思是分页被禁用.
  10.     page_size = api_settings.PAGE_SIZE
  12.     #django_paginator_class赋值了Django 分页器类（DjangoPaginator）
  13.     django_paginator_class = DjangoPaginator
  15.     # 客户端可以使用此查询参数控制页面.
  16.     page_query_param = 'page'
  17.     page_query_description = _('A page number within the paginated result set.')
  19.     #客户端可以使用这个查询参数来控制页面大小。
  20.     #默认为“None”。设置为eg 'page_size'以启用使用。
  21.     page_size_query_param = None
  22.     #每页返回的结果数
  23.     page_size_query_description = _('Number of results to return per page.')
  25.     #设置一个整数来限制客户端可能请求的最大页面大小。
  26.     #只有当设置了'page_size_query_param'时才相关.
  27.     max_page_size = None
  28.     #字符串值的列表或元组，指可与请求集合中最后一页一起使用的值。默认为page_query_param('last',)
  29.     last_page_strings = ('last',)
  30.     #在可浏览 API 中呈现分页控件时要使用的模板的名称。可以重写以修改呈现样式，
  31.     #或设置为完全禁用 HTML 分页控件。
  32.     template = 'rest_framework/pagination/numbers.html'
  34.     invalid_page_message = _('Invalid page.')
  36.     #该方法将传递初始查询集参数，并应返回一个可迭代对象。该对象仅包含所请求页面（本页面）中的数据
  37.     def paginate_queryset(self, queryset, request, view=None):
  38.         """
  39.         如果需要，对查询集进行分页，或者返回一个页面对象
  40.         如果没有为此视图配置分页，则为' None '。
  41.         """
  42.         #获取页面的大小
  43.         page_size = self.get_page_size(request)
  44.         if not page_size: #如果不存在返回为none
  45.             return None
  47.         paginator = self.django_paginator_class(queryset, page_size)
  48.         page_number = self.get_page_number(request, paginator)
  50.         try:
  51.             self.page = paginator.page(page_number)
  52.         except InvalidPage as exc:
  53.             msg = self.invalid_page_message.format(
  54.                 page_number=page_number, message=str(exc)
  55.             )
  56.             raise NotFound(msg)
  58.         if paginator.num_pages > 1 and self.template is not None:
  59.             # The browsable API should display pagination controls.
  60.             self.display_page_controls = True
  62.         self.request = request
  63.         return list(self.page)
  64.     #返回分页的页数
  65.     def get_page_number(self, request, paginator):
  66.         page_number = request.query_params.get(self.page_query_param, 1)
  67.         if page_number in self.last_page_strings:
  68.             page_number = paginator.num_pages
  69.         return page_number
  71.     #该方法将传递一个序列化的页面数据，并应返回一个实例
  72.     def get_paginated_response(self, data):
  73.         return Response(OrderedDict([
  74.             ('count', self.page.paginator.count),
  75.             ('next', self.get_next_link()),
  76.             ('previous', self.get_previous_link()),
  77.             ('results', data)
  78.         ]))
  79.     #返回一个页面显示的模式样板
  80.     def get_paginated_response_schema(self, schema):
  82.         return {
  83.             'type': 'object',
  84.             'properties': {
  85.                 'count': {
  86.                     'type': 'integer',
  87.                     'example': 123,
  88.                 },
  89.                 'next': {
  90.                     'type': 'string',
  91.                     'nullable': True,
  92.                     'format': 'uri',
  93.                     'example': 'http://api.example.org/accounts/?{page_query_param}=4'.format(
  94.                         page_query_param=self.page_query_param)
  95.                 },
  96.                 'previous': {
  97.                     'type': 'string',
  98.                     'nullable': True,
  99.                     'format': 'uri',
  100.                     'example': 'http://api.example.org/accounts/?{page_query_param}=2'.format(
  101.                         page_query_param=self.page_query_param)
  102.                 },
  103.                 'results': schema,
  104.             },
  105.         }
  106.     #获取页面的容量大小
  107.     def get_page_size(self, request):
  108.         if self.page_size_query_param:
  109.             try:
  110.                 return _positive_int(
  111.                     request.query_params[self.page_size_query_param],
  112.                     strict=True,
  113.                     cutoff=self.max_page_size
  114.                 )
  115.             except (KeyError, ValueError):
  116.                 pass
  118.         return self.page_size
  119.     #在结果中返回下一个页面链接地址
  120.     def get_next_link(self):
  121.         if not self.page.has_next():
  122.             return None
  123.         url = self.request.build_absolute_uri()
  124.         page_number = self.page.next_page_number()
  125.         return replace_query_param(url, self.page_query_param, page_number)
  126.     #在结果中返回上一个页面链接地址
  127.     def get_previous_link(self):
  128.         if not self.page.has_previous():
  129.             return None
  130.         url = self.request.build_absolute_uri()
  131.         page_number = self.page.previous_page_number()
  132.         if page_number == 1:
  133.             return remove_query_param(url, self.page_query_param)
  134.         return replace_query_param(url, self.page_query_param, page_number)

2.3 Paginator：

提供参考的第三方举例详情地址https://www.jianshu.com/p/e9686192e7ee

  1. class Paginator:
  2.     # Translators: 字符串，用于替换省略页中的省略页码
  3.     # 分页器生成的范围, e.g. [1, 2, '…', 5, 6, 7, '…', 9, 10].
  4.     ELLIPSIS = _('…')
  6.     def __init__(self, object_list, per_page, orphans=0,
  7.                  allow_empty_first_page=True):
  8.         self.object_list = object_list
  9.         self._check_object_list_is_ordered()
  10.         self.per_page = int(per_page) #每页中允许的最大对象数。必选参数
  11.         self.orphans = int(orphans) #这是一个缺省参数，如果最后一页的数据小于这个值，会合并到上一页
  12.         self.allow_empty_first_page = allow_empty_first_page   #允许首页为空 ，默认为True
  14.     def __iter__(self):
  15.         for page_number in self.page_range:
  16.             yield self.page(page_number)
  18.     def validate_number(self, number):
  19.         """校验给的基于1的页数"""
  20.         try:
  21.             #先判断页面数是不是float并且不是整形抛出异常
  22.             if isinstance(number, float) and not number.is_integer():
  23.                 raise ValueError
  24.             number = int(number)
  25.         except (TypeError, ValueError):
  26.             raise PageNotAnInteger(_('That page number is not an integer'))
  27.         #如果页数小于1，抛出EmptyPage
  28.         if number < 1:
  29.             raise EmptyPage(_('That page number is less than 1')
  30.         #如果页数大于总页数，抛出EmptyPage
  31.         if number > self.num_pages:
  32.             #这个就是属于结果为0的情况没有一个页，并且允许首页为空就pass，否则抛出空页面异常                
  33.             if number == 1 and self.allow_empty_first_page:
  34.                 pass
  35.             else:
  36.                 raise EmptyPage(_('That page contains no results'))
  37.         return number
  40.     def get_page(self, number):
  41.         """
  42.         返回指定页的page对象，页码从1开始。该方法可处理超出范围或无效的页码
  43.         如果给定页码不是数字则返回第一页，如果给定页码小于1或大于总页数，则返回最后一页
  44.         """
  45.         try:
  46.             #先得到一个通过验证的页数值                
  47.             number = self.validate_number(number)
  48.         #给出不是整形的异常，则给number赋值1
  49.         except PageNotAnInteger:
  50.             number = 1
  51.         #给出空页异常处理，则给number赋值为总页数也就是最后一页                   
  52.         except EmptyPage:
  53.             number = self.num_pages
  54.         return self.page(number)
  57.     def page(self, number):
  58.         """返回指定页的page对象，它不能处理超出范围或无效页码，指定的页码无效时会触发validate_number异常."""
  59.         number = self.validate_number(number)
  60.         #bottom值代表的是指定页中的第一个对象在self.object_list列表中的下标
  61.         #不代表该页面第一个对象所排序的位置，例如一共5个对象，一个页面容量2个对象，总共就是3个页面
  62.         #第二个页面的第一个也就是起始对象的序号是3
  63.         bottom = (number - 1) * self.per_page
  64.         #top值代表的self.object_list列表中的区间的右边界值（但不包含）其实取的也就是该页的最后一个对象
  65.         top = bottom + self.per_page
  66.         #top + self.orphans（代表列表右边界值）如果大于等于所有页的总对象数，两边同时家去top值，相当于
  67.         #最后一页的对象数量小于等于self.orphans值，则将最后一页的对象数合并到前一页中            
  68.         if top + self.orphans >= self.count:
  69.             top = self.count
  70.         #object_list[bottom:top]代表该页的所有对象                   
  71.         return self._get_page(self.object_list[bottom:top], number, self)
  73.     def _get_page(self, *args, **kwargs):
  74.         """
  75.         返回单个页面的实例。
  76.          其中的Page是另一个源码类
  77.         """
  78.         return Page(*args, **kwargs)
  81.     @cached_property #缓存属性的意思，类似于@property的效果
  82.     def count(self):
  83.         """返回所有页面中的对象总数"""
  84.         c = getattr(self.object_list, 'count', None)
  85.         if callable(c) and not inspect.isbuiltin(c) and method_has_no_args(c):
  86.             return c()
  87.         return len(self.object_list)
  89.     @cached_property
  90.     def num_pages(self):
  91.         """返回总页数."""
  92.         #如果总对象数=0,并且self.allow_empty_first_page不为True,返回0                    
  93.         if self.count == 0 and not self.allow_empty_first_page:
  94.             return 0
  95.         #max取最大值，其中self.count - self.orphans可能会看不懂为什么这么减，但是你只要验证符合页面数
  96.         #计算结果，例如count为5,orphans=2,差值hits就是3,那hits/self.per_page=1.5，你会发现页面数为2                                          
  97.         #是符合原本应该为3页其最后一页为1个对象满足小于等于orphans值2，也就符合合并到前一页，成为2页。                    
  98.         hits = max(1, self.count - self.orphans)
  99.         #以整数形式返回该变量的上限值，如ceil(1.5)=2。                    
  100.         return ceil(hits / self.per_page)  
  102.     @property
  103.     def page_range(self):
  104.         """
  105.         返回页面迭代器，页码从1开始
  106.         """
  107.         #self.num_pages+1为右边界值(开区间)，为的是能取到最后一页的值                    
  108.         return range(1, self.num_pages + 1)
  110.     def _check_object_list_is_ordered(self):
  111.         """
  112.         警告实例。object_list是无序的(通常是QuerySet)。
  113.         """
  114.         ordered = getattr(self.object_list, 'ordered', None)                   
  115.         if ordered is not None and not ordered:
  116.             obj_list_repr = (
  117.                 '{} {}'.format(self.object_list.model, self.object_list.__class__.__name__)
  118.                 if hasattr(self.object_list, 'model')
  119.                 else '{!r}'.format(self.object_list)
  120.             )
  121.             warnings.warn(
  122.                 'Pagination may yield inconsistent results with an unordered '
  123.                 'object_list: {}.'.format(obj_list_repr),
  124.                 UnorderedObjectListWarning,
  125.                 stacklevel=3
  126.             )
  128.     def get_elided_page_range(self, number=1, *, on_each_side=3, on_ends=2):
  129.         """
  130.         返回一个基于1的页面范围，其中某些值被省略。
  131.         第一个参数number为当前页码数, on_each_side为当前页码左右两边的页数，on_ends为首尾页码范围。
  132.         如果当前页码为第10页，使用该方法将输出如下页码范围(page_range)。10左右两边各有3页，首尾各
  133.         有2页，其余页码号码用...代替。将page_range这个变量传递到前端模板进行遍历即可实现智能分页。
  134.         例如:[1, 2, '…', 7, 8, 9, 10, 11, 12, 13, '…', 49, 50]
  135.         """
  136.         number = self.validate_number(number)
  138.         if self.num_pages <= (on_each_side + on_ends) * 2:
  139.             yield from self.page_range
  140.             return
  142.         if number > (1 + on_each_side + on_ends) + 1:
  143.             yield from range(1, on_ends + 1)
  144.             yield self.ELLIPSIS
  145.             yield from range(number - on_each_side, number + 1)
  146.         else:
  147.             yield from range(1, number + 1)
  149.         if number < (self.num_pages - on_each_side - on_ends) - 1:
  150.             yield from range(number + 1, number + on_each_side + 1)
  151.             yield self.ELLIPSIS
  152.             yield from range(self.num_pages - on_ends + 1, self.num_pages + 1)
  153.         else:
  154.             yield from range(number + 1, self.num_pages + 1)

2.4 DjangoFilterBackend(后端过滤类)：

  1. class DjangoFilterBackend(metaclass=RenameAttributes):
  2.     filterset_base = filterset.FilterSet
  3.     raise_exception = True
  5.     @property
  6.     def template(self):
  7.         if compat.is_crispy():
  8.             return 'django_filters/rest_framework/crispy_form.html'
  9.         return 'django_filters/rest_framework/form.html'
  11.     def get_filterset(self, request, queryset, view):
  12.         '''
  13.         先调用self.get_filterset_class获取视图中的过滤集类filterset_class
  14.         如果filterset_class为none,则返回none,除此之外就返回filterset_class(**kwargs)
  15.         '''
  16.         filterset_class = self.get_filterset_class(view, queryset)
  17.         if filterset_class is None:
  18.             return None
  19.         #调用self.get_filterset_kwargs返回一个字典有keys:queryset,request,data
  20.         #其中的data就是url后的过滤参数request.query_params
  21.         kwargs = self.get_filterset_kwargs(request, queryset, view)
  22.         return filterset_class(**kwargs)
  24.     def get_filterset_class(self, view, queryset=None):
  25.         """
  26.            获取过滤集类
  27.         """
  28.         #从我们定义的视图中获取filterset_class属性
  29.         filterset_class = getattr(view, 'filterset_class', None)
  30.         #从我们定义的视图中获取filterset_fields属性
  31.         filterset_fields = getattr(view, 'filterset_fields', None)
  33.         #例如我们自定义的视图类提供了filter_classs属性并赋值了自定义的过滤类
  34.         #如果filterset_class为none,并且定义的视图类中有filter_class属性  
  35.         if filterset_class is None and hasattr(view, 'filter_class'):
  36.             utils.deprecate(
  37.                 "`%s.filter_class` attribute should be renamed `filterset_class`."
  38.                 % view.__class__.__name__)
  39.             #从试图类中获取filter_classs属性并赋值给filterset_class
  40.             filterset_class = getattr(view, 'filter_class', None)
  42.         #如果filterset_fields为none,并且定义的视图类中有filter_fields属性
  43.         if filterset_fields is None and hasattr(view, 'filter_fields'):
  44.             utils.deprecate(
  45.                 "`%s.filter_fields` attribute should be renamed `filterset_fields`."
  46.                 % view.__class__.__name__)
  47.             #从试图类中获取filter_fields属性并赋值给filterset_fields
  48.             filterset_fields = getattr(view, 'filter_fields', None)
  49.         #如果视图中的filterset_class属性不为空
  50.         if filterset_class:
  51.             filterset_model = filterset_class._meta.model
  53.             # FilterSets不需要指定一个元类
  54.             if filterset_model and queryset is not None:
  55.                 assert issubclass(queryset.model, filterset_model), \
  56.                     'FilterSet model %s does not match queryset model %s' % \
  57.                     (filterset_model, queryset.model)
  59.             return filterset_class
  60.         #如果视图中的filterset_fields属性和queryset不为none
  61.         if filterset_fields and queryset is not None:
  63.             MetaBase = getattr(self.filterset_base, 'Meta', object)
  65.             class AutoFilterSet(self.filterset_base):
  66.                 class Meta(MetaBase):
  67.                     model = queryset.model
  68.                     fields = filterset_fields
  70.             return AutoFilterSet
  72.         return None
  74.     def get_filterset_kwargs(self, request, queryset, view):
  75.         '''
  76.         返回一个字典有data，queryset，request
  77.         request.query_params就是get请求url后拼接的过滤参数
  78.         '''
  79.         return {
  80.             'data': request.query_params,
  81.             'queryset': queryset,
  82.             'request': request,
  83.         }
  85.     def filter_queryset(self, request, queryset, view):
  86.         filterset = self.get_filterset(request, queryset, view)
  87.         if filterset is None:
  88.             return queryset
  90.         if not filterset.is_valid() and self.raise_exception:
  91.             raise utils.translate_validation(filterset.errors)
  92.         return filterset.qs
  94.     def to_html(self, request, queryset, view):
  95.         filterset = self.get_filterset(request, queryset, view)
  96.         if filterset is None:
  97.             return None
  99.         template = loader.get_template(self.template)
  100.         context = {'filter': filterset}
  101.         return template.render(context, request)
  103.     def get_coreschema_field(self, field):
  104.         if isinstance(field, filters.NumberFilter):
  105.             field_cls = compat.coreschema.Number
  106.         else:
  107.             field_cls = compat.coreschema.String
  108.         return field_cls(
  109.             description=str(field.extra.get('help_text', ''))
  110.         )
  112.     def get_schema_fields(self, view):
  113.         # This is not compatible with widgets where the query param differs from the
  114.         # filter's attribute name. Notably, this includes `MultiWidget`, where query
  115.         # params will be of the format `<name>_0`, `<name>_1`, etc...
  116.         assert compat.coreapi is not None, 'coreapi must be installed to use `get_schema_fields()`'
  117.         assert compat.coreschema is not None, 'coreschema must be installed to use `get_schema_fields()`'
  119.         try:
  120.             queryset = view.get_queryset()
  121.         except Exception:
  122.             queryset = None
  123.             warnings.warn(
  124.                 "{} is not compatible with schema generation".format(view.__class__)
  125.             )
  127.         filterset_class = self.get_filterset_class(view, queryset)
  129.         return [] if not filterset_class else [
  130.             compat.coreapi.Field(
  131.                 name=field_name,
  132.                 required=field.extra['required'],
  133.                 location='query',
  134.                 schema=self.get_coreschema_field(field)
  135.             ) for field_name, field in filterset_class.base_filters.items()
  136.         ]
  138.     def get_schema_operation_parameters(self, view):
  139.         try:
  140.             queryset = view.get_queryset()
  141.         except Exception:
  142.             queryset = None
  143.             warnings.warn(
  144.                 "{} is not compatible with schema generation".format(view.__class__)
  145.             )
  147.         filterset_class = self.get_filterset_class(view, queryset)
  149.         if not filterset_class:
  150.             return []
  152.         parameters = []
  153.         for field_name, field in filterset_class.base_filters.items():
  154.             parameter = {
  155.                 'name': field_name,
  156.                 'required': field.extra['required'],
  157.                 'in': 'query',
  158.                 'description': field.label if field.label is not None else field_name,
  159.                 'schema': {
  160.                     'type': 'string',
  161.                 },
  162.             }
  163.             if field.extra and 'choices' in field.extra:
  164.                 parameter['schema']['enum'] = [c[0] for c in field.extra['choices']]
  165.             parameters.append(parameter)
  166.         return parameters