第一种
from django.shortcuts import render
from rest_framework.response import Response
from rest_framework import serializers
from app01 import models
from rest_framework.views import APIView
# Create your views here.
class PublishSerializers(serializers.ModelSerializer):
class Meta:
model=models.Publish
fields='__all__'
基本视图
class PublishView(APIView):
def get(self, request):
publish_list = models.Publish.objects.all()
bs = PublishSerializers(publish_list, many=True)
# 序列化数据
return Response(bs.data)
def post(self, request):
# 添加一条数据
print(request.data)
bs=PublishSerializers(data=request.data)
if bs.is_valid():
bs.save() # 生成记录
return Response(bs.data)
else:
return Response(bs.errors)
class PublishDetailView(APIView):
def get(self,request,pk):
publish_obj=models.Publish.objects.filter(pk=pk).first()
bs=PublishSerializers(publish_obj,many=False)
return Response(bs.data)
def put(self,request,pk):
publish_obj = models.Publish.objects.filter(pk=pk).first()
bs=PublishSerializers(data=request.data,instance=publish_obj)
if bs.is_valid():
bs.save() # update
return Response(bs.data)
else:
return Response(bs.errors)
def delete(self,request,pk):
models.Publish.objects.filter(pk=pk).delete()
return Response("")
第二种
基于mixins来封装的视图
from rest_framework.mixins import CreateModelMixin,ListModelMixin,RetrieveModelMixin,DestroyModelMixin,UpdateModelMixin
from rest_framework.generics import GenericAPIView
class PublishView(CreateModelMixin,ListModelMixin,GenericAPIView):
queryset = models.Publish.objects.all()
serializer_class = PublishSerializers
def post(self,request, *args, **kwargs):
return self.create(request, *args, **kwargs)
def get(self,request, *args, **kwargs):
return self.list(request, *args, **kwargs)
class PublishDetailView(RetrieveModelMixin,DestroyModelMixin,UpdateModelMixin,GenericAPIView):
queryset = models.Publish.objects.all()
serializer_class = PublishSerializers
def get(self,request, *args, **kwargs):
return self.retrieve(request, *args, **kwargs)
def put(self,request, *args, **kwargs):
return self.update(request, *args, **kwargs)
def delete(self,request, *args, **kwargs):
return self.destroy(request, *args, **kwargs)
第三种写法
from rest_framework.generics import CreateAPIView,ListCreateAPIView,DestroyAPIView,RetrieveUpdateDestroyAPIView
class PublishView(ListCreateAPIView):
queryset = models.Publish.objects.all()
serializer_class = PublishSerializers
class PublishDetailView(RetrieveUpdateDestroyAPIView):
queryset = models.Publish.objects.all()
serializer_class = PublishSerializers
第四种写法
路由
url(r'^publish/$', views.PublishView.as_view({'get':'list','post':'create'})),
url(r'^publish/(?P<pk>d+)/$', views.PublishView.as_view({'get':'retrieve','put':'update','delete':'destroy'})),
from rest_framework.viewsets import ModelViewSet
class PublishView(ModelViewSet):
queryset=models.Publish.objects.all()
serializer_class=PublishSerializers
频率组件使用
-第一步，写一个频率类，继承SimpleRateThrottle
#重写get_cache_key，返回self.get_ident(request)
#一定要记住配置一个scop=字符串
class Throttle(SimpleRateThrottle):
scope = 'lxx'
def get_cache_key(self, request, view):
return self.get_ident(request)
-第二步：在setting中配置
# REST_FRAMEWORK = {
#
# 'DEFAULT_THROTTLE_RATES':{
# 'lxx':'3/m'
# }
# }
-局部使用
-在视图类中配置：
-throttle_classes=[Throttle,]
-全局使用
-在setting中配置
'DEFAULT_THROTTLE_CLASSES':['自己定义的频率类'],
-局部禁用
throttle_classes=[]
自定义频率校验
from django.shortcuts import render
# Create your views here.
from rest_framework.views import APIView
from rest_framework.response import Response
from rest_framework.throttling import SimpleRateThrottle,BaseThrottle
#第一步，写一个频率类，继承SimpleRateThrottle
#重写get_cache_key，返回self.get_ident(request)
#一定要记住配置一个scop=字符串
# 第二步：在setting中配置
# REST_FRAMEWORK = {
#
# 'DEFAULT_THROTTLE_RATES':{
# 'mythro`':'3/m'
# }
# }
class Throttle(SimpleRateThrottle):
scope = 'mythro'
def get_cache_key(self, request, view):
# return request.META.get('REMOTE_ADDR')
#返回什么值，就以什么做过滤，返回用户id，就以用户id做过滤
return self.get_ident(request)
#自定义频率类
class MyThrottle(BaseThrottle):
VISIT_RECORD = {}
def __init__(self):
self.history=None
def allow_request(self,request,view):
#自定义控制每分钟访问多少次，运行访问返回true，不允许访问返回false
# （1）取出访问者ip{ip1:[第二次访问时间，第一次访问时间],ip2:[]}
# （2）判断当前ip不在访问字典里，如果不在添加进去，并且直接返回True,表示第一次访问，在字典里，继续往下走
# （3）循环判断当前ip的列表，有值，并且当前时间减去列表的最后一个时间大于60s，把这种数据pop掉，这样列表中只有60s以内的访问时间，
# （4）判断，当列表小于3，说明一分钟以内访问不足三次，把当前时间插入到列表第一个位置，返回True，顺利通过
# （5）当大于等于3，说明一分钟内访问超过三次，返回False验证失败
# （1）取出访问者ip
# print(request.META)
#取出访问者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
#是个当前访问者ip对应的时间列表 [第一次访问的时间，]
self.history = self.VISIT_RECORD.get(ip)
# （3）循环判断当前ip的列表，有值，并且当前时间减去列表的最后一个时间大于60s，把这种数据pop掉，这样列表中只有60s以内的访问时间，
while self.history and ctime - self.history[-1] > 60:
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])
class Books(APIView):
# throttle_classes=[Throttle,]
throttle_classes=[MyThrottle,]
def get(self,request):
return Response('')
频率校验源码解析
在使用频率校验组件的时候必须要实现get_cache_key方法
class Throttle(SimpleRateThrottle):
scope = 'mythro'
def get_cache_key(self, request, view):
# return request.META.get('REMOTE_ADDR')
#返回什么值，就以什么做过滤，返回用户id，就以用户id做过滤
return self.get_ident(request)