自定义频率类

from rest_framework.throttling import BaseThrottle
class MyThrottle(BaseThrottle):
    VISIT_RECORD = {}  # 存放用户访问记录{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.VISIT_RECORD:
            self.VISIT_RECORD[ip] = [ctime, ]
            return True
        self.history = self.VISIT_RECORD.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])

频率功能源码分析

# SimpleRateThrottle
	- 源码里执行的频率类的allow_request,读SimpleRateThrottle的allow_request

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
	 # __init__,只要类实例化对象就会执行，一旦执行，self.rate就会有值，self.num_requests, self.duration也会有值
    def __init__(self):
        if not getattr(self, 'rate', None):
            # 在频率类中反射rate属性或方法，发现没有，返回None，就符合if判断，执行下面的代码
            self.rate = self.get_rate()  # 返回 '3/m'
        self.num_requests, self.duration = self.parse_rate(self.rate)
		# self.num_request=3	self.duration=60
  
    def get_rate(self):
        try:
            return self.THROTTLE_RATES[self.scope]  # 字典取值，配置文件中咱们配置的字典{'ss':'3/m',},根据'ss'获取到'3/m'
        except KeyError:
            msg = "No default throttle rate set for '%s' scope" % self.scope
            raise ImproperlyConfigured(msg)

    def parse_rate(self, rate):
        if rate is None:
            return (None, None)
        # rate:字符串'3/m'，根据 / 切分，切成了['3','m']
        # num=3,period=m
        num, period = rate.split('/')
        # num_requests=3 数字3
        num_requests = int(num)
        # period='m'--> period[0]-->'m'
        # {'s': 1, 'm': 60, 'h': 3600, 'd': 86400}[period[0]]
        # duration=60 
        duration = {'s': 1, 'm': 60, 'h': 3600, 'd': 86400}[period[0]]
        return (num_requests, duration) # 3 60

    def allow_request(self, request, view):
        if self.rate is None:
            return True
		# 我们自己写的返回什么就以什么做限制，我这里写的是返回IP地址
        # self.key=当前访问者的ip地址
        self.key = self.get_cache_key(request, view)
        if self.key is None:
            return True
        # self.history 访问者的时间列表，从缓存中拿到，如果拿不到就是空列表，如果之前有就是[时间2，时间1]

        self.history = self.cache.get(self.key, [])
        # 当前时间
        self.now = self.timer()

        while self.history and self.history[-1] <= self.now - self.duration:
            self.history.pop()
        if len(self.history) >= self.num_requests:
            return self.throttle_failure()
        return self.throttle_success()

'''
总结：以后要再写频率类，只要继承只需要继承SimpleRateThrottle，重写get_cache_key,配置类属性scope，配置文件中配置一下就可以
'''

分页功能

• 应用环境

  查询所有的接口才需要分页

• 小知识点

  分页后端的写法是固定的，但是前端展示形式是不一样的

  • pc端的点击下一页
  • app中，翻页是下拉加载更多

• drf中分页的使用

  1.写一个类，继承drf提供的三个分页类之一
  2.重写某几个类属性
  3.把它配置在继承了GenericAPIView+ListModelMixin的子视图类上
  4.如果是继承APIView，需要自己写
  	page = MyPageNumberPagination()
      res = page.paginate_queryset(qs, request)
  

  from rest_framework.pagination import PageNumberPagination, LimitOffsetPagination, CursorPagination
  
  
  class DPageNumberPagination(PageNumberPagination):  # 这个用的最多
      page_size = 2  # 每页显示的条数
      page_query_param = 'page'  # /books/?page=3 查询第几页的参数
      page_size_query_param = 'size'  # /books/?page=3&size=4  查询第三页，每页显示4条
      max_page_size = 10  # 限制通过size查询，最大条数
  
  
  class ELimitOffsetPagination(LimitOffsetPagination):
      default_limit = 3  # 每页显示的条数
      limit_query_param = 'page'  # /books/?limit=4  这一页显示4条数据
      offset_query_param = 'offset'  # /books/?offset=3&limit=4  从第3条开始，取4条数据
      max_limit = 5  # 限制最多显示多少条
  
  
  class FCursorPagination(CursorPagination):
      # 只能上一页和下一页，它的分页效率是最高的，，高于上面所有的分页方式，大数据量的分页，建议使用这种
      cursor_query_param = 'cursor'
      page_size = 3  # 每页显示条数
      ordering = 'id'  # 排序，必须是表中的字段
  
  

排序功能

• 应用环境

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

• drf中排序的使用

  # 必须是继承GenericAPIView+ListModelMixin的子视图类上
  1.配置排序类
  	filter_backends=[OrderingFilter,]
  2.配置排序的字段
  	ordering_fields=['id','price']
  3.支持前端的访问形式
  	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的子视图类上
  1.配置过滤类：
  	filter_backends=[SearchFilter,]
  2.配置过滤的字段
  	ordering_fields=['name','publish']
  3.支持前端的访问形式
  	http://127.0.0.1:8000/books/?search=三
  # 只要name中或publish中有三都能搜出来
  # 内置过滤类只能通过search写条件，如果配置了多个过滤字段，是或者的条件
  
   # 不够用：
  	-第三方：过滤类
      -自己写：自己写过滤类