视图的其他写法与频率校验的使用

第一种

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)