权限
使用
权限是在认证之后，认证成功之后才控制权限。比如有些内容需要是vip可以查看，有些是超级vip可以查看。
from rest_framework.permissions import BasePermission
class MyPermission(BasePermission):
message = '无权限访问'
def has_permission(self, request, view):
user = User.objects.filter(name=request.user).first()
if user.get_level_display() == 'svip':
return True
return False
局部使用
class UserView(ModelViewSet):
permission_classes = [MyPermission]
queryset = User.objects.all()
serializer_class = UserSerializer
全局使用
REST_FRAMEWORK = {
'UNAUTHENTICATED_USER': None,
'UNAUTHENTICATED_TOKEN': None,
"DEFAULT_PERMISSION_CLASSES": [
"vue.utils.permission.MyPermission",
],
}
源码流程
频率控制
使用
自定义频率控制类
visit_dict = {}
import time
class MyThrottle(object):
"""一分钟3次"""
def __init__(self):
self.history = []
def allow_request(self, request, view):
remote_addr = request.META.get('REMOTE_ADDR')
ctime = int(time.time())
if remote_addr not in visit_dict:
visit_dict[remote_addr] = [ctime]
return True
else:
self.history = visit_dict[remote_addr]
while self.history and self.history[-1] < ctime - 60:
self.history.pop()
self.history.insert(0, ctime)
if len(self.history) <= 3:
return True
else:
return False
def wait(self):
"""
Optionally, return a recommended number of seconds to wait before
the next request.
"""
ctime = int(time.time())
return 60 - (ctime - self.history[-1])
在views.py中对应的视图中加上配置throttle_classes = [MyThrottle]即可。
继承内在限流类
上述MyThrottle的代码逻辑django restframework已经帮我们完成了相应的逻辑部分，我们只需要更改做相应配置。
例如我们要做一个匿名用户5/m，登录用户10/m，管理员无访问限制的功能。vue.utils.throttle.py中的代码
from rest_framework.throttling import SimpleRateThrottle
class AnnoThrottle(SimpleRateThrottle):
scope = 'anno'
def get_cache_key(self, request, view):
if not request.user:
return self.get_ident(request)
else:
# 返回None就表示不走这个节流类
return None
class UserThrottle(SimpleRateThrottle):
scope = 'user'
def get_cache_key(self, request, view):
if request.user and request.user != 'admin':
return request.user
else:
return None
views.py中的代码：
class UserView(ModelViewSet):
throttle_classes = [AnnoThrottle, UserThrottle]
queryset = User.objects.all()
serializer_class = UserSerializer
def throttled(self, request, wait):
# raise exceptions.Throttled(wait)
# 定制中文显示信息
class MyThrottle(exceptions.Throttled):
default_detail = '请求被限制'
extra_detail_plural = '还需要再等{wait}秒'
raise MyThrottle(wait)
django settings的配置
REST_FRAMEWORK = {
"DEFAULT_THROTTLE_RATES":{
'anno':'5/m',
'user':'10/m',
}
}
源码流程
节流大体流程
内置节流类流程
class BaseThrottle(object):
"""
Rate throttling of requests.
"""
def allow_request(self, request, view):
"""
Return `True` if the request should be allowed, `False` otherwise.
"""
raise NotImplementedError('.allow_request() must be overridden')
def get_ident(self, request):
"""
获取标识，其实就是获取ip
"""
xff = request.META.get('HTTP_X_FORWARDED_FOR')
remote_addr = request.META.get('REMOTE_ADDR')
num_proxies = api_settings.NUM_PROXIES
if num_proxies is not None:
if num_proxies == 0 or xff is None:
return remote_addr
addrs = xff.split(',')
client_addr = addrs[-min(num_proxies, len(addrs))]
return client_addr.strip()
return ''.join(xff.split()) if xff else remote_addr
def wait(self):
"""
Optionally, return a recommended number of seconds to wait before
the next request.
"""
return None
我们自定义的节流类用一个全局变量的字典存数据，restframework考虑的使用缓存来存这些访问信息，而且使用的是django默认的缓存。看一下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):
# 第1步：因为没有定义rate属性，走self.get_rate()
if not getattr(self, 'rate', None):
self.rate = self.get_rate()
# 第3步：得到限制次数和限制时间
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.
"""
# 第5步：必须被重写
raise NotImplementedError('.get_cache_key() must be overridden')
def get_rate(self):
"""
Determine the string representation of the allowed request rate.
"""
# 第2步：判断有没有定义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:
# 去 THROTTLE_RATES（api_settings.DEFAULT_THROTTLE_RATES）这个字典里根据key为
# scope去取访问频率，如 "10/m" 这样的字符串,如果返回None表示不限制
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:
<allowed number of requests>, <period of time in seconds>
"""
# 第3步: 返回限制次数和限制时间
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`.
"""
# 第4步：如果self.rate是None, 表示不限流
if self.rate is None:
return True
# 第5步：获取key，类似于我们自定义节流类获取的ip
self.key = self.get_cache_key(request, view)
# 第6步：如果想要不走这个节流类，就可以在自定义的get_cache_key返回None
# 这样就可以完全通过这个节流类了
if self.key is None:
return True
# 根据self.key去取访问信息,剩下的逻辑和自定义的节流类逻辑基本一致
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)
补充
self.initial(request, *args, **kwargs)中完成了四件事，版本，认证，权限和节流，在self.initial(request, *args, **kwargs)外层有try语句块来捕捉异常，所以从前到后，从版本到认证，从认证到权限，从权限到节流，四个环节的任何一个环节出现错误都会主动抛出异常(从源码就可以看出)，接下来的环节都不会执行，只有前面一个环节按照规定的走完才会走下一个环节。其实，这也是符合我们正常的开发逻辑的。只有先认证成功才会谈权限，只有有了不同权限才会有不同访问评率的说法