drf之自定义频率类、分页功能、排序功能、过滤功能

自定义频率类

from rest_framework.throttling import BaseThrottle

from rest_framework.throttling import BaseThrottle
class MyThrottle(BaseThrottle):
    VISIT_RECORD = {}  # 存放用户访问记录{ip1:[时间1，时间2]，ip2:[时间1，时间2]，'192.168.1.101':[当前时间，]}

    def __init__(self):
        self.history = None
    def allow_request(self, request, view):
        # 在这里写逻辑：根据ip地址判断用户是不是超过了频率限制
        # （1）取出访问者ip
        ip = request.META.get('REMOTE_ADDR')
        import time
        ctime = time.time() # 取出当前时间
        # （2）判断当前ip不在访问字典里，添加进去，并且直接返回True,表示第一次访问
        if ip not in self.VISIT_RECORD:
            self.VISIT_RECORD[ip] = [ctime, ]
            return True
        self.history = self.VISIT_RECORD.get(ip) # 当前访问者的时间列表 [时间2，]
        # （3）循环判断当前ip的时间列表，有值，并且当前时间减去列表的最后一个时间大于60s，把这种数据pop掉，这样列表中只有60s以内的访问时间，
        while self.history and -ctime + self.history[-1] < 60: #循环结束后，剩下的都是1分钟以后访问的时间
            self.history.pop()
        # （4）判断，当列表小于3，说明一分钟以内访问不足三次，把当前时间插入到列表第一个位置，返回True，顺利通过
        # （5）当大于等于3，说明一分钟内访问超过三次，返回False验证失败
        if len(self.history) < 3:
            self.history.insert(0, ctime)
            return True
        else:
            return False

    def wait(self):
        import time
        ctime = time.time()
        return 60 - (ctime - self.history[-1])

频率功能源码剖析(SimpleRateThrottle)

	-源码里执行的频率类的allow_request，读SimpleRateThrottle的allow_request
    
class SimpleRateThrottle(BaseThrottle):
    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):  # 只要类实例化得到对象就会执行，一执行，self.rate就有值了，而且self.num_requests和self.duration
        if not getattr(self, 'rate', None):  # 去频率类中反射rate属性或方法，发现没有，返回了None，这个if判断就符合，执行下面的代码
            self.rate = self.get_rate()  # 返回了  '3/m'
        #  self.num_requests=3
        #  self.duration=60
        self.num_requests, self.duration = self.parse_rate(self.rate)

    def get_rate(self):
         return self.THROTTLE_RATES[self.scope]  # 字典取值，配置文件中咱们配置的字典{'ss': '3/m',}，根据ss取到了 '3/m'

    def parse_rate(self, rate):
        if rate is None:
            return (None, None)
        # rate：字符串'3/m'  根据 / 切分，切成了 ['3','m']
        # num=3,period=m
        num, period = rate.split('/')
        # num_requests=3  数字3
        num_requests = int(num)
        # period='m'  ---->period[0]--->'m'
        # {'s': 1, 'm': 60, 'h': 3600, 'd': 86400}[period[0]]
        # duration=60
        duration = {'s': 1, 'm': 60, 'h': 3600, 'd': 86400}[period[0]]
        # 3     60
        return (num_requests, duration)

    def allow_request(self, request, view):
        if self.rate is None:
            return True
        # 咱们自己写的，返回什么就以什么做限制  咱们返回的是ip地址
        # self.key=当前访问者的ip地址
        self.key = self.get_cache_key(request, view)
        if self.key is None:
            return True
        # self.history 访问者的时间列表，从缓存中拿到，如果拿不到就是空列表，如果之前有 [时间2，时间1]
        self.history = self.cache.get(self.key, [])
        # 当前时间
        self.now = self.timer()
        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()

总结：以后要再写频率类，只需要继承SimpleRateThrottle，重写get_cache_key，配置类属性scope，配置文件中配置一下就可以了

分页功能

查询所有的接口才需要分页
分页后端写法是固定的，前端展现形式是不一样的
PC端的下一页的点击
APP中，翻页是下拉加载更多

drf中分页的使用

from rest_framework.pagination import PageNumberPagination, LimitOffsetPagination, CursorPagination

写一个类，继承drf提供的三个分页类之一
重写某几个类属性
把它配置在继承自GenericAPIView+ListModelMixin的子视图类上
如果继承的是APIView，就需要自己写

page = MyPageNumberPagination()
res = page.paginate_queryset(qs, request)

• 继承PageNumberPagination来写

class Paging(PageNumberPagination):
    page_size = 5                  # 每页显示的数据条数
    page_query_param = 'page'      # 页码的参数名
    page_size_query_param = 'size' # 每页显示条数的参数名
    max_page_size = 10             # 最大显示条数 只有size参数有值才会生效

• 继承LimitOffsetPagination来写

class Paging1(LimitOffsetPagination):
    default_limit = 5             # 每页默认显示多少条
    limit_query_param = 'limit'   # 限制条数的参数名
    offset_query_param = 'offset' # 偏移量的参数名
    max_limit = 10                # 最大限制条数

• 继承CursorPagination来写

class Paging2(CursorPagination):
    cursor_query_param = 'cursor'  # 游标的参数
    page_size = 5                  # 每页显示的条数
    ordering = 'id,price'          # 排序的字段，必须是表中有的字段

排序功能

查询所有才涉及到排序，其它接口都不需要
必须是继承GenericAPIView+ListModelMixin的子视图类上
导入from rest_framework.filters import OrderingFilter

1.配置排序类
    class BookView(ModelViewSet):
        filter_backends = [OrderingFilter,SearchFilter]

2.配置排序字段(必须表里有的字段)
    class BookView(ModelViewSet):
        filter_backends = [OrderingFilter,SearchFilter]
        ordering_fields = ['price','id']  # 排序类

3.支持前端的访问形式
    http://127.0.0.1:8000/books/?ordering=-price,id  # 先按价格的降序排，如果价格一样再按id的升序排

"""
补充
    分页和排序能一起用，但是是先排序后分页的
    price 表示针对id字段进行倒序排序
    peice 表示针对id字段进行升序排序
"""

过滤功能

查询所有才涉及到过滤，其它接口都不需要
restful规范中有一条 请求地址中带过滤条件:分页，排序，过滤统称为过滤
必须是继承GenericAPIView+ListModelMixin的子视图类上

• 内置过滤

使用内置过滤类使用步骤
导入from rest_framework.filters import SearchFilter

1.配置过滤类
    class BookView(ModelViewSet):
        filter_backends = [SearchFilter]  # 过滤类
        search_fields = ['name']

2.配置过滤的字段(必须表里有的字段)
    class BookView(ModelViewSet):
        filter_backends = [SearchFilter]  # 过滤类
        search_fields = ['name','publish']  # 表里有的字段

3.支持前端的访问形式
    http://127.0.0.1:8000/books/?search=三 # 只要name中或publish中有三都能搜出来

"""
注意
    内置过滤类只能通过search来写条件 如果配置了多个过滤字段 是或者的条件
"""

• 第三方过滤类

内置的过滤类 只能通过?search=搜索条件 这种搜索，不能指定 name=三国&publish=出版社
使用pip install django-filter

1.安装pip3 install django-filter
2.配置在视图类中配置：filter_backends = [DjangoFilterBackend, ]
3.配置搜索的字段：filterset_fields = ['name', 'publish']
4.支持的搜索方式：http://127.0.0.1:8008/books/?name=三国演义&publish=南京出版社
    精准搜索，条件是并且的关系

三、自定义过滤类

1.写一个类，继承BaseFilterBackend
2.重写某个方法：filter_queryset，在该方法中实现过滤，返回qs对象
    def filter_queryset(self, request, queryset, view):
        # 在这里面实现过滤，一定要返回qs对象，过滤后的数据
        name = request.query_params.get('name', None)
        publish = request.query_params.get('publish', None)
        qs = queryset.filter(name__icontains=name, publish__icontains=publish)
        return qs
3.配置在视图类上
    filter_backends = [MyFilter, ]