drf的路由和各种自定义

drf的路由

请看这篇博客：
https://zhuanlan.zhihu.com/p/83096958
这篇大佬的博客写的很详细，很容易看懂

drf的登录验证

使用方法

局部使用：
在对应的类下写入以下这段话:
authentication_classes = [认证路由1,…… ]
表示你在这个类中导入了认证(下同)(如果你在全局设置了,这里就不要加了)
例：

class Login_session(APIView):
    authentication_classes = [auth_required]
    def get(self, request):

局部禁用
在对应的类下写入以下这段话:
authentication_classes = [ ]
表示在这个类中覆盖了全局使用的认证，导致没有认证(下同)
例：

class Login_session(APIView):
    authentication_classes = []
    def get(self, request):

全局使用
在setting中写入这段话
REST_FRAMEWORK={
‘DEFAULT_AUTHENTICATION_CLASSES’:[‘认证路由1,’]
}
表示不管你在哪我都要认证，除非你在类中取空(下同)

登录验证的具体写法

class Myauth_rel(BaseAuthentication):  #必须继承BaseAuthentication类
    def authenticate(self, request):   #修改authenticate的方法
        token=request.META.get('HTTP_TOKEN')  #获取你想要验证的key值,我这取得是token
        if token:
            user_token = Auth_token.objects.filter(token=token).first()
            if user_token:
                return user_token.user,token  #必须有返回值,返回是一个元组，第一个为登录用户第二个为登录验证(第二个可以为空)
            else:
                raise AuthenticationFailed('秘钥错误') #将异常放入错误提示信息里面
        else:
            raise AuthenticationFailed('请输入秘钥')

drf的权限验证

局部使用
在对应类下写下这句话
permission_classes = [‘权限路由1,’]

class Login_session(APIView):
    permission_classes = [‘权限路由’]
    def get(self, request):

局部禁用
在对应类下写下这一句
permission_classes = []

class Login_session(APIView):
    permission_classes = []
    def get(self, request):

全局使用
REST_FRAMEWORK={
‘DEFAULT_PERMISSION_CLASSES’: [
‘权限路由’,
],
}

权限认证的具体写法

class UserPermission(BasePermission): #继承BasePermission
    def  has_permission(self, request, view): #重写has_permission这个方法
        # 由于认证已经过了，request内就有user对象了，当前登录用户
        user=request.user  # 当前登录用户
        # 如果该字段用了choice，通过get_字段名_display()就能取出choice后面的中文
        print(user.get_user_type_display())
        if user.user_type==1:
            return True  #True权限通过
        else:
            return False #False不通过

频率

对于频率不需要去自定义,基本使用内置的！！

全局使用
‘DEFAULT_THROTTLE_CLASSES’: ( #限制用户的话可以定义在局部也可以定义在全局
‘rest_framework.throttling.AnonRateThrottle’, #未登录用户
‘rest_framework.throttling.UserRateThrottle’ #已登录用户
),
‘DEFAULT_THROTTLE_RATES’: { #限制频率次数一定要在全局定义
‘user’: ‘10/m’, # 登录用户访问次数10次/分钟
‘anon’: ‘5/m’, # 未登录用户访问次数5次/分钟
}

局部使用

class Login_session(APIView):
						#限制未登录用户	 #限制登录用户
    throttle_classes = [AnonRateThrottle,UserRateThrottle] 
    def get(self, request):

局部禁用

class Login_session(APIView):
    throttle_classes = []
    def get(self, request):

过滤排序

请参考大佬博客:https://www.cnblogs.com/chichung/p/9945295.html
写的同样很详细

自定义异常处理

这里不需要继承任何的类,直接重写方法就好了

def my_exception_handler(exc, context):
	response=exception_handler(exc, context) 
	#两种情况，一个是None，drf没有处理
	#另一种是response对象，django处理了，但是处理的不符合咱们的要求
	if not response:
        if isinstance(exc, ZeroDivisionError):
            return Response(data={'status': 777, 'msg': "除以0的错误" + str(exc)}, status=status.HTTP_400_BAD_REQUEST)
        return Response(data={'status':999,'msg':str(exc)},status=status.HTTP_400_BAD_REQUEST)
    else:
        # return response
        return Response(data={'status':888,'msg':response.data.get('detail')},status=status.HTTP_400_BAD_REQUEST)

当然了，想要引用这个自定义的异常处理需要在全局定义
‘EXCEPTION_HANDLER’: ‘app01.app_auth.my_exception_handler’,

自定义Response对象

class APIResponse(Response): #在Response的基础上进行封装
    def __init__(self,code=100,msg='成功',data=None,status=None,headers=None,**kwargs):
        dic = {'code': code, 'msg': msg}
        if  data:
            dic = {'code': code, 'msg': msg,'data':data}
        dic.update(kwargs)
        super().__init__(data=dic, status=status,headers=headers)

自定义频率

##简单版本
from rest_framework.throttling import ScopedRateThrottle,SimpleRateThrottle
class MyThrottle(SimpleRateThrottle):  #继承上面两种都可以
    scope='luffy'    # 要与setting中的key对应起来,不对应的话,频率无法限制
    def get_cache_key(self, request, view):  #重写get_cache_key
        print(request.META.get('REMOTE_ADDR'))
        return request.META.get('REMOTE_ADDR')   #限制什么就要拿什么
        
setting中配置
REST_FRAMEWORK={
    'DEFAULT_THROTTLE_CLASSES': (
        'utils.throttling.MyThrottle',
    ),
    'DEFAULT_THROTTLE_RATES': {
        'luffy': '3/m'  # key要跟类中的scop对应
    },
}



## 复杂版本
# 自定制频率类，需要写两个方法
	-# 判断是否限次：没有限次可以请求True，限次了不可以请求False
    	def allow_request(self, request, view):
    -# 限次后调用，显示还需等待多长时间才能再访问，返回等待的时间seconds
    	def wait(self):
            
# 代码
import time
class IPThrottle():
    #定义成类属性,所有对象用的都是这个
    VISIT_DIC = {}
    def __init__(self):
        self.history_list=[]
    def allow_request(self, request, view):
        '''
        #（1）取出访问者ip
        #（2）判断当前ip不在访问字典里，添加进去，并且直接返回True,表示第一次访问，在字典里，继续往下走
        #（3）循环判断当前ip的列表，有值，并且当前时间减去列表的最后一个时间大于60s，把这种数据pop掉，这样列表中只有60s以内的访问时间，
        #（4）判断，当列表小于3，说明一分钟以内访问不足三次，把当前时间插入到列表第一个位置，返回True，顺利通过
        #（5）当大于等于3，说明一分钟内访问超过三次，返回False验证失败
        '''

        ip=request.META.get('REMOTE_ADDR')
        ctime=time.time()
        if ip not in self.VISIT_DIC:
            self.VISIT_DIC[ip]=[ctime,]
            return True
        self.history_list=self.VISIT_DIC[ip]   #当前访问者时间列表拿出来
        while True:
            if ctime-self.history_list[-1]>60:
                self.history_list.pop() # 把最后一个移除
            else:
                break
        if len(self.history_list)<3:
            self.history_list.insert(0,ctime)
            return True
        else:
            return False

    def wait(self):
        # 当前时间，减去列表中最后一个时间
        ctime=time.time()

        return 60-(ctime-self.history_list[-1])

#全局使用，局部使用