Django rest framework源碼分析（3）—-節流
添加節流
自定義節流的方法
（1）API文件夾下面新建throttle.py，代碼如下：
# utils/throttle.py
from rest_framework.throttling import BaseThrottle
import time
VISIT_RECORD = {} #保存訪問記錄
class VisitThrottle(BaseThrottle):
'''60s內只能訪問3次'''
def __init__(self):
self.history = None #初始化訪問記錄
def allow_request(self,request,view):
#獲取用戶ip (get_ident)
remote_addr = self.get_ident(request)
ctime = time.time()
#如果當前IP不在訪問記錄裏面，就添加到記錄
if remote_addr not in VISIT_RECORD:
VISIT_RECORD[remote_addr] = [ctime,] #鍵值對的形式保存
return True #True表示可以訪問
#獲取當前ip的歷史訪問記錄
history = VISIT_RECORD.get(remote_addr)
#初始化訪問記錄
self.history = history
#如果有歷史訪問記錄，並且最早一次的訪問記錄離當前時間超過60s，就刪除最早的那個訪問記錄，
#只要為True，就一直循環刪除最早的一次訪問記錄
while history and history[-1] < ctime - 60:
history.pop()
#如果訪問記錄不超過三次，就把當前的訪問記錄插到第一個位置（pop刪除最後一個）
if len(history) < 3:
history.insert(0,ctime)
return True
def wait(self):
'''還需要等多久才能訪問'''
ctime = time.time()
return 60 - (ctime - self.history[-1])
（2）settings中全局配置節流
#全局
REST_FRAMEWORK = {
#節流
"DEFAULT_THROTTLE_CLASSES":['API.utils.throttle.VisitThrottle'],
}
（3）現在訪問auth看看結果：
- 60s內訪問次數超過三次，會限制訪問
- 提示剩餘多少時間可以訪問
接着訪問
節流源碼分析
（1）dispatch
def dispatch(self, request, *args, **kwargs):
"""
`.dispatch()` is pretty much the same as Django's regular dispatch,
but with extra hooks for startup, finalize, and exception handling.
"""
self.args = args
self.kwargs = kwargs
#對原始request進行加工，豐富了一些功能
#Request(
# request,
# parsers=self.get_parsers(),
# authenticators=self.get_authenticators(),
# negotiator=self.get_content_negotiator(),
# parser_context=parser_context
# )
#request(原始request,[BasicAuthentications對象，])
#獲取原生request,request._request
#獲取認證類的對象，request.authticators
#1.封裝request
request = self.initialize_request(request, *args, **kwargs)
self.request = request
self.headers = self.default_response_headers # deprecate?
try:
#2.認證
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
def initial(self, request, *args, **kwargs):
"""
Runs anything that needs to occur prior to calling the method handler.
"""
self.format_kwarg = self.get_format_suffix(**kwargs)
# Perform content negotiation and store the accepted info on the request
neg = self.perform_content_negotiation(request)
request.accepted_renderer, request.accepted_media_type = neg
# Determine the API version, if versioning is in use.
version, scheme = self.determine_version(request, *args, **kwargs)
request.version, request.versioning_scheme = version, scheme
# Ensure that the incoming request is permitted
#4.實現認證
self.perform_authentication(request)
#5.權限判斷
self.check_permissions(request)
#6.控制訪問頻率
self.check_throttles(request)
（3）check_throttles
裏面有個allow_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())
（4）get_throttles
def get_throttles(self):
"""
Instantiates and returns the list of throttles that this view uses.
"""
return [throttle() for throttle in self.throttle_classes]
（5）thtottle_classes
內置節流類
上面是寫的自定義節流，drf內置了很多節流的類，用起來比較方便。
（1）BaseThrottle
- 自己要寫allow_request和wait方法
- get_ident就是獲取ip
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):
"""
Identify the machine making the request by parsing HTTP_X_FORWARDED_FOR
if present and number of proxies is > 0. If not use all of
HTTP_X_FORWARDED_FOR if it is available, if not use REMOTE_ADDR.
"""
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
（2）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):
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):
"""
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.
"""
raise NotImplementedError('.get_cache_key() must be overridden')
def get_rate(self):
"""
Determine the string representation of the allowed request rate.
"""
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):
"""
Given the request rate string, return a two tuple of:
<allowed number of requests>, <period of time in seconds>
"""
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`.
"""
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()
# 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)
我們可以通過繼承SimpleRateThrottle類，來實現節流，會更加的簡單，因為SimpleRateThrottle裏面都幫我們寫好了
（1）throttle.py
from rest_framework.throttling import SimpleRateThrottle
class VisitThrottle(SimpleRateThrottle):
'''匿名用戶60s只能訪問三次（根據ip）'''
scope = 'NBA' #這裏面的值，自己隨便定義，settings裏面根據這個值配置Rate
def get_cache_key(self, request, view):
#通過ip限制節流
return self.get_ident(request)
class UserThrottle(SimpleRateThrottle):
'''登錄用戶60s可以訪問10次'''
scope = 'NBAUser' #這裏面的值，自己隨便定義，settings裏面根據這個值配置Rate
def get_cache_key(self, request, view):
return request.user.username
（2）settings.py
#全局
REST_FRAMEWORK = {
#節流
"DEFAULT_THROTTLE_CLASSES":['API.utils.throttle.UserThrottle'], #全局配置，登錄用戶節流限制（10/m）
"DEFAULT_THROTTLE_RATES":{
'NBA':'3/m', #沒登錄用戶3/m，NBA就是scope定義的值
'NBAUser':'10/m', #登錄用戶10/m，NBAUser就是scope定義的值
}
}
（3）views.py
局部配置方法
class AuthView(APIView):
.
.
.
# 默認的節流是登錄用戶（10/m）,AuthView不需要登錄，這裏用匿名用戶的節流（3/m）
throttle_classes = [VisitThrottle,] . .
# views.py
from django.shortcuts import render,HttpResponse
from django.http import JsonResponse
from rest_framework.views import APIView
from API import models
from rest_framework.request import Request
from rest_framework import exceptions
from rest_framework.authentication import BaseAuthentication
from API.utils.permission import SVIPPremission,MyPremission
from API.utils.throttle import VisitThrottle
ORDER_DICT = {
1:{
'name':'apple',
'price':15
},
2:{
'name':'dog',
'price':100
}
}
def md5(user):
import hashlib
import time
#當前時間，相當於生成一個隨機的字符串
ctime = str(time.time())
m = hashlib.md5(bytes(user,encoding='utf-8'))
m.update(bytes(ctime,encoding='utf-8'))
return m.hexdigest()
class AuthView(APIView):
'''用於用戶登錄驗證'''
authentication_classes = [] #裏面為空，代表不需要認證
permission_classes = [] #不裏面為空，代表不需要權限
# 默認的節流是登錄用戶（10/m）,AuthView不需要登錄，這裏用匿名用戶的節流（3/m）
throttle_classes = [VisitThrottle,]
def post(self,request,*args,**kwargs):
ret = {'code':1000,'msg':None}
try:
user = request._request.POST.get('username')
pwd = request._request.POST.get('password')
obj = models.UserInfo.objects.filter(username=user,password=pwd).first()
if not obj:
ret['code'] = 1001
ret['msg'] = '用戶名或密碼錯誤'
#為用戶創建token
token = md5(user)
#存在就更新，不存在就創建
models.UserToken.objects.update_or_create(user=obj,defaults={'token':token})
ret['token'] = token
except Exception as e:
ret['code'] = 1002
ret['msg'] = '請求異常'
return JsonResponse(ret)
class OrderView(APIView):
'''
訂單相關業務(只有SVIP用戶才能看)
'''
def get(self,request,*args,**kwargs):
self.dispatch
#request.user
#request.auth
ret = {'code':1000,'msg':None,'data':None}
try:
ret['data'] = ORDER_DICT
except Exception as e:
pass
return JsonResponse(ret)
class UserInfoView(APIView):
'''
訂單相關業務(普通用戶和VIP用戶可以看)
'''
permission_classes = [MyPremission,] #不用全局的權限配置的話，這裏就要寫自己的局部權限
def get(self,request,*args,**kwargs):
print(request.user)
return HttpResponse('用戶信息')
說明：
- API.utils.throttle.UserThrottle 這個是全局配置（根據ip限制，10/m）
- DEFAULT_THROTTLE_RATES —>>>設置訪問頻率的
- throttle_classes = [VisitThrottle,] —>>>局部配置（不適用settings裏面默認的全局配置）
總結
基本使用
- 創建類，繼承BaseThrottle, 實現：allow_request ，wait
- 創建類，繼承SimpleRateThrottle, 實現： get_cache_key， scope=’NBA’ (配置文件中的key)
全局
#節流
"DEFAULT_THROTTLE_CLASSES":['API.utils.throttle.UserThrottle'], #全局配置，登錄用戶節流限制（10/m）
"DEFAULT_THROTTLE_RATES":{
'NBA':'3/m', #沒登錄用戶3/m，NBA就是scope定義的值
'NBAUser':'10/m', #登錄用戶10/m，NBAUser就是scope定義的值
}
}
局部
throttle_classes = [VisitThrottle,]
所有代碼
認證、權限和節流
# MyProject/urls.py
from django.contrib import admin
from django.urls import path
from API.views import AuthView,OrderView,UserInfoView
urlpatterns = [
path('admin/', admin.site.urls),
path('api/v1/auth/',AuthView.as_view()),
path('api/v1/order/',OrderView.as_view()),
path('api/v1/info/',UserInfoView.as_view()),
]
#全局 settings.py
REST_FRAMEWORK = {
#認證
"DEFAULT_AUTHENTICATION_CLASSES":['API.utils.auth.Authentication',],
#權限
"DEFAULT_PERMISSION_CLASSES":['API.utils.permission.SVIPPermission'],
#節流
"DEFAULT_THROTTLE_CLASSES":['API.utils.throttle.UserThrottle'], #全局配置，登錄用戶節流限制（10/m）
"DEFAULT_THROTTLE_RATES":{
'NBA':'3/m', #沒登錄用戶3/m，NBA就是scope定義的值
'NBAUser':'10/m', #登錄用戶10/m，NBAUser就是scope定義的值
}
}
# API/models.py
from django.db import models
class UserInfo(models.Model):
USER_TYPE = (
(1,'普通用戶'),
(2,'VIP'),
(3,'SVIP')
)
user_type = models.IntegerField(choices=USER_TYPE)
username = models.CharField(max_length=32)
password = models.CharField(max_length=64)
class UserToken(models.Model):
user = models.OneToOneField(UserInfo,on_delete=models.CASCADE)
token = models.CharField(max_length=64)
# API/views.py
from django.shortcuts import render,HttpResponse
from django.http import JsonResponse
from rest_framework.views import APIView
from API import models
from rest_framework.request import Request
from rest_framework import exceptions
from rest_framework.authentication import BaseAuthentication
from API.utils.permission import SVIPPermission,MyPermission
from API.utils.throttle import VisitThrottle
ORDER_DICT = {
1:{
'name':'apple',
'price':15
},
2:{
'name':'dog',
'price':100
}
}
def md5(user):
import hashlib
import time
#當前時間，相當於生成一個隨機的字符串
ctime = str(time.time())
m = hashlib.md5(bytes(user,encoding='utf-8'))
m.update(bytes(ctime,encoding='utf-8'))
return m.hexdigest()
class AuthView(APIView):
'''用於用戶登錄驗證'''
authentication_classes = [] #裏面為空，代表不需要認證
permission_classes = [] #不裏面為空，代表不需要權限
# 默認的節流是登錄用戶（10/m）,AuthView不需要登錄，這裏用匿名用戶的節流（3/m）
throttle_classes = [VisitThrottle,]
def post(self,request,*args,**kwargs):
ret = {'code':1000,'msg':None}
try:
user = request._request.POST.get('username')
pwd = request._request.POST.get('password')
obj = models.UserInfo.objects.filter(username=user,password=pwd).first()
if not obj:
ret['code'] = 1001
ret['msg'] = '用戶名或密碼錯誤'
#為用戶創建token
token = md5(user)
#存在就更新，不存在就創建
models.UserToken.objects.update_or_create(user=obj,defaults={'token':token})
ret['token'] = token
except Exception as e:
ret['code'] = 1002
ret['msg'] = '請求異常'
return JsonResponse(ret)
class OrderView(APIView):
'''
訂單相關業務(只有SVIP用戶才能看)
'''
def get(self,request,*args,**kwargs):
self.dispatch
#request.user
#request.auth
ret = {'code':1000,'msg':None,'data':None}
try:
ret['data'] = ORDER_DICT
except Exception as e:
pass
return JsonResponse(ret)
class UserInfoView(APIView):
'''
訂單相關業務(普通用戶和VIP用戶可以看)
'''
permission_classes = [MyPermission,] #不用全局的權限配置的話，這裏就要寫自己的局部權限
def get(self,request,*args,**kwargs):
print(request.user)
return HttpResponse('用戶信息')
# API/utils/auth/py
from rest_framework import exceptions
from API import models
from rest_framework.authentication import BaseAuthentication
class Authentication(BaseAuthentication):
'''用於用戶登錄驗證'''
def authenticate(self,request):
token = request._request.GET.get('token')
token_obj = models.UserToken.objects.filter(token=token).first()
if not token_obj:
raise exceptions.AuthenticationFailed('用戶認證失敗')
#在rest framework內部會將這兩個字段賦值給request，以供後續操作使用
return (token_obj.user,token_obj)
def authenticate_header(self, request):
pass
# utils/permission.py
from rest_framework.permissions import BasePermission
class SVIPPermission(BasePermission):
message = "必須是SVIP才能訪問"
def has_permission(self,request,view):
if request.user.user_type != 3:
return False
return True
class MyPermission(BasePermission):
def has_permission(self,request,view):
if request.user.user_type == 3:
return False
return True
# utils/throttle.py
#
# from rest_framework.throttling import BaseThrottle
# import time
# VISIT_RECORD = {} #保存訪問記錄
#
# class VisitThrottle(BaseThrottle):
# '''60s內只能訪問3次'''
# def __init__(self):
# self.history = None #初始化訪問記錄
#
# def allow_request(self,request,view):
# #獲取用戶ip (get_ident)
# remote_addr = self.get_ident(request)
# ctime = time.time()
# #如果當前IP不在訪問記錄裏面，就添加到記錄
# if remote_addr not in VISIT_RECORD:
# VISIT_RECORD[remote_addr] = [ctime,] #鍵值對的形式保存
# return True #True表示可以訪問
# #獲取當前ip的歷史訪問記錄
# history = VISIT_RECORD.get(remote_addr)
# #初始化訪問記錄
# self.history = history
#
# #如果有歷史訪問記錄，並且最早一次的訪問記錄離當前時間超過60s，就刪除最早的那個訪問記錄，
# #只要為True，就一直循環刪除最早的一次訪問記錄
# while history and history[-1] < ctime - 60:
# history.pop()
# #如果訪問記錄不超過三次，就把當前的訪問記錄插到第一個位置（pop刪除最後一個）
# if len(history) < 3:
# history.insert(0,ctime)
# return True
#
# def wait(self):
# '''還需要等多久才能訪問'''
# ctime = time.time()
# return 60 - (ctime - self.history[-1])
from rest_framework.throttling import SimpleRateThrottle
class VisitThrottle(SimpleRateThrottle):
'''匿名用戶60s只能訪問三次（根據ip）'''
scope = 'NBA' #這裏面的值，自己隨便定義，settings裏面根據這個值配置Rate
def get_cache_key(self, request, view):
#通過ip限制節流
return self.get_ident(request)
class UserThrottle(SimpleRateThrottle):
'''登錄用戶60s可以訪問10次'''
scope = 'NBAUser' #這裏面的值，自己隨便定義，settings裏面根據這個值配置Rate
def get_cache_key(self, request, view):
return request.user.username
本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理
【其他文章推薦】
※教你寫出一流的銷售文案?
※廣告預算用在刀口上，台北網頁設計公司幫您達到更多曝光效益
※回頭車貨運收費標準
※別再煩惱如何寫文案,掌握八大原則!
※超省錢租車方案
※產品缺大量曝光嗎?你需要的是一流包裝設計!
歐洲斑姬鶲（European pied flycatcher）通常對環境變遷有一定適應能力。Aaron Maizlish攝（CC BY-NC 2.0）
加州的交通狀況。攝（CC0 1.0）