- RESTful 规范
- django rest framework 之 认证（一）
- django rest framework 之 权限（二）
- django rest framework 之 节流（三）
- django rest framework 之 版本（四）
- django rest framework 之 解析器（五）
- django rest framework 之 序列化（六）
- django rest framework 之 分页（七）
- django rest framework 之 视图（八）
一、节流
1、简介
节流又叫限流，限制访问。就是通常一个用户在多次请求一个页面，或者点击一个链接的时候，前几次点击是没有问题的，但是一旦连续几次之后，就会出现访问受限，离下一次访问还有50秒等的字样，在django rest framework 中有一个专门的组件来做限制访问。
2、思路
一旦一个用户向资源发送请求，那么根据用户的身份就有两种情况，匿名用户和认证用户。那么根据用户的身份怎么做限制访问？就是要找到用户的唯一标识。
- 匿名用户：对于匿名用户，唯一能用来标识的只有请求的IP。
- 认证用户：认证用户的用户名，或者用户ID等。
用户标识的问题解决了，假设设置的是每分钟只能访问5次，也就是5次/min。当用户发送请求，可以拿到用户的唯一标识，判断用户是第几次访问。有下面几种情况：
- 第一到五次：这是可以通过的，返回资源。
一分钟之内- 第六次：请求被禁止，并返回提示信息。
一分钟之后 - 第六次：请求别允许，返回资源。
- 第六次：请求被禁止，并返回提示信息。
根据上面的情况可以得出以下思路：
当一个用户发送请求的时候，我可以在缓存(django rest framework就是这么做的)中生成一个字典，字典的键值对分别是用户的唯一标识和用户的访问时间，例如下面：
VISIT_RECORD = {
'weilan': [127,125， 121，110，89，68] # 标识第一次访问时间是68秒，第二次访问时间是89秒，第三次访问时间是110秒
}
第一步：当一个用户第一次发送请求的时候，缓存VISIT_RECORD中没有他的键，就会添加一个键是他的表示，值是一个列表，列表中存放他的第一次访问时间为t1。
第二步：当再次发送请求的时候，会先在缓存VISIT_RECORD中找有没有他的键，如果没有，会返回第一步。如果有，取出列表，查看列表中的最后一次访问值T1，并与本次访问时间Tn比较，如果Tn-T1>60s，则将T1删除，如果Tn-T1<60s，则保留T1，因为要保证一分钟之内的访问次数。
第三步：判断当前列表中保存的时间的个数，如果小于5个，说明一分钟之内还没有访问5次，将但访问时间Tn插入到列表头。如果个数超过5个，则说明一分钟已经访问过5次，本次访问已经是第6次，则不插人列表。
这样根据思路就可以写出下面限流类：
import time
VISIT_RECORD = {} # 这里再内存中生成，可以写入缓存
class VisitThrottle(BaseThrottle):
def __init__(self):
self.history = None
def allow_request(self,request,view):
# 1. 获取用户IP 或者认证用户的用户名
remote_addr = self.get_ident(request)
ctime = time.time()
if remote_addr not in VISIT_RECORD: # 判断是否有访问记录
VISIT_RECORD[remote_addr] = [ctime,]
return True
history = VISIT_RECORD.get(remote_addr)
self.history = history
while history and history[-1] < ctime - 60: # 计算出本次访问时间与最远一次访问的时间差
history.pop()
if len(history) < 5:
history.insert(0,ctime)
return True
# return True # 表示可以继续访问
# return False # 表示访问频率太高，被限制
def wait(self):
# 还需要等多少秒才能访问
ctime = time.time()
return 60 - (ctime - self.history[-1])
二、示例
1、目录结构
同样的我们向认证，权限那样再utils包中定义限流组件
2、具体限制访问
对于匿名用户和认证用户做不同的限制访问
from rest_framework.throttling import BaseThrottle,SimpleRateThrottle
class VisitThrottle(SimpleRateThrottle):
scope = "anonymous"
def get_cache_key(self, request, view):
return self.get_ident(request)
class UserThrottle(SimpleRateThrottle):
scope = "user"
def get_cache_key(self, request, view):
return request.user.username
3、配置限流类
可以再setting.py文件中全局配置，也可以再视图中重写，局部配置，但是访问频率，需要限流类的scope属性定义。
对于匿名用户，每分钟访问5次，认证用户，每分钟5次
REST_FRAMEWORK = {
"DEFAULT_THROTTLE_CLASSES":["api.utils.throttle.UserThrottle"],
"DEFAULT_THROTTLE_RATES":{
"anonymous":'5/m',
"user":'10/m',
}
}
4、视图
from rest_framework.views import APIView
class UserInfoView(APIView):
authentication_classes = []
permission_classes = []
throttle_classes = [throttle.VisitThrottle] # 标识匿名用户访问
def get(self, request, *args, **kwargs):
print(request.META.get('REMOTE_ADDR')) # 这里可以获取到访问的IP
return HttpResponse('访问成功')
5、请求测试
使用postman或者浏览器发送请求
一分钟连续发送5次，正常
发送第6次时，访问受限
三、源码分析
像django rest framework 之 认证一样进入，request的请求流程，进入源码查看具体权限的操作
1、进入dispath()方法
2、进入initial()方法
3、进入check_throttles()方法
4、获取限流类
获取限流类之后并实例化成对象，使得可以调用具体的方法
同样的默认的是通过全局配置
5、原生的限流类
在rest framework中也有相应的限流类，主要使用SimpleRateThrottle，因为在SimpleRateThrottle中的一些方法已经是实现了我们需要的逻辑
来看一下SimpleRateThrottle具体做了什么
class SimpleRateThrottle(BaseThrottle):
cache = default_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): # 需要返回请求发情用户的唯一标识
raise NotImplementedError('.get_cache_key() must be overridden')
def get_rate(self): # scope属性需要在节流类和配置文件中定义，才能达到节流的效果
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): # 解析配置文件中的时间等
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): # 这与上面节流的操作相似，是具体的逻辑
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()
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):
self.history.insert(0, self.now)
self.cache.set(self.key, self.history, self.duration)
return True
def throttle_failure(self): # 请求失败的时候
return False
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)
以上就是节流的流程和源码分析
四、总结
节流同样可以通过全局配置和局部配置的方法，影响视图。
值得注意的是，有一个必须要重写的接口get_cache_key()
- 当匿名用户的时候，返回值是匿名用户的IP
- 当为认证用户的时候，可以是用户的任何唯一标识。
因为在VISIT_RECORD中的键是唯一的。
scope定义了具体一个节流类怎么节流，在setting.py文件和节流类中都需要定义。SimpleRateThrottle中的parse_rate()方法对scope进行了解析
- "user":'1/s', 表示一秒访问一次
- "user":'1/m', 表示一分钟访问一次
- "user":'1/h', 表示一小时访问一次
- "user":'1/d', 表示一天访问一次