权限组件(要么全用内置得要么全用自定义得，不能混合使用)
源码分析
# APIView---->dispatch---->initial--->self.check_permissions(request)(APIView的对象方法)
def check_permissions(self, request):
# 遍历权限对象列表得到一个个权限对象(权限器)，进行权限认证
for permission in self.get_permissions():
# 权限类一定有一个has_permission权限方法，用来做权限认证的
# 参数：权限对象self、请求对象request、视图类对象
# 返回值：有权限返回True，无权限返回False
if not permission.has_permission(request, self):
self.permission_denied(
request, message=getattr(permission, 'message', None)
)
自定义权限使用
# 写一个类，继承BasePermission，重写has_permission，如果权限通过，就返回True，不通过就返回False
from rest_framework.permissions import BasePermission
class UserPermission(BasePermission):
def has_permission(self, request, view):
# 不是超级用户，不能访问
# 由于认证已经过了，request内就有user对象了，当前登录用户
user=request.user # 当前登录用户
# 如果该字段用了choice，通过get_字段名_display()就能取出choice后面的中文
print(user.get_user_type_display())
if user.user_type==1:
return True
else:
return False
# 局部使用
class TestView2(APIView):
permission_classes = [app_auth.UserPermission]
# 全局使用
REST_FRAMEWORK={
"DEFAULT_AUTHENTICATION_CLASSES":["app01.app_auth.MyAuthentication",],
'DEFAULT_PERMISSION_CLASSES': [
'app01.app_auth.UserPermission',
],
}
# 局部禁用
class TestView2(APIView):
permission_classes = []
内置权限使用（了解）
# 内置权限的使用：IsAdminUser，控制是否对网站后台有权限的人
# 1 创建超级管理员
# 2 写一个测试视图类
from rest_framework.permissions import IsAdminUser # 内置权限组件
from rest_framework.authentication import SessionAuthentication # 使用内置得认证组件
class TestView(APIView):
# 局部配置
authentication_classes = [SessionAuthentication]
permission_classes = [IsAdminUser]
def get(self, request):
return APIResponse(message='使用内置认证组件才能访问')
# 3 超级管理员登录到admin，再访问test就有权限
# 4 普通管理员，没有查看或修改admin后台管理的权限只有访问test的权限（根据auth_user表中的is_staff字段来判断）
频率组件
自定义频率组件
# 自定制频率类，需要写两个方法
-# 判断是否限次：没有限次可以请求True，限次了不可以请求False
def allow_request(self, request, view):
-# 限次后调用，显示还需等待多长时间才能再访问，返回等待的时间seconds
def wait(self):
# 代码
import time
# 可以不继承BaseThrottle，因为是鸭子类型
class IPThrottle():
#定义成类属性,所有对象用的都是这个
VISIT_DIC = {}
def __init__(self):
# 每个ip的时间列表都是各自独立的
self.history_list=[]
def allow_request(self, request, view):
'''
#（1）取出访问者ip
#（2）判断当前ip不在访问字典里，添加进去，并且直接返回True,表示第一次访问，在字典里，继续往下走
#（3）循环判断当前ip的列表，有值，并且当前时间减去列表的最后一个时间大于60s，把这种数据pop掉，这样列表中只有60s以内的访问时间，
#（4）判断，当列表小于3，说明一分钟以内访问不足三次，把当前时间插入到列表第一个位置，返回True，顺利通过
#（5）当大于等于3，说明一分钟内访问超过三次，返回False验证失败
'''
ip=request.META.get('REMOTE_ADDR') # 获取ip
ctime=time.time()
if ip not in self.VISIT_DIC:
self.VISIT_DIC[ip]=[ctime,]
return True
self.history_list=self.VISIT_DIC[ip] #当前访问者时间列表拿出来
while True:
if ctime-self.history_list[-1]>60:
self.history_list.pop() # 把最后一个移除
else:
break
if len(self.history_list)<3:
self.history_list.insert(0,ctime)
return True
else:
return False
def wait(self):
# 当前时间，减去列表中最后一个时间
ctime=time.time()
return 60-(ctime-self.history_list[-1])
#全局使用，局部使用
全局配置
# 在settings.py文件中设置如下代码,可以设置多个
REST_FRAMEWORK = {
'DEFAULT_THROTTLE_CLASSES': ('work.user_auth.IPThrottle',)
}
局部配置
# 在视图类中设置
throttle_classes = [IPThrottle, ]
内置频率组件
'DEFAULT_THROTTLE_CLASSES': (
'rest_framework.throttling.AnonRateThrottle',
# 对于未登录用户的频率限制（自定义或者内置认证都可使用）
'rest_framework.throttling.UserRateThrottle'
# 只有内置认证组件登录后才能用
),
'DEFAULT_THROTTLE_RATES': {
'user': '6/m', # 限制内置认证组件登录后每分钟最多访问6次
'anon': '3/m', # 限制未登录用户每分钟最多访问3次
}
根据ip进行频率限制
# 写一个类，继承SimpleRateThrottle，只需要重写get_cache_key
from rest_framework.throttling import ScopedRateThrottle,SimpleRateThrottle
#继承SimpleRateThrottle
class MyThrottle(SimpleRateThrottle):
scope='luffy'
def get_cache_key(self, request, view):
print(request.META.get('REMOTE_ADDR'))
return request.META.get('REMOTE_ADDR') # 返回
# 局部使用，全局使用
REST_FRAMEWORK={
'DEFAULT_THROTTLE_CLASSES': (
'utils.throttling.MyThrottle',
),
'DEFAULT_THROTTLE_RATES': {
'luffy': '3/m' # key要跟类中的scop对应
},
}
# python3 manage.py runserver 0.0.0.0:8000 你们局域网就可以相互访问
# 内网穿透
SimpleRateThrottle源码分析
# SimpleRateThrottle源码分析
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:
# scope是定义的类属性
return self.THROTTLE_RATES[self.scope] # scope：'user' => '3/min'
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('/') # rate：'3/min'
num_requests = int(num)
# 不管/后面写m或者min或者mmm都只取第一个字符——>period[0]
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
#当前登录用户的ip地址
self.key = self.get_cache_key(request, view) # key：'throttle_user_1'
if self.key is None:
return True
# 初次访问缓存为空，self.history为[]，是存放时间的列表
self.history = self.cache.get(self.key, [])
# 获取一下当前时间，存放到 self.now
self.now = self.timer()
# 当前访问与第一次访问时间间隔如果大于60s，第一次记录清除，不再算作一次计数
while self.history and self.now - self.history[-1] >= self.duration:
self.history.pop()
# history的长度与限制次数3进行比较
# history 长度第一次访问0，第二次访问1，第三次访问2，第四次访问3失败
if len(self.history) >= self.num_requests:
# 直接返回False，代表频率限制了
return self.throttle_failure()
# history的长度未达到限制次数3，代表可以访问
# 将当前时间插入到history列表的开头，将history列表作为数据存到缓存中，key是throttle_user_1，过期时间60s
return self.throttle_success()
