1.权限源码分析
1.APIView源码497行:self.initial(request, *args, **kwargs)中进行了三大认证。
2.在initial的源码中，以下三行代码是进行三大认证的代码:
self.perform_authentication(request)
self.check_permissions(request)
self.check_throttles(request)
# 按照顺序从上往下执行，先执行认证，再执行权限认证，最后执行频率认证。三大认证走不完视图类也不会走。
self.check_permissions(request)进行了权限认证，依然是在APIView中找到了check_permissions方法:
def check_permissions(self, request):
for permission in self.get_permissions():
...
发现有一个get_permissions()方法。
3.依然是在APIView中，找到了get_permissions()方法:
def get_permissions(self):
return [permission() for permission in self.permission_classes]
self是视图类的对象，视图类BookView中我们添加权限认证时已经正好添加了permission_classes。并且permission_classes可以有多个值，返回值permission()就是一个个权限类的对象。
4.回到check_permissions:
def check_permissions(self, request):
# 此时的self.get_permissions()就是一个个权限类对象，用permission进行for循环
for permission in self.get_permissions():
# 用permission点方法has_permission(),这也是我们重写has_permission()方法需要返回布尔值的原因。
if not permission.has_permission(request, self):
# 如果has_permission返回了None,权限类对象点方法permission_denied()时权限认证就会停止。所以只要有一个权限类认证不通过，那么就无法通过。
self.permission_denied(
request,
# permission_denied方法有属性messgae和code,message就是在前端提示的detail错误信息，code是提示码
message=getattr(permission, 'message', None),
code=getattr(permission, 'code', None)
)
"""
总结：
-APIView---dispatch----》initial---》倒数第二行---》self.check_permissions(request)
里面取出配置在视图类上的权限类，实例化得到对象，一个个执行对象的has_permission方法，如果返回False，就直接结束，不再继续往下执行，权限就认证通过
-如果视图类上不配做权限类：permission_classes = [CommonPermission]，会使用配置文件的api_settings.DEFAULT_PERMISSION_CLASSES
优先使用项目配置文件，其次使用drf内置配置文件
"""
2.认证源码分析
1.和之前一样，APIView中497行会执行三大认证，进入到initial源码中:
self.perform_authentication(request)
self.check_permissions(request)
self.check_throttles(request)
进入到perform_authentication()方法。
2.perform_authentication()代码如下:
def perform_authentication(self, request):
request.user
此时用ruquest点数据user,此时需要进入到类Request中查找user的来源。
"""
1.user代码如下，可以看出user是被伪装成数据的方法:
@property
def user(self):
if not hasattr(self, '_user'):
with wrap_attributeerrors():
self._authenticate()
# self是Request的对象，现在要从Request中找_authenticate()方法
return self._user
2._authenticate()方法代码如下:
def _authenticate(self):
"""
Attempt to authenticate the request using each authentication instance
in turn.
"""
for authenticator in self.authenticators:
try:
user_auth_tuple = authenticator.authenticate(self)
except exceptions.APIException:
self._not_authenticated()
raise
if user_auth_tuple is not None:
self._authenticator = authenticator
self.user, self.auth = user_auth_tuple
return
self._not_authenticated()
3.上述for循环self.authenticators，点进self.authenticators，
class Request:
def __init__(self, request, parsers=None, authenticators=None,
negotiator=None, parser_context=None):
self.authenticators = authenticators or ()
说明authenticators属性是在类Request产生对象时生成，
"""
3.在APIView中391行中，包含了新的request:
def initialize_request(self, request, *args, **kwargs):
parser_context = self.get_parser_context(request)
return Request(
request,
parsers=self.get_parsers(),
authenticators=self.get_authenticators(),
# authenticators这时候传进去了
negotiator=self.get_content_negotiator(),
parser_context=parser_context
)
4.self.get_authenticators()是生成authenticators这时候传进去了属性，点进去方法get_authenticators():
def get_authenticators(self):
return [auth() for auth in self.authentication_classes]
发现get_authenticators()方法的返回值是视图类中一个个认证类。
5.再回到类Request中的方法_authenticate():
def _authenticate(self):
for authenticator in self.authenticators:
try:
# self是Request对象，所以此时调用了我们自己定义的认证类中的方法:authenticate(self),并且这里的self是自定义类方法中的参数request:
# 自定义类方法:def authenticate(self, request):
user_auth_tuple = authenticator.authenticate(self)
except exceptions.APIException:
self._not_authenticated()
raise
# 如果拿到的元组不为空，说明在自定义认证类中认证成功，token表中有该字符串，此时直接结束for循环。所以认证类只要有一个类认证成功直接结束。而权限类需要所有的类全部校验完成才算成功。
if user_auth_tuple is not None:
self._authenticator = authenticator
self.user, self.auth = user_auth_tuple
# 解压赋值:self.user是用户对象(token字符串对应的用户)， self.auth是token字符串。此时的self是Request对象，所以拿到的是用户对象。
return
# 返回None则继续下一个视图类，所以多个认证类时只需要最后一个认证类返回两个结果就可以，其他的返回None。
self._not_authenticated()
"""
总结：
1 配置在视图类上的认证类，会在执行视图类方法之前执行，在权限认证之前执行
2 自己写的认证类，可以返回两个值或None
3 后续可以从request.user 取出当前登录用户(前提是你要在认证类中返回)
"""
3.自定义频率类
1.思路:
1.取出访问者ip
2.判断当前ip在不在访问字典内，如果不在则添加进去，并且直接返回True，表示第一次访问，在字典里。继续往下走，数据类型按照如下格式:{ip地址:[时间1，时间2，时间3，时间4]}
3.循环判断当前ip的列表，并且保证列表不为空，并且当前时间减去列表的最后一个时间大于60s，把这种数据pop掉，这样列表中只有60s以内的访问
4.判断，当列表小于3，说明一分钟以内访问不足三次，把当前时间插入到列表第一个位置，返回True，顺利通过
5.当大于等于3，说明一分钟内访问超过三次，返回False验证失败
2.代码:
from rest_framework.throttling import BaseThrottle
import time
#
class SuperThrottle(BaseThrottle):
VISIT_RECODE = {}
def __init__(self):
self.history = None
def allow_request(self, request, view):
ip = request.META.get('REMOTE_ADDR')
ctime = time.time()
if not ip in self.VISIT_RECODE:
self.VISIT_RECODE[ip] = [ctime,]
self.history = self.VISIT_RECODE.get(ip,[])
while self.history and ctime - self.history[-1] > 60:
self.history.pop()
if len(self.history) < 4:
self.history.insert(0,ctime)
return True
else:
return False
def wait(self): # 时间提示
import time
ctime = time.time()
return 60 - (ctime - self.history[-1])
4.频率源码分析
1.自定义频率类代码:
from rest_framework.throttling import SimpleRateThrottle
class Mythrottle(SimpleRateThrottle):
scope = 'zkz'
def get_cache_key(self, request, view):
return request.META.get('REMOTE_ADDR')
2.我们首先去Mythrottle的父类当中寻找方法，在类SimpleRateThrottle可以找到该方法:
def allow_request(self, request, view):
if self.rate is None: # rate是一个属性，要去__init__方法中找
return True
3.同样是在在类SimpleRateThrottle可以找到该方法:
def __init__(self):
if not getattr(self, 'rate', None):
self.rate = self.get_rate() # get_rate()也是类中的一个方法
self.num_requests, self.duration = self.parse_rate(self.rate)
4.在类SimpleRateThrottle找get_rate()方法:
def get_rate(self):
# 我们在盘频率类中定义了scope = 'zkz',所以不会报错
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是频率类的对象，THROTTLE_RATES同样是类SimpleRateThrottle中的方法
# THROTTLE_RATES = api_settings.DEFAULT_THROTTLE_RATES，self.scope = 'zkz'，所以self.THROTTLE_RATES[self.scope]相当于settings.py中的REST_FRAMEWORK中的DEFAULT_THROTTLE_RATES['zkz'],self.THROTTLE_RATES[self.scope]得结果是'10/m'。
return self.THROTTLE_RATES[self.scope]
except KeyError:
msg = "No default throttle rate set for '%s' scope" % self.scope
raise ImproperlyConfigured(msg)
5.回到类SimpleRateThrottle的__init__方法，self.rate = '10/m'。
self.num_requests, self.duration = self.parse_rate(self.rate)。现在寻找parse_rate(self.rate)方法:
def parse_rate(self, rate):
# rate有值，不会返回(None, None)
if rate is None:
return (None, None)
# num=10,period=m
num, period = rate.split('/')
# 将num转化成整形
num_requests = int(num)
# period[0]就是m，所以只要首字母在duration当中，就可以
duration = {'s': 1, 'm': 60, 'h': 3600, 'd': 86400}[period[0]]
# return (10,60)
return (num_requests, duration)
6.再回到类SimpleRateThrottle中的__init__方法:
def __init__(self):
if not getattr(self, 'rate', None):
# 此时self.rate有值，是'10/m'
self.rate = self.get_rate()
# 此时self.num_requests是10，self.duration是60
self.num_requests, self.duration = self.parse_rate(self.rate)
7.再回到allow_request:
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.cache.get(self.key, [])是从缓存当中取，取不到就拿一个空列表
self.history = self.cache.get(self.key, [])
# 获取当前时间，time=time.time,什么时候加括号什么时候调用
self.now = self.timer()
# 列表中的最后一个数字小于当前时间-60s(其他场景是每分钟或者每小时)
while self.history and self.history[-1] <= self.now - self.duration:
# 超出每个时间单位的时间，剔除，循环，直到列表中剩下最后一个数据为止
self.history.pop()
# self.num_requests是数字限制，就是10，如果在单位时间访问次数大于限制次数，报错。如果小于，则返回True
if len(self.history) >= self.num_requests:
return self.throttle_failure()
return self.throttle_success()
"""
def throttle_failure(self):
return False
def throttle_success(self):
# 在列表的最前面插入当前时间
self.history.insert(0, self.now)
self.cache.set(self.key, self.history, self.duration)
return True
"""
5.基于APIView编写分页
views.py:
from .commonLimitOffsetPagination import CommonLimitOffsetPagination
class BookView(ViewSetMixin,APIView):
def list(self,request):
books = Book.objects.all()
paginator = CommonLimitOffsetPagination()
page = paginator.paginate_queryset(books,request,self)
if page is not None:
serializer = BookSerializer(instance=page,many=True)
return Response({
'total':paginator.count,
'next':paginator.get_next_link(),
'previous':paginator.get_previous_link(),
'results':serializer.data
})
commonLimitOffsetPagination.py:
from rest_framework.pagination import LimitOffsetPagination
class CommonLimitOffsetPagination(LimitOffsetPagination):
default_limit = 3
limit_query_param = 'limit'
offset_query_param = 'offset'
max_limit = 5
6.异常处理
1.在drf中通过如下方式导入drf异常:
from rest_framework.exceptions import APIException
如果我们主动在代码中抛出drf异常，那么前端会处理成json格式,非drf错误不管是主动抛出还是非主动抛出的错误，都无法自动捕获并处理:
2.我们的目标是，不管什么错误(主动还是非主动)都处理成:{"code":999,"msg":"系统错误,请联系管理员"}
3.代码:
# 新建一个py文件
exception_handler.py:
from rest_framework.views import exception_handler
from rest_framework.response import Response
def common_exception_handler(exc, context):
# 调用函数exception_handler()
res = exception_handler(exc, context)
# 如果有值说明是drf错误
if res:
res = Response({'code':101,'msg':res.data.get('detail')})
else:
# 没有值说明是非drf错误，针对这种错误统一处理，msg也可以直接写死:'系统错误，请联系系统管理员'
res = Response({'code':102,'msg':str(exc)})
return res
setting.py:
REST_FRAMEWORK = {
'EXCEPTION_HANDLER':'app01.exception_handler.common_exception_handler',
}
浙公网安备 33010602011771号