drf组件之自定义频率使用
from rest_framework.throttling import BaseThrottle, SimpleRateThrottle
class MyThrottle(BaseThrottle):
access_record = {}
def __init__(self):
self.history = None
def allow_request(self, request, view):
ip = request.META.get('REMOTE_ADDR')
import time
ctime = time.time()
if ip not in self.access_record:
self.access_record[ip] = [ctime, ]
return True
self.history = self.access_record.get(ip)
while self.history and -ctime + self.history[-1] < -60:
self.history.pop()
if len(self.history) < 5:
self.history.insert(0, ctime)
return True
else:
return False
def wait(self):
import time
ctime = time.time()
return 60 - (ctime - self.history[-1])
drf组件之频率类源码分析
# 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，配置文件中配置一下就可以了
drf组件之分页功能
# drf中分页的使用：
1 写一个类，继承drf提供的三个分页类之一
2 重写某几个类属性
3 把它配置在继承自GenericAPIView+ListModelMixin的子视图类上
4 如果继承的是APIView，需要自己写
page = MyPageNumberPagination()
res = page.paginate_queryset(qs, request)
drf组件之排序功能
# 查询所有才涉及到排序，其它接口都不需要
# 必须是继承GenericAPIView+ListModelMixin的子视图类上
-配置排序类：
filter_backends=[OrderingFilter,]
-配置排序的字段
ordering_fields=['id','price']
-支持前端的访问形式
http://127.0.0.1:8000/books/?ordering=-price,id # 先按价格的降序排，如果价格一样再按id的升序排
# 纯自己写的，继承了APIView的，需要自己从请求地址中取出排序规则，自己排序
-'price','id'=reqeust.query_params.get('ordering').split(',')
-qs = Book.objects.all().order_by('price','id')
# 分页和排序能一起用，但是是先排序后分页的
drf组件之过滤功能
# 查询所有接口才涉及到过滤，其它接口都不需要
# restful规范中有一条，请求地址中带过滤条件：分页，排序，过滤统称为过滤
# 使用内置过滤类使用步骤 查询所有才涉及到排序，其它接口都不需要
必须是继承GenericAPIView+ListModelMixin的子视图类上
-配置过滤类：
filter_backends=[SearchFilter,]
-配置过滤的字段
ordering_fields=['name','publish']
-支持前端的访问形式
http://127.0.0.1:8000/books/?search=三 # 只要name中或publish中有三都能搜出来
# 内置过滤类只能通过search写条件，如果配置了多个过滤字段，是或者的条件
# 不够用：
-第三方：过滤类
-自己写：自己写过滤类
自主练习
urls.py
from django.contrib import admin
from django.urls import path, include
from app01 import views
from rest_framework.routers import SimpleRouter
router = SimpleRouter()
router.register('books', views.BookView, 'books')
urlpatterns = [
path('admin/', admin.site.urls),
path('', include(router.urls))
]
models.py
from django.db import models
class Book(models.Model):
"书籍表"
book_name = models.CharField(max_length=32, verbose_name='书籍名')
book_price = models.IntegerField(verbose_name='书籍价格')
book_publish = models.CharField(max_length=32, verbose_name='书籍出版社')
def __str__(self):
return self.book_name
serializer.py
from rest_framework.serializers import ModelSerializer
from .models import Book
class BookModelSerializer(ModelSerializer):
class Meta:
model = Book
fields = '__all__'
views.py
from rest_framework.viewsets import ViewSetMixin
from rest_framework.mixins import CreateModelMixin
from rest_framework.generics import ListAPIView
from .models import Book
from .serializer import BookModelSerializer
from .page import BookPage, LimitBookPage, CursorBookPage
from rest_framework.filters import OrderingFilter, SearchFilter
class BookView(ViewSetMixin, ListAPIView, CreateModelMixin):
pagination_class = BookPage
queryset = Book.objects.all()
serializer_class = BookModelSerializer
filter_backends = [OrderingFilter, SearchFilter]
Ordering_fields = ['id', 'book_price']
search_fields = ['book_name']
page.py
from rest_framework.pagination import PageNumberPagination, LimitOffsetPagination, CursorPagination
class BookPage(PageNumberPagination):
"基本分页"
page_size = 3
page_query_param = 'page'
page_size_query_param = 'size'
max_page_size = 6
class LimitBookPage(LimitOffsetPagination):
"偏移分页"
page_size = 3
page_query_param = 'limit'
page_size_query_param = 'offset'
max_page_size = 6
class CursorBookPage(CursorPagination):
"游标分页"
cursor_query_param = 'cursor'
page_size = 3
ordering = 'id'
继承APIView，实现分页
class BookView01(APIView):
def get(self, request):
queryset = Book.objects.all() # 取出所有数据
page = BookPage() # 实例化出一个分页类的对象
data = page.paginate_queryset(queryset, request) # 拿到分页后的数据
serializer = BookModelSerializer(instance=data, many=True) # 进行序列化
return page.get_paginated_response(serializer.data) # 最后调用GenericAPIView里边的get_paginated_response方法
浙公网安备 33010602011771号