认证，权限，节流，版本，解析器的基本使用

认证

• 先自定义认证的类

from rest_framework.authentication import BaseAuthentication
class MyOrderAuthentication(BaseAuthentication):
       在这里实现认证的逻辑
    def authenticate(self, request):
        token = request._request.GET.get('token')
        # 获取到token之后，需要在数据库中查找token
        obj = UserToken.objects.filter(token=token).first()
        if not obj:
            # 没有通过认证
            raise AuthenticationFailed('认证失败')
        # 返回元组（ user, auth ）
        return (obj.user, obj)

• 使用局部配置(在view视图中)

class OrderView(APIView):

通过authentication_classes设置认证类
    authentication_classes = [MyOrderAuthentication,]

 通过authentication_classes设置为空列表,就不再进行认证了
authentication_classes = []

• 如果用全局的话就在settings中配置

首先要先建一个文件夹 将认证的类 放py文件 代码清晰 在settings中配置下路径

REST_FRAMEWORK = {
    'DEFAULT_AUTHENTICATION_CLASSES':['unitls.authentication.MyOrderAuthentication'],
}

• 设置匿名用户

REST_FRAMEWORK = {
'UNAUTHENTICATED_USER': lambda :"匿名用户",
'UNAUTHENTICATED_TOKEN': lambda :'123456',
}

认证的流程

APIView中的as_view方法调用了父类的as_view方法-->然方法后调用dispatch方法-->执行dispatch方法-->执行完这个，得到封装之后Request对象--->获取认证类的列表-->然后执行initial方法--> 调用request的user 方法-->然后执行 self._authenticate方法

权限 跟认证类同

• 跟认证一样 自定义权限类

from rest_framework.permissions import BasePermission

  class MyOrderPermission(BasePermission):
      #自定义权限认证的类，必须要实现has_permission方法
      message = '你不是超级用户，没有权限访问'
      def has_permission(self, request, view):

          #Return `True` if permission is granted, `False` otherwise.
          #返回True表示有权限访问，返回False表示没有权限访问
          if request.user.user_type != 3:
              return False
          return True

---

• 局部使用

 class OrderView(APIView):

  # permission_classes设置权限类
  permission_classes = [MyOrderPermission,]

  # 通过authentication_classes设置为空列表,就不再进行权限认证了
  permission_classes = []

---

• 全局的设定

 REST_FRAMEWORK = {
  'DEFAULT_PERMISSION_CLASSES':['unitls.permission.MyOrderPermission'],
}

---

• 权限的认证流程

APIView中的as_view方法调用了父类的as_view方法-->然方法后调用dispatch方法-->执行dispatch方法-->执行完这个，得到封装之后Request对象--->获取认证类的列表-->然后执行initial方法--> 调用request的user 方法-->然后执行 self._permission方法

节流

• 自定义节流类

class VisitThrottle(object):
    def allow_request(self, request, view):
        return True  # False表示访问频率太高被限制
    def wait(self):
        return None  

---

VISIT_RECORD = {}
 class VisitThrottle(object):

     def __init__(self):
         self.history = None

     def allow_request(self,request,view):
         #实现节流的逻辑
         #基于ip做节流
         # #获取用户访问的IP地址
         # ip_address = request._request.META.get('REMOTE_ADDR')
         ctime = time.time()
         # if ip_address not in VISIT_RECORD:
         #     #第一次访问的时候将访问的时间存储在字典中（ip地址为Key,访问的时间为value值）
         #     VISIT_RECORD[ip_address] = [ctime,]
         #
         # #第二次访问的时候取出访问的历史记录
         # history = VISIT_RECORD[ip_address]

         # 基于用户的节流
         username = request.user.username
         if username not in VISIT_RECORD:
             VISIT_RECORD[username] = [ctime, ]
         history = VISIT_RECORD[username]
         self.history = history

         while history and history[-1] < ctime - 10:
             #如果访问的时间记录超过60秒,就把超过60秒的时间记录移除
             history.pop()

         if len(history) < 6:
             history.insert(0,ctime)
             return True

         return False

     def wait(self):
         #一旦用户访问次数到达阀值,显示用户需要等待的时间
         ctime = time.time()
                     #09:54:30    09:54:28
         return 10 - (ctime - self.history[-1])

• 局部使用

 class OrderView(APIView):
    
    # throttle_classes设置节流类
    throttle_classes = [VisitThrottle,]

• 全局使用

 REST_FRAMEWORK = {
    'DEFAULT_THROTTLE_CLASSES':['unitls.throttle.VisitThrottle'],
 }

• 使用DRF内置的限频类

from rest_framework.throttling import SimpleRateThrottle

#推荐使用这种
class VisitThrottle(SimpleRateThrottle):
    #没有登录用户，每分钟访问10次
    scope = 'logined'
    def get_cache_key(self, request, view):
    return request.user.username

• 全局使用

REST_FRAMEWORK = {
    'DEFAULT_THROTTLE_RATES':{
    'unlogin':'10/m',
    'logined':'3/m',
    },
    'DEFAULT_THROTTLE_CLASSES':['unitls.throttle.VisitThrottle'],
}

版本

• 什么是版本控制？

有时在开发的时候，我们会开发出很多个版本，不同的版本的会返回不同的数据，所以前端要访问不同的版本，后端要传递给相应的类型。

• 自定义版本控制类

 class ParmasVersion(object):
        def determine_version(self, request, *args, **kwargs):
        version = request.query_params.get('version')
        return version

• 使用(局部)

    class VersionView(APIView):
        #设置获取版本的类
        versioning_class = ParmasVersion

• 全局设置

'DEFAULT_VERSIONING_CLASS':'unitls.version.ParmasVersion',

• DRF内置的版本控制类QueryParameterVersioning(局部)

    from rest_framework.versioning import QueryParameterVersioning
    class VersionView(APIView):
        #设置获取版本的类
        versioning_class = QueryParameterVersioning

• 设置文件中的配置信息

REST_FRAMEWORK = {
    'VERSION_PARAM':'version',
    'DEFAULT_VERSION':'v1',
    'ALLOWED_VERSIONS':['v1','v2'],
    }

• 全局设置

REST_FRAMEWORK = {
    'VERSION_PARAM':'version',
    'DEFAULT_VERSION':'v1',
    'ALLOWED_VERSIONS':['v1','v2'],
    'DEFAULT_VERSIONING_CLASS':'rest_framework.versioning.QueryParameterVersioning',
    }

• DRF内置的版本控制类URLPathVersioning(局部)

from rest_framework.versioning import URLPathVersioning
    class VersionView(APIView):
    #设置获取版本的类
    versioning_class = URLPathVersioning

• 设置文件中的配置信息

REST_FRAMEWORK = {
    'VERSION_PARAM':'version',
    'DEFAULT_VERSION':'v1',
    'ALLOWED_VERSIONS':['v1','v2'],
    }

• 全局设置

REST_FRAMEWORK = {
    'VERSION_PARAM':'version',
    'DEFAULT_VERSION':'v1',
    'ALLOWED_VERSIONS':['v1','v2'],
    'DEFAULT_VERSIONING_CLASS':'rest_framework.versioning.URLPathVersioning',
    }

• 如果使用URLPathVersioning，路由格式如下

url(r"^(?P[v1|v2]+)/version/",VersionView.as_view(),name='vvvv')

• 使用 DRF内置的版本控制类URLPathVersioning 反向生成url地址

#反向生成url地址 reverse
    url1 = obj.reverse(viewname='orders',request=request)
    
    #使用django的reverse方法反响生成url地址
    from django.urls import reverse
    url2 = reverse(viewname='orders',kwargs={'version':'v2'})

• 因为开发人员post请求上传数据时，传递的数据类型不同，我们可能在request._request.POST中获取不到数据

 username = request._request.POST.get('username')
    age = request._request.POST.get('age')
    sex = request._request.POST.get('sex')

• DRF内置的解析器FormParser, JSONParser 局部

from rest_framework.parsers import FormParser,JSONParser
   class UserInfoView(APIView):
        parser_classes = [FormParser,JSONParser]
        #这时DRF 内部代码会根据request.Content-Type和解析器支持的media_type比较
        从而选择对应的解析器
        
        def post(self,request,*args,**kwargs):
            # 如果使用JSONParser、FormParser解析数据的话
            data = request.data
            print(data)

解析器

1 请求头中 Content-Type : application/x-www-form-urlencoded,
    2 数据格式： name=alex&age=18

   request.POST 中才有值

    比如 form 表单提交 满足 1,2

        ajax 提交的时候也是默认 1,2 条件
    

    当然可以定义 ajax 发送的请求头和数据格式：
        headers:{'Content-Type':'application/json'}
        data:JSONstringfy({name:'aaa',age:12})
    
        这时候 后台 request.POST 中不再有数据
              可以从 request.BODY 中获取数据
        注意：只有使用 request.data的时候，parser对象才调用

        #如果客户端的Content-Type的值和 application/json 匹配：JSONParser处理数据
        #如果客户端的Content-Type的值和 application/x-www-form-urlencoded 匹配：FormParser处理数据

1 获取用户的请求
2 获取用户的请求体
3 根据用户的请求头 和 parser_classes 中支持的 parser 进行比较
4 parser对象 去请求
5 request.data