一、rest-framework登录验证
网站登录之后就有个人中心可以对个人信息进行修改，但是在每次向服务器发请求时，由于http是无状态的，导致每次都是新的请求。
服务端则需要对每次请求都进行认证，确认用户是否登录及登录用户是谁。
因此需要将认证逻辑抽离出来，之前的做法主要是加装饰器或中间件。在前后端不分离的项目中通常是使用cookie和session，前后端分离的项目通常是使用token。
1、models.py添加User和Token模型
class User(models.Model):
name = models.CharField(max_length=32)
pwd = models.CharField(max_length=32) class Token(models.Model):
user = models.OneToOneField("User", on_delete=models.CASCADE)
token = models.CharField(max_length=128) def __str__(self):
return self.token
添加后执行数据库迁移，添加app01_user和app01_token表。
2、给login配置url
urlpatterns = [
...
re_path(r'^login/$', views.LoginView.as_view(), name="login"),
]
3、配置视图
def get_random_str(user):
""" 生成随机字符串 """
import hashlib, time
ctime = str(time.time())
md5 = hashlib.md5(bytes(user, encoding='utf-8'))
md5.update(bytes(ctime, encoding="utf-8"))
return md5.hexdigest() class LoginView(APIView):
def post(self, request):
# 验证逻辑：获取用户名密码与数据库比对
name = request.data.get("name")
pwd = request.data.get("pwd")
user = User.objects.filter(name=name, pwd=pwd).first()
res = {"state_code": 1000, "msg": None} # 成功或失败需要返回的字典标识这次的状态
if user:
# 通过校验 拿到随机字符串交给这个人
random_str = get_random_str(user.name) # 获取随机字符串
token = Token.objects.update_or_create(user=user, defaults={"token": random_str})
res["token"] = str(token) # json不能序列化对象，因此转为字符串
else:
# 校验失败
res["state_code"]=1001 # 错误状态码
res["msg"] = "用户名或密码错误" return Response(json.dumps(res))
注意：
（1）登录验证逻辑
class LoginView(APIView):
def post(self, request):
# 验证逻辑：获取用户名密码与数据库比对
name = request.data.get("name")
pwd = request.data.get("pwd")
user = User.objects.filter(name=name, pwd=pwd).first()
if user:
# 通过校验 拿到随机字符串交给这个人
pass
else:
# 校验失败
pass return Response("login....")
（2）生成随机字符串
def get_random_str(user):
""" 生成随机字符串 """
import hashlib, time
ctime = str(time.time())
md5 = hashlib.md5(bytes(user, encoding='utf-8'))
md5.update(bytes(ctime, encoding="utf-8"))
return md5.hexdigest()
注意：ctime=str(time.time()) ，世界上一直在变化的就是时间变量，因此ctime这个变量每个都是不同的。
hashlib.md5()构建md5对象。实例化md5时传递参数叫做加盐：
md5 = hashlib.md5(bytes(user, encoding='utf-8'))
md5.update()写入要加密的字节：(这里的md5是实例化出来的对象)
md5.update(bytes(ctime, encoding="utf-8"))
md5_obj.hexdigest()：获取密文
return md5.hexdigest()
加盐之后，即使要加密的数据完全一样，但是用户名肯定不一样，因此产生的密文一定唯一。
（3）update_or_create(self, defaults=None, **kwargs)方法
Token.objects.update_or_create(user=user,defaults={"token":random_str})
用给定的**kwargs值查找对象（这里是user=user）,如果defaults不为None则用defaults的值{"token":random_str}更新对象；如果为None则创建一个新对象。
class QuerySet:
def update_or_create(self, defaults=None, **kwargs):
"""
Look up an object with the given kwargs, updating one with defaults
if it exists, otherwise create a new one.
Return a tuple (object, created), where created is a boolean
specifying whether an object was created.
"""
defaults = defaults or {}
如果是create操作返回值是添加的数据，如果是update操作返回值是更新的条数。
二、局部视图认证
from rest_framework import exceptions class TokenAuth(object): # 这个类名可以任意取
def authenticate(self, request): # 这个方法名不可变动
token = request.GET.get("token")
token_obj = Token.objects.filter(token=token).first()
if not token_obj:
raise exceptions.AuthenticationFailed("验证失败!")
# 如果有值 return两个值中间加逗号，就构成了一个元组
return token_obj.user.name, token_obj.token # 元组：(关联用户对象的名字，当前登录对象token) def authenticate_header(self, request): # 不加会报错，要求要传入两个参数
pass class BookView(APIView):
authentication_classes = [TokenAuth, ] def get(self, request):
book_list = Book.objects.all()
bs = BookModelSerializers(book_list, many=True, context={"request": request}) # 序列化结果
# return HttpResponse(bs.data)
return Response(bs.data) def post(self, request):
# POST请求的数据
bs = BookModelSerializers(data=request.data)
if bs.is_valid(): # 验证数据是否合格
print(bs.validated_data)
bs.save() # create方法
return Response(bs.data) # 当前添加的数据
else:
return Response(bs.errors)
1、分析源码
每次请求都要执行dispatch。
（1）dispatch分发前的认证权限验证
在用户访问时执行APIView的dispatch方法，在dispatch进行分发操作前，需要先执行self.initial(request, *args, **kwargs)，执行认证、权限、频率操作。
def dispatch(self, request, *args, **kwargs):
self.args = args
self.kwargs = kwargs
request = self.initialize_request(request, *args, **kwargs) # 构建新request
self.request = request
self.headers = self.default_response_headers # deprecate? try:
self.initial(request, *args, **kwargs) # 认证权限频率 # Get the appropriate handler method
if request.method.lower() in self.http_method_names:
handler = getattr(self, request.method.lower(),
self.http_method_not_allowed)
else:
handler = self.http_method_not_allowed response = handler(request, *args, **kwargs) except Exception as exc:
response = self.handle_exception(exc) self.response = self.finalize_response(request, response, *args, **kwargs)
return self.response
（2）initial()方法中的认证权限频率组件
class APIView(View):
def initial(self, request, *args, **kwargs):
"""代码省略"""
# Ensure that the incoming request is permitted
# 初始化认证组件
self.perform_authentication(request)
# 权限组件
self.check_permissions(request)
# 频率组件
self.check_throttles(request)
（3）查看perform_authentication()方法
def perform_authentication(self, request):
request.user
由于在dispatch函数中，self.initial(request, *args, **kwargs)晚于request = self.initialize_request(request, *args, **kwargs)。因此这里的request是新构建的request。request.user即需要去Request类中寻找user静态方法。
这个新request通过initialize_request方法返回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(),
negotiator=self.get_content_negotiator(),
parser_context=parser_context
)
（4）Request类中有方法user
紧跟with后面的语句会被求值，返回对象的__enter__()方法被调用，这个方法的返回值将被赋值给as关键字后面的变量，当with后面的代码块全部被执行完之后，将调用前面返回对象的__exit__()方法。
with语句最关键的地方在于被求值对象必须有__enter__()和__exit__()这两个方法。
由此可知 self._authenticate()一定会执行。
@property
def user(self):
"""
Returns the user associated with the current request, as authenticated
by the authentication classes provided to the request.
当request已经通过认证类提供的认证,返回当前请求关联的用户
"""
if not hasattr(self, '_user'):
with wrap_attributeerrors():
self._authenticate()
return self._user
注意：@property装饰器就是负责把一个方法变成属性调用。未通过验证的需要用self._authenticate()方法来进行校验。
（5）_authenticate方法分析（认证核心）
循环 self.authenticators，拿到我们配置的每个认证类的实例化对象。
配置的认证类中一定要实现authenticate()方法，否则一定会报错。
需要注意的是：这里的 self 就是 request。authenticate()方法的返回值是一个元组——user_auth_tuple。
class Request:
def _authenticate(self):
"""
Attempt to authenticate the request using each authentication instance in turn.
"""
# 循环 self.authenticators，拿到我们配置的每个认证类的实例化对象。
for authenticator in self.authenticators:
try:
# 配置的认证类中一定要实现authenticate()方法，否则一定会报错
# 这里的 self 就是 request。authenticate()方法的返回值是一个元组——user_auth_tuple
user_auth_tuple = authenticator.authenticate(self)
except exceptions.APIException:
self._not_authenticated()
raise if user_auth_tuple is not None:
self._authenticator = authenticator
# 元组的值赋给：request.user和request.auth
self.user, self.auth = user_auth_tuple
return self._not_authenticated()
继续追溯 self.authenticators 的来源是Request实例化时传入的：
class Request:
"""
Wrapper allowing to enhance a standard `HttpRequest` instance. Kwargs:
- request(HttpRequest). The original request instance.
- parsers_classes(list/tuple). The parsers to use for parsing the
request content.
- authentication_classes(list/tuple). The authentications used to try
authenticating the request's user.
""" def __init__(self, request, parsers=None, authenticators=None,
negotiator=None, parser_context=None):
assert isinstance(request, HttpRequest), (
'The `request` argument must be an instance of '
'`django.http.HttpRequest`, not `{}.{}`.'
.format(request.__class__.__module__, request.__class__.__name__)
) self._request = request
self.parsers = parsers or ()
self.authenticators = authenticators or ()
...
（6）追溯self.authenticators
找到Request实例化的方法：initialize_request
class APIView(View):
def initialize_request(self, request, *args, **kwargs):
return Request(
authenticators=self.get_authenticators(),
)
再由此找到get_authenticators方法：
class APIView(View):
def get_authenticators(self):
"""
Instantiates and returns the list of authenticators that this view can use.
"""
return [auth() for auth in self.authentication_classes]
继续追溯 self.authentication_classes：
# rest_framework/views.py
class APIView(View): # The following policies may be set at either globally, or per-view.
renderer_classes = api_settings.DEFAULT_RENDERER_CLASSES
parser_classes = api_settings.DEFAULT_PARSER_CLASSES
authentication_classes = api_settings.DEFAULT_AUTHENTICATION_CLASSES
self.authentication_classes 去配置文件中拿所有的认证类。
authentication_classes就是我们在视图函数中定义的列表：
class BookView(APIView):
authentication_classes = [TokenAuth, ]
def get(self, request):... def post(self, request):...
[auth() for auth in self.authentication_classes]这个语句的含义：循环每一个认证类并进行实例化，放在数组中。以[TokenAuth, ]为例返回值是[TokenAuth(), ]。
因此回传回去authenticators=[TokenAuth(), ]。
（7）_authenticate方法处理
class Request(object):
def __init__(self, request, parsers=None, authenticators=None,
negotiator=None, parser_context=None):
self._request = request
self.parsers = parsers or ()
self.authenticators = authenticators or () # 如果是None返回空元组，如果有值返回authenticators
"""
print(3 and 0) # 0
print(0 and 2) # 0
print(0 or 1) # 1
print(4 or 1) # 4
""" def _authenticate(self):
"""
Attempt to authenticate the request using each authentication instance
in turn.
"""
for authenticator in self.authenticators: # [TokenAuth(), ]， authenticator:TokenAuth()
try:
user_auth_tuple = authenticator.authenticate(self) # TokenAuth必须有authenticate方法
# authenticator.authenticate(self):是一个实例对象调用自己的实例方法，本不需要传self，这里一定是传的一个形参。
# 这个方法是在Request类中，追溯调用关系可知，这里的self是一个新request对象
except exceptions.APIException: # 抛出错误
self._not_authenticated() # 没有验证成功
raise if user_auth_tuple is not None: # 如果user_auth_tuple有值
self._authenticator = authenticator
self.user, self.auth = user_auth_tuple # 将元组的值赋给self.user和self.auth
return self._not_authenticated() # 没有验证成功
authenticator.authenticate(self):是一个实例对象调用自己的实例方法，本不需要传self，这里一定是传的一个形参。这个方法是在Request类中，追溯调用关系可知，这里的self是一个新request对象。因此在构建自定义的TokenAuth时一定要在def authenticate(self, request): 添加request参数。
2、测试验证
访问时添加数据库查到的token信息，验证通过：
打印之前在_authenticate将元组的值赋给self.user和self.auth的值：
class BookView(APIView):
authentication_classes = [TokenAuth, ] def get(self, request):
print(request.user) # egon
print(request.auth) # 02aee930be6011068e24f68935d52b02
可以看到正好对应authoerticate函数的返回值：return token_obj.user.name, token_obj.token.
因此在视图中类中配置authentication_classes，即可实现局部认证。
3、BaseAuthentication模块引入规范简化认证类编写
from rest_framework import exceptions
from rest_framework.authentication import BaseAuthentication class TokenAuth(BaseAuthentication):
def authenticate(self, request):
token = request.GET.get("token")
token_obj = Token.objects.filter(token=token).first()
if not token_obj:
raise exceptions.AuthenticationFailed("验证失败!")
# 如果有值 return两个值中间加逗号，就构成了一个元组
return token_obj.user.name, token_obj.token # 元组：(关联用户对象的名字，当前登录对象token) # def authenticate_header(self, request): # 不加会报错，且要求要传入两个参数
# pass
BaseAuthentication包含authenticate和authenticate_header函数。默认用来被覆盖。
三、全局视图认证
1、源码分析
如果没有在局部定义authentication_classes=[TokenAuth, ]。回溯查找默认的authentication_classes。
（1）APIView有变量authentication_classes
class APIView(View):
authentication_classes = api_settings.DEFAULT_AUTHENTICATION_CLASSES
api_settings.DEFAULT_AUTHENTICATION_CLASSES是类的实例对象.属性的模式。当调用不存在的属性时，Python会试图调用__getattr__(self,attr)来获取属性，并且返回attr。
（2）查看api_settings
该语句在rest_framework/settings.py中。发现api_settings是一个实例对象。实例化时执行相应的init方法。
api_settings = APISettings(None, DEFAULTS, IMPORT_STRINGS)
DEFAULTS这个值是一个字典，每一个键后面都是跟着一个元组，保存了关于rest_framework所有默认配置。也定义在rest_framework/settings.py文件中。
（3）查看APISettings类__init__方法
class APISettings(object):
def __init__(self, user_settings=None, defaults=None, import_strings=None):
if user_settings:
self._user_settings = self.__check_user_settings(user_settings)
self.defaults = defaults or DEFAULTS
self.import_strings = import_strings or IMPORT_STRINGS
self._cached_attrs = set()
user_settings默认为None，如果有值拿到user_settings.
self.defaults = defaults or DEFAULTS 拿到DEFAULTS字典值。
（4）APISettings类的def __getattr__(self, attr)方法
class APISettings(object):
def __getattr__(self, attr):
if attr not in self.defaults:
raise AttributeError("Invalid API setting: '%s'" % attr) try:
# Check if present in user settings
val = self.user_settings[attr]
except KeyError: # 当self.user_settings的值是一个空字典，取值报错KeyError
# Fall back to defaults
val = self.defaults[attr] # 异常处理去取默认的DEFAULT值 # Coerce import strings into classes
if attr in self.import_strings:
val = perform_import(val, attr) # Cache the result
self._cached_attrs.add(attr)
setattr(self, attr, val)
return val
__getattr__是python里的一个内建函数，可以很方便地动态返回一个属性；当调用不存在的属性时，Python会试图调用__getattr__(self,item)来获取属性，并且返回item；
class Person(object):
def __init__(self, name):
self.name = name def __getattr__(self, item):
print("item", item) def dream(self):
print("dreaming。。。。。") alex = Person("alex")
alex.yuan # 打印：item yuan
val = self.user_settings[attr]：user_settings执行的返回值后面加上[attr]
（5）APISettings类的user_settings方法执行
class APISettings(object):
@property
def user_settings(self): # 静态方法
if not hasattr(self, '_user_settings'):
self._user_settings = getattr(settings, 'REST_FRAMEWORK', {})
return self._user_settings
这里的settings指的是restDemo项目中的restDemo/settings.py。
因此getattr(settings, 'REST_FRAMEWORK', {}) 代表的意思是：去settings.py中去拿REST_FRAMEWORK变量，如果拿不到则取一个空字典。因此self._user_settings一定是一个字典。
因此self.user_settings[attr]是在字典中取键attr的值.当字典为空时，取不到值会抛出Keyerror错误，进行异常处理去取默认的DEFAULT字典中的值：
DEFAULTS = {
"""省略代码"""
'DEFAULT_AUTHENTICATION_CLASSES': (
'rest_framework.authentication.SessionAuthentication',
'rest_framework.authentication.BasicAuthentication'
),
"""省略代码"""
2、在settings.py中配置全局视图
REST_FRAMEWORK = {
# 仿照DEFAULT配置认证类路径
"DEFAULT_AUTHENTICATION_CLASSES": ["app01.utils.TokenAuth"]
}
（1）REST_FRAMEWORK是一个字典
键必须是DEFAULT_AUTHENTICATION_CLASSES
（2）值是认证类路径
由于要指定认证类路径因此要把之前写的TokenAuth从views.py迁移到一个新文件(文件名自定义)中，这里是：/app01/utils.py。在这里定义认证类TokenAuth，认证类必须包含authenticate方法。
注意：不能继承object类，必须继承基础认证类——BaseAuthentication。
from .models import *
from rest_framework import exceptions
from rest_framework.authentication import BaseAuthentication class TokenAuth(BaseAuthentication):
def authenticate(self, request):
token = request.GET.get("token")
token_obj = Token.objects.filter(token=token).first()
if not token_obj:
raise exceptions.AuthenticationFailed("验证失败!")
# 如果有值 return两个值中间加逗号，就构成了一个元组
return token_obj.user.name, token_obj.token # 元组：(关联用户对象的名字，当前登录对象token)
3、在全局认证情况下，配置部分访问不进行认证
class LoginView(APIView):
authentication_classes = [] # 配置为空，优先级高于全局认证，不用进行认证
def post(self, request):....
四、权限组件
权限是对某件事情决策的范围和程度，权限在项目开发中经常会用到。视频网站中，很多视频需要vip用户才能观看，甚至还有一些视频需要svip、ssvip才能观看。
1、权限组件源码分析
DRF的权限与版本、认证、频率组件都非常相似，均是在initial方法里初始化的。一般来说权限基于登录，因此在DRF源码中先执行版本和认证才执行权限。
（1）访问请求交给APIView类下的dispatch方法处理
class APIView(View):
def dispatch(self, request, *args, **kwargs):
self.args = args
self.kwargs = kwargs
request = self.initialize_request(request, *args, **kwargs)
self.request = request
self.headers = self.default_response_headers # deprecate? try:
self.initial(request, *args, **kwargs)
"""代码省略"""
在dispatch中使用的initial()方法，包含了权限组件：
def initial(self, request, *args, **kwargs):
"""代码省略"""
# Ensure that the incoming request is permitted
# 认证组件
self.perform_authentication(request)
# 权限组件
self.check_permissions(request)
# 频率组件
self.check_throttles(request)
（2）权限函数——check_permissions
这里循环拿到的permission是我们配置的每一个权限类的实例对象(MyPermission等)；
permission_denied用于抛出异常，因此权限类必须有has_permission方法，否则将抛出异常。
注意：这里的self一直是我们视图类的实例化对象。
失败抛出异常时，通过反射在实例化对象中找message属性，因此可以在权限类中定义message来定义异常信息。
class APIView(View):
def check_permissions(self, request):
"""
Check if the request should be permitted.
Raises an appropriate exception if the request is not permitted.
"""
for permission in self.get_permissions(): # 循环的是[SVIPPermission(), ] permission是SVIPPermission()——权限实例
if not permission.has_permission(request, self): # 由此可见权限类必须有has_permission方法
# 通过权限认证什么都不用做，不通过执行以下代码
self.permission_denied(
request, message=getattr(permission, 'message', None)
)
self.get_permissions()是权限类实例对象组成的列表。
permission.has_permission()是权限类中的权限方法。
self.permission_denied()是在权限没有权限方法时，抛出异常。
1）查看get_permissions方法
class APIView(View):
def get_permissions(self):
"""
Instantiates and returns the list of permissions that this view requires.
"""
return [permission() for permission in self.permission_classes]
[permission() for permission in self.permission_classes]与认证组件完全类似：循环每一个权限类并进行实例化，组成一个列表返回。
2）查看确认permission_classes的值
class APIView(View):
# The following policies may be set at either globally, or per-view.
authentication_classes = api_settings.DEFAULT_AUTHENTICATION_CLASSES
permission_classes = api_settings.DEFAULT_PERMISSION_CLASSES
如果在自己的视图类中定义了permission_classes(优先取当前视图的局部配置) ，说明配置了局部视图权限，就取自己定义的。
如果没有定义：
由于权限组件依然是用了api_settings这个APISettings类实例对象，实例化时执行__init__函数，因此也执行了user_settings静态方法。
class APISettings(object):
def __init__(self, user_settings=None, defaults=None, import_strings=None):
if user_settings:
self._user_settings = self.__check_user_settings(user_settings)
self.defaults = defaults or DEFAULTS def user_settings(self):
if not hasattr(self, '_user_settings'):
self._user_settings = getattr(settings, 'REST_FRAMEWORK', {}) # 去settings.py中去拿REST_FRAMEWORK变量，如果拿不到则取一个空字典
return self._user_settings
这里user_settings函数通过反射取settings下是否有配置‘REST_FRAMEWORK’，如果有配置即说明配置了全局视图权限。self._user_settings取配置的值。
getattr(settings, 'REST_FRAMEWORK', {})里的settings是从django引入过来的：
from django.conf import settings
如果没有配置则self._user_settings是一个空字典，需要进一步分析api_settings.DEFAULT_PERMISSION_CLASSES：
APISettings类中包含__getattr__方法，当调用不存在的属性时，Python会试图调用__getattr__(self,item)来获取属性，并且返回item：
class APISettings(object):
def __getattr__(self, attr):
if attr not in self.defaults:
raise AttributeError("Invalid API setting: '%s'" % attr) try:
# Check if present in user settings
val = self.user_settings[attr] # 全局权限视图未设置时self.user_settings返回值是一个空字典,设置时取到全局配置
except KeyError: # 空字典取值报错抛出异常
# Fall back to defaults
val = self.defaults[attr] # 获取DEFAULT中默认值 # Coerce import strings into classes
if attr in self.import_strings:
val = perform_import(val, attr) # Cache the result
self._cached_attrs.add(attr)
setattr(self, attr, val)
return val
由于全局权限视图未未设置时self.user_settings返回值是一个空字典，因此取值会失败，通过异常处理获取DEFAULT默认配置中的值。
3）总结
self.get_permissions()的返回值是权限实例列表，以下面的示例为例是[SVIPPermission(), ]。因此for循环拿到的permission是一个个权限实例：SVIPPermission()
因此如果permission.has_permission返回值是true，直接完成权限验证；如果返回值是False，则返回没有权限的提示。
因此，权限类一定要有has_permission方法，否则会抛出异常。
2、局部视图权限
（1）前置准备
修改models.py中user表结构，设置用户类型和默认值：
class User(models.Model):
name = models.CharField(max_length=32)
pwd = models.CharField(max_length=32)
type_choice = ((1, "普通用户"), (2, "VIP"), (3, "SVIP"))
user_type = models.IntegerField(choices=type_choice, default=1)
修改后完成数据库迁移。
（2）配置权限类
自定义工具包文件夹utils，创建permission.py权限文件：
from rest_framework.permissions import BasePermission class SVIPPermission(BasePermission):
message = "您没有权限"
# 超级用户可用
def has_permission(self, request, view):
username = request.user # 获取前面认证过的信息：egon
user_type = User.objects.filter(name=username).first().user_type
if user_type == 3:
# 通过权限认证
return True
else:
# 未通过权限认证
return False
视图配置如下所示：
from rest_framework import viewsets
from utils.permission import SVIPPermission # 权限 class AuthorViewSet(viewsets.ModelViewSet):
# authentication_classes = [TokenAuth, ]
permission_classes = [SVIPPermission, ]
queryset = Author.objects.all() # 配置queryset:告知这个类这次处理的数据
serializer_class = AuthorModelSerializers # 告知处理用到的序列化组件
显示效果：
（3）用message自定义配置错误提示
查看源码可以看到，check_permissions中失败抛出异常时，通过反射在实例化对象中找message属性，因此可以在权限类中定义message来定义异常信息。
class SVIPPermission(object):
# 超级用户可用
message = "只有超级用户才能访问"
def has_permission(self, request, view):
username = request.user # 获取前面认证过的信息：egon
user_type = User.objects.filter(name=username).first().user_type
if user_type == 3:
# 通过权限认证
return True
else:
# 未通过权限认证
return False
显示效果：
3、全局视图权限
在settings.py中配置全局权限
REST_FRAMEWORK = {
# 认证类路径
"DEFAULT_AUTHENTICATION_CLASSES": ["app01.utils.TokenAuth"],
# 权限类路径
"DEFAULT_PERMISSION_CLASSES": ["utils.permission.SVIPPermission"]
}
五、throttle(频率访问)组件
开放平台的API接口调用需要限制其频率，以节约服务器资源和避免恶意的频繁调用。
1、源码分析
频率组件的源码和前面的版本、认证、权限是一个流程。
class APIView(View):
def dispatch(self, request, *args, **kwargs):
try:
self.initial(request, *args, **kwargs) def initial(self, request, *args, **kwargs):
self.check_throttles(request) def check_throttles(self, request):
"""
Check if request should be throttled.
Raises an appropriate exception if the request is throttled.
"""
for throttle in self.get_throttles():
if not throttle.allow_request(request, self):
self.throttled(request, throttle.wait()) def get_throttles(self):
return [throttle() for throttle in self.throttle_classes] # 频率对象列表
get_throttles：去配置文件中拿到所有频率控制类，并实例化放入列表中。
因此 throttle 是配置中每个频率控制类的实例化对象。
self.throttled 则是失败抛出异常。
throttle.wait方法主要用来向客户端返回还需要多少时间可以继续访问。
2、频率组件原理和模板
（1）频率组件原理
DRF中频率控制基本原理是基于访问次数和时间，可以通过自己定义的方法来实现。
请求走到频率组件的时候，DRF内部会有一个字典记录访问者的IP，以这个IP为KEY，value为一个列表，存放访问者每次访问的时间。
{ip: [time1, time2, time3],}
把每次访问最新时间放入列表的最前面，记录这样一个数据结构后，既可以用如下示例（设置10秒内只能访问次）实现限流：
-- 1、判断访问者的IP是否在这个请求IP的字典里
-- 2、保证这个列表里都是最近10秒内的访问的时间
判断当前请求时间和列表里最早的(也就是最后的)请求时间的查
如果差大于10秒，说明请求以及不是最近10秒内的，删除掉，
继续判断倒数第二个，直到差值小于10秒
-- 3、判断列表的长度(即访问次数)，是否大于我们设置的5次，
如果大于就限流，否则放行，并把时间放入列表的最前面。
（2）频率组件模板
创建文件DRFDemo/utils/throttle.py：
import time
from rest_framework.throttling import BaseThrottle VISIT_RECORD = {} class MyThrottle(BaseThrottle): def allow_request(self, request, view):
# 实现限流的逻辑
# 以ip地址限流
# 访问列表 {ip: [time1,time2,time3]}
# 1、获取请求的ip地址
# 2、判断ip地址是否在访问列表
# 2.1 不在，给访问列表添加key,value
# 2.2 在，需要获取该ip的访问记录，把当前时间加入列表
# 3、确保列表里最新访问即最老访问的时间差 是1分钟
# 4、得到列表的长度，判断是否是允许的次数 pass def wait(self):
# 返回还剩多久可继续访问
pass
3、局部视图throttle
（1）限制类定义
直接将频率限制类定义在DRFDemo/utils/throttle.py中：
import time
from rest_framework.throttling import BaseThrottle VISIT_RECORD = {} class MyThrottle(BaseThrottle): def __init__(self):
self.history = None def allow_request(self, request, view):
# 实现限流的逻辑
# 以ip地址限流：要求访问站点的频率一分钟不超过3次
# 访问列表 {ip: [time1,time2,time3]}
# 1、获取请求的ip地址
remote_ip = request.META.get("REMOTE_ADDR")
ctime = time.time()
# 2、判断ip地址是否在访问列表
if remote_ip not in VISIT_RECORD:
# 2.1 不在，给访问列表添加key,value
VISIT_RECORD[remote_ip] = [ctime, ]
return True # 2.2 在，需要获取该ip的访问记录，把当前时间加入列表
history = VISIT_RECORD.get(remote_ip) # 取到列表 # 3、确保列表里最新访问即最老访问的时间差 是1分钟
while history and history[0] - history[-1] > 60:
history.pop() # 删最后一个
self.history = history
# 4、得到列表的长度，判断是否是允许的次数
if len(history) < 3:
# 未达到频率限制
history.insert(0, ctime) # 加到第一个
return True
else:
return False def wait(self):
# 返回还剩多久可继续访问
ctime = 60 - (self.history[0] - self.history[-1]) # 最新的时间减去最老的时间(可能是已经删除的时间)
return ctime
（2）视图中配置局部频率限制
在视图类中中配置局部频率限制：
import uuid # UUID对象和生成函数
from .models import User
from utils.auth import MyAuth # 认证
from utils.permission import MyPermission # 权限
from utils.throttle import MyThrottle # 频率
from rest_framework.views import APIView
from rest_framework.response import Response class DemoView(APIView):
def get(self, request):
return Response("认证demo~") class LoginView(APIView):
def post(self, request):
username = request.data.get("username")
pwd = request.data.get("pwd")
# 登录成功，生成token会将token给你返回
token = uuid.uuid4() # 通过随机数来生成UUID
User.objects.create(username=username, pwd=pwd, token=token)
return Response("创建用户成功") class TestView(APIView):
authentication_classes = [MyAuth, ] # 局部认证
# permission_classes = [MyPermission, ] # 局部权限
throttle_classes = [MyThrottle, ] def get(self, request):
# 访问：GET /auth/test?token=98bc3edce82143f8ad638f9cad336807
print(request.user) # User object (1)
print(request.auth) # 98bc3edce82143f8ad638f9cad336807
return Response("认证测试")
注意：request.META 是一个Python字典，包含了所有本次HTTP请求的Header信息，比如用户IP地址和用户Agent（通常是浏览器的名称和版本号）。 注意，Header信息的完整列表取决于用户所发送的Header信息和服务器端设置的Header信息。
（3）频率组件测试
连续访问：http://127.0.0.1:8000/auth/test?token=98bc3edce82143f8ad638f9cad336807，前三次均显示“认证测试”。第四次显示如下所示：
4、全局视图throttle
在restDemo/settings.py中配置：
REST_FRAMEWORK = {
# "DEFAULT_VERSIONING_CLASS": "utils.version.MyVersion",
# 默认使用的版本控制类
"DEFAULT_VERSIONING_CLASS": "rest_framework.versioning.QueryParameterVersioning",
# 默认使用的版本
"DEFAULT_VERSION": "v1",
# 允许的版本
"ALLOWED_VERSIONS": "v1, v2",
# 版本使用的参数名称
"VERSION_PARAM": "ver",
# 默认认证类
"DEFAULT_AUTHENTICATION_CLASSES": ["utils.auth.MyAuth",],
# 默认权限类
"DEFAULT_PERMISSION_CLASSES": ["utils.permission.MyPermission"],
# 默认频率类
"DEFAULT_THROTTLE_CLASSES": ["utils.throttle.MyThrottle"]
}
5、框架内置throttle限流类
将频率配置类修改为：
class MyThrottle(SimpleRateThrottle):
scope = "WD" def get_cache_key(self, request, view):
# 如果以ip地址做限流返回ip地址
key = self.get_ident(request)
return key
settings.py设置：
REST_FRAMEWORK = {
# 默认使用的版本控制类
"DEFAULT_VERSIONING_CLASS": "rest_framework.versioning.QueryParameterVersioning",
# 默认使用的版本
"DEFAULT_VERSION": "v1",
# 允许的版本
"ALLOWED_VERSIONS": "v1, v2",
# 版本使用的参数名称
"VERSION_PARAM": "ver",
"DEFAULT_THROTTLE_RATES": {
"WD": "3/m"
}
}