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 queryset

3、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._paginator

4.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 django.test import TestCase

# Create your tests here.
from rest_framework.pagination import PageNumberPagination
from collections import OrderedDict
from rest_framework.response import Response
from rest_framework.exceptions import ValidationError

class GenericPageNumberPagination(PageNumberPagination):
    page_size = 20 #默认的每页大小
    page_query_param = 'page' #查询页码的字符串
    page_size_query_param = 'page_size' #查询每页大小的字符串
    max_page_size = page_size + (page_size // 2) #限制每页最大数据量
    def __init__(self):
        self.total_count=None #总数据量
        self.total_page=None #总页数
        self.current_page=None #当前页码
        self.has_next_page = None #是否有下一页
        self.has_previous_page = None #是否有上一页

    # 重写父类的: 校验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)
        error = {'error': None, 'code': 400}
        if page == None:
            return None

        try:
            page = int(page)
            # 1、判断查询的页码是否大于0
            if page <= 0:
                error['error'] = '页码必须大于0'
            # 2、总数据量
            self.total_count = len(queryset)
            # 3、判断查询的数据是否有数据
            if self.total_count == 0:
                error['error']='查询不到相关数据'
            # 3、总页数
            self.total_page, has_number = divmod(self.total_count, page_size)
            if has_number:
                self.total_page += 1
            # 4、判断查询的页码是否大于总页码
            if page > self.total_page:
                error['error'] = f'查询的页码{page}大于总页码数{self.total_page}'
            #5、当前的页码
            self.current_page = page

            #返回值
            if error.get('error') == None:
                return self.current_page
            else:
                return error
        except Exception:
            error['error'] = '页码必须是数值'
            return error

    # 重写父类的: 获取当前页的QuerySet对象
    def paginate_queryset(self, queryset, request,view=None,serializer_class=None):
        '''
        功能：获取当前页的queryset对象
        :param queryset: 所有的queryset
        :param request: 当前请求
        :param view: 当前视图类
        :param serializer_class: 手动添加时的start方法会调用这个，ListModelMixin不会传递这个的
        :return: None，{’error‘:''}, QuerySet
        '''
        page_size = self.get_page_size(request)
        page = self.get_page(request, queryset, page_size)
        if isinstance(page, dict):
            # page参数错误，没有传递page时
            if serializer_class:
                #手动调用时，报错消息直接返回
                return page
            else:
                #ListModelMixin 调用时，有报错，就抛出异常
                raise ValidationError(page.get('error'))
        if page == None:
            if serializer_class:
                #手动调用时
                return {'error':'没有携带查询页码page','code':400}
            else:
                #ListModelMixin 调用时
                return None
        ##1、实例化django的分页器
        paginator = self.django_paginator_class(queryset, page_size)

        ##2、获取当前页数据: 使用django的分页器来实现的
        self.page = paginator.page(self.current_page)
        self.request = request

        ##3、是否有上一页和下一页
        self.has_next_page = 1 if self.get_next_link() else 0
        self.has_previous_page = 1 if self.get_previous_link() else 0

        return list(self.page)

    # 重写父类的：将当前页的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的错误消息
            if serializer_class:
                #手动调用就返回错误消息
                return page_queryset
            else:
                return None
        elif isinstance(page_queryset, list):
            data = {
                'code': 201,
                'msg': '获取数据成功',
                'data': '',  # 当前页数据
                'next': self.has_next_page,  # 是否有下一页
                'previous': self.has_previous_page,  # 是否有上一页
                'count': self.total_count,  # 总数据量
                'pages': self.total_page,  # 总页码数
                'current_page': self.current_page,  # 当前页码
                'page_size': self.page_size,  # 每页大小

            }
            if serializer_class:
                print('手动调用时，走这里')
                # 1、手动使用start方法调用时,
                page_ser = serializer_class(instance=page_queryset, many=True)
                page_data = page_ser.data
                data['data'] = page_data
                return data
            else:
                print('ListModelMixin 走这里')
                # 2、配合mixins.ListModelMixin源码使用, 其调用了paginate_queryset，拿到queryset对象，将序列化结果传递进来
                page_queryset = self.handle_data(page_queryset)
                data['data'] = page_queryset
                return Response(OrderedDict([
                    (k,v) for k,v in data.items()
                ]))
        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,序列化类,模型对象)
    '''
    page = GenericPageNumberPagination()
    page_data = page.start('request对象', '序列化器类', '数据库查询的queryset')

（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')