DRF-源码解析-4.1-SimpleRateThrottle源码解析：SimpleRateThrottle源码解析，SimpleRateThrottle实现1/5m此类型的规则

一、限流类解析

from rest_framework.throlle import SimpleRateThrottle

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
	
    #1、初始化对象
    def __init__(self):
        #查看有无rate(限流规则)成员变量：1/m、1/s、1/h、1/d
        if not getattr(self, 'rate', None):
            #没有就去调用get_rate方法
            self.rate = self.get_rate()
        
        #解析限流规则：5/m ---> 5,60s
        self.num_requests, self.duration = self.parse_rate(self.rate)
	#4-1、获取唯一标识
    def get_cache_key(self, request, view):
       	#唯一标识，对请求中的什么进行限流
        raise NotImplementedError('.get_cache_key() must be overridden')
        
	#2、获从配置文件中获取限流规则
    def get_rate(self):
        #获取scope成员变量
        if not getattr(self, 'scope', None):
            msg = ("scope是必须配置的 '%s'" %
                   self.__class__.__name__)
            raise ImproperlyConfigured(msg)

        try:
            #从配置文件中，获取到scope 对应的限流规则
            return self.THROTTLE_RATES[self.scope]
        except KeyError:
            msg = "No default throttle rate set for '%s' scope" % self.scope
            raise ImproperlyConfigured(msg)
            
	#3、解析限流规则的
    def parse_rate(self, rate):
        if rate is None:
            return (None, None)
        num, period = rate.split('/')
        #解析出，限流规则的次数
        num_requests = int(num)
        #解析出，限流规则的总秒数
        duration = {'s': 1, 'm': 60, 'h': 3600, 'd': 86400}[period[0]]
        return (num_requests, duration)
	
    #4、判断是否超出限流的访问次数了
    def allow_request(self, request, view):
        if self.rate is None:
            return True
		#获取唯一标识：
        self.key = self.get_cache_key(request, view)
        if self.key is None:
            return True
		#拿到该唯一标识，存在cache中的访问时间列表
        self.history = self.cache.get(self.key, [])
        self.now = self.timer()
		#把不符合要求的访问时间点剔除：5/m 的规则，超过一分钟前访问的时间点都要剔除
        while self.history and self.history[-1] <= self.now - self.duration:
            self.history.pop()
        #判断符合要求的访问时间点列表长度，是否大于等于5
        if len(self.history) >= self.num_requests:
            #return False
            return self.throttle_failure()
        #return True
        return self.throttle_success()
	
    #4.3、返回True
    def throttle_success(self):
        #把当前请求的时间点插入到列表的第一位
        self.history.insert(0, self.now)
        self.cache.set(self.key, self.history, self.duration)
        return True
    
	#4.2、返回False
    def throttle_failure(self):
        return False
	
    #5、限流超过规则限制时，计算还需要等待的时间（秒）
    def wait(self):
        if self.history:
            remaining_duration = self.duration - (self.now - self.history[-1])
        else:
            remaining_duration = self.duration

        available_requests = self.num_requests - len(self.history) + 1
        if available_requests <= 0:
            return None

        return remaining_duration / float(available_requests)

在drf中：执行的流程:

• 先1，拿到所有限流对象
  • 在1中，要执行2，获取到限流规则：5/m
  • 在1中，要执行3，获取到解析后的限流规则：（5,60）
• 再4，判断此次请求是否可以进行访问
  • 在4中，先执行4.1，获取到唯一标识，
    • 通过唯一标识从cache中获取历史访问时间列表
    • 把超过1分钟前访问的时间点剔除掉
    • 判断符合要求的时间点列表长度是否大于等于5
  • 在4中，如果大于等于5，就执行4.2
  • 在4中，如果小于5，就执行4.3
• 如果上面return False，就会执行5
  • 获取还需要等待多少时间才能解除限流

二、实战使用

在实战中，我们可能需要是5分钟一次，或3分钟一次，或10s一次。在drf中，只支持n/m,n/s等限流规则，即不能实现5分钟n次，或5秒n等限流规则。

改造：支持2/3m 等限流规则

from rest_framework.throlle import SimpleRateThrottle
from rest_framework.throttling import SimpleRateThrottle
 
#重写了限制频率的方法，原始只能支持1/s,m,h,d , 不能支持5分钟一次，10秒中一次
class NewSimpleRateThrottle(SimpleRateThrottle):
    def parse_rate(self, rate):
        """
        这个方法，就是将2/10m 提取出2 和 10m
        计算出用户需要等待多少秒，才能再次访问的
        """
        if rate is None:
            return (None, None)
        num, period = rate.split('/') # 2/10m  10分钟两次请求
        dic = {'s': 1, 'm': 60, 'h': 3600, 'd': 86400}
        #1、计算需要等待的总秒数
        if len(period)>1:
            #这里，支持了1/5m,1/10s 等频率规则
            key = period[-1] #必须是s,m,h,d
            if key not in ('s','m','h','d'):
                raise Exception(f'流量控制设置的rate有问题，不能是{rate},格式：1/10m')
            try:
                period_num = int(period.split(key)[0])
            except Exception:
                raise Exception(f'流量控制设置的rate有问题，不能是{rate}，格式: 2/10m')
            #求出需要的等待的总时长，展示到前端时，还需要除以int(num)
            duration = dic[key]*period_num
        elif len(period) == 1:
            if period not in ('s','m','h','d'):
                raise Exception(f'流量控制设置的rate有问题，不能是{rate},格式：3/10m')
            #这里是对1/s,2/m,等的支持
            duration = dic[period]
        else:
            #排除掉 1/ 2/ 等错误的频率规则
            raise Exception(f'流量控制设置的rate有问题，不能是{rate}，格式：4/m')
        #2、除以整个数值，就是真实等待秒数
        try:
            num_requests = int(num)
        except Exception:
            raise Exception(f'流量控制设置的rate有问题，不能是{rate}，格式: 5/m')
        return (num_requests, duration)
 
 

流量控制：

#对请求源的IP进行限制
class IPThrottle(NewSimpleRateThrottle):
    # 在settings中配置频率时使用到的关键字，有scope来指定
    scope = 'IP'
    def get_cache_key(self, request, view):
        # 这里return什么，就以什么作为限制,上面的scope本来就是用于这里去配置文件中获取rate的
        return self.get_ident(request)+self.scope
    # 可以在这里设置访问频率
    def get_rate(self):
        return '10/m'
 
#对请求的用户进行限制
class UserThrottle(NewSimpleRateThrottle):
    scope = 'UserID'
 
    def get_cache_key(self, request, view):
        # 这里return什么，就以什么作为限制,上面的scope本来就是用于这里去配置文件中获取rate的
        user_pk = request.user.pk
        return user_pk+self.scope
 
    # 可以在这里设置访问频率,就无需到settings.py中设置了
    def get_rate(self):
        return '30/m'
 
#用户请求发送验证码的接口进行限制
class PhoneNumberThrottle(NewSimpleRateThrottle):
    #唯一标识的一部分
    scope = 'phoneNumber'
    #以什么作为唯一标识
    def get_cache_key(self, request, view):
        # 这里return什么，就以什么作为限制,上面的scope本来是用于这里去配置文件中获取rate的
        phone = request.data.get('phone')
        return phone+self.scope
    def get_rate(self):
        #设置1分钟一次
        return '1/5m'

三、配置

1、在settings.py中配置

####3、 drf的配置，全局配置
REST_FRAMEWORK = {
    #4、全局的使用的频率限制
    'DEFAULT_THROTTLE_CLASSES': (
        'base.throttle.IPThrottle', #使用的频率了

    ),
    #4.1、对于scope=IP的限制, 给每个限流类设置上规则
    'DEFAULT_THROTTLE_RATES': {
        'IP': '60/m',  # 一个ip一分钟只能访问60次  ，对频率进行限制
        'UserID':'30/m',
        'phoneNumber':'1/5m'
    },

}

2、不在settings.py中配置: 在限流类中实现get_rate方法，返回限流规则。（也可以设置类变量 rate=‘30/m’）

def get_rate(self):
    return '30/m'

总结：在settings.py中配置时规则时，无需重写get_rate方法。不在settings.py中配置规则时，需要重写get_rate方法。