排序源码分析
ListAPIView是视图家族的工具视图类，因为继承了ListModelMixin类，所以有了list群查方法。而排序就是在这个list方法里面进行的。
ListModelMixin
class ListModelMixin:
"""
List a queryset.
"""
def list(self, request, *args, **kwargs):
#看名字也知道是这一步完成的过滤
queryset = self.filter_queryset(self.get_queryset())
#这一步完成的是获取分页的页数
page = self.paginate_queryset(queryset)
#如果没有分页直接做返回，如果有的话就在这里面再做处理
if page is not None:
serializer = self.get_serializer(page, many=True)
return self.get_paginated_response(serializer.data)
serializer = self.get_serializer(queryset, many=True)
return Response(serializer.data)
这里的filter_queryset点不过去，所以如果我们想要给自己的类加上过滤条件，就要进入GenericAPIView（ListAPIView也继承了这个），发现了一个类属性filter_backends = api_settings.DEFAULT_FILTER_BACKENDS ，表示在filter_backends 里有一些类，类里面有一些方法，直接定位，找到一个filters.py
进入filters.py文件，这个文件里有一个排序类OrderingFilter，一个搜索类SearchFilter，和一个基类BaseFilterBackend，排序类和搜索类继承这个基类，并且三个类都有 filter_queryset 方法，这就很明显要我们继承这个类重写这个方法就好了。
先分析一下OrderingFilter的 filter_queryset方法，发现他是传进去一个queryset，返回一个queryset，那么肯定是在这里面给过滤了，在这里面把他的数据量变少就好了。怎么做的？queryset有一个特点，那就是他可以继续使用queryset的方法，可以继续加filter！
看一下 OrderingFilter 的filter_queryset 是怎么写的
def filter_queryset(self, request, queryset, view):
ordering = self.get_ordering(request, queryset, view)
if ordering:
#这一句就完成了排序，所以就看ordering是怎么拿到的
return queryset.order_by(*ordering)
return queryset
看一下get_ordering拿到的是什么东西赋值给 ordering
def get_ordering(self, request, queryset, view):
"""
Ordering is set by a comma delimited ?ordering=... query parameter.
The `ordering` query parameter can be overridden by setting
the `ordering_param` value on the OrderingFilter or by
specifying an `ORDERING_PARAM` value in the API settings.
"""
#query_params表示前端发送的请求所带的参数，想要在这个参数里面获取ordering_param表示的值，所以去看要去找到ordering_param这个属性值，结果在配置文件中找到了'ORDERING_PARAM': 'ordering'，所以这里的ordering_param代表的就是ordering，我们只需要在请求中附带参数，用“ordering=xxx”可以了。
params = request.query_params.get(self.ordering_param)
if params:
#这里表示请求中可以传多个排序条件，通过逗号
fields = [param.strip() for param in params.split(',')]
#为了防止我们乱传一些ordering=asdfasdfa这样的东西，这个方法实现了排除不符合条件的排序条件，进入这个方法看一下是怎么做的
ordering = self.remove_invalid_fields(queryset, fields, view, request)
if ordering:
return ordering
# No ordering was included, or all the ordering fields were invalid
return self.get_default_ordering(view)
remove_invalid_fields
def remove_invalid_fields(self, queryset, fields, view, request):
#用这个方法来获取允许的排序条件。
valid_fields = [item[0] for item in self.get_valid_fields(queryset, view, {'request': request})]
return [term for term in fields if term.lstrip('-') in valid_fields and ORDER_PATTERN.match(term)]
进入get_valid_fields方法
def get_valid_fields(self, queryset, view, context={}):
#通过反射从我们自己的视图类中获取'ordering_fields'
valid_fields = getattr(view, 'ordering_fields', self.ordering_fields)
所以很明白了，我们需要在自己的视图类中配置 ordering_fields=[ ]，比如id ，price等等，这样请求参数传的不符合的数据就会被抛掉。
比如：
from django_filters.rest_framework import DjangoFilterBackend
from .filters import CourseFilterSet
from .filters import LimitFilter
class FreeCourseListAPIView(ListAPIView):
queryset = models.Course.objects.filter(is_delete=False, is_show=True).order_by('-orders').all()
serializer_class = serializers.FreeCourseModelSerializer
# 配置过滤器类
filter_backends = [OrderingFilter, LimitFilter] # LimitFilter自定义过滤器
# 参与排序的字段: ordering=-price,id
ordering_fields = ['price', 'id']
filters.py
from rest_framework.filters import BaseFilterBackend
class LimitFilter(BaseFilterBackend):
def filter_queryset(self, request, queryset, view):
limit = request.query_params.get('limit')
try:
return queryset[:int(limit)]
except:
return queryset
搜索源码分析
和上面的一样，从SearchFilter进去找，
看到这个方法
def get_search_fields(self, view, request):
"""
Search fields are obtained from the view, but the request is always
passed to this method. Sub-classes can override this method to
dynamically change the search fields based on request content.
"""
#从视图里面拿search_fields
return getattr(view, 'search_fields', None)
所以只要在视图类里配置这个search_fields就可以了。
class FreeCourseListAPIView(ListAPIView):
queryset = models.Course.objects.filter(is_delete=False, is_show=True).order_by('-orders').all()
serializer_class = serializers.FreeCourseModelSerializer
# 配置过滤器类
# filter_backends = [OrderingFilter, LimitFilter] # LimitFilter自定义过滤器
filter_backends = [OrderingFilter, SearchFilter, DjangoFilterBackend]
# 参与排序的字段: ordering=-price,id
ordering_fields = ['price', 'id', 'students']
# 参与搜索的字段: search=python (name或brief字段中带python就ok)
search_fields = ['name', 'brief']
分页器源码分析
class ListModelMixin:
"""
List a queryset.
"""
def list(self, request, *args, **kwargs):
#看名字也知道是这一步完成的过滤
queryset = self.filter_queryset(self.get_queryset())
#这一步完成的是获取分页的页数
page = self.paginate_queryset(queryset)
#如果没有分页直接做返回，如果有的话就在这里面再做处理
if page is not None:
serializer = self.get_serializer(page, many=True)
return self.get_paginated_response(serializer.data)
serializer = self.get_serializer(queryset, many=True)
return Response(serializer.data)
直接去找到pagination.py文件
里面有四个类， BasePagination基类，CursorPagination根据游标分类 ， LimitOffsetPagination根据偏移分页 ，PageNumberPagination基础分页。看一下PageNumberPagination,有一些配置，我们只需要设置这些配置就可以了。
page_size = api_settings.PAGE_SIZE
django_paginator_class = DjangoPaginator
# Client can control the page using this query parameter.
page_query_param = 'page'
page_query_description = _('A page number within the paginated result set.')
# Client can control the page size using this query parameter.
# Default is 'None'. Set to eg 'page_size' to enable usage.
page_size_query_param = None
page_size_query_description = _('Number of results to return per page.')
# Set to an integer to limit the maximum page size the client may request.
# Only relevant if 'page_size_query_param' has also been set.
max_page_size = None
有经验了，知道一定是在视图类里面配置。
views
from .paginations import CoursePageNumberPagination, CourseLimitOffsetPagination, CourseCursorPagination
# 分类筛选：django-filter：filter_backends配置DjangoFilterBackend，再在filter_fields中配置分组筛选的字段
from django_filters.rest_framework import DjangoFilterBackend
from .filters import CourseFilterSet
class FreeCourseListAPIView(ListAPIView):
queryset = models.Course.objects.filter(is_delete=False, is_show=True).order_by('-orders').all()
serializer_clas s = serializers.FreeCourseModelSerializer
# 配置过滤器类
# filter_backends = [OrderingFilter, LimitFilter] # LimitFilter自定义过滤器
filter_backends = [OrderingFilter, SearchFilter, DjangoFilterBackend]
# 参与排序的字段: ordering=-price,id
ordering_fields = ['price', 'id', 'students']
# 参与搜索的字段: search=python (name字段中带python就ok)
search_fields = ['name', 'brief']
# 分页器
pagination_class = CoursePageNumberPagination
# pagination_class = CourseLimitOffsetPagination
# pagination_class = CourseCursorPagination
分页器Pagination
from rest_framework.pagination import PageNumberPagination, LimitOffsetPagination, CursorPagination
class CoursePageNumberPagination(PageNumberPagination):
# 默认一页条数
page_size = 2
# 选择哪一页的key
page_query_param = 'page'
# 用户自定义一页条数
page_size_query_param = 'page_size'
# 用户自定义一页最大控制条数
max_page_size = 10
class CourseLimitOffsetPagination(LimitOffsetPagination):
# 默认一页条数
default_limit = 2
# 从offset开始往后显示limit条
limit_query_param = 'limit'
offset_query_param = 'offset'
max_limit = 2
class CourseCursorPagination(CursorPagination):
cursor_query_param = 'cursor'
page_size = 2
page_size_query_param = 'page_size'
max_page_size = 2
# ordering = 'id' # 默认排序规则，不能和排序过滤器OrderingFilter共存
注意：分页后的结果和没有分页的结果是不一样的，分页后返回的是字典，有下一页的路由，上一页的路由，和result，分页后的结果是把没有分页的结果丢进result返回的
分类筛选过滤器
普通使用
分类筛选 drf 和 django 都干不了，需要安装一个插件
pip install django-filters
插个插件可以解决前后端不分离的分类筛选，也可以完成前后端分离的筛选
用法：
from .paginations import CoursePageNumberPagination, CourseLimitOffsetPagination, CourseCursorPagination
# 分类筛选：django-filter：filter_backends配置DjangoFilterBackend，再在filter_fields中配置分组筛选的字段
from django_filters.rest_framework import DjangoFilterBackend
from .filters import CourseFilterSet
class FreeCourseListAPIView(ListAPIView):
queryset = models.Course.objects.filter(is_delete=False, is_show=True).order_by('-orders').all()
serializer_clas s = serializers.FreeCourseModelSerializer
# 配置过滤器类
# filter_backends = [OrderingFilter, LimitFilter] # LimitFilter自定义过滤器
filter_backends = [OrderingFilter, SearchFilter, DjangoFilterBackend]
# 参与排序的字段: ordering=-price,id
ordering_fields = ['price', 'id', 'students']
# 参与搜索的字段: search=python (name字段中带python就ok)
search_fields = ['name', 'brief']
# 参与分类筛选的字段：所有字段都可以，但是用于分组的字段更有意义
filter_fields = ['course_category']
分类筛选：django-filter：filter_backends配置DjangoFilterBackend，再在filter_fields中配置分组筛选的字段，就完成了分类筛选的基本使用
高级使用
区间筛选过滤器
我们说过的，过滤器就是把数据给减少了返回，所以他一定是走了 filter_queryset 方法的，看一下 django-filter 里面，找到这个方法
进入DjangoFilterBackend，找到 django-filter
def filter_queryset(self, request, queryset, view):
filterset = self.get_filterset(request, queryset, view)
#如果为空，就直接返回原来的queryset，就等于啥也没过滤
if filterset is None:
return queryset
if not filterset.is_valid() and self.raise_exception:
raise utils.translate_validation(filterset.errors)
return filterset.qs
进去看一下get_filterset方法，是怎么获取filterset的
def get_filterset(self, request, queryset, view):
#这里一定不为空，不然的话就返回none了，然后前面那个方法就原样返回queryset了，等于什么也没做。所以进去看一下get_filterset_class方法
filterset_class = self.get_filterset_class(view, queryset)
if filterset_class is None:
return None
kwargs = self.get_filterset_kwargs(request, queryset, view)
return filterset_class(**kwargs)
进入get_filterset_class
def get_filterset_class(self, view, queryset=None):
"""
Return the `FilterSet` class used to filter the queryset.
"""
#从视图类中找filterset_class和filterset_fields，我们在视图类中配置的是filter_fields，所以这两个都是none
filterset_class = getattr(view, 'filterset_class', None)
filterset_fields = getattr(view, 'filterset_fields', None)
# TODO: remove assertion in 2.1
#这里又判断了，如果filterset_class是空，有filter_class也行，但是这个也没有
if filterset_class is None and hasattr(view, 'filter_class'):
utils.deprecate(
"`%s.filter_class` attribute should be renamed `filterset_class`."
% view.__class__.__name__)
filterset_class = getattr(view, 'filter_class', None)
# TODO: remove assertion in 2.1
#这里才是我们能进去的地方
if filterset_fields is None and hasattr(view, 'filter_fields'):
utils.deprecate(
"`%s.filter_fields` attribute should be renamed `filterset_fields`."
% view.__class__.__name__)
#把我们在视图类里配置的filter_fields反射出来给了filterset_fields
filterset_fields = getattr(view, 'filter_fields', None)
#空，不走
“1” if filterset_class:
filterset_model = filterset_class._meta.model
# FilterSets do not need to specify a Meta class
if filterset_model and queryset is not None:
assert issubclass(queryset.model, filterset_model),
'FilterSet model %s does not match queryset model %s' %
(filterset_model, queryset.model)
return filterset_class
#满足，走这个
if filterset_fields and queryset is not None:
#看一下这个filterset_base，ctrl+左键一点，跑上面找到了一个filterset_base = filterset.FilterSet，然后看一下他导入的filterset，是从哪里导入的，结果是 from . import filters, filterset，这个 . ，看一下目录，他代表的就是django_filters下的rest_framwork，那么filterset就找到了
MetaBase = getattr(self.filterset_base, 'Meta', object)
#所以这里的AutoFilterSet类就相当于继承了filterset.FilterSet
“2” class AutoFilterSet(self.filterset_base):
class Meta(MetaBase):
#这里能找到他的类是什么
model = queryset.model
fi elds = filterset_fields
return AutoFilterSet
return None
所以看上面的“1”处，如果你给的是类，他就返回一个类，如果你给的是一个字段，他也
把你格式化成类返回了（看“2”），所以我们把这个AutoFilterSet拉出来，放在自己写的过滤器里就好了
filters
# 基于django-filter插件，完成指定区间筛选（一般都是对应数字字段）
from django_filters.rest_framework.filterset import FilterSet
from . import models
#这个名字可以改
class CourseFilterSet(FilterSet):
class Meta:
model = models.Course
fields = ['course_category']
写完后，前面的普通使用的filter_fields = ['course_category']也可以写成filterset_class=CourseFilterSet
问题：这样好像变得更麻烦了，我为什么不直接写个字段就好呢？
答案：因为后面的方式我们可以自定义字段，比如实现区间筛选。
from django_filters.rest_framework.filterset import FilterSet
from django_filters import filters
from . import models
class CourseFilterSet(FilterSet):
#field_name表示我这个自定义字段跟price这个字段有关系，lookup_expr表示筛选规则，其实这个内部就是做了基于双下划綫的规则
max_price = filters.NumberFilter(field_name='price', lookup_expr='lte')
min_price = filters.NumberFilter(field_name='price', lookup_expr='gte')
class Meta:
model = models.Course
fields = ['course_category', 'max_price', 'min_price']