drf学习笔记

今日内容概要

• 自定义频率类
• 频率类源码分析
• 分页功能
• 排序功能
• 过滤功能

今日内容详细

自定义频率类

自定义的逻辑

（1）取出访问者ip {192.168.1.13[访问时间3，访问时间2，访问时间1],192.168.1.12:[],192.168.1.14:[]}
（2）判断当前ip不在访问字典里，添加进去，并且直接返回True,表示第一次访问，在字典里，继续往下走
（3）循环判断当前ip的列表，有值，并且当前时间减去列表的最后一个时间大于60s，把这种数据pop掉，这样列表中只有60s以内的访问时间，
（4）判断，当列表小于3，说明一分钟以内访问不足三次，把当前时间插入到列表第一个位置，返回True，顺利通过
（5）当大于等于3，说明一分钟内访问超过三次，返回False验证失败

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])

频率类源码分析

入口：APIView的dispatch的496行上下：self.initial(request, *args, **kwargs)
# self是谁？self是个对象，是谁的对象？ 是视图类的对象---》BookView这些视图类
APIView的initial方法的413行上下有三行代码，分别是认证，权限，频率
    self.perform_authentication(request)  # 认证
    self.check_permissions(request)  # 权限
    self.check_throttles(request)  # 频率

1.APIView的check_throttles方法：352行上下
    def check_throttles(self, request):
        throttle_durations = []
        for throttle in self.get_throttles():  # 配在视图类上频率类列表 频率类的对象
            if not throttle.allow_request(request, self):
                throttle_durations.append(throttle.wait())

# 要写频率类，必须重写allow_request方法，返回True就是没有被频率限制住，返回False就是被频率限制了
2.源码里执行的频率类的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'
        # a = {'s': 1, 'm': 60, 'h': 3600, 'd': 86400}
        # a[period[0]]
        # [period[0]]='m'
        # 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()  # 把所有超过60的数据都剔除，self.history只剩60s以内的访问时间
        if len(self.history) >= self.num_requests:  # 大于等于配置的数字3 
            return self.throttle_failure()  # return False
        return self.throttle_success()  # 把当前时间插入，retrun True

分页功能

使用步骤：

1.写一个类，继承drf提供的三个分页类之一
2.重写某几个类属性
3.把它配置在继承自GenericAPIView+ListModelMixin的子视图类上
4.如果继承得到是APIView，需要自己写
    page = MyPageNumberPagination()
    res = page.paginate_queryset(qs, request)

1. PageNumberPagination---基本分页

前端访问网址形式：

GET  http://127.0.0.1:8000/books/?page=2&size=3

可以在子类中定义的属性：

• page_size 每页数目
• page_query_param 前端发送的页数关键字名，默认为”page”
• page_size_query_param 前端发送的每页数目关键字名，默认为None
• max_page_size 前端最多能设置的每页数量

from rest_framework.pagination import PageNumberPagination,LimitOffsetPagination,CursorPagination

class MyPageNumberPagination(PageNumberPagination):  # 这个用的最多，其他了解
    # 写4个类属性即可
    page_size = 4  # 每页显示的条数
    page_query_param = 'page'  # /books/?page=3  查询第几页的参数
    page_size_query_param = 'size'  # /books/?page=3&size=4  # 查询第三页，每页显示4条
    max_page_size = 10  # 限制通过size查询，最大的条数

2. LimitOffsetPagination---偏移分页

前端访问网址形式：

GET http://127.0.0.1/books/?offset=3&limit=4

可以在子类中定义的属性：

• default_limit 默认限制，默认值与PAGE_SIZE设置一直
• limit_query_param limit参数名，默认’limit’
• offset_query_param offset参数名，默认’offset’
• max_limit 最大limit限制，默认None

class MyLimitOffsetPagination(LimitOffsetPagination):
    default_limit = 3  # 每页显示的条数
    limit_query_param = 'limit'  # /books/?limit=4   这一页显示4条数据
    offset_query_param = 'offset'  # /books/?offset=3&limit=4  # 从第3条开始，取4条数据
    max_limit = 5  # 限制最多显示多少条

3. CursorPagination---游标分页

前端访问网址形式：

GET http://127.0.0.1/books/?cursor=cD0xNQ%3D%3D

可以在子类中定义的属性：

• cursor_query_param:默认查询字段，不需要修改
• page_size：每页数目
• ordering：按什么排序，需要指定

class MyCursorPagination(CursorPagination): # 只能上一页和下一页，它的分页效率是最高的，高于上面所有的分页方式，大数据量的分页，建议使用这种
    cursor_query_param = 'cursor'
    page_size = 3  #每页显示条数
    ordering = 'id'  # 排序，必须是表中得字段

排序功能

# 查询所有才涉及到排序，其它接口都不需要

# 必须是继承GenericAPIView+ListModelMixin的子视图类上
配置排序类：
    filter_backends=[OrderingFilter,]
配置排序的字段：
    ordering_fields=['id','price']
支持前端的访问形式：
    http://127.0.0.1:8000/books/?ordering=-price,id # 先按价格的降序排，如果价格一样再按id的升序排

代码演示：
from rest_framework.filters import OrderingFilter
class BookView(GenericViewSet, ListModelMixin):
    serializer_class = BookSerializer
    queryset = Book.objects.all()

    filter_backends = [OrderingFilter, ]
    ordering_fields = ['price','id' ]


# 纯自己写的，继承了APIView的，需要自己从请求地址中取出排序规则，自己排序
    'price','-id'=reqeust.query_params.get('ordering').split(',')
    qs = Book.objects.all().order_by('price','-id')

 # 分页和排序能一起用，但是是先排序后分页的

过滤功能

内置过滤

# 查询所有才涉及到过滤，其它接口都不需要
# restful规范中有一条，请求地址中带过滤条件：分页，排序，过滤统称为过滤
# 使用内置过滤类使用步骤   查询所有才涉及到排序，其它接口都不需要
必须是继承GenericAPIView+ListModelMixin的子视图类上
    配置过滤类：
        filter_backends=[SearchFilter,]
    配置过滤的字段
        ordering_fields=['name','publish']
    支持前端的访问形式
        http://127.0.0.1:8000/books/?search=三 # 只要name中或publish中有三都能搜出来
# 内置过滤类只能通过search写条件，如果配置了多个过滤字段，是或者的条件

代码演示：
from rest_framework.filters import SearchFilter
class BookView(GenericViewSet, ListModelMixin):
    serializer_class = BookSerializer
    queryset = Book.objects.all()

    filter_backends = [SearchFilter,]
    search_fields=['name','price']  # 按name或price过滤


# 不够用：
第三方：过滤类
自己写：自己写过滤类

作业

# 1 自定义频率类，写一遍
# 2 使用3种分页方式，实现对查询所有数据接口的分页
# 3 带排序，带按名字过滤
# 4 继承APIView，实现分页,返回格式跟之前一样
# class BookView1(APIView):
#     def get(self, request):
#         qs = Book.objects.all()
#         page = MyPageNumberPagination()
#         res = page.paginate_queryset(qs, request)
#         ser = BookSerializer(instance=res,many=True)
#         return Response(ser.data)


# views.py
from rest_framework.viewsets import ViewSetMixin
from rest_framework.generics import ListAPIView
from .models import Book
from .serializer import BookSerializer
from .func import FuncThrottle
from rest_framework.filters import OrderingFilter, SearchFilter
from .pagination import FuncPageNumber, FuncLimitOffset, FuncCursor
from rest_framework.views import APIView
from rest_framework.response import Response


class BookView(ViewSetMixin, ListAPIView):
    queryset = Book.objects.all()
    serializer_class = BookSerializer

    throttle_classes = [FuncThrottle, ]

    pagination_class = FuncPageNumber

    filter_backends = [OrderingFilter, SearchFilter, ]
    ordering_fields = ['price', 'id']
    search_fields = ['name']


class BookView1(APIView):
    def get(self, request):
        books = Book.objects.all()
        page = FuncPageNumber()
        res = page.paginate_queryset(books, request)
        ser = BookSerializer(instance=res, many=True)
        return Response({
            'count': books.count(),
            'next': page.get_next_link(),
            'previous': page.get_previous_link(),
            'results': ser.data
        })


# pagination.py
from rest_framework.pagination import PageNumberPagination, LimitOffsetPagination, CursorPagination


class FuncPageNumber(PageNumberPagination):
    page_size = 3
    page_query_param = 'page'
    page_size_query_param = 'size'
    max_page_size = 5


class FuncLimitOffset(LimitOffsetPagination):
    default_limit = 3
    limit_query_param = 'limit'
    offset_query_param = 'offset'
    max_limit = 5


class FuncCursor(CursorPagination):
    cursor_query_param = 'cursor'
    page_size = 3
    ordering = 'id'


# urls.py
from django.contrib import admin
from django.urls import path
from rest_framework.routers import SimpleRouter
from app01 import views

routers = SimpleRouter()

routers.register('books', views.BookView)

urlpatterns = [
    path('admin/', admin.site.urls),
    path('book/', views.BookView1.as_view()),
]
urlpatterns += routers.urls


# func.py
from rest_framework.throttling import BaseThrottle
import time


class FuncThrottle(BaseThrottle):
    dict = {}

    def __init__(self):
        self.history = None

    def allow_request(self, request, view):
        ip = request.META.get('REMOTE_ADDR')
        ctime = time.time()
        if ip not in self.dict:
            self.dict[ip] = [ctime, ]
            return True
        self.history = self.dict.get(ip)
        while self.history and ctime - self.history[-1] > 60:
            self.history.pop()
        if len(self.history) < 3:
            self.history.insert(0, ctime)
            return True
        return False

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