精华内容
下载资源
问答
  • drf频率组件

    2019-10-02 17:23:58
    drf频率组件 限流Throttling 可以对接口访问的频次进行限制,以减轻服务器压力。 一般用于付费购买次数,投票等场景使用. 使用 # 可以在配置文件中,使用`DEFAULT_THROTTLE_CLASSES` 和 `DEFAULT_THROTTLE_RATES`...

    drf频率组件

    限流Throttling

    可以对接口访问的频次进行限制,以减轻服务器压力。
    
    一般用于付费购买次数,投票等场景使用.

    使用

    # 可以在配置文件中,使用`DEFAULT_THROTTLE_CLASSES` 和 `DEFAULT_THROTTLE_RATES`进行全局配置
    REST_FRAMEWORK = {
        'DEFAULT_THROTTLE_CLASSES': (
            'rest_framework.throttling.AnonRateThrottle',
            'rest_framework.throttling.UserRateThrottle'
        ),
        'DEFAULT_THROTTLE_RATES': {
            'anon': '100/day',
            'user': '1000/day'  # DEFAULT_THROTTLE_RATES` 可以使用 `second`, `minute`, `hour` 或`day`来指明周期。
        }
    }
    
    # 局部配置  在具体视图中通过throttle_classess属性来配置
    from rest_framework.throttling import UserRateThrottle
    from rest_framework.views import APIView
    
    class ExampleView(APIView):
        throttle_classes = (UserRateThrottle,)
        ...
    

    可选限流类

    1) AnonRateThrottle
    
    限制所有匿名未认证用户,使用IP区分用户。
    
    使用`DEFAULT_THROTTLE_RATES['anon']` 来设置频次  # 在配置文件的字典中设置相应的值
    
    2)UserRateThrottle
    
    限制认证用户,使用User id 来区分。
    
    使用`DEFAULT_THROTTLE_RATES['user']` 来设置频次  # 在配置文件的字典中设置相应的值
    
    3)ScopedRateThrottle
    
    限制用户对于每个视图的访问频次,使用ip或user id。
    
    
    class ContactDetailView(APIView):
        throttle_scope = 'contacts'  # 设置在内存中的key
        ...
    
    class UploadView(APIView):
        throttle_scope = 'uploads'
        ...
    REST_FRAMEWORK = {
        'DEFAULT_THROTTLE_CLASSES': (
            'rest_framework.throttling.ScopedRateThrottle',
        ),
        'DEFAULT_THROTTLE_RATES': {
            'contacts': '1000/day',
            'uploads': '20/day'
        }
    }
    

    自定义限流类

    class TimeRateThrottle(SimpleRateThrottle):
        scope = 'time_rate'  # 一定要在settings配置DEFAULT_THROTTLE_RATES
        def get_cache_key(self, request, view):
            # return 'throttle_time_rate'
            if request.user and request.user.is_authenticated:  # 登陆用户
                return 'throttle_%s_%s' % (request.user.username, request.user.pk)
            # 必须写活 - 需要对游客非IP限制条件才需要自定义
            return 'throttle_time_rate'  # 游客,可以从request.META中取出IP等信息作为限制

    转载于:https://www.cnblogs.com/zhouze/p/11385193.html

    展开全文
  • drf频率组件 什么是频率 控制用户对某个url的请求频率,比如一分钟之内,只能访问三次 自定义频率规则 1.取出访问者ip 2.判断当前ip在不在访问字典中: 不在,则添加进去,返回True; 3.循环判断当前ip的列表,有值,并且...

    drf频率组件

    什么是频率
    控制用户对某个url的请求频率,比如一分钟之内,只能访问三次

    自定义频率规则

    1.取出访问者ip
    2.判断当前ip在不在访问字典中:
        不在,则添加进去,返回True;
    3.循环判断当前ip的列表,有值,并且当前时间减去列表的最后一个事件大于60s,(判断最早登陆的是不是超过60s)把这种数据pop掉,这样列表中只有60s以内的访问时间
    4.判断,当前列表小于3,说明一分钟以内访问不足三次,把当前时间插入到列表的第一个位置(最早时间是否超过60s),返回True,顺利通过
    5.当大于等于3,说明一分钟访问超过三次,返回False验证失败

    Http request请求 META(获得用户IP)

    7.HttpRequest.META
    一个标准的Python 字典,包含所有的HTTP 首部。具体的头部信息取决于客户端和服务器,下面是一些示例:
    取值:
    
    CONTENT_LENGTH —— 请求的正文的长度(是一个字符串)。
    CONTENT_TYPE —— 请求的正文的MIME 类型。
    HTTP_ACCEPT —— 响应可接收的Content-Type。
    HTTP_ACCEPT_ENCODING —— 响应可接收的编码。
    HTTP_ACCEPT_LANGUAGE —— 响应可接收的语言。
    HTTP_HOST —— 客服端发送的HTTP Host 头部。
    HTTP_REFERER —— Referring 页面。
    HTTP_USER_AGENT —— 客户端的user-agent 字符串。
    QUERY_STRING —— 单个字符串形式的查询字符串(未解析过的形式)。
    REMOTE_ADDR —— 客户端的IP 地址。
    REMOTE_HOST —— 客户端的主机名。
    REMOTE_USER —— 服务器认证后的用户。
    REQUEST_METHOD —— 一个字符串,例如"GET" 或"POST"。
    SERVER_NAME —— 服务器的主机名。
    SERVER_PORT —— 服务器的端口(是一个字符串)。
    从上面可以看到,除 CONTENT_LENGTH 和 CONTENT_TYPE 之外,请求中的任何 HTTP 首部转换为 META 的键时,
    都会将所有字母大写并将连接符替换为下划线最后加上 HTTP_  前缀。
    所以,一个叫做 X-Bender 的头部将转换成 META 中的 HTTP_X_BENDER 键。
    

    自定义频率控制器

    import time
    class Mythorttle():
        request_dic = {}
        def __init__(self):
            self.history = None
        def allow_request(self, request, view):
            ip = request.META.get('REMOTE_ADDR')
            if not ip:return False
            ctime = time.time()
            if ip not in self.request_dic:
                self.request_dic[ip] = [ctime,]
                return True
            self.history = self.request_dic[ip]
            while self.history and ctime - self.history[-1]>60:
                self.history.pop()
            if len(self.history)>=3:
                return False
            self.history.insert(0,ctime)
            return True
    
        def wait(self):
            return 60 - (time.time()-self.history[-1])

    drf的内置频率控制器

    写一个类,继承自SimpleRateThrottle,(根据ip限制)问:要根据用户现在怎么写
    
    from rest_framework.throttling import SimpleRateThrottle
    class VisitThrottle(SimpleRateThrottle):
        scope = 'num'
        def get_cache_key(self, request, view):
            return self.get_ident(request)
        
        
    在setting里配置:(一分钟访问五次) 
    
    REST_FRAMEWORK = {
        'DEFAULT_THROTTLE_RATES':{
            'num':'5/m'
        }
    }
    
    在视图类里使用
    class Users(ModelViewSet):
        # authentication_classes = [Auth, ]
        throttle_classes = [VisitThrottle,]
        serializer_class = UserSerializer
        queryset = UserInfo.objects.all()

    错误信息中文显示

    class Course(APIView):
        authentication_classes = [TokenAuth, ]
        permission_classes = [UserPermission, ]
        throttle_classes = [MyThrottles,]
        
        def throttled(self, request, wait):
            from rest_framework.exceptions import Throttled
            class MyThrottled(Throttled):
                default_detail = '傻逼啊'
                extra_detail_singular = '还剩 {wait} second.'
                extra_detail_plural = '还剩 {wait} seconds.'
            raise MyThrottled(wait)

    内置频率类及全局使用

    REST_FRAMEWORK = {
        'DEFAULT_THROTTLE_CLASSES':['app01.utils.VisitThrottle',],
        'DEFAULT_THROTTLE_RATES':{
            'luffy':'3/m'
        }
    }

    转载于:https://www.cnblogs.com/robert-zhou/p/10651342.html

    展开全文
  • drf 频率组件使用

    2019-09-25 00:53:44
    局部使用: 首先:环境配置:  pip3 install django-restframework 在app中添加 INSTALLED_APPS = [ 'django.contrib.admin', 'django.contrib.auth', 'django.contrib.contenttypes', 'django.contrib.ses.....

    局部使用:

     

    首先:环境配置:  

    pip3 install django-restframework

    在app中添加 

    INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
      添加rest_framwork
    'rest_framework',
    'movie.apps.MovieConfig',
    ]

     

    第一步:

    from rest_framework.throttling import SimpleRateThrottle
    class VisitThrottle(SimpleRateThrottle):
        scope = 'luffy' #这里的luffy指的是setting的luffy,每minute允许访问的次数
        def get_cache_key(self, request, view):
            return self.get_ident(request)

     

    第二步:在 settings中配置

    REST_FRAMEWORK = {
        'DEFAULT_THROTTLE_RATES':{
            'luffy':'3/m' 每minute允许访问3次
        }
    }

    第三步 :在类视图函数中使用(类视图函数必须继承APIview)

    class Book(APIview):

      throttle_classes = [VisitThrottle,] #这个函数限制每分钟访问3次

      def get(self,request,*args,**kwargs)

        pass

      def post(self,request,*args,**kwargs)

        pass

     

    转载于:https://www.cnblogs.com/jingandyuer/p/11299272.html

    展开全文
  • 导入频率组件,也就是上面的文件 from app01.service.throttle import VisitThrottle # 图书视图类 class BookView(ModelViewSet): # 频率限制 throttle_classes = [VisitThrottle] # 获取图书...

    整理了几个版本的,经过测试目前正常.....

    第一版:

    第一版和第三版引用方式不同,第三版是在视图类里面,第一版是在配置文件引用.

    REST_FRAMEWORK = {
        'DEFAULT_THROTTLE_CLASSES': (
            'throttle.service.throttle_class.VisitThrottle',
        ),
    }

     

    第二版:

    #!/usr/bin/env python
    # -*- coding:utf-8 -*-
    
    # Python
    import time
    # Third-party Library
    from rest_framework.throttling import BaseThrottle
    from rest_framework import exceptions
    
    
    class MyException(exceptions.Throttled):
        default_detail = "你的访问次数超限,请稍后在访问..."
        extra_detail_plural = extra_detail_singular = '请在{wait}秒内访问'
    
        def __init__(self, wait=None, detail=None, code=None):
            super().__init__(wait=wait, detail=detail, code=code)
    
    # 访问记录
    VISITED_RECORD = {}
    
    
    class VisitThrottle(BaseThrottle):
        def __init__(self):
            self.history = None
            self.ctime = time.time()
            self.period = 60
            self.visit_ip = None
    
        # 访问限制方法
        def allow_request(self, request, view):
            visit_ip = self.get_ident(request)
            self.visit_ip = visit_ip
            # visit_ip=request.META.get('REMOTE_ADDR')
            print(visit_ip)
    
    
            # 第一次访问请求
            if visit_ip not in VISITED_RECORD:
                VISITED_RECORD[visit_ip] = [self.ctime]
                return True
            # self.history:当前请求IP的记录列表
            self.history = VISITED_RECORD[visit_ip]
            print(self.history)
    
            # 第2,3,...次访问请求
            if len(VISITED_RECORD[visit_ip]) < 3:
                VISITED_RECORD[visit_ip].insert(0, self.ctime)
                return True
    
            if self.ctime - VISITED_RECORD[visit_ip][-1] > self.period:
                VISITED_RECORD[visit_ip].pop()
                VISITED_RECORD[visit_ip].insert(0, self.ctime)
                return True
            view.throttled = self.throttled
            return False
    
        def wait(self):
            return self.ctime - VISITED_RECORD[self.visit_ip][-1]
    
        def throttled(self, request, wait):
            raise MyException(wait=wait)

     

    第三版:

    #!/usr/bin/env python
    # -*- coding:utf-8 -*-
    """
    功能:限制用户访问频率
    """
    # Django Library
    import time, math
    # Third-party Library
    from rest_framework import exceptions
    
    
    class MyException(exceptions.Throttled):
        default_detail = '连接次数过多...'
        extra_detail_plural = extra_detail_singular = '请在{wait}秒内访问'
    
        def __init__(self, wait=None, detail=None, code=None):
            super().__init__(wait=wait, detail=detail, code=code)
    
    
    class VisitThrottle():
        user_visit_information = dict()
        visited_times = 1
        period = 60
        allow_times_per_minute = 5
        first_time_visit = True
    
        def allow_request(self, request, view):
            self.request_host = request_host = request.META.get("REMOTE_ADDR")
            current_user_info = self.user_visit_information.get(request_host, None)
    
            if not self.__class__.first_time_visit:
                self.user_visit_information[request_host][0] += 1
                current_visit_times = self.user_visit_information[request_host][0]
    
                if current_visit_times > self.allow_times_per_minute:
                    if self._current_time - current_user_info[1] <= self.period:
                        if len(current_user_info) > 2:
                            current_user_info[2] = self._time_left
                        else:
                            current_user_info.append(self._time_left)
    
                        view.throttled = self.throttled
                        return None
                    else:
                        self.__class__.first_time_visit = True
    
            if self.first_time_visit:
                self.__class__.first_time_visit = False
                self._initial_infomation()
    
            return True
    
        def wait(self):
            return self.period - self.user_visit_information[self.request_host][2]
    
        def throttled(self, request, wait):
            raise MyException(wait=wait)
    
        @property
        def _current_time(self):
            return time.time()
    
        @property
        def _time_left(self):
            return math.floor(self._current_time - self.user_visit_information.get(self.request_host)[1])
    
        def _initial_infomation(self):
            self.user_visit_information[self.request_host] = [self.visited_times, self._current_time]

    如何使用上面的代码限制频率

    打开你的视图文件,一般是views.py,如果你把文件修改名字了,那么就放在你修改你后的文件里.

    # 导入频率组件,也就是上面的文件
    from app01.service.throttle import VisitThrottle
    
    # 图书视图类
    class BookView(ModelViewSet):
        # 频率限制
        throttle_classes = [VisitThrottle]
        # 获取图书列表
        queryset = Book.objects.all()
        # 序列化类
        serializer_class = BookSerializer
    
    '''
    注意:
    因为之前写过认证组件和权限组件了,这里只写和频率认证组件有关的代码,就不重复粘代码.
    可以去上一篇把代码粘过来.
    https://www.cnblogs.com/apollo1616/articles/10100264.html
    '''

     

    转载于:https://www.cnblogs.com/apollo1616/articles/10101236.html

    展开全文
  • DRF频率组件

    2018-12-11 16:27:00
    几种drf频率组件使用总结 一 - 定义一个频率类 class RateThrottle(): def allow_request(request, self): if 没有超过限制(伪代码): return True else: return False def wait(...
  • setting中的配置: ... # 全局使用认证组件配置 'DEFAULT_AUTHENTICATION_CLASSES': ['app01.my_author.TokenAuth'], # 全局使用权限组件配置 'DEFAULT_PERMISSION_CLASSES': ['app01.my_author.MyPe...
  • 阅读目录 认证组件 权限组件 频率组件 认证组件 权限组件 频率组件
  • DRF频率

    2019-09-25 23:06:09
    目录 使用自带的频率限制类 使用自定义的频率限制类 "开发平台的API接口调用需要限制其频率,以节约服务器资源和避免恶意的频繁调用. DRF就为我们提供了一些频率限制的方法. ...DRF频率组件原理 ·...
  • ---》用户项目的配置文件(全局配置)----》drf默认的配置文件(不配置) 6 认证源码分析 -所有drf的请求,都会执行APIView的dispatch -Request对象中有个authenticators属性,它是我们在视图类中配置的认证类的...
  • DRF节流组件

    2019-09-27 02:18:23
     和上述的认证组件使用方式一样,定义一个频率组件类,推荐继承BaseThrottle类,  需定义defallow_request(self,request,view):pass方法和defwait(self):pass提示信息方法    seetings.p...
  • DRF视图组件

    2021-04-26 21:45:35
    DRF视图组件 文章目录DRF视图组件一、视图视图继承关系二、2个视图基类1.APIViewAPIView与View示例小结2.GenericAPIView (通用视图类)1.通用视图类介绍2.提供关于序列化器的属性和方法3.示例三、五个视图扩展类1.五...
  • DRF权限和频率组件

    2019-07-15 11:40:00
    权限是什么  大家之前都应该听过权限~那么我们权限到底是做什么用的呢~~  大家都有博客~或者去一些论坛~一定知道管理员这个角色~ ... 那我们看DRF框架给我们提供的权限组件都有哪些方法~~ ...
  • DRF十大组件解析

    2019-08-04 19:23:06
    DRF十大组件 ** 认证 作用,检测用户是否登录 自定义认证类(继承自object) class MyBaseAuthentication(Object): def authenticate(self, request): #完成认证逻辑 def authenticate_header(self, request):...
  • DRF认证组件

    2019-07-15 11:28:00
    如果我们细心我们能看到~版本的下面其实就是我们的认证,权限,频率组件了~~ 我们先看看我们的认证组件~~ 我们进去我们的认证看下~~ 我们这个权限组件返回的是request.user,那我们这里的request是新的还是旧...
  • 目录 一、实现自定义访问频率...二、DRF 内置频率类 - SimpleRateThrottle 2-1 频率控制实现  2-2 源码分析 三、频率类的使用配置 3-1 局部配置 3-2 全局配置 及 局部禁用 四、频率错误信息的中文显示 -...
  • 一 认证组件: 使用方法: 1.写一个认证类,新建文件:my_auth.py class MyAuth(BaseAuthentication): def authenticate(self, request): from app01.views import produce_token #在url中发送token # token = ...
  • 在编程的世界中,我们认为,用户输入的所有数据都是不可靠的,不合法的,直接使用用户输入的数据是不安全的,不仅如此,我们还需要控制用户的访问行为,接下来,我们要学习认证组件、权限组件、频率组件。...
  • DRF十大组件使用

    2019-11-17 19:21:10
    DRF 十大组件总结: 认证 权限 节流 版本 解析器 序列化 分页 视图 路由 渲染器 认证 作用:判断用户是否登录,之后登录后的用户才有权限访问接口 自定义认证类继承BaseAuthentication 认证(判断用户是否登录...
  •  1认证 权限 频率组件原理基本相同  2 认证相关:  session cookie token 认证相关的 这里用token  token 1 有时间限制,超时则失效 2 每次登录更换一个token  3 访问频率限制  1 防止同一时间多次访问的...
  • 认证组件格式: from rest_framework.authentication import BaseAuthentication from rest_framework.exceptions import APIException from .models import UserToken # 1、定义认证类 class UserAuth...
  • 一.DRF的认证组件 token  学习过使用cookie和session两种方式可以保存用户信息,这两种方式不同的是cookie保存在客户端浏览器中,而session保存在服务器中,他们各有优缺点,配合起来使用,可将重要的敏感的信息...
  • 转载于:https://www.cnblogs.com/mpfei/p/10103159.html
  • 关于drf组件

    2019-02-24 21:58:00
    关于版本控制组件:(赋值 reques.version request.versioning_scheme) from rest_framework.versioning import AcceptHeaderVersioning 查看源码 重点:重写 determine_version(request, *args, **kwargs) 方法 ...
  • 三、频率组件 使用方法: 一、认证组件 回到顶部 使用方法: ①写一个认证类,新建文件:my_examine.py -------------------------------------------------------------------- 注:如果你对py...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 417
精华内容 166
关键字:

drf频率组件