drf之认证、权限、限流、过滤

一 drf认证Authentication

1 drf认证功能介绍

0) 认证，频率，权限
1) 用户是否登录到系统中
2) 后期基本上会用JWT的认证
3) 自定制的认证

2 认证功能源码分析

2.1 源码分析

1) APIView---》dispatch---》self.initial(request, *args, **kwargs)--》self.perform_authentication(request)---》Request.user--->self._authenticate(self):Request类的方法---》self.authenticators:Request类的属性---》在Request对象实例化的时候传入的----》Request在什么时候实例化的？dispatch的时候---》APIView：self.get_authenticators()--》return [auth() for auth in self.authentication_classes]----》如果在自己定义的视图类中写了authentication_classes=[类1，类2]----》Request的self.authenticators就变成了我们配置的一个个类的对象

# # 源码分析详解
# a) APIView---》
    @classmethod
    def as_view(cls, **initkwargs): 
        view = super().as_view(**initkwargs)

	# 调用view下的as_view()
    @classonlymethod
    def as_view(cls, **initkwargs):        
        def view(request, *args, **kwargs):
            self = cls(**initkwargs)
            if hasattr(self, ‘get‘) and not hasattr(self, ‘head‘):
                self.head = self.get
            self.request = request
            self.args = args
            self.kwargs = kwargs
            return self.dispatch(request, *args, **kwargs)

# b) dispatch---》  # 调用了dispatch，APIView中有此方法，故是APIView中的dispatch方法
    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   # 对request进行了属性的赋值

        try:
            self.initial(request, *args, **kwargs)   #  运行位置

# c) self.initial(request, *args, **kwargs)--》
    def initial(self, request, *args, **kwargs):        
        self.perform_authentication(request)  # 运行到此处
        self.check_permissions(request)
        self.check_throttles(request)

# d) self.perform_authentication(request)---》  # 运行
    def perform_authentication(self, request):
        """
        Perform authentication on the incoming request. Note that if you override this and simply ‘pass‘, then authentication will instead be performed lazily, the first time either
 `request.user` or `request.auth` is accessed.        """
        # 不是原生django的user，是新的Request对象的方法
        request.user

# e) Request.user--->  # Request下的user方法
	@property
    def user(self):
        """  Returns the user associated with the current request, as authenticated by the authentication classes provided to the request.   """
        if not hasattr(self, ‘_user‘):
            with wrap_attributeerrors():
                self._authenticate()
        return self._user

# f) self._authenticate(self):Request类的方法---》
    def _authenticate(self):
        """ Attempt to authenticate the request using each authentication instance in turn. """
        for authenticator in self.authenticators:  # 是Request类的属性
            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()

# g) self.authenticators:  Request类的属性---》  h) 在Request对象实例化的时候传入的----》
    def __init__(self, request, parsers=None, authenticators=None, negotiator=None, parser_context=None):
        assert isinstance(request, HttpRequest), (
            ‘The `request` argument must be an instance of ‘
            ‘`django.http.HttpRequest`, not `{}.{}`.‘
            .format(request.__class__.__module__, request.__class__.__name__)
        )
        self._request = request
        self.parsers = parsers or ()
        self.authenticators = authenticators or ()

# i) Request在什么时候实例化的？  dispatch开始的时候的时候---》
    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)  # request在APIView的dispatch这里实例化的

# j) APIView：self.get_authenticators()--》
    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
        )

# k) return [auth() for auth in self.authentication_classes]----》
    def get_authenticators(self):
        """        Instantiates and returns the list of authenticators that this view can use.        """
        return [auth() for auth in self.authentication_classes]  # 一个列表推导式

# l) 如果在自己定义的视图类中写了authentication_classes=[类1，类2]----》
class APIView(View):
    # The following policies may be set at either globally, or per-view.
    authentication_classes = api_settings.DEFAULT_AUTHENTICATION_CLASSES

# m) Request的self.authenticators就变成了我们配置的一个个类的对象

2.2 Request类的: self._authenticate(self) 方法

2) self._authenticate(self):Request类的方法
def _authenticate(self):
     for authenticator in self.authenticators: # BookView中配置的一个个类的对象
            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

3) 只要在视图类中配置authentication_classes = [MyAuthen.LoginAuth, ]
	就会执行上面的方法，执行认证

3 自定义认证类（重点）

from rest_framework.exceptions import AuthenticationFailed
from rest_framework.authentication import SessionAuthentication, BasicAuthentication

# 1 使用（GET方法）
1)-定义一个类，继承BaseAuthentication
class LoginAuth(BaseAuthentication):
    def authenticate(self, request):
        token = request.GET.get(‘token‘)
        res = models.UserToken.objects.filter(token=token).first()
        if res:
            return 元组
        else:
            raise AuthenticationFailed(‘您没有登录‘)

2)-重写authenticate方法

3)-局部使用和全局使用
	-局部：在视图类中配置（只要配置了，就是登录以后才能访问，没配置，不用登录就能访问）
		authentication_classes = [MyAuthen.LoginAuth, ]
	-全局
        REST_FRAMEWORK = {
        "DEFAULT_AUTHENTICATION_CLASSES": ["app01.MyAuthen.LoginAuth", ]
        }
        
4)-注意：
	1) 认证类，认证通过可以返回一个元组，有两个值，第一个值会给，request.user,第二个值会个request.auth
    2) 认证类可以配置多个，按照从前向后的顺序执行，如果前面有返回值，认证就不再继续往下走了

4 认证功能局部使用和全局使用

1) 全局使用（所有接口，都需要登录才能访问）
	-在配置文件中
        REST_FRAMEWORK = {
        "DEFAULT_AUTHENTICATION_CLASSES": ["app01.MyAuthen.LoginAuth", ]
        }

2) 局部使用
	-在想局部使用的视图类上
	authentication_classes = [MyAuthen.LoginAuth,]

3) 局部禁用
	-在想禁用的视图类上
    authentication_classes = []

5 内置认证方案(需要配合权限使用)

5.1 全局使用

# 可以在配置文件中配置全局默认的认证方案
REST_FRAMEWORK = {
    ‘DEFAULT_AUTHENTICATION_CLASSES‘: (
        ‘rest_framework.authentication.SessionAuthentication‘,  # session认证
        ‘rest_framework.authentication.BasicAuthentication‘,   # 基本认证
    )
}

5.2 局部使用

# 也可以在每个视图中通过设置authentication_classess属性来设置
from rest_framework.authentication import SessionAuthentication, BasicAuthentication
from rest_framework.views import APIView

class ExampleView(APIView):
    # 类属性
    authentication_classes = [SessionAuthentication, BasicAuthentication]
    ...

5.3 认证失败的返回值

# 认证失败会有两种可能的返回值：
-401 Unauthorized       # 未认证
-403 Permission Denied  # 权限被禁止

二 def权限Permissions

# 权限控制可以限制用户对于视图的访问和对于具体数据对象的访问。
    -在执行视图的dispatch()方法前，会先进行视图访问权限的判断
    -在通过get_object()获取具体对象时，会进行模型对象访问权限的判断

1 自定义权限功能（重点）

1) 登录成功以后，超级用户可以干某些事，普通用户不能干---》超级用户可以查看某些接口，普通用户不能查看

2) 使用：写一个类继承BasePermission，重写has_permission
    class SuperPermission(BasePermission):
        def has_permission(self, request, view):
            # Return `True` if permission is granted, `False` otherwise.
            # 超级用户可以访问，除了超级用户以外，都不能访问
            if request.user.user_type == ‘1‘:
                return True
            else:
                return False
       
3) 局部使用和全局使用
	-在想局部使用的视图类上
	permission_classes = [MyAuthen.SuperPermission]
    -全局使用
      REST_FRAMEWORK = {
        "DEFAULT_PERMISSION_CLASSES": ["app01.MyAuthen.SuperPermission", ]
        }
     -局部禁用
    permission_classes = []

2 权限功能局部使用和全局使用

# 1 使用方式
1)-在想局部使用的视图类上
	permission_classes = [MyAuthen.SuperPermission]

2)-全局使用
	REST_FRAMEWORK = {
        "DEFAULT_PERMISSION_CLASSES": ["app01.MyAuthen.SuperPermission", ]
        }

3)-局部禁用
    permission_classes = []

3 内置的权限类

# 内置权限类
from rest_framework.permissions import AllowAny,IsAuthenticated,IsAdminUser,IsAuthenticatedOrReadOnly
    - AllowAny          # 允许所有用户
    - IsAuthenticated   # 仅通过认证的用户
    - IsAdminUser       # 仅管理员用户
    - IsAuthenticatedOrReadOnly  # 已经登陆认证的用户可以对数据进行增删改操作，没有登陆认证的只能查看数据。

4 权限源码分析

4.1 源码分析

# 1 源码分析
	-APIView的dispatch---》APIView的initial---》APIView的check_permissions(request)
        for permission in self.get_permissions(): # 权限类对象放到列表中
        if not permission.has_permission(request, self):
            self.permission_denied(
                 request,
                 message=getattr(permission, ‘message‘, None),
                 code=getattr(permission, ‘code‘, None)
                )

4.2 错误信息的中文显示

# 2 错误信息的中文显示
	在权限类中加一个 message=字符串  ————》message=getattr(permission, ‘message‘, None),

5 模型层choice字段使用（重点）

1) 模型表：Student表，写接口应该选择继承哪个视图类
2) 推荐使用自动生成路由的方式（继承ViewSetMixin及它的字类）
3) 但是目前来说，你先实现功能即可（至于选择哪个，慢慢体会）

4) choice的使用
	-在模型类中使用
    sex = models.SmallIntegerField(choices=((1, ‘男‘), (2, ‘女‘), (3, ‘未知‘)), default=1)
    -在视图类中，在序列化类中
    	-get_字段名_dispaly()的方法，该方法获得choice字段对应的数据

三 drf限流Throttling

1 自定义频率类（分析,了解）

1.1 自定义频率类用途及使用

1) 限制某个人，某个ip的访问频次

2) 自定义频率类及使用
from rest_framework.throttling import BaseThrottle
class MyThrottle(BaseThrottle):
    VISIT_RECORD = {}  # 存用户访问信息的大字典
    def __init__(self):
        self.history = None
    def allow_request(self,request,view):
        # 根据ip进行频率限制，每分钟只能访问3次
        # 限制的逻辑
        ‘‘‘
        #（1）取出访问者ip
        #（2）判断当前ip不在访问字典里，添加进去，并且直接返回True, 表示第一次访问，在字典里，继续往下走
        #（3）循环判断当前ip的列表，有值，并且当前时间减去列表的最后一个时间大于60s，把这种数据pop掉，这样列表中只有60s以内的访问时间，
        #（4）判断，当列表小于3，说明一分钟以内访问不足三次，把当前时间插入到列表第一个位置，返回True，顺利通过
        #（5）当大于等于3，说明一分钟内访问超过三次，返回False验证失败
        ‘‘‘
        # （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])   

1.2 局部使用与全局使用

1)-局部使用
	throttle_classes = [auth.MyThrottle,]

2)-全局使用
	REST_FRAMEWORK = {
    ‘DEFAULT_THROTTLE_CLASSES‘:[‘app01.auth.MyThrottle‘,],
}

2 内置频率类使用

2.1 内置频率类

-BaseThrottle：      # 基类
-AnonRateThrottle：  # 限制匿名用户的访问次数
-SimpleRateThrottle：# 我们自定义扩写它
-ScopedRateThrottle：
-UserRateThrottle：  # 限制登录用户访问次数

2.2 扩展内置频率类（重点记住）

# 扩展内置频率类（重点记住）
1)-写一个类，继承SimpleRateThrottle
    class MySimpleThrottle(SimpleRateThrottle):
        scope = ‘xxx‘
        def get_cache_key(self, request, view):
            #以ip限制
            return self.get_ident(request)

2)-setting.py中配置
    REST_FRAMEWORK = {
        ‘DEFAULT_THROTTLE_RATES‘ : {
            ‘xxx‘:‘10/m‘  # key跟scope对应，value是一个时间
        }
    }

3)-局部使用与全局使用

2.3 源码分析

# 源码分析
-继承SimpleRateThrottle---》allow_request（跟咱们写的一样）

2.4 其它内置频率类

# 其它内置频率类
1)-限制未登录用户的频率（AnonRateThrottle）（根据ip限制）
-使用：
	-局部使用，全局使用
	-setting.py中配置
	‘DEFAULT_THROTTLE_RATES‘ : {
    ‘anon‘:‘1/m‘
	}

2)-限制登录用户访问次数 UserRateThrottle（根据用户id限制）
-使用：
    -局部使用，全局使用
    -setting.py中配置
    ‘DEFAULT_THROTTLE_RATES‘ : {
        ‘user‘:‘1/m‘
    }

3)-ScopedRateThrottle(有兴趣看一下，没有就不看了) 

四 过滤Filter与排序

1 内置，第三方过滤功能（次重点）

1) 过滤：筛选查询结果

2) 内置筛选的使用
	-在视图类中配置
        filter_backends = [SearchFilter,]
        search_fields = (‘name‘,) # 表模型中的字段
    -查询的时候
    	http://127.0.0.1:8000/students/?search=e
                
3) 第三方扩展的过滤功能
	-pip3 install django-filter  ：最新版本（2.4.0）要跟django2.2以上搭配
    
    -在视图类中配置
        filter_backends = [DjangoFilterBackend,]
    	filter_fields = [‘name‘,‘age‘]
    -查询的时候
    	http://127.0.0.1:8000/students/?name=lqz&age=18

2 排序功能(次重点)

-在视图类中配置
    filter_backends = [OrderingFilter,]
    ordering_fields = [‘id‘,‘age‘]

-查询的时候
	http://127.0.0.1:8000/students/?ordering=-age
            
            
 ### 过滤后再排序
  -在视图类中配置
    filter_backends = [OrderingFilter,DjangoFilterBackend]
    ordering_fields = (‘id‘, ‘age‘)
    filter_fields = [‘name‘,‘age‘]

  -查询的时候
	http://127.0.0.1:8000/students/?name=lqz&age=19&ordering=-age,-id

3 自定制过滤器

3.1 使用原理

1)-查询所有才会有过滤---》list才需要过滤---》queryset = self.filter_queryset(self.get_queryset())---》GenericAPIView-->filter_queryset

3.2 使用方法

# 基于django-filter扩写

1) 写一个类MyFilter，继承BaseFilterBackend

2) 重写filter_queryset方法，在该方法内部进行过滤（自己设置的过滤条件）
    def filter_queryset(self, queryset):
        for backend in list(self.filter_backends):
            queryset = backend().filter_queryset(self.request, queryset, self)
            return queryset
# self.get_queryset() 就是 models.表名.objects.all()

3) 返回queryset对象（过滤后的queryset对象）

4) 配置在视图类中
	filter_backends = [MyFilter,]

五 拓展

1) select_related的使用
# 基于对象的跨表查询，可以减少查询数据库的次数
articleList=models.Article.objects.select_related("category").all()
for article_obj in articleList:
        #  Doesn‘t hit the database, because article_obj.category
        #  has been prepopulated in the previous query.
        #不再查询数据库，因为第一次查询，数据已经填充进去了
        print(article_obj.category.title)
        
2) mysql的悲观锁和乐观锁

3) drf内部内置了一些认证类，分别干了什么事
	待填坑

drf之认证、权限、限流、过滤