drf分页、排序、过滤

自定义频率类

# 首先我们导入时间模块用来计时
import time
# 创建一个类继承BaseThrottle
class Frequency(BaseThrottle):
    # 创建一个字典用来存放用户访问记录的时间
    dic1 = {}
    # 我们
    def __init__(self):
        self.history = None
    # 改写allow_request
    def allow_request(self, request, view):
        # 因为我们是使用用户ip来判断是否超过我们的频率限制，所以我们需要获取用户的ip地址
        user_ip = request.META.get('REMOTE_ADDR')
        # 取出当前时间
        ctime = time.time()
        # 判断我们拿到的ip是否在我们之前定义的字典中存在，如果不存在直接添加进去并返回True
        if user_ip not in self.dic1:
            # 将用户ip和当前时间添加入字典中
            self.dic1[user_ip] = [ctime, ]
            # 最后返回True
            return True
        # 将当前ip用户的时间添加到history中
        self.history = self.dic1.get(user_ip)
        # 循环判断当前ip的时间列表，如果有值并且当前时间减去列表中最后一个时间大于六十秒，
        # 那么就将这个数据用pop弹出最后一个值，循环到该列表中没有任意一个超过六十秒的时间，这样表中就只剩下不足六十秒的值
        while self.history and ctime - self.history[-1] > 60:
            # 弹出大于六十秒的值
            self.history.pop()
        # 判断列表中的是否小于5个，如果小于那么将当前时间插入列表中，并且返回True
        if len(self.history) < 5:
            self.history.insert(0, ctime)
            return True
        else:
            # 如果列表中的值大于或等于5个那么就表示已经在一分钟内访问过五次，所以直接返回False表示验证失败
            return False
    # 我们最后也可以给她返回距离最近一次可访问的时间是多少
    def wait(self):
        # 获取当前时间
        ctime = time.time()
        # 返回60秒减去(当前时间减最早一次的访问时间，也就是列表中最右侧的一个时间记录)
        return 60 - (ctime - self.history[-1])
        # 这样我们继承(BaseThrottle)的频率限制器就写完了

频率功能源码剖析

首先我们是改写了allow_reqyest，所以我们需要到SimpleRateThrottle的allow_request来理解他是怎样运行的
# 首先肯定是继承了BaseThrottle，
class SimpleRateThrottle(BaseThrottle):
    cache = default_cache
    timer = time.time
    cache_format = 'throttle_%(scope)s_%(ident)s'
    scope = None
    THROTTLE_RATES = api_settings.DEFAULT_THROTTLE_RATES
	# 只要类实例化得到对象那么就会执行，一执行那么self.rate中就会得到值，将内部值实例化(解压赋值)到self.num_requests和self.duration中
    def __init__(self):
        if not getattr(self, 'rate', None):  # 到频率类汇总反射rate属性或方法，发现没有反悔了None，这个if判断就符合，执行下面的代码
            self.rate = self.get_rate()  # 返回了'5/m'
        # 将上方的'5/m'解压赋值到self.num_requests和self.duration中，那么self.num_requests就等于5，self.duration则是m
        self.num_requests, self.duration = self.parse_rate(self.rate)
	# 如果我们继承的是SimpleRateThrottle我们则就需要重写这个方法
    def get_cache_key(self, request, view):
        raise NotImplementedError('.get_cache_key() must be overridden')
	# 上方实例化会到这里寻找rate
    def get_rate(self):
        # 如果没有那么就会反射回一个'scope'也就是我们给它命名的scope
        if not getattr(self, 'scope', None):
            # 返回报错信息
            msg = ("You must set either `.scope` or `.rate` for '%s' throttle" %
                   self.__class__.__name__)
            raise ImproperlyConfigured(msg)
		# 进行错误捕获
        try:
            # 字典取值，配置文件中咱们配置的信息返回也就是['scope':'5/m'],根据scope取到'5/m'
            return self.THROTTLE_RATES[self.scope]
        except KeyError:
            # 如果报错返回报错信息
            msg = "No default throttle rate set for '%s' scope" % self.scope
            raise ImproperlyConfigured(msg)
	# 接收rate也就是'5/m'
    def parse_rate(self, rate):
        # 如果rate是空的话直接返回两个空，也就是没有限制
        if rate is None:
            return (None, None)
        # 如果有值的话那么就使用split去除/并进行解压赋值使用num和period接收，num='5'， period=m
        num, period = rate.split('/')
        # 将字符串的num转成整型的num
        num_requests = int(num)
        # 将period索引的第一个值与该字典进行匹配，也就是说我们的period不光可以写m也可以写minute取出来也是m，并且有四种限制频率的方式
        duration = {'s': 1, 'm': 60, 'h': 3600, 'd': 86400}[period[0]]
        # 返回num_request,和duration
        return (num_requests, duration)
	# 重写allow_request
    def allow_request(self, request, view):
        # 如果rate中没有值的话返回True也就是没有限制
        if self.rate is None:
            return True
        # self.key=当前访问者的ip地址
        self.key = self.get_cache_key(request, view)
        if self.key is None:
            return True
        # self.history 范文哲的时间列表，从缓存中拿到，如果拿不到的话那么就是空列表也就是说这个用户没有访问过，如果有的话那么就是时间列表
        self.history = self.cache.get(self.key, [])
        # 获取当前时间
        self.now = self.timer()
        # 那么就将这个数据用pop弹出最后一个值，循环到该列表中没有任意一个超过duration的时间，这样表中就只剩下不足duration的值
        while self.history and self.history[-1] <= self.now - self.duration:
            self.history.pop()
        # # 判断列表中的是否小于我们所传入的次数也就是num_request，如果小于那么将当前时间插入列表中，并且返回True
        if len(self.history) >= self.num_requests:
            return self.throttle_failure()
        return self.throttle_success()
    
    def wait(self):
        # 如果时间列表中有值那么计算距离下一次访问还剩多长时间
        if self.history:
            remaining_duration = self.duration - (self.now - self.history[-1])
        else:
            remaining_duration = self.duration
        # 返回duration减去(当前时间减最早一次的访问时间，也就是列表中最右侧的一个时间记录)
        available_requests = self.num_requests - len(self.history) + 1
        if available_requests <= 0:
            return None

        return remaining_duration / float(available_requests)

分页功能

查询所有的接口CIA需要分页，分页在后端的写法是固定的前端展示形式却是不一样的
    在pc端是下一页下一页的点击进行换页操作
    在移动端则是下拉刷新或者加载更多

drf中分页的使用:
    写一个类，继承drf提供的三个分页类之一
    重写某几个类属性
    降压配置在继承自GenericAPIView+ListModelMixin的子视图类上
    如果继承的是APIView，需要自己写
    page = MypageNumberPagination()
    res = page.paginate_queryset(qs,request)

from rest_framework.pagination import PageNumberPagination,LimitOffsetPagination,CursorPagination


class AsPageNumberPagination(PageNumberPagination):  # 使用的最多
    # 我们继承过来只需要写四个类属性即可
    page_size = 2 # 每页显示的条数
    page_query_param = 'page'  # 查询第几页的参数
    page_size_query_param = 'size'  # 可以控制当前页显示多少条数据
    max_page_size = 5  # 最多一页显示多少条数据


class AsLimitOffsetPagination(LimitOffsetPagination):  # 偏移分页，
    # 我们继承过来只需要写四个类属性即可
    default_limit = 2 # 每页显示的条数
    limit_query_param = 'limit'  # 查询第几页的参数
    offset_query_param = 'offset'  # 可以控制当前页显示多少条数据
    max_limit = 5  # 最多一页显示多少条数据


class AsCursorPagination(CursorPagination):  # 游标分页，如果数据非常多那么一般使用这个
    # 我们继承过来只需要写三个类属性即可
    cursor_query_param = 'cursor'# 可以控制当前页显示多少条数据，但是只能前一页和后一页，使用这个
    page_size = 2  # 每页显示的条数
    ordering = '-id'  # 按照什么来进行排序，必须是表中有的字段

排序功能

查询所有才能涉及到排序，其他接口都不需要排序

必须是继承GenericAPIView+ListModelMixin的子视图类上
	配置排序类：
		filter_backends=[OrderingFilter,]
	配置排序的字段
		ordering_fields=['id','price']
	支持前端的访问形式
		http://127.0.0.1:8000/books/?ordering=-price,id  # 先按价格的降序排，如果价格一样再按id的升序排
    
纯自己写的，继承了APIView的，需要自己从请求地址中取出排序规则，自己排序
	'price','-id'=reqeust.query_params.get('ordering').split(',')
	qs = Book.objects.all().order_by('price','-id')
    
    
分页和排序能一起用，但是是先排序后分页的

过滤功能

查询所有才涉及到过滤，其它接口都不需要
restful规范中有一条，请求地址中带过滤条件：分页，排序，过滤统称为过滤
使用内置过滤类使用步骤   查询所有才涉及到排序，其它接口都不需要
	必须是继承GenericAPIView+ListModelMixin的子视图类上
		配置过滤类：
			filter_backends=[SearchFilter,]
		配置过滤的字段
			ordering_fields=['name','publish']
		支持前端的访问形式
			http://127.0.0.1:8000/books/?search=三 # 只要name中或publish中有三都能搜出来
内置过滤类只能通过search写条件，如果配置了多个过滤字段，是或者的条件
        
不够用：
	第三方：过滤类
		from django_filters.rest_framework import DjangoFilterBackend
	自己写：自己写过滤类
		from rest_framework.filters import BaseFilterBackend
		class FilterName(BaseFilterBackend):
			def filter_queryset(self, request, queryset, view):
				name = request.query_params.get('name')
				return queryset.filter(name__contains=name)