Drf从入门到精通七（自定义频率类、频率源码分析、分页、排序、过滤功能）

一、自定义频率类

方式一:
	from rest_framework.throttling import BaseThrottle, SimpleRateThrottle

	class MyThrottling(SimpleRateThrottle):     # 继承SimpleRateThrottle
	    scope = 'luffy'     # 类属性 属性名称可以随意取 但是要跟配置文件对应
	
	    def get_cache_key(self, request, view):
	        return request.META.get('REMOTE_ADDR')
	
	    '''
	        返回什么 频率就可以做什么限制
	        通过用户IP地址进行限制 REMOTE_ADDR
	    '''
	 
方式二:
	class MyThrottling(BaseThrottle):
	    data_IP = {}  # 存放IP的列表
	    ip = None  # 默认None
	
	    def allow_request(self, request, view):
	        ip = request.META.get('REMOTE_ADDR')
	        self.ip = ip  # 获取到传来的IP 保存至IP
	
	        if ip not in self.data_IP:  # 判断IP是否存在 如果不存在添加进去
	            self.data_IP[ip] = []  # 将IP作为K 时间作为V
	            self.data_IP[ip].append(time.time())
	            return True  # 第一次访问返回
	        print(self.data_IP)
	
	        while True:  # 循环判断当前IP列表 用当前时间去减掉列表最后一位时间大于60 Pop
	            if time.time() - self.data_IP[ip][-1] > 60:  # -1最后一位 >60
	                self.data_IP[ip].pop()
	            break
	
	        print(self.data_IP)
	
	        if len(self.data_IP[ip]) > 3:  # 判断当前IP列表访问时间是否超过三次 超过返回False
	            return False
	        else:
	            self.data_IP[ip].insert(0, time.time())  # 没超过 把当前时间插入到IP访问时间列表第一位 返回True
	            return True
	            
方式三:
	class OneThrottles(BaseThrottle):
	    VISIT_RECORD = {}       # 创建访问字典
	
	    def __init__(self):
	        self.history = None
	
	    def allow_request(self, request, view):         # 重写allow_request
	        ip = request.META.get('REMOTE_ADDR')        # 取出访问者的IP
	        import time
	        ctime = time.time()                         # 获取当前访问时间
	
	        if ip not in self.VISIT_RECORD:             # 判断当前IP是否在访问字典里面 如果不在则添加进去
	            self.VISIT_RECORD[ip] = [ctime, ]
	            return True                             # 直接返回True 表示第一次访问
	        self.history = self.VISIT_RECORD.get(ip)
	        while self.history and ctime-self.history[-1] > 60:     # 循环当前访问字典 减去最后一位时间大于60的pop
	            self.history.pop()
	        if len(self.history) < 3:                   # 判断当前字典小于3次
	            self.history.insert(0, ctime)           # 如果反问超过三次 把当前时间放到第一位 返回False
	            return True
	        else:
	            return False
	
	    def wait(self):
	        ctime = time.time()
	        return 60-(ctime-self.history[-1])          # 过60秒减去访问记录最后一条

二、频率功能源码分析

# 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
    def __init__(self):  # 只要类实例化得到对象就会执行，一执行，self.rate就有值了，而且self.num_requests和self.duration
        if not getattr(self, 'rate', None): # 去频率类中反射rate属性或方法，发现没有，返回了None，这个if判断就符合，执行下面的代码
            self.rate = self.get_rate()  #返回了  '3/m'
        #  self.num_requests=3
        #  self.duration=60
        self.num_requests, self.duration = self.parse_rate(self.rate)

    def get_rate(self):
         return self.THROTTLE_RATES[self.scope] # 字典取值，配置文件中咱们配置的字典{'ss': '3/m',}，根据ss取到了 '3/m'

    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]]
        # 3     60
        return (num_requests, duration)

    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，配置文件中配置一下就可以了

三、分页功能

'''
	分页功能 首先是查询多条数据一页展示太多 用分页来真是较为美观
	分页类型总共有三种 PageNumberPagination, LimitOffsetPagination, CursorPagination
	分页的模型类需要继承GenericAPIView+ListModelMixin的子视图类上 否则不能使用
	如果继承的是APIView，需要自己写
	page = MyPageNumberPagination()
	res = page.paginate_queryset(qs, request)
'''

models.py
	class Movie(models.Model):		# 表模型
	    name = models.CharField(max_length=32)
	    price = models.IntegerField(max_length=32)
	    author = models.CharField(max_length=32)

page.py		# 自定义分页类的文件
	from rest_framework.pagination import PageNumberPagination, LimitOffsetPagination, CursorPagination

	class MyPageNumberPagination(PageNumberPagination):	
	    page_size = 3                   # 每页展示的条数
	    page_query_param = 'page'       # 查询第几页的参数名称  /movies/?page=2
	    page_size_query_param = 'size'  # /movies/?page=2&size=4    查询第二页每页显示4条
	    max_page_size = 5               # 限制通过size查询 最大条数 一页最大查询5条
	
	
	class MyLimitOffsetPagination(LimitOffsetPagination):
	    default_limit = 2               # 每页展示的条数
	    limit_query_param = 'limit'     # /movies/?limit=4  这一页显示4条数据
	    offset_query_param = 'offset'   # /movies/?offset=2&limit=4  查询第二页每页显示4条
	    max_limit = 5                   # 限制通过size查询 最大条数 一页最大查询5条
	
	
	class MyCursorPagination(CursorPagination):
	    cursor_query_param = 'cursor'   # 只能上一页下一页 不能通过控制去到那一页 它分页效率是最高的 大量的分页建议使用这种
	    page_size = 3                   # 每页展示的条数
	    ordering = 'id'                 # 排序 必须是表中的字段

view.py
	from .page import MyPageNumberPagination, LimitOffsetPagination, CursorPagination
	
	class MovieView(ViewSetMixin, ListAPIView, CreateModelMixin):
	    pagination_class = MyPageNumberPagination  	# 配置分页类		
	    # pagination_class = LimitOffsetPagination  # 配置分页类
	    # pagination_class = CursorPagination  		# 配置分页类
	    
	    queryset = Movie.objects.all()			
	    serializer_class = MovieSerializer

四、排序功能

'''
	跟分页功能一样 涉及到查询所有才有排序 其他接口都不需要
	
	想使用到排序功能需要导入rest_framework.filter中的 OrderingFilter
	排序的模型类需要继承GenericAPIView+ListModelMixin的子视图类上 否则不能使用
	如果继承的是APIView，需要自己写 需要自己从请求地址中取出排序规则，自己排序
	-'price','-id'=reqeust.query_params.get('ordering').split(',')
    -qs = Book.objects.all().order_by('price','-id')
	
	分页和排序可以一起使用 但是是先排序后分页的
	
'''
views.py
	from rest_framework.filters import OrderingFilter, SearchFilter
	
	class MovieView(ViewSetMixin, ListAPIView, CreateModelMixin):
	    pagination_class = MyPageNumberPagination  # 分页类
	    
	    queryset = Movie.objects.all()
	    serializer_class = MovieSerializer
	
	    filter_backends = [OrderingFilter]      # 排序类的配置
	    ordering_fields = ['id', 'price']       # 指定按照那个字段排序
	
	'''
		前端访问需要用到关键字?ordering=price
   		http://127.0.0.1:8000/movies/?ordering=price
	'''

五、过滤功能

'''
	跟分页功能一样 涉及到查询所有才有排序 其他接口都不需要
	restful规范中有一条 请求地址中带过滤条件：分页、排序、过滤统称为过滤
	过滤的模型类需要继承GenericAPIView+ListModelMixin的子视图类上 否则不能使用
'''

views.py
	from rest_framework.filters import OrderingFilter, SearchFilter
	
	class MovieView(ViewSetMixin, ListAPIView, CreateModelMixin):
	    pagination_class = MyPageNumberPagination  # 分页类
	    
	    queryset = Movie.objects.all()
	    serializer_class = MovieSerializer

		filter_backends = [SearchFilter]          # 排序类的配置
	    search_fields = ['name', 'author']      # 指定过滤字段
	
	    # 前端访问需要用到关键字?search=七
	    # http://127.0.0.1:8000/movies/?search=L
	
	    '''
	        如果是指定两个过滤字段 搜索的关系是 or 不是and
	        只要名字中带有L 就符合要求
	    '''