drf 频率过滤与排序组件

drf 频率过滤与排序组件

频率组件

• 控制用户对某个url请求的频率

内置频率类

BaseThrottle是所有类的基类：方法：**def get_ident(self, request)**获取标识，其实就是获取ip，自定义的需要继承它

AnonRateThrottle：未登录用户ip限制，需要配合auth模块用，使用DEFAULT_THROTTLE_RATES[‘anno’],来设置频次

SimpleRateThrottle：重写此方法，可以实现频率现在，不需要咱们手写上面自定义的逻辑

UserRateThrottle:登录用户频率限制，这个得配合auth模块来用,使用DEFAULT_THROTTLE_RATES[‘user’],来设置频次

ScopedRateThrottle：应用在局部视图上的,限制用户对每个视图的访问频次

全局配置与使用

# settings中  限制未登录用户一分钟访问3次
REST_FRAMEWORK = {
    'DEFAULT_THROTTLE_CLASSES': (
        'rest_framework.throttling.AnonRateThrottle',
    ),
    'DEFAULT_THROTTLE_RATES': {
        'anon': '3/m',
    }
}

# views.py
class TestView3(APIView):
    permission_classes = []
    authentication_classes = []

    def get(self, request, *args, **kwargs):
        return Response('这是测试数据3 ')

局部配置与使用

注意: 局部使用，settings配置文件中需要配置DEFAULT_THROTTLE_RATES

# settings.py
REST_FRAMEWORK = {
    'DEFAULT_THROTTLE_RATES': {
        'anon': '3/m',   # 这里必须是anon
    }
}

# views.py
class TestView4(APIView):
    permission_classes = []
    authentication_classes = []
    throttle_classes = [AnonRateThrottle]

    def get(self, request, *args, **kwargs):
        return Response('这是测试数据4 ')

限制登录用户的访问频次

# 未登录用户1分钟访问5次，登录用户一分钟访问10次
# THROTTLE_CLASSES和THROTTLE_RATES中是一对一对应的
全局：在setting中
  'DEFAULT_THROTTLE_CLASSES': (
        'rest_framework.throttling.AnonRateThrottle',
        'rest_framework.throttling.UserRateThrottle'
    ),
    'DEFAULT_THROTTLE_RATES': {
        'user': '10/m',
        'anon': '5/m',
    }

局部配置
	在视图类中，配置即可       

自定义限制类

# 自定制频率类，需要写两个方法
	-# 判断是否限次：没有限次可以请求True，限次了不可以请求False
    	def allow_request(self, request, view):
    -# 限次后调用，显示还需等待多长时间才能再访问，返回等待的时间seconds
    	def wait(self):
            
# 代码
import time
class IPThrottle():
    #定义成类属性,所有对象用的都是这个
    VISIT_DIC = {}
    def __init__(self):
        self.history_list=[]
    def allow_request(self, request, view):
        '''
        #（1）取出访问者ip
        #（2）判断当前ip不在访问字典里，添加进去，并且直接返回True,表示第一次访问，在字典里，继续往下走
        #（3）循环判断当前ip的列表，有值，并且当前时间减去列表的最后一个时间大于60s，把这种数据pop掉，这样列表中只有60s以内的访问时间，
        #（4）判断，当列表小于3，说明一分钟以内访问不足三次，把当前时间插入到列表第一个位置，返回True，顺利通过
        #（5）当大于等于3，说明一分钟内访问超过三次，返回False验证失败
        '''

        ip=request.META.get('REMOTE_ADDR')
        ctime=time.time()
        if ip not in self.VISIT_DIC:
            self.VISIT_DIC[ip]=[ctime,]
            return True
        self.history_list=self.VISIT_DIC[ip]   #当前访问者时间列表拿出来
        while True:
            if ctime-self.history_list[-1]>60:
                self.history_list.pop() # 把最后一个移除
            else:
                break
        if len(self.history_list)<3:
            self.history_list.insert(0,ctime)
            return True
        else:
            return False

    def wait(self):
        # 当前时间，减去列表中最后一个时间
        ctime=time.time()

        return 60-(ctime-self.history_list[-1])

SimpleRateThrottle源码分析

    def get_rate(self):
        if not getattr(self, 'scope', None):
            msg = ("You must set either `.scope` or `.rate` for '%s' throttle" %
                   self.__class__.__name__)
            raise ImproperlyConfigured(msg)

        try:
            return self.THROTTLE_RATES[self.scope]  # scope：'user' => '3/min'
        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)
        #3  mmmmm
        num, period = rate.split('/')  # rate：'3/min'
        num_requests = int(num)
        duration = {'s': 1, 'm': 60, 'h': 3600, 'd': 86400}[period[0]]
        return (num_requests, duration)
    def allow_request(self, request, view):
        if self.rate is None:
            return True
        #当前登录用户的ip地址
        self.key = self.get_cache_key(request, view)  # key：'throttle_user_1'
        if self.key is None:
            return True

        # 初次访问缓存为空，self.history为[]，是存放时间的列表
        self.history = self.cache.get(self.key, [])
        # 获取一下当前时间，存放到 self.now
        self.now = self.timer()

        # Drop any requests from the history which have now passed the
        # throttle duration

        # 当前访问与第一次访问时间间隔如果大于60s，第一次记录清除，不再算作一次计数
        # 10 20 30 40
        # self.history:[10:23,10:55]
        # now:10:56
        while self.history and  self.now - self.history[-1] >= self.duration:
            self.history.pop()

        # history的长度与限制次数3进行比较
        # history 长度第一次访问0，第二次访问1，第三次访问2，第四次访问3失败
        if len(self.history) >= self.num_requests:
            # 直接返回False，代表频率限制了
            return self.throttle_failure()

        # history的长度未达到限制次数3，代表可以访问
        # 将当前时间插入到history列表的开头，将history列表作为数据存到缓存中，key是throttle_user_1，过期时间60s
        return self.throttle_success()

根据ip进行频率限制

# 写一个类，继承SimpleRateThrottle，只需要重写get_cache_key 
from rest_framework.throttling import SimpleRateThrottle

# 继承SimpleRateThrottle
class MyThrottle(SimpleRateThrottle):
    def get_cache_key(self, request, view):
        return request.META.get('REMOTE_ADDR')  # 返回
    
全局配置和局部配置
REST_FRAMEWORK = {
    'DEFAULT_THROTTLE_CLASSES': (
        'app01.app_auth.MyThrottle'
    ),
    'DEFAULT_THROTTLE_RATES': {
        'luffy': '3/m',  # key要跟类中的scop对应
    }
}

过滤组件(Filtering)

• 对于列表数据可能需要根据字段进行过滤，可以通过添加django-fitlter扩展来增强支持。

pip install django-filter

使用:

1. 在app中注册
2. 全局配，或者局部配置
REST_FRAMEWORK = {
	 'DEFAULT_FILTER_BACKENDS': ('django_filters.rest_framework.DjangoFilterBackend',)}

from django_filters.rest_framework import DjangoFilterBackend
FILTER_BACKENDS=[DjangoFilterBackend]
        
3. 视图类  # 需要继承GenericAPIView才能使用，通常用户继承ListAPIView使用
class BookView(ListAPIView): 
    queryset = Book.objects.all()
    serializer_class = BookSerializer
    filter_fields = ('name',)  # 配置可以按照指定字段来过滤        

排序组件

对于列表数据，REST framework提供了OrderingFilter过滤器来帮助我们快速指明数据按照指定字段进行排序。

使用方法：

在类视图中设置filter_backends，使用rest_framework.filters.OrderingFilter过滤器，REST framework会在请求的查询字符串参数中检查是否包含了ordering参数，如果包含了ordering参数，则按照ordering参数指明的排序字段对数据集进行排序。

前端可以传递的ordering参数的可选字段值需要在ordering_fields中指明。

class StudentListView(ListAPIView):
    queryset = Student.objects.all()
    serializer_class = StudentModelSerializer
    filter_backends = [OrderingFilter]
    ordering_fields = ('id', 'age')

# 127.0.0.1:8000/books/?ordering=-age 
# 必须是ordering=某个值
# -id 表示针对id字段进行倒序排序
# id  表示针对id字段进行升序排序

如果需要在过滤以后再次进行排序，则需要两者结合!

from rest_framework.generics import ListAPIView
from students.models import Student
from .serializers import StudentModelSerializer
from django_filters.rest_framework import DjangoFilterBackend #需要使用一下它才能结合使用
class Student3ListView(ListAPIView):
    queryset = Student.objects.all()
    serializer_class = StudentModelSerializer
    filter_fields = ('age', 'sex')
    # 因为filter_backends是局部过滤配置，局部配置会覆盖全局配置,所以需要重新把过滤组件核心类再次声明,
    # 否则过滤功能会失效
    filter_backends = [OrderingFilter,DjangoFilterBackend]
    ordering_fields = ('id', 'age')
    
    
    # 针对的是继承的类中的list方法
    
# 127.0.0.1:8000/books/?sex=1&ordering=-age