DRF-通用分页器（PageNumberPagination）：ListModelMixin可以使用的通用分页器
一、ListModelMixin 和GenericAPIView源码
ListModelMixin 是一个单一功能类，必须配合GenericAPIView（或其子类）来一起使用，才能完成其视图的功能
class ListModelMixin:
"""
List a queryset.
"""
def list(self, request, *args, **kwargs):
#1、这里获取queryset
queryset = self.filter_queryset(self.get_queryset())
#2、这里获取当前页的queryset数据，[<数据模型>]
page = self.paginate_queryset(queryset)
if page is not None:
#3、对当前页的模型对象，进行序列化
serializer = self.get_serializer(page, many=True)
#4、获取到当前页的数据，里面整合了当前页的序列化数据
return self.get_paginated_response(serializer.data)
serializer = self.get_serializer(queryset, many=True)
return Response(serializer.data)主要就按照：一步一步走就可以了，如果ListModelMixin没有的方法，就去GenericAPIView找
self.filter_queryset(self.get_queryset())--->self.paginate_queryset(queryset)-->self.get_serializer(page, many=True)-->self.get_paginated_response(serializer.data)
1、ListModelMixin ： queryset = self.filter_queryset(self.get_queryset())
当前类是没有实现get_queryset和filter_queryset方法的，
配合GenericAPIView使用，调用的是GenericAPIView的get_queryset和filter_queryset方法
2、GenericAPIView: get_queryset, 拿到queryset对象
def get_queryset(self):
queryset = self.queryset
if isinstance(queryset, QuerySet):
queryset = queryset.all()
return queryset3、GenericAPIView:filter_queryset 这个是过滤器，没有配置就是空，没有做如何操作
4、GenericAPIView：paginate_queryset(queryset) ：
4.1、GenericPAIView : paginator : 拿到配置的分页器类，返回分页器的实例化对象
@property
def paginator(self):
if not hasattr(self, '_paginator'):
if self.pagination_class is None:
self._paginator = None
else:
self._paginator = self.pagination_class()
return self._paginator4.2、根据4.1，拿到的分页器对象，调用分页器的paginate_queryset 方法： 该方法就是返回当前页的queryset
def paginate_queryset(self, queryset):
if self.paginator is None:
return None
return self.paginator.paginate_queryset(queryset, self.request, view=self)5、GenericAPIView: get_paginated_response 方法： 调用分页器对象的get_paginated_response
def get_paginated_response(self, data):
assert self.paginator is not None
return self.paginator.get_paginated_response(data)总结来说：
1、要满足第一个要求，符合ListModelMixin的功能，需要在自定义的分页器类中重写paginate_queryset和get_paginated_response
2、在start方法中，调用这两个方法
3、再开一个方法handle_data，在get_paginated_response中调用这个方法，后续重写handle_data来进行数据定制功能
二、自定义PageNumber的分页器
（1）自定义的基本分页器类
from rest_framework.pagination import PageNumberPagination
class GenericPageNumberPagination(PageNumberPagination):
page_size = 20
page_query_param = 'page'
page_size_query_param = 'page_size'
max_page_size = page_size+(page_size//2)
#重写父类的: 校验page_size
def get_page_size(self, request):
'''
功能：校验page_size，没有传递或传递类型有问题时，按照默认的大小设置，超过最大页面大小时，设置成最大页面
:param request:
:return: 数值
'''
page_size = request.GET.get(self.page_size_query_param)
if not page_size:
page_size = self.page_size #取的是类的page_size
else:
try:
page_size = int(page_size)
except Exception:
page_size = self.page_size #取的是类的page_size
if page_size > self.max_page_size:
page_size = self.max_page_size
#给分页的实例对象赋值每页大小
self.page_size = page_size
return self.page_size
#自己定义: 校验page
def get_page(self,request,queryset,page_size):
'''
功能：判断携带page是否合法，页码必须大于0，不能大于最大页数，页码必须是数值
:param request: 当前请求对象
:param queryset: 模型uqeryset
:param page_size: 每页大小
:return: None，{"error":'错误消息'}，数值
'''
page = request.GET.get(self.page_query_param)
if page == None:
return None
try:
page = int(page)
self.page = page
#判断查询的页码是否大于0
if page <=0:
self.page = {'error':'页码必须大于0','code':400}
#总数据量
self.count = len(queryset)
##判断查询的数据是否有数据
if self.count == 0:
self.page = {'error':'查询不到相关数据','code':400}
#总页数
self.pages, has_number = divmod(self.count,page_size)
if has_number:
self.pages += 1
## 判断查询的页码是否大于总页码
if page > self.pages:
self.page = {'error':f'查询的页码{page}大于总页码数{self.pages}','code':400}
return self.page
except Exception:
self.page = {'error':'页码必须是数值','code':400}
return self.page
#自定义的
def has_next_page(self,page=None,pages = None):
'''
是否有下一页的数据
:param page: 当前页
:param pages: 总页数
:return: 0或1
'''
if page == None:
page = self.page
if pages == None:
pages = self.pages
if page == 1:
if pages <= 1:
return 0
else:
return 1
else:
#page > 1
if pages > page:
return 1
else:
return 0
#自定义的
def has_previous_page(self,page=None,pages = None):
'''
功能：是否有上一页的数据
:param page: 当前页
:param pages: 总页数
:return: 0或1
'''
if page == None:
page = self.page
if pages == None:
pages = self.pages
if pages <=1:
return 0
else:
if page>1:
return 1
else:
return 0
#重写父类的: 获取当前页的QuerySet对象
def paginate_queryset(self, queryset, request, view=None):
'''
功能：获取当前页的queryset对象
:param queryset: 所有的queryset
:param request: 当前请求
:param view: 当前视图类
:return: None，{’error‘:''}, QuerySet
'''
page_size = self.get_page_size(request)
page = self.get_page(request,queryset,page_size)
if isinstance(page,dict) or page == None:
#page参数错误，没有传递page时
return page
queryset_len = len(queryset)
if queryset_len == 0:
return {'error':'查询不到相关数据','code':400}
#1、总数据量,在get_page 中就设置了
self.count = len(queryset)
#2、总页数，在get_page 中就设置了
self.pages, has_number = divmod(self.count, page_size)
if has_number:
self.pages += 1
# 3、下一页
self.next = self.has_next_page() # 有下一页，返回1，没有返回0
# 4、上一页
self.previous = self.has_next_page() # 有上一页时，返回1，没有返回0
#5、当前页
self.current_page = self.page
#6、截取指定的数据
if self.page == 1:
self.queryset = queryset[:self.page_size]
else:
start = self.page_size*(self.page-1)
end = self.page_size*(self.page)
self.queryset = queryset[start:end]
return self.queryset
#重写父类的：将当前页的QuerySet对象序列化
def get_paginated_response(self,page_queryset,serializer_class=None):
'''
功能：根据传递进来的dict，None（page没有传递，就不返回数据了），当前页的List，当前页QuerySet，
:param page_queryset: dict,None,List，QuerySet
:param serializer_class: 序列化器类
:return: {}
'''
if isinstance(page_queryset,dict):
#paginate_queryset的错误消息
return page_queryset
elif isinstance(page_queryset,list):
data = {
'code': 201,
'msg': '获取数据成功',
'data': '', # 当前页数据
'next': self.has_next_page(), # 是否有下一页
'previous': self.has_previous_page(), # 是否有上一页
'count': self.count, # 总数据量
'pages': self.pages, # 总页码数
'current_page': self.page, # 当前页码
'page_size': self.page_size, # 每页大小
}
if serializer_class:
#1、手动使用start方法调用时,
page_ser = serializer_class(instance=page_queryset, many=True)
page_data = page_ser.data
data['data'] = page_data
return data
else:
#2、配合mixins.ListModelMixin源码使用, 其调用了paginate_queryset，拿到queryset对象，将序列化结果传递进来
page_queryset = self.handle_data(page_queryset)
data['data'] = page_queryset
return data
elif page_queryset == None:
return {'code':400,'error':'没有传递页码值'}
else:
raise Exception('分页器只支持，dict，list，QuerySet，None 类型')
#自己定义的，对当前页数据，进一步的处理
def handle_data(self,data_list):
return data_list
#手动调用时，获取结果的
def start(self,request,serializer_class,queryset):
#1、获取当前页的QuerySet对象
page_queryset = self.paginate_queryset(queryset=queryset,request=request)
if page_queryset == None:
return {'code':400,'error':'页码必须携带'}
if isinstance(page_queryset,dict):
return page_queryset
#2、将当前页的QuerySet对象传递进去，得到分页的响应结果
page_data = self.get_paginated_response(page_queryset=page_queryset,serializer_class=serializer_class)
return page_data
if __name__ == '__main__':
'''
mixins.ListModelMixin的调用逻辑：
1、调用paginate_queryset
2、1的返回值如果是None时，就不执行获取分页的数据，就去获取所有的数据返回
3、1的返回值不为None时，就执行get_paginated_response，拿到分页的结果
手动调用使用：
data = page.start(request,序列化类,模型对象)
'''（2）、使用
1、对于ListModelMixin，使用的逻辑是一样的，无需变化。
2、手动使用
page = GenericPageNumberPagination()
page_data = page.start(request,'序列化器类','数据库查询的queryset')
（3）、继承
对于需要特殊处理返回的数据时，可以继承分页器类，重写handle_data方法
class UserPageNumberPagination(GenericPageNumberPagination):
def handle_data(self,data_list):
for dic in data_list:
dic['type'] = '患者'
return data_list
#使用
page = UserPageNumberPagination()
page_data = page.start(request,'序列化器类','数据库查询到关于用户的queryset')