Rest Framework

目录导航

　　一、RESTful 规范

　　二、APIView 组件

　　三、序列化组件

　　四、认证组件

　　五、权限组件

　　六、频率组件

　　七、分页器组件

一、RESTful 规范

• 什么是RESTful规范：

  • 　REST与技术无关，代表的是一种软件架构风格，REST是Representational State Transfer的简称，中文翻译为“表征状态转移”
  • 　REST从资源的角度类审视整个网络，它将分布在网络中某个节点的资源通过URL进行标识，客户端应用通过URL来获取资源的表征，获得这些表征致使这些应用转变状态
  • 　REST与技术无关，代表的是一种软件架构风格，REST是Representational State Transfer的简称，中文翻译为“表征状态转移”
  • 　所有的数据，不过是通过网络获取的还是操作（增删改查）的数据，都是资源，将一切数据视为资源是REST区别与其他架构风格的最本质属性
  • 　对于REST这种面向资源的架构风格，有人提出一种全新的结构理念，即：面向资源架构（ROA：Resource Oriented Architecture）

• RESTful API 设计：

  • API与用户的通信协议，总是使用HTTPs协议。
  • 域名
    • https://api.example.com                         尽量将API部署在专用域名（会存在跨域问题）
    • https://example.org/api/                        API很简单
  • 版本　
    • URL，如：https://api.example.com/v1/
    • 请求头                                                  跨域时，引发发送多次请求
  • 路径，视网络上任何东西都是资源，均使用名词表示（可复数）
    • https://api.example.com/v1/zoos
    • https://api.example.com/v1/animals
    • https://api.example.com/v1/employees
  • method
    • GET      ：从服务器取出资源（一项或多项）
    • POST    ：在服务器新建一个资源
    • PUT      ：在服务器更新资源（客户端提供改变后的完整资源）
    • PATCH  ：在服务器更新资源（客户端提供改变的属性）
    • DELETE ：从服务器删除资源
  • 过滤，通过在url上传参的形式传递搜索条件
    • https://api.example.com/v1/zoos?limit=10：指定返回记录的数量
    • https://api.example.com/v1/zoos?offset=10：指定返回记录的开始位置
    • https://api.example.com/v1/zoos?page=2&per_page=100：指定第几页，以及每页的记录数
    • https://api.example.com/v1/zoos?sortby=name&order=asc：指定返回结果按照哪个属性排序，以及排序顺序
    • https://api.example.com/v1/zoos?animal_type_id=1：指定筛选条件
  • 状态码

　　　　　　'''
　　　　　　200 OK - [GET]：服务器成功返回用户请求的数据，该操作是幂等的（Idempotent）。
　　　　　　201 CREATED - [POST/PUT/PATCH]：用户新建或修改数据成功。
　　　　　　202 Accepted - [*]：表示一个请求已经进入后台排队（异步任务）
　　　　　　204 NO CONTENT - [DELETE]：用户删除数据成功。
　　　　　　400 INVALID REQUEST - [POST/PUT/PATCH]：用户发出的请求有错误，服务器没有进行新建或修改数据的操作，该操作是幂等的。
　　　　　　401 Unauthorized - [*]：表示用户没有权限（令牌、用户名、密码错误）。
　　　　　　403 Forbidden - [*] 表示用户得到授权（与401错误相对），但是访问是被禁止的。
　　　　　　404 NOT FOUND - [*]：用户发出的请求针对的是不存在的记录，服务器没有进行操作，该操作是幂等的。
　　　　　　406 Not Acceptable - [GET]：用户请求的格式不可得（比如用户请求JSON格式，但是只有XML格式）。
　　　　　　410 Gone -[GET]：用户请求的资源被永久删除，且不会再得到的。
　　　　　　422 Unprocesable entity - [POST/PUT/PATCH] 当创建一个对象时，发生一个验证错误。
　　　　　　500 INTERNAL SERVER ERROR - [*]：服务器发生错误，用户将无法判断发出的请求是否成功。

　　　　　　更多看这里：http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html
　　　　　　'''

• • 错误处理，应返回错误信息，error当做key。
  • 返回结果，针对不同操作，服务器向用户返回的结果应该符合以下规范。
    • GET /collection：返回资源对象的列表（数组）

• • • GET　/collection/resource：返回单个资源对象

• • • POST /collection：返回新生成的资源对象

• • • PUT /collection/resource：返回完整的资源对象

• • • PATCH /collection/resource：返回完整的资源对象

• • • DELETE /collection/resource：返回一个空文档
  • Hypermedia API，RESTful API最好做到Hypermedia，即返回结果中提供链接，连向其他API方法，使得用户不查文档，也知道下一步应该做什么。
    • {"link": {
        "rel":   "collection https://www.example.com/zoos",
        "href":  "https://api.example.com/zoos",
        "title": "List of zoos",
        "type":  "application/vnd.yourformat+json"
      }}

• 基于Django实现

　　　　

 urlpatterns = [
     url(r'^users/$', views.Users.as_view()),
     url(r'^users2/$', views.user2),

 ]

路由系统配置

　　　　

 import json

 def  user2(request):
     if request.method=='GET':
         dic = {'status':200,'name': 'lqz2', 'age': 18}
         return HttpResponse(json.dumps(dic))
     elif request.method=='POST':
         dic = {'status': 200, 'msg': '修改成功'}
         return JsonResponse(dic)

 class Users(View):
     def get(self, request):
         dic = {'status':200,'name': 'lqz', 'age': 18}
         return HttpResponse(json.dumps(dic))

     def post(self, request):
         dic = {'status': 200, 'msg': '修改成功'}
         return JsonResponse(dic)

views.py

二、APIView 组件

• 安装djangorestframework

  • 方式一：pip3 install djangorestframework
  • 方式二：pycharm图形化界面安装
  • 方式三：pycharm命令行下安装（装在当前工程所用的解释器下）

• djangorestframework的APIView分析

 @classmethod
     def as_view(cls, **initkwargs):
         """
         Store the original class on the view function.

         This allows us to discover information about the view when we do URL
         reverse lookups.  Used for breadcrumb generation.
         """
         if isinstance(getattr(cls, 'queryset', None), models.query.QuerySet):
             def force_evaluation():
                 raise RuntimeError(
                     'Do not evaluate the `.queryset` attribute directly, '
                     'as the result will be cached and reused between requests. '
                     'Use `.all()` or call `.get_queryset()` instead.'
                 )
             cls.queryset._fetch_all = force_evaluation

         view = super(APIView, cls).as_view(**initkwargs)
         view.cls = cls
         view.initkwargs = initkwargs

         # Note: session based authentication is explicitly CSRF validated,
         # all other authentication is CSRF exempt.
         return csrf_exempt(view)

as_view方法

 def dispatch(self, request, *args, **kwargs):
         """
         `.dispatch()` is pretty much the same as Django's regular dispatch,
         but with extra hooks for startup, finalize, and exception handling.
         """
         self.args = args
         self.kwargs = kwargs
         request = self.initialize_request(request, *args, **kwargs)
         self.request = request
         self.headers = self.default_response_headers  # deprecate?

         try:
             self.initial(request, *args, **kwargs)

             # Get the appropriate handler method
             if request.method.lower() in self.http_method_names:
                 handler = getattr(self, request.method.lower(),
                                   self.http_method_not_allowed)
             else:
                 handler = self.http_method_not_allowed

             response = handler(request, *args, **kwargs)

         except Exception as exc:
             response = self.handle_exception(exc)

         self.response = self.finalize_response(request, response, *args, **kwargs)
         return self.response

dispatch

def initialize_request(self, request, *args, **kwargs):
        """
        Returns the initial request object.
        """
        parser_context = self.get_parser_context(request)

        return Request(
            request,
            parsers=self.get_parsers(),
            authenticators=self.get_authenticators(),
            negotiator=self.get_content_negotiator(),
            parser_context=parser_context
        )

initialize_request

 def initial(self, request, *args, **kwargs):
         """
         Runs anything that needs to occur prior to calling the method handler.
         """
         self.format_kwarg = self.get_format_suffix(**kwargs)

         # Perform content negotiation and store the accepted info on the request
         neg = self.perform_content_negotiation(request)
         request.accepted_renderer, request.accepted_media_type = neg

         # Determine the API version, if versioning is in use.
         version, scheme = self.determine_version(request, *args, **kwargs)
         request.version, request.versioning_scheme = version, scheme

         # Ensure that the incoming request is permitted
         self.perform_authentication(request)
         self.check_permissions(request)
         self.check_throttles(request)

initial方法（内部调用认证，权限和频率）

三、序列化组件

• rest-framework序列化之Serializer

　　　　

 from django.db import models

 # Create your models here.

 class Book(models.Model):
     title=models.CharField(max_length=32)
     price=models.IntegerField()
     pub_date=models.DateField()
     publish=models.ForeignKey("Publish")
     authors=models.ManyToManyField("Author")
     def __str__(self):
         return self.title

 class Publish(models.Model):
     name=models.CharField(max_length=32)
     email=models.EmailField()
     def __str__(self):
         return self.name

 class Author(models.Model):
     name=models.CharField(max_length=32)
     age=models.IntegerField()
     def __str__(self):
         return self.name

models.py

　　　　

 from rest_framework.views import APIView
 from rest_framework.response import Response
 from .models import *
 from django.shortcuts import HttpResponse
 from django.core import serializers

 from rest_framework import serializers

 class BookSerializers(serializers.Serializer):
     title=serializers.CharField(max_length=32)
     price=serializers.IntegerField()
     pub_date=serializers.DateField()
     publish=serializers.CharField(source="publish.name")
     #authors=serializers.CharField(source="authors.all")
     authors=serializers.SerializerMethodField()
     def get_authors(self,obj):
         temp=[]
         for author in obj.authors.all():
             temp.append(author.name)
         return temp
 　　#此处可以继续用author的Serializers，
 　　# def get_authors(self,obj):
 　　　　#     ret=obj.authors.all()
 　　　　#     ss=AuthorSerializer(ret,many=True)
 　　　　#     return ss.data

 class BookViewSet(APIView):

     def get(self,request,*args,**kwargs):
         book_list=Book.objects.all()
         # 序列化方式1:
         # from django.forms.models import model_to_dict
         # import json
         # data=[]
         # for obj in book_list:
         #     data.append(model_to_dict(obj))
         # print(data)
         # return HttpResponse("ok")

         # 序列化方式2:
         # data=serializers.serialize("json",book_list)
         # return HttpResponse(data)

         # 序列化方式3:
         bs=BookSerializers(book_list,many=True)     #many=True代表有多条数据，如果只有一条数据，many=False
         return Response(bs.data)
 　　　　 # 序列化方式4:
 　　    # ret=models.Book.objects.all().values('nid','title')
 　　　　 # dd=list(ret)
         # return HttpResponse(json.dumps(dd))

views.py

　　　　注意：

　　　　　　source 如果是字段，会显示字段，如果是方法，会执行方法，不用加括号（authors=serializers.CharField(source='authors.all')）如在模型中定义一个方法，直接可以在在source指定执行

　　　　　　　　

　　　　　　

class UserInfo(models.Model):
    user_type_choices = (
        (1,'普通用户'),
        (2,'VIP'),
        (3,'SVIP'),
    )
    user_type = models.IntegerField(choices=user_type_choices)

    username = models.CharField(max_length=32,unique=True)
    password = models.CharField(max_length=64)

#视图
ret=models.UserInfo.objects.filter(pk=1).first()
aa=ret.get_user_type_display()

#serializer
xx=serializers.CharField(source='get_user_type_display')

• rest-framework序列化之ModelSerializer

 class BookSerializers(serializers.ModelSerializer):
     class Meta:
         model = models.Book
         # fields = "__all__"
         fields=['nid','title','authors','publish']
         # exclude=('nid',)   #不能跟fields同时用
         # depth = 1    #深度控制，写 几 往里拿几层，层数越多，响应越慢，官方建议0--10之间，个人建议最多3层
     publish=serializers.SerializerMethodField()
     def get_publish(self,obj):
         return obj.publish.name
     authors=serializers.SerializerMethodField()
     def get_authors(self,obj):
         ret=obj.authors.all()
         ss=AuthorSerializer(ret,many=True)
         return ss.data

• 生成hypermedialink（极少数）

 class BookSerializers(serializers.ModelSerializer):
     class Meta:
         model = models.Book
         fields = "__all__"
     # 生成连接，直接查看出版社详情
     publish = serializers.HyperlinkedIdentityField(view_name='ttt', lookup_field='publish_id', lookup_url_kwarg='pkk')
     authors=serializers.SerializerMethodField()
     def get_authors(self,obj):
         ret=obj.authors.all()
         ss=AuthorSerializer(ret,many=True)
         return ss.data
 #--------------

 res=BookSerializers(ret,many=True,context={'request': request})

 #--------------

 class Publish(APIView):
     def get(self,request,pkk):
         print(pkk)
         return HttpResponse('ok')
 #----路由---
 url(r'^publish/(?P<pkk>\d+)$', views.Publish.as_view(),name='ttt'),

• 序列化组件之请求数据校验和保存功能

class BookSerializers(serializers.ModelSerializer):
    class Meta:
        model=Book
        fields="__all__"

#————————
class BookView(APIView):

    def post(self, request):

        # 添加一条数据
        print(request.data)

        bs=BookSerializers(data=request.data)
        if bs.is_valid():
            bs.save()  # 生成记录
            return Response(bs.data)
        else:

            return Response(bs.errors)

class BookSerializer1(serializers.Serializer):
    title=serializers.CharField(error_messages={'required': '标题不能为空'})

#这种方式要保存，必须重写create方法

　　通过源码查看留的校验字段的钩子函数：

 #is_valid---->self.run_validation-(执行Serializer的run_validation)-->self.to_internal_value(data)---（执行Serializer的run_validation：485行）
 def validate_title(self, value):
         from rest_framework import exceptions
         raise exceptions.ValidationError('看你不顺眼')
         return value

 #全局
 def validate(self, attrs):
     from rest_framework import exceptions
     if attrs.get('title')== attrs.get('title2'):
         return attrs
     else:
         raise exceptions.ValidationError('不想等啊')

• 序列化组件源码分析

 '''
 序列化组件，先调用__new__方法，如果many=True，生成ListSerializer对象，如果为False，生成Serializer对象
 序列化对象.data方法--调用父类data方法---调用对象自己的to_representation（自定义的序列化类无此方法，去父类找）
 Aerializer类里有to_representation方法，for循环执行attribute = field.get_attribute(instance)
 再去Field类里去找get_attribute方法，self.source_attrs就是被切分的source，然后执行get_attribute方法，source_attrs
 当参数传过去，判断是方法就加括号执行，是属性就把值取出来
 '''

　　　　图书的增删查改resful接口：

　　　　　　

 class BookSerializers(serializers.ModelSerializer):
     class Meta:
         model=models.Book
         fields='__all__'

 class BookView(APIView):

     def get(self, request):
         book_list = models.Book.objects.all()
         bs = BookSerializers(book_list, many=True)
         # 序列化数据

         return Response(bs.data)

     def post(self, request):
         # 添加一条数据
         print(request.data)

         bs=BookSerializers(data=request.data)
         if bs.is_valid():
             bs.save()  # 生成记录
             return Response(bs.data)
         else:

             return Response(bs.errors)

 class BookDetailView(APIView):
     def get(self,request,pk):
         book_obj=models.Book.objects.filter(pk=pk).first()
         bs=BookSerializers(book_obj,many=False)
         return Response(bs.data)
     def put(self,request,pk):
         book_obj = models.Book.objects.filter(pk=pk).first()

         bs=BookSerializers(data=request.data,instance=book_obj)
         if bs.is_valid():
             bs.save() # update
             return Response(bs.data)
         else:
             return Response(bs.errors)
     def delete(self,request,pk):
         models.Book.objects.filter(pk=pk).delete()

         return Response("")

views.py

　　　　　　

     url(r'^books/$', views.BookView.as_view()),
     url(r'^books/(?P<pk>\d+)$', views.BookDetailView.as_view()),

urls.py

四、认证组件

• 认证简介

　　　　　　只有认证通过的用户才能访问指定的url地址，比如：查询课程信息，需要登录之后才能查看，没有登录，就不能查看，这时候需要用到认证组件

• 局部使用

　　　　

 class User(models.Model):
     username=models.CharField(max_length=32)
     password=models.CharField(max_length=32)
     user_type=models.IntegerField(choices=((1,'超级用户'),(2,'普通用户'),(3,'二笔用户')))

 class UserToken(models.Model):
     user=models.OneToOneField(to='User')
     token=models.CharField(max_length=64)

models.py

　　　　

 from rest_framework.authentication import BaseAuthentication
 class TokenAuth():
     def authenticate(self, request):
         token = request.GET.get('token')
         token_obj = models.UserToken.objects.filter(token=token).first()
         if token_obj:
             return
         else:
             raise AuthenticationFailed('认证失败')
     def authenticate_header(self,request):
         pass

新建认证类（验证通过return两个参数）

　　　　

 def get_random(name):
     import hashlib
     import time
     md=hashlib.md5()
     md.update(bytes(str(time.time()),encoding='utf-8'))
     md.update(bytes(name,encoding='utf-8'))
     return md.hexdigest()
 class Login(APIView):
     def post(self,reuquest):
         back_msg={'status':1001,'msg':None}
         try:
             name=reuquest.data.get('name')
             pwd=reuquest.data.get('pwd')
             user=models.User.objects.filter(username=name,password=pwd).first()
             if user:
                 token=get_random(name)
                 models.UserToken.objects.update_or_create(user=user,defaults={'token':token})
                 back_msg['status']=''
                 back_msg['msg']='登录成功'
                 back_msg['token']=token
             else:
                 back_msg['msg'] = '用户名或密码错误'
         except Exception as e:
             back_msg['msg']=str(e)
         return Response(back_msg)

 class Course(APIView):
     authentication_classes = [TokenAuth, ]

     def get(self, request):
         return HttpResponse('get')

     def post(self, request):
         return HttpResponse('post')

views.py

　　　　

 def get_token(id,salt=''):
     import hashlib
     md=hashlib.md5()
     md.update(bytes(str(id),encoding='utf-8'))
     md.update(bytes(salt,encoding='utf-8'))

     return md.hexdigest()+'|'+str(id)

 def check_token(token,salt=''):
     ll=token.split('|')
     import hashlib
     md=hashlib.md5()
     md.update(bytes(ll[-1],encoding='utf-8'))
     md.update(bytes(salt,encoding='utf-8'))
     if ll[0]==md.hexdigest():
         return True
     else:
         return False

 class TokenAuth():
     def authenticate(self, request):
         token = request.GET.get('token')
         success=check_token(token)
         if success:
             return
         else:
             raise AuthenticationFailed('认证失败')
     def authenticate_header(self,request):
         pass
 class Login(APIView):
     def post(self,reuquest):
         back_msg={'status':1001,'msg':None}
         try:
             name=reuquest.data.get('name')
             pwd=reuquest.data.get('pwd')
             user=models.User.objects.filter(username=name,password=pwd).first()
             if user:
                 token=get_token(user.pk)
                 # models.UserToken.objects.update_or_create(user=user,defaults={'token':token})
                 back_msg['status']=''
                 back_msg['msg']='登录成功'
                 back_msg['token']=token
             else:
                 back_msg['msg'] = '用户名或密码错误'
         except Exception as e:
             back_msg['msg']=str(e)
         return Response(back_msg)
 from rest_framework.authentication import BaseAuthentication
 class TokenAuth():
     def authenticate(self, request):
         token = request.GET.get('token')
         token_obj = models.UserToken.objects.filter(token=token).first()
         if token_obj:
             return
         else:
             raise AuthenticationFailed('认证失败')
     def authenticate_header(self,request):
         pass

 class Course(APIView):
     authentication_classes = [TokenAuth, ]

     def get(self, request):
         return HttpResponse('get')

     def post(self, request):
         return HttpResponse('post')

不存数据库的token验证

　　　　总结：局部使用，只需要在视图类里加入：

　　 　　authentication_classes = [TokenAuth, ]

• 全局使用

REST_FRAMEWORK={
    "DEFAULT_AUTHENTICATION_CLASSES":["app01.service.auth.Authentication",]
}

• 源码分析

 #Request对象的user方法
 @property
 def user(self):
 the authentication classes provided to the request.
         if not hasattr(self, '_user'):
             with wrap_attributeerrors():
                 self._authenticate()
         return self._user

 def _authenticate(self):
         for authenticator in self.authenticators:
             try:
                 user_auth_tuple = authenticator.authenticate(self)
             except exceptions.APIException:
                 self._not_authenticated()
                 raise
             #认证成功，可以返回一个元组，但必须是最后一个验证类才能返回
             if user_auth_tuple is not None:
                 self._authenticator = authenticator
                 self.user, self.auth = user_auth_tuple
                 return

         self._not_authenticated()

self.authenticators

    def get_authenticators(self):
        return [auth() for auth in self.authentication_classes]

认证类使用顺序：先用视图类中的验证类，再用settings里配置的验证类，最后用默认的验证类

五、权限组件

• 权限简介

　　　　　　只用超级用户才能访问指定的数据，普通用户不能访问，所以就要有权限组件对其限制

• 局部使用

　　　　

 from rest_framework.permissions import BasePermission
 class UserPermission(BasePermission):
     message = '不是超级用户，查看不了'
     def has_permission(self, request, view):
         # user_type = request.user.get_user_type_display()
         # if user_type == '超级用户':
         user_type = request.user.user_type
         print(user_type)
         if user_type == 1:
             return True
         else:
             return False
 class Course(APIView):
     authentication_classes = [TokenAuth, ]
     permission_classes = [UserPermission,]

     def get(self, request):
         return HttpResponse('get')

     def post(self, request):
         return HttpResponse('post')

　　　　局部使用只需要在视图类里加入：

　　　　permission_classes = [UserPermission,]

• 全局使用

REST_FRAMEWORK={
    "DEFAULT_AUTHENTICATION_CLASSES":["app01.service.auth.Authentication",],
    "DEFAULT_PERMISSION_CLASSES":["app01.service.permissions.SVIPPermission",]
}

• 源码分析

 def check_permissions(self, request):
     for permission in self.get_permissions():
         if not permission.has_permission(request, self):
             self.permission_denied(
                 request, message=getattr(permission, 'message', None)
                 )

self.get_permissions()

def get_permissions(self):
     return [permission() for permission in self.permission_classes]

权限类使用顺序：先用视图类中的权限类，再用settings里配置的权限类，最后用默认的权限类

六、频率组件

• 频率简介

　　　　　　为了控制用户对某个url请求的频率，比如，一分钟以内，只能访问三次

• 自定义频率类，自定义频率规则

　　　　自定义的逻辑：

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

　　　　代码实现：

　

 class MyThrottles():
     VISIT_RECORD = {}
     def __init__(self):
         self.history=None
     def allow_request(self,request, view):
         #（1）取出访问者ip
         # print(request.META)
         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)
         # （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])

• 内置频率类及局部使用

　　　　　　写一个类，继承自SimpleRateThrottle，（根据ip限制）问：要根据用户现在怎么写

 from rest_framework.throttling import SimpleRateThrottle
 class VisitThrottle(SimpleRateThrottle):
     scope = 'luffy'
     def get_cache_key(self, request, view):
         return self.get_ident(request)

　　　　　　在setting里配置：（一分钟访问三次）

 REST_FRAMEWORK = {
     'DEFAULT_THROTTLE_RATES':{
         'luffy':'3/m'
     }
 }

　　　　　　在视图类里使用

throttle_classes = [MyThrottles,]

　　　　　　错误信息的中文提示：

 class Course(APIView):
     authentication_classes = [TokenAuth, ]
     permission_classes = [UserPermission, ]
     throttle_classes = [MyThrottles,]

     def get(self, request):
         return HttpResponse('get')

     def post(self, request):
         return HttpResponse('post')
     def throttled(self, request, wait):
         from rest_framework.exceptions import Throttled
         class MyThrottled(Throttled):
             default_detail = '傻逼啊'
             extra_detail_singular = '还有 {wait} second.'
             extra_detail_plural = '出了 {wait} seconds.'
         raise MyThrottled(wait)

　　　　　　内置频率限制类：

　　　　

　　　　BaseThrottle是所有类的基类：方法：def get_ident(self, request)获取标识，其实就是获取ip，自定义的需要继承它

　　　　AnonRateThrottle：未登录用户ip限制，需要配合auth模块用

　　　　SimpleRateThrottle：重写此方法，可以实现频率现在，不需要咱们手写上面自定义的逻辑

　　　　UserRateThrottle:登录用户频率限制，这个得配合auth模块来用

　　　　ScopedRateThrottle：应用在局部视图上的（忽略）

• 内置频率类及全局使用

REST_FRAMEWORK = {
    'DEFAULT_THROTTLE_CLASSES':['app01.utils.VisitThrottle',],
    'DEFAULT_THROTTLE_RATES':{
        'luffy':'3/m'
    }
}

• 源码分析

　　　　省略。。。。。。

七、分页器组件

• 简单分页（查看第n页，每页显示n条）

 from rest_framework.pagination import PageNumberPagination
 # 一 基本使用：url=url=http://127.0.0.1:8000/pager/?page=2&size=3，size无效
 class  Pager(APIView):
     def get(self,request,*args,**kwargs):
         # 获取所有数据
         ret=models.Book.objects.all()
         # 创建分页对象
         page=PageNumberPagination()
         # 在数据库中获取分页的数据
         page_list=page.paginate_queryset(ret,request,view=self)
         # 对分页进行序列化
         ser=BookSerializer1(instance=page_list,many=True)
         return Response(ser.data)
 # 二 自定制 url=http://127.0.0.1:8000/pager/?page=2&size=3
 # size=30，无效，最多5条
 class Mypage(PageNumberPagination):
     page_size = 2
     page_query_param = 'page'
     # 定制传参
     page_size_query_param = 'size'
     # 最大一页的数据
     max_page_size = 5
 class  Pager(APIView):
     def get(self,request,*args,**kwargs):
         # 获取所有数据
         ret=models.Book.objects.all()
         # 创建分页对象
         page=Mypage()
         # 在数据库中获取分页的数据
         page_list=page.paginate_queryset(ret,request,view=self)
         # 对分页进行序列化
         ser=BookSerializer1(instance=page_list,many=True)
         # return Response(ser.data)
         # 这个也是返回Response对象，但是比基本的多了上一页，下一页，和总数据条数（了解即可）
         return page.get_paginated_response(ser.data)

setting中配置：

REST_FRAMEWORK = {
    # 每页显示两条
    'PAGE_SIZE':2
}

路由： url(r'^pager/$', views.Pager.as_view()),

新建类： Serializers

 class BookSerializer1(serializers.ModelSerializer):
     class Meta:
         model=models.Book
         # fields="__all__"
         exclude=('authors',)

• 偏移分页（在第n个位置，向后查看n条数据）

 # http://127.0.0.1:8000/pager/?offset=4&limit=3
 from rest_framework.pagination import LimitOffsetPagination
 # 也可以自定制，同简单分页
 class  Pager(APIView):
     def get(self,request,*args,**kwargs):
         # 获取所有数据
         ret=models.Book.objects.all()
         # 创建分页对象
         page=LimitOffsetPagination()
         # 在数据库中获取分页的数据
         page_list=page.paginate_queryset(ret,request,view=self)
         # 对分页进行序列化
         ser=BookSerializer1(instance=page_list,many=True)
         # return page.get_paginated_response(ser.data)
         return Response(ser.data)

• CursorPagination（加密分页，只能看上一页和下一页，速度快）

 from rest_framework.pagination import CursorPagination
 # 看源码，是通过sql查询，大于id和小于id
 class  Pager(APIView):
     def get(self,request,*args,**kwargs):
         # 获取所有数据
         ret=models.Book.objects.all()
         # 创建分页对象
         page=CursorPagination()
         page.ordering='nid'
         # 在数据库中获取分页的数据
         page_list=page.paginate_queryset(ret,request,view=self)
         # 对分页进行序列化
         ser=BookSerializer1(instance=page_list,many=True)
         # 可以避免页码被猜到
         return page.get_paginated_response(ser.data)