Title

自定义频率类

合集 - drf(15)
1.两个视图基类GenericAPIView,APIView2.5个视图扩展类3.权限4.认证5.drf自动生产路由6.9个视图子类7.drf8.django-simpleui使用9.djangorestframework-simplejwt使用10.drf过滤，排序，分页，异常处理
11.自定义频率类
12.drf视图13.drf频率的使用14.django高级15.python
收起

自定义频率类

class SuperThrottle(BaseThrottle):
    VISIT_RECORD = {}

    def __init__(self):
        self.history = None

    def allow_request(self, request, view):
        # 自己写逻辑，判断是否超频
        # （1）取出访问者ip
        # （2）判断当前ip不在访问字典里，添加进去，并且直接返回True,表示第一次访问，在字典里，继续往下走 {ip地址:[时间1，时间2，时间3，时间4]}
        # （3）循环判断当前ip的列表，有值，并且当前时间减去列表的最后一个时间大于60s，把这种数据pop掉，这样列表中只有60s以内的访问时间，
        # （4）判断，当列表小于3，说明一分钟以内访问不足三次，把当前时间插入到列表第一个位置，返回True，顺利通过
        # （5）当大于等于3，说明一分钟内访问超过三次，返回False验证失败
        # （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  = [时间1]
        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])

SimpleRateThrottle源码

# 写一个频率类，重写allow_request方法，在里面实现频率控制

# SimpleRateThrottle---》allow_request
    def allow_request(self, request, view):
		# 这里就是通过配置文件和scop取出 频率限制是多少，比如一分钟访问5此
        if self.rate is None:
            return True

        # 返回了ip，就以ip做限制
        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()
        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的init方法
    def __init__(self):
        if not getattr(self, 'rate', None):
            # self.rate= '5、h'
            self.rate = self.get_rate()
        # 5    36000
        self.num_requests, self.duration = self.parse_rate(self.rate)
# SimpleRateThrottle的get_rate() 方法
    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:
            #  self.scope 是 lqz 字符串
            # return '5/h'
            return self.THROTTLE_RATES[self.scope]
        except KeyError:
            msg = "No default throttle rate set for '%s' scope" % self.scope
            raise ImproperlyConfigured(msg)
            
            
#     SimpleRateThrottle的parse_rate 方法
	def parse_rate(self, rate):
        # '5/h'
        if rate is None:
            return (None, None)
        # num =5
        # period= 'hour'
        num, period = rate.split('/')
        # num_requests=5
        num_requests = int(num)
        duration = {'s': 1, 'm': 60, 'h': 3600, 'd': 86400}[period[0]]
        # (5,36000)
        return (num_requests, duration)

频率

 # 1 频率类
    - 写一个类，继承SimpleRateThrottle，重写get_cache_key，返回[ip，用户id]什么，就以什么做限制，编写类属性  scope = 字符串，在配置文件中配置
      'DEFAULT_THROTTLE_RATES': {
        '字符串': '3/m',
    }
    -配置在视图类，全局使用(配置在配置文件中)
    
    
# 2 自定义频率类
	-源码中找---》自定义频率类如何写---》写个类，重写allow_request，如果能访问就返回True，不能访问返回False
    -APIView---》dispatch---》
        def check_throttles(self, request):
            throttle_durations = []
            # 在视图类上配置的频率类的列表中一个个频率类的对象
            for throttle in self.get_throttles():
                if not throttle.allow_request(request, self):
                    throttle_durations.append(throttle.wait())

            if throttle_durations:
                durations = [
                    duration for duration in throttle_durations
                    if duration is not None
                ]
                duration = max(durations, default=None)
                self.throttled(request, duration)
# 3 自定义频率类
class MyThrottles():
    VISIT_RECORD = {} # 访问者 ip 字典，格式是{ip1:[时间4，时间3，时间2，时间1]，ip2:[时间，时间]，ip3:[当前时间]}
    def __init__(self):
        self.history = None
    def allow_request(self, request, view):
        # （1）取出访问者ip
        # print(request.META)
        ip = request.META.get('REMOTE_ADDR')
        import time
        ctime = time.time()
        # （2）判断当前ip不在访问字典里，添加进去，并且直接返回True,表示第一次访问
        if ip not in self.VISIT_RECORD:
            # {ip地址作为key:[当前时间，时间1，时间2，时间3]}
            self.VISIT_RECORD[ip] = [ctime, ]
            return True
        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])
    
    
    
# 3 SimpleRateThrottle源码分析
    -allow_request：必须有的，频率类，必须重写它
    -get_cache_key：没有具体实现，直接抛了异常，需要子类重写
    -wait：必须有的，返回一个数字，告诉前端，还有多长时间能访问
    -------都是为了给allow_request辅助的-----
    get_rate
    parse_rate
    throttle_failure
    throttle_success
    
   
def allow_request(self, request, view):
        if self.rate is None: # 要取init中看,self.rate=3/m,如果自己在频率类中写rate=5/m,我们就不需要写scope和配置文件了
            return True
        # get_cache_key返回了ip：192.168.1.19
        self.key = self.get_cache_key(request, view)
        if self.key is None: # 如果get_cache_key返回None，也不会做频率限制
            return True
        # self.history = self.VISIT_RECORD.get(self.key, [])
        # self.cache 是缓存，相当于咱们的self.VISIT_RECORD
        self.history = self.cache.get(self.key, [])
        self.now = self.timer()# 取出当前时间
        # self.duration：配置的1分钟访问3次，self.duration就是60
        while self.history and self.history[-1] <= self.now - self.duration:
            self.history.pop()
        if len(self.history) >= self.num_requests: # '5/m',num_requests就是5
            return self.throttle_failure()
        return self.throttle_success()

# __init__    
def __init__(self):
  if not getattr(self, 'rate', None): # 如果没有，执行下面的代码
      self.rate = self.get_rate()  
  self.num_requests, self.duration = self.parse_rate(self.rate)

# self.get_rate()  
    def get_rate(self):
        # self.scope  我们自己写的字符串
        # self.THROTTLE_RATES配置文件中的那个字典
        return self.THROTTLE_RATES[self.scope]  # 咱们配置的 3/m
# self.num_requests, self.duration = self.parse_rate(self.rate)---》self.rate是3/s
    def parse_rate(self, rate):
        if rate is None:
            return (None, None)
        # 3/m---->num=3,period=m
        num, period = rate.split('/')
        # num_requests=数字3
        num_requests = int(num)
        # 
        d={'s': 1, 'm': 60, 'h': 3600, 'd': 86400}
        period[0]='m'
        d[m]
        duration = {'s': 1, 'm': 60, 'h': 3600, 'd': 86400}[period[0]]
        return (num_requests, duration)
posted @   哈哈哈哼  阅读(14)  评论(0)  编辑  收藏  举报
相关博文：
· drf频率的使用
· python
· 自定义与内置频率类
· drf之频率类源码
· 自定制频率
阅读排行：
· 震惊！C++程序真的从main开始吗？99%的程序员都答错了
· 别再用vector＜bool＞了！Google高级工程师：这可能是STL最大的设计失误
· 单元测试从入门到精通
· 【硬核科普】Trae如何「偷看」你的代码？零基础破解AI编程运行原理
· 上周热点回顾（3.3-3.9）
点击右上角即可分享
微信分享提示