频率组件

-使用：

　　-第一步，写一个频率类，继承SimpleRateThrottle

　　　　#重写get_cache_key，返回self.get_ident(request)

　　　　#一定要记住配置一个scop=字符串

class Throttle(SimpleRateThrottle):　　scope = 'lxx'　　def get_cache_key(self, request, view):　　return self.get_ident(request)

 

　　-第二步：在setting中配置

　　　　

REST_FRAMEWORK = {'DEFAULT_THROTTLE_RATES':{'lxx':'3/m'}}

 

-局部使用

　　-在视图类中配置：

　　-throttle_classes=[Throttle,]

-全局使用

　　-在setting中配置

　　'DEFAULT_THROTTLE_CLASSES':['自己定义的频率类'],

-局部禁用

　　throttle_classes=[]

频率组件分析：

-核心源代码：

def check_throttles(self, request):　　for throttle in self.get_throttles():　　　　if not throttle.allow_request(request, self):　　　　　　self.throttled(request, throttle.wait())

 

-自定义的频率类：详解代码views.py 25行开始

#自定义频率类class MyThrottle(BaseThrottle):    VISIT_RECORD = {}    def __init__(self):        self.history=None    def allow_request(self,request,view):  #  校验是否可以访问        #自定义控制每分钟访问多少次，运行访问返回true，不允许访问返回false        # （1）取出访问者ip{ip1:[第二次访问时间，第一次访问时间],ip2:[]}        # （2）判断当前ip不在访问字典里，如果不在添加进去，并且直接返回True,表示第一次访问，在字典里，继续往下走        # （3）循环判断当前ip的列表，有值，并且当前时间减去列表的最后一个时间大于60s，把这种数据pop掉，这样列表中只有60s以内的访问时间，        # （4）判断，当列表小于3，说明一分钟以内访问不足三次，把当前时间插入到列表第一个位置，返回True，顺利通过        # （5）当大于等于3，说明一分钟内访问超过三次，返回False验证失败        # （1）取出访问者ip        # print(request.META)        #取出访问者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        #是个当前访问者ip对应的时间列表 [第一次访问的时间，]        self.history = self.VISIT_RECORD.get(ip)        # （3）循环判断当前ip的列表，有值，并且当前时间减去列表的最后一个时间大于60s，把这种数据pop掉，这样列表中只有60s以内的访问时间，        while self.history and ctime - self.history[-1] > 60:            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])class Books(APIView):    # throttle_classes=[Throttle,]    throttle_classes=[MyThrottle,]    def get(self,request):        return Response('')

 

-SimpleRateThrottle源码

class SimpleRateThrottle(BaseThrottle):    """    A simple cache implementation, that only requires `.get_cache_key()`    to be overridden.    The rate (requests / seconds) is set by a `rate` attribute on the View    class.  The attribute is a string of the form 'number_of_requests/period'.    Period should be one of: ('s', 'sec', 'm', 'min', 'h', 'hour', 'd', 'day')    Previous request information used for throttling is stored in the cache.    """    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):        if not getattr(self, 'rate', None):            self.rate = self.get_rate()        self.num_requests, self.duration = self.parse_rate(self.rate)    def get_cache_key(self, request, view):        """        Should return a unique cache-key which can be used for throttling.        Must be overridden.        May return `None` if the request should not be throttled.        """        raise NotImplementedError('.get_cache_key() must be overridden')    def get_rate(self):        """        Determine the string representation of the allowed request rate.        """        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]        except KeyError:            msg = "No default throttle rate set for '%s' scope" % self.scope            raise ImproperlyConfigured(msg)    def parse_rate(self, rate):        """        Given the request rate string, return a two tuple of:        
     
      , 
      
               """        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)    def allow_request(self, request, view):        """        Implement the check to see if the request should be throttled.        On success calls `throttle_success`.        On failure calls `throttle_failure`.        """        if self.rate is None:            return True        self.key = self.get_cache_key(request, view)        if self.key is None:            return True        self.history = self.cache.get(self.key, [])        self.now = self.timer()        # Drop any requests from the history which have now passed the        # throttle duration        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()    def throttle_success(self):        """        Inserts the current request's timestamp along with the key        into the cache.        """        self.history.insert(0, self.now)        self.cache.set(self.key, self.history, self.duration)        return True    def throttle_failure(self):        """        Called when a request to the API has failed due to throttling.        """        return False    def wait(self):        """        Returns the recommended next request time in seconds.        """        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)