断点调试使用、认证，权限，频率源码分析(了解)、基于APIView编写分页、异常处理

1|0断点调试使用、认证，权限，频率源码分析(了解)、基于APIView编写分页、异常处理

2|0昨日回顾

2|11.认证的使用

1.有些接口需要登录后才能访问
2.原生的django如何使用认证：auth的user表，auth自带了认证
3.认证类的使用步骤：
	 1.写一个类，继承BaseAuthentication
     2.重写authenticate，在方法中完成认证，并且获取当前登录用户，然后返回
       -代码地址中获取
    	request.query_params.get('token')
       -原生djanngo,取出前端传入的cookie
    	request.COOKIE.get('sessionid')
       -后期从请求头中获取
    	request.META.get('HTTP_TOKEN')

2|22.权限的使用

1 写一个权限类，继承BasePermission
2 重写has_permission方法，在该方法在中实现权限认证，在这方法中，request.user就是当前登录用户
3 如果有权限，返回True
4 没有权限，返回False，定制返回的中文： self.message='中文'
5 局部使用和全局使用
	ACL:访问控制列表
    rbac:公司内部系统，基于角色的访问控制
    abac：rbac升级版，加了属性认证

2|33.频率的使用

1 写一个频率类，继承SimpleRateThrottle
2 重写get_cache_key方法，返回什么，就以什么做限制----》ip，用户id做限制
3 配置一个类属性：scope = 'book_5_m'
4 在配置文件中配置

2|4断点调试使用

程序是debug模式运行的，可以在任意位置停下，看看当前情况下变量数据的情况
方法：
	1.在左侧空白处，点击加入断点(红色的圈)
    2.step over  单步调试   执行下一行
    3.step into  进入到函数内部运行，跳到里面执行
    4.绿色箭头：快速跳到下一个断点

2|5认证，权限，频率源码分析(了解)

1|01 权限类的执行源码

# 权限的源码执行流程
	-写一个权限类，局部使用，配置在视图类的，就会执行权限类的has_permission方法，完成权限校验
    
    
# 之前读过：drf的apiview，在执行视图类的方法之前，执行了3大认证----》dispatch方法中的
    -self.initial(request, *args, **kwargs)---》执行3大认证
    
# APIView类的399行左右：
    def initial(self, request, *args, **kwargs):
        # 能够解析的编码，版本控制。。。。
        self.format_kwarg = self.get_format_suffix(**kwargs)
        neg = self.perform_content_negotiation(request)
        request.accepted_renderer, request.accepted_media_type = neg
        version, scheme = self.determine_version(request, *args, **kwargs)
        request.version, request.versioning_scheme = version, scheme

     	# 认证组件的执行位置
        self.perform_authentication(request)
        # 权限组件  [读它]
        self.check_permissions(request)
        # 频率组件
        self.check_throttles(request)
                
        
    def check_permissions(self, request):
        # self.get_permissions()----》[CommonPermission(),]
        # permission 是我们配置在视图类上权限类的对象
        for permission in self.get_permissions():
            # 权限类的对象，执行has_permission，这就是为什么我们写的权限类要重写has_permission方法	
            # self 是视图类的对象，就是咱们自己的的权限类的has_permission的view参数
            if not permission.has_permission(request, self):
                # 如果return 的是False，就会走这里，走这里是，没有权限
                # 如果配了多个权限类，第一个没过，直接不会再执行下一个权限类了
                self.permission_denied(
                    request,
                    message=getattr(permission, 'message', None),
                    code=getattr(permission, 'code', None)
                )
                
                
# APIView的274行左右  get_permissions
    def get_permissions(self):
        # self.permission_classes  是咱们配置在视图类上的列表，里面是一个个的权限类，没加括号
        # permission_classes = [CommonPermission]
        # [CommonPermission(),]   本质返回了权限类的对象，放到列表中
        return [permission() for permission in self.permission_classes]
    
    
    
    
# 总结：
	-APIView---dispatch----》initial---》倒数第二行---》self.check_permissions(request)
    里面取出配置在视图类上的权限类，实例化得到对象，一个个执行对象的has_permission方法，如果返回False，就直接结束，不再继续往下执行，权限就认证通过
        
    -如果视图类上不配做权限类：permission_classes = [CommonPermission]，会使用配置文件的api_settings.DEFAULT_PERMISSION_CLASSES
    优先使用项目配置文件，其次使用drf内置配置文件

1|02 认证源码分析

# 之前读过：drf的apiview，在执行视图类的方法之前，执行了3大认证----》dispatch方法中的
    -self.initial(request, *args, **kwargs)---》执行3大认证
    
# APIView类的399行左右：
    def initial(self, request, *args, **kwargs):
        # 能够解析的编码，版本控制。。。。
        self.format_kwarg = self.get_format_suffix(**kwargs)
        neg = self.perform_content_negotiation(request)
        request.accepted_renderer, request.accepted_media_type = neg
        version, scheme = self.determine_version(request, *args, **kwargs)
        request.version, request.versioning_scheme = version, scheme

     	# 认证组件的执行位置【读它】
        self.perform_authentication(request)
        # 权限组件 
        self.check_permissions(request)
        # 频率组件
        self.check_throttles(request)
            
 # APIView的316行左右
    def perform_authentication(self, request):
        request.user #咱们觉得它是个属性，其实它是个方法，包装成了数据属性
                
 # Request类的user方法   219行左右
    @property
    def user(self):
        if not hasattr(self, '_user'):
            with wrap_attributeerrors():
                self._authenticate()
        return self._user
    
 # self 是Request的对象，找Request类的self._authenticate()   373 行
    def _authenticate(self):
        # self.authenticators 我们配置在视图类上认证类的一个个对象，放到列表中
        # Request类初始化的时候，传入的
        for authenticator in self.authenticators:
            try:
                # 返回了两个值，第一个是当前登录用户，第二个的token，只走这一个认证类，后面的不再走了
                # 可以返回None，会继续执行下一个认证类
                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是当次请求的新的Request的对象
                #self.auth=token
                self.user, self.auth = user_auth_tuple
                return

        self._not_authenticated()
             
 # self.authenticators  去Request类的init中找     152行左右
    def __init__(self, request, parsers=None, authenticators=None,
                 negotiator=None, parser_context=None):
        .....
        self.authenticators = authenticators or ()
		.....
              
 # 什么时候调用Reqeust的__init__？---》APIVIew的dispatch上面的492行的：request = self.initialize_request(request, *args, **kwargs)-----》385行----》
    def initialize_request(self, request, *args, **kwargs):
        return Request(
            request,
            parsers=self.get_parsers(),
            authenticators=self.get_authenticators(),
            negotiator=self.get_content_negotiator(),
            parser_context=parser_context
        )
  
 # 总结：
	1 配置在视图类上的认证类，会在执行视图类方法之前执行，在权限认证之前执行
    2 自己写的认证类，可以返回两个值或None
    3 后续可以从request.user 取出当前登录用户(前提是你要在认证类中返回

1|03 频率源码分析

# 之前读过：drf的apiview，在执行视图类的方法之前，执行了3大认证----》dispatch方法中的
    -497行左右， self.initial(request, *args, **kwargs)---》执行3大认证
    
# APIView类的399行左右：
    def initial(self, request, *args, **kwargs):
        # 能够解析的编码，版本控制。。。。
        self.format_kwarg = self.get_format_suffix(**kwargs)
        neg = self.perform_content_negotiation(request)
        request.accepted_renderer, request.accepted_media_type = neg
        version, scheme = self.determine_version(request, *args, **kwargs)
        request.version, request.versioning_scheme = version, scheme

     	# 认证组件的执行位置
        self.perform_authentication(request)
        # 权限组件 
        self.check_permissions(request)
        # 频率组件【读它】
        self.check_throttles(request)
        
        
# APIView 的352行
    def check_throttles(self, request):
        throttle_durations = []
        #self.get_throttles() 配置在视图类上的频率类的对象，放到列表中
        # 每次取出一个频率类的对象，执行allow_request方法，如果是False，频率超了，不能再走了
        # 如果是True，没有超频率，可以直接往后
        for throttle in self.get_throttles():
            if not throttle.allow_request(request, self):
                throttle_durations.append(throttle.wait())

        if throttle_durations:
            # Filter out `None` values which may happen in case of config / rate
            # changes, see #1438
            durations = [
                duration for duration in throttle_durations
                if duration is not None
            ]

            duration = max(durations, default=None)
            self.throttled(request, duration)
            
        
# 总结：
	-我们写的频率类：继承BaseThrottle，重写allow_request，在内部判断，如果超频了，就返回False，如果没超频率，就返回True

class SuperThrottle(BaseThrottle):
    VISIT_RECORD = {}

    def __init__(self):
        self.history = None
    def allow_request(self, request, view):
        # 自己写逻辑，判断是否超频
        # （1）取出访问者ip
        # （2）判断当前ip不在访问字典里，添加进去，并且直接返回True,表示第一次访问，在字典里，继续往下走 {ip地址:[时间1，时间2，时间3，时间4]}
        # （3）循环判断当前ip的列表，有值，并且当前时间减去列表的最后一个时间大于60s，把这种数据pop掉，这样列表中只有60s以内的访问时间，
        # （4）判断，当列表小于3，说明一分钟以内访问不足三次，把当前时间插入到列表第一个位置，返回True，顺利通过
        # （5）当大于等于3，说明一分钟内访问超过三次，返回False验证失败

        # （1）取出访问者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
        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])

1|04 自定义频率类(了解)

class SuperThrottle(BaseThrottle):
    VISIT_RECORD = {}

    def __init__(self):
        self.history = None

    def allow_request(self, request, view):
        # 自己写逻辑，判断是否超频
        # （1）取出访问者ip
        # （2）判断当前ip不在访问字典里，添加进去，并且直接返回True,表示第一次访问，在字典里，继续往下走 {ip地址:[时间1，时间2，时间3，时间4]}
        # （3）循环判断当前ip的列表，有值，并且当前时间减去列表的最后一个时间大于60s，把这种数据pop掉，这样列表中只有60s以内的访问时间，
        # （4）判断，当列表小于3，说明一分钟以内访问不足三次，把当前时间插入到列表第一个位置，返回True，顺利通过
        # （5）当大于等于3，说明一分钟内访问超过三次，返回False验证失败
        # （1）取出访问者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
        # self.history  = [时间1]
        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])

2|6基于APIView编写分页

# 基于APIView写分页功能
from rest_framework.views import APIView
from .page import CommonCursorPagination,CursorPagination,CommonLimitOffsetPagination

class BookView(ViewSetMixin, APIView):
    def list(self, request):
        books = Book.objects.all()
        # 1.实例化一个分页对象
        paginator = CommonLimitOffsetPagination()
        # 2.调佣分页类对象的paginator_queryset来完成分页
        page = paginator.paginate_queryset(books,request,self)
        if page is not None:
            serializer = BookSerializer(instance=page,many=True)
            # 3.返回数据，调用paginator的get_paginator_response方法
            return Response({
                'total': paginator.count,
                'next':paginator.get_next_link(),
                'previous':paginator.get_previous_link(),
                'results':serializer.data
            })

2|7异常处理

视图类中如果出了异常，会被异常捕获，捕获后统一处理
drf内置了一个函数，只要上面过程出了异常，就会执行这个函数，这个函数只处理drf的异常

步骤：
	程序主动抛出的异常，函数程序自动出错了，都不会被处理
    解决方法，唯一目标，无论是主动抛异常函数程序运行出错了，都统一按照规定格式返回------>>能记录日志的方法，
    公司里一般返回   {code:999,'msg':'系统错误，请联系管理员'}

from rest_framework.views import exception_handler
from rest_framework.response import Response

def common_exception_handler(exc,context):
    # exc 错误对象
    # context  上下文
    # 只要走到这里，就要记录日志，只有出错了，才会执行下面的代码
    res = exception_handler(exc,context)
    if res:   # 有值，说明返回了Response对象，没有值说明返回None
        res = Response(data={'code':888,'msg':res.data.get('detail','请联系管理员')})
    else:
        res = Response(data={'code':999,'msg':res.data.get('detail','请联系管理员')})
    return res

REST_FRAMEWORK = {
'EXCEPTION_HANDLER': 'app01.exceptions.common_exception_handler',
}

__EOF__

本文作者：泡芙有点甜
本文链接：https://www.cnblogs.com/zx0524/p/17103381.html
关于博主：评论和私信会在第一时间回复。或者直接私信我。
版权声明：本博客所有文章除特别声明外，均采用 BY-NC-SA 许可协议。转载请注明出处！
声援博主：如果您觉得文章对您有帮助，可以点击文章右下角【推荐】一下。您的鼓励是博主的最大动力！