Django-rest-framework框架之自定义频率类与过滤排序分页

今日内容概要

• 自定义频率类
• 分页功能
• 排序功能
• 过滤功能
• 继承APIView实现分页

自定义频率类

代码展示
需求：
（1）取出访问者ip
（2）判断当前ip不在访问字典里，添加进去，并且直接返回True,表示第一次访问，在字典里，继续往下走
（3）循环判断当前ip的列表，有值，并且当前时间减去列表的最后一个时间大于60s，把这种数据pop掉，这样列表中只有60s以内的访问时间，
（4）判断，当列表小于3，说明一分钟以内访问不足三次，把当前时间插入到列表第一个位置，返回True，顺利通过
（5）当大于等于3，说明一分钟内访问超过三次，返回False验证失败

from rest_framework.throttling import BaseThrottle
from rest_framework.throttling import SimpleRateThrottle
class OurThrottle(SimpleRateThrottle):
   scope = 'jason'
def get_cache_key(self, request, view):
       return request.META.get('REMOTE_ADDR')

class MyThrottle(BaseThrottle):
func_dict = {}   # 存放用户访问记录{ip1:[时间1，时间2],ip2:[时间1，时间2],'192.168.1.101':[当前时间，]}


   def __init__(self):
       self.history = None
   def allow_request(self, request, view):
       # 在这里写逻辑：根据ip地址判断用户是不是超过了频率限制
       # （1）取出访问者ip
       ip = request.META.get('REMOTE_ADDR')
       import time
       ctime = time.time()   # 取出当前时间
       # （2）判断当前ip不在访问字典里，添加进去，并且直接返回True，表示第一次访问
       if ip not in self.func_dict:
           self.func_dict[ip] = [ctime,]
           return True
       self.history = self.func_dict.get(ip)  # 当前访问者的时间列表[时间2，]
       # （3）循环判断当前ip的时间表，有值，并且当前时间减去列表的最后一个时间大于60s，把这种数据pop掉，这样列表中只有60s以内的访问时间，
       while self.history and -ctime + self.history[-1] < 60:   # 循环结束后，剩下的都是1分钟以后访问的时间
           self.history.pop()
           # （4）判断，当列表小于3，说明一分钟以内访问不足三次，把当前时间插入到列表第一个位置，返回True，顺利通过
           #（5）当大于等于3，说明一分钟内访问超过三次，返回False验证失败
           if len(self.history) < 3:
               self.history.insert(0,ctime)
               return True
           else:
               return False
               
# 显示还剩多长时间功能：
       def wait(self):
           import time
           ctime = time.time()
           return 60 - (ctime - self.history[-1])

分页功能

1.drf中分页的使用：

• 写一个类，继承drf提供的三个分页类之一；
• 重写某几个类属性
• 把它配置在继承自GenericAPIView+ListModelMixin的子视图类上
• 如果继承的是APIView，需要自己写

page = MyPageNumberPagination()
res = page.paginate_queryset(qs, request)

2.源码分析
重写paglination.py

from rest_framework.pagination import >PageNumberPagination,LimitOffsetPagination,CursorPagination


# 第一种分页方法
class OnePageNumberPagination(PageNumberPagination):
   # 4个参数，重写属性
   page_size = 3   # 每页显示的条数
   page_query_param = 'page'   # 查询第几页的参数  ?page=2
   page_size_query_param = 'size'  # 查询第几页，每页显示几条数据
   max_page_size = 4    # 限制通过size查询，最大的条数


class TwoLimitOffsetPagination(LimitOffsetPagination):
   default_limit = 2   # 每页显示的条数
   limit_query_param = 'limit'   # ?limit=3  这一页显示3条数据
   offset_query_param = 'offset'  # ?offset=2&limit=3   从第2条开始，取三条数据
max_limit = None   # 限制最多显示多少条数据

class ThreeCursorPagination(CursorPagination):
   cursor_query_param = 'cursor'
   page_size = 2    # 每页显示条数
   ordering = 'id'  # 排序，必须是表中字段

3.继承内部提供的三个分页类，重写List：

• 扩展：返回给前端的格式变一下，重写list；
• 扩展：所有的查询所有返回格式都变，写一个类，继承ListModelMixin，重写list方法。

from rest_framework.mixins import ListModelMixin
class MyListModel(ListModelMixin):
   def List(self,request,*args,**kwargs)
   res.data['code']=100
   res.data['msg']='成功'
   return Response(res.data)

排序功能

1.首先查询所有才涉及到排序，其它接口都不需要
2.必须是继承GenericAPIView+ListModelMixin的子视图类上

• 配置排序类：

filter_backends=[OrderingFilter,]

• 配置排序的字段

ordering_fields=['id','price']

• 支持前端的访问形式(postman)

http://127.0.0.1:8000/books/?ordering=-price,id # 先按价格的降序排，如果价格一样再按id的升序排

3.纯自己写的，继承了APIView的，需要自己从请求地址中取出排序规则，自己排序

'price','-id'=reqeust.query_params.get('ordering').split(',')

qs = Book.objects.all().order_by('price','-id')

4.分页和排序能一起用，但是是先排序后分页的

过滤功能

1.内置过滤

• 查询所有才涉及到过滤，其它接口都不需要
• restful规范中有一条，请求地址中带过滤条件：分页，排序，过滤统称为过滤
• 使用内置过滤类使用步骤 查询所有才涉及到排序，其它接口都不需要
• 必须是继承GenericAPIView+ListModelMixin的子视图类上
  （1）配置过滤类：

filter_backends=[SearchFilter,]

（2）配置过滤的字段

ordering_fields=['name','publish']

（3）支持前端的访问形式

http://127.0.0.1:8000/books/?search=三 # 只要name中或publish中有三都能搜出来

• 内置过滤类只能通过search写条件，如果配置了多个过滤字段，是或者的条件
• 如果后期发现内置过滤不够用，可以考虑：
  （1）第三方：过滤类
  （2）自己写：自己写过滤类

继承APIView实现分页

代码展示：

from rest_framework.views import APIView
class BookView1(APIView):
   def get(self,request):
       qs = Book.objects.all()
       # 第一步：实例化得到分页类的对象
       page = OnePageNumberPagination()
       # 第二步：调用分页类对象的paginate_queryset方法，完成分页（传入了所有数据，传入了请求对象：page = 3和size = 5）
       # 分页后的数据=qs[(page-1)*size:page*size]
       res = page.paginate_queryset(qs,request)
       ser = BookSerializer(instance=res,many=True)
       # 第三步：调用分页类对象的get_paginated_response方法返回
       return page.get_paginated_response(ser.data)