drf之认证、权限、频率

认证组件

需求：

有的接口需要登录后才能访问，有的接口，不登录就能访问——这就是登录认证的限制

简单实现的方式：写一个登录接口，返回token，以后只要带着token过来，就是登录了，不带，就没有登录。条件如下：

• 查询所有不需要登录就能访问
• 查询单个，需要登录才能访问

登录接口

# 认证是基于登录的接口上面操作的 所以前戏编写一个简单的登录接口

models.py
class User(models.Model):  # 简易的用户信息账号密码
    username = models.CharField(max_length=32)
    password = models.CharField(max_length=32)

    def __str__(self):
        return self.username

	'跟User表是一对一外键关联，存储用户登录状态用的 [这个表可以没有，如果没有，把字段直接写在User表上也可以]'
class UserToken(models.Model):  # 用户信息登录记录表
    user = models.OneToOneField(to='User', on_delete=models.CASCADE)  # 一对一关联
    token = models.CharField(max_length=32, null=True)  # 如果用户没有登录则没有值 如果登录则有值

views.py
	'登录接口功能:自动生成路由+登录功能，不用序列化，因此继承ViewSet即可'
class UserView(ViewSet):
    @action(methods=['POST'], detail=False, url_path='login', url_name='login')
    def login(self, request):
        username = request.data.get('username')     # 获取用户名与密码
        password = request.data.get('password')
        user = User.objects.filter(username=username, password=password).first()    # 比对用户名与密码
        if user:
            token = str(uuid.uuid4())  
            # uuid4 随机获得永不重复的字符串 机制跟Cookie中的验证码一样
            # 在userToken表中存储一下：1 从来没有登录过，插入一条，     2 登录过，修改记录
            
            
            UserToken.objects.update_or_create(defaults={'token': token}, user=user) 
            # 通过user去UserToken表中查数据，如果能查到，使用defaults的数据更新，如果查不到，直接通过user和defaults的数据新增
            # kwargs 传入的东西查找，能找到，使用defaults的更新，否则新增一条
            return Response({'code': 100, 'msg': '登录成功', 'token': token})
        else:
            return Response({'code': 101, 'msg': '用户名或密码错误'})

urls.py
	from rest_framework.routers import SimpleRouter, DefaultRouter
	router = SimpleRouter()
	router.register('users', views.UserView, 'users')
	urlpatterns += router.urls

'''这个时候一个简单的登录接口就写好了 每次登录都会更新Token 相当于登录了之前的设备就无效了 '''

update_or_create源码如下

    def update_or_create(self, defaults=None, **kwargs):
        defaults = defaults or {}
        self._for_write = True
        with transaction.atomic(using=self.db):
            try:
                obj = self.select_for_update().get(**kwargs)
            except self.model.DoesNotExist:
                params = self._extract_model_params(defaults, **kwargs)
                obj, created = self._create_object_from_params(kwargs, params, lock=True)
                if created:
                    return obj, created
            for k, v in defaults.items():
                setattr(obj, k, v() if callable(v) else v)
            obj.save(using=self.db)
        return obj, False

认证组件使用步骤

• 1、需要写一个认证类，因此我们需要在应用中另外创建一个py文件编写认证类，需要继承BaseAuthentication这个类

通过查看源码我们可以发现有个authenticate方法需要我们重写，否则就会报错，这就是我们需要编写认证功能的类。

class BaseAuthentication:
    def authenticate(self, request):
        raise NotImplementedError(".authenticate() must be overridden.")

    def authenticate_header(self, request):
        pass

• 2、重写authenticate方法，在该方法在中实现登录认证

token在哪带的？如何认证它是登录了的？

用token来判断是否登陆，登陆了在访问的时候带上token，目前阶段我们直接在地址栏中携带token的数据，后面可以在请求头中添加token的数据

• 3、如果认证成功，返回两个值【返回None或两个值（固定的：当前登录用户，token）】
• 4、认证不通过，用AuthenticationFailed类抛异常

代码如下：

authenticate.py(认证类)

# 自己写的认证类，继承某个类

from rest_framework.authentication import BaseAuthentication
from rest_framework.exceptions import AuthenticationFailed
from .models import UserToken


class LoginAuth(BaseAuthentication):
    def authenticate(self, request):
        # 在这里实现认证，如果是登录的，继续往后走返回两个值，如果不是抛异常
        # 请求中是否携带token，判断是否登录，放在地址栏中
        token = request.query_params.get('token', None) # 查找是否有token这个变量名的值，如果没有就返回None，默认好像返回的是数字
        if token:  # 前端传入token了，去表中查，如果能查到，登录了，返回两个值[固定的：当前登录用户，token]
            user_token = UserToken.objects.filter(token=token).first()
            if user_token:
                return user_token.user, token
            else:
                # 没有登录抛异常
                raise AuthenticationFailed('token认证失败')
        else:
            raise AuthenticationFailed('token没传')

# 前端传入的请求头中的数据从哪取？  GET，body，POST，data

• 5、认证类的使用

当我们编写好了认证类中的认证代码，接着就需要导入到视图层然后使用他。

from rest_framework.generics import ListAPIView, RetrieveAPIView
from rest_framework.viewsets import ViewSetMixin
from .authenticate import LoginAuth

# 查询所有
class BookView(ViewSetMixin, ListAPIView):
    queryset = Book.objects.all()
    serializer_class = BookSerializer


    
    
class BookDetailView(ViewSetMixin, RetrieveAPIView):
    queryset = Book.objects.all()
    serializer_class = BookSerializer
    authentication_classes = [LoginAuth]  # 需要写一个认证类，需要咱们自行编写

• 6、局部使用和全局使用

局部使用：只在某个视图类中使用【当前视图类管理的所有接口】

        class BookDetailView(ViewSetMixin, RetrieveAPIView):
            authentication_classes = [LoginAuth] 

全局使用：在配置文件settings.py中编写，全局所有接口都生效

    REST_FRAMEWORK = {
    	'DEFAULT_AUTHENTICATION_CLASSES':['app01.authenticate.LoginAuth']
	}

注意事项：不要在配置文件中乱导入不使用的东西，否则会报错，但是在导入类似认证类这样的文件时，可以写上导入的代码然后再修改，最后写进配置中，这样可以减少错误。

局部禁用：（登陆接口很明显是不需要校验是否登陆的，因此有了这个局部禁用的需求，我们把他的authentication_classes配置成空就是局部禁用）

    	 class BookDetailView(ViewSetMixin, RetrieveAPIView):
            authentication_classes = [] 

• 7、测试路由参考

整体代码

views.py

# 查询所有
class BookView(ViewSetMixin, ListAPIView):
    queryset = Book.objects.all()
    serializer_class = BookSerializer


# 查询单个
class BookDetailView(ViewSetMixin, RetrieveAPIView):
    queryset = Book.objects.all()
    serializer_class = BookSerializer
    authentication_classes = [LoginAuth]  # 需要写一个认证类，需要咱们自行编写

authenticate.py(认证类)

# 自己写的认证类，继承某个类

from rest_framework.authentication import BaseAuthentication
from rest_framework.exceptions import AuthenticationFailed
from .models import UserToken


class LoginAuth(BaseAuthentication):
    def authenticate(self, request):
        # 在这里实现认证，如果是登录的，继续往后走返回两个值，如果不是抛异常
        # 请求中是否携带token，判断是否登录，放在地址栏中
        token = request.query_params.get('token', None) # 查找是否有token这个变量名的值，如果没有就返回None，默认好像返回的是数字
        if token:  # 前端传入token了，去表中查，如果能查到，登录了，返回两个值[固定的：当前登录用户，token]
            user_token = UserToken.objects.filter(token=token).first()
            if user_token:
                return user_token.user, token
            else:
                # 没有登录抛异常
                raise AuthenticationFailed('token认证失败')
        else:
            raise AuthenticationFailed('token没传')

# 前端传入的请求头中的数据从哪取？  GET，body，POST，data

urls.py

from django.contrib import admin
from django.urls import path, include
from app01 import views
from rest_framework.routers import SimpleRouter

router = SimpleRouter()  # 后面这个少的用的多,
router.register('user', views.UserView, 'user')
router.register('books', views.BookView, 'books')
router.register('books', views.BookDetailView, 'books')

urlpatterns = [
    path('admin/', admin.site.urls),
    path('api/v1/', include(router.urls)),

]

认证时cookie的获取方式

• 当前端从地址栏中返回cookie时，就跟我们代码中返回token是一样的，获取方式：

request.query_params.get('token')

• 原生djangozhong ，取出前端传入cookie(即前端直接传入cookie)，从哪取的？

request.COOKIE.get('sessionid')

• 后期如果想从请求头中取cookie

request.META.get('HTTP_TOKEN')

权限组件

需求分析：

在一些软件中即便我们登陆成功了有些接口，还是不能访问，因为没有权限。

这里我们的需求是：

	-查询单个需要超级管理员才能访问
    -查询所有，所有登录用户都能访问

而我们的User表中并没有字段用于区分用户权限，因此这里我们需要手动创建一个新的user_type字段：

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

权限的使用

• 1、跟认证类的使用类似，需要先创建一个py文件编写权限类，需要继承BasePermission父类
• 2、这里我们需要重写has_permission方法，在该方法在中实现权限认证，在这方法中，request.user就是当前登录用户（简单来说就是因为认证组件校验的时候返回的是user，这里不展开讲解，后面会讲）
• 3、如果有权限，返回True。没有权限，返回False，并给当前对象产生一个定制的返回信息： self.message='中文'
• 4、在视图层中导入使用（测试的时候路由跟认证组件中的一样）
• 5、局部使用和全局使用

局部使用：只在某个视图类中使用【当前视图类管理的所有接口】

        class BookDetailView(ViewSetMixin, RetrieveAPIView):
    		permission_classes = [CommonPermission]

全局使用：在配置文件settings.py中编写，全局所有接口都生效

          REST_FRAMEWORK = {
            'DEFAULT_PERMISSION_CLASSES': [
                'app01.permissions.CommonPermission',
            ],

        }

局部禁用：局部配置中的配置信息改成空就可以设置成局部禁用

    	 class BookDetailView(ViewSetMixin, RetrieveAPIView):
            permission_classes = [] 

代码

整体部分不需要修改，跟认证组件末尾的代码一样，需要修改的代码如下：

models.py（修改User表的配置后需要重新进行数据库迁移）

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

permission.py（权限类）

# 写权限类，写一个类，继承基类BasePermission，重写has_permission方法，在方法中实现权限认证,如果有权限return True ，如果没有权限，返回False
from rest_framework.permissions import BasePermission


class CommonPermission(BasePermission):
    def has_permission(self, request, view):
        # 实现权限的控制  ---》知道当前登录用户是谁？当前登录用户是  request.user
        if request.user.user_type == 1:
            return True
        else:
            # 没有权限，向对象中放一个属性 message
            # 如果表模型中，使用了choice，就可以通过  get_字段名_display()  拿到choice对应的中文
            self.message = '您是【%s】，您没有权限' % request.user.get_user_type_display()
            return False

views.py

别的部分也不需要改，主要是查询单个部分需要改

from .permissions import CommonPermission


class BookDetailView(ViewSetMixin, RetrieveAPIView):
    queryset = Book.objects.all()
    serializer_class = BookSerializer
    # authentication_classes = [LoginAuth]  # 需要写一个认证类，需要咱们写
    permission_classes = [CommonPermission]

频率组件

需求分析：

我们需要控制某个接口被访问的频率（次数）

通常来说我们是想着某个ip的访问次数

使用步骤

• 1、跟前两个组件类似，需要先创建一个py文件编写频率类，需要继承SimpleRateThrottle父类
• 2、重写get_cache_key方法（可以在源码中发现这个方法不重写会报错），这个方法返回什么，就以什么做限制，比如我们返回ip，就以用户id做限制
• 3、编写完方法后我们在频率类中还需要配置一个scope属性，这个属性影响着配置文件中的使用
• 4、在settings.py中添加配置，设置限制的方式

    'DEFAULT_THROTTLE_RATES': {
        'lqz': '5/h',
    },

我们在scope属性中写什么，这里的配置的key就是什么，后面的value是频率限制的方式，有以下几种：3/m（分） 3/h（小时） 3/s（秒） 3/d（天），这里只要开头字母符合条件即可，写成mxxx也会自动识别到的。

• 5、接着我们在视图类中以类似前面两个组件的方式使用即可（测试路由也基本一样）
• 6、局部使用和全局使用

局部使用：只在某个视图类中使用【当前视图类管理的所有接口】

from .throttling import CommonThrottle

class BookDetailView(ViewSetMixin, RetrieveAPIView):
    throttle_classes = [CommonThrottle]

全局使用：在配置文件settings.py中编写，全局所有接口都生效

          REST_FRAMEWORK = {
             'DEFAULT_THROTTLE_CLASSES': ['app01.throttling.CommonThrottle'],

        }

局部禁用:局部配置中的配置信息改成空就可以设置成局部禁用

    	 class BookDetailView(ViewSetMixin, RetrieveAPIView):
            throttle_classes = [] 

代码

throttling.py（频率类）

# 频率类，不继承BaseThrottle，继承SimpleRateThrottle，少写代码
from rest_framework.throttling import BaseThrottle, SimpleRateThrottle


class CommonThrottle(SimpleRateThrottle):
    # 类属性，属性值随便写
    # 配置文件中配置
    scope = 'lqz'

    def get_cache_key(self, request, view):
        # 返回什么，就以什么做频率限制【可以返回ip  或用户ID】
        # 客户端的ip地址从哪里拿？
        return request.META.get('REMOTE_ADDR')  # 以ip做限制
        # return request.user.pk  # 以用户id做限制

settings.py

# 以后这个配置项，就是该项目drf的自有配置
REST_FRAMEWORK = {
    'DEFAULT_THROTTLE_RATES': {
        'lqz': '5/h',
    },
    'DEFAULT_THROTTLE_CLASSES': ['app01.throttling.CommonThrottle'],
}
'最后这个是全局配置的配置代码'

views.py

from .throttling import CommonThrottle

class BookDetailView(ViewSetMixin, RetrieveAPIView):
    queryset = Book.objects.all()
    serializer_class = BookSerializer
    # authentication_classes = [LoginAuth]  # 需要写一个认证类，需要咱们写
    # permission_classes = [CommonPermission]
    throttle_classes = [CommonThrottle]

权限组件源码分析

# 0 目标
	1 为什么写一个类继承BasePermission，重写has_permission
    	-可以不继承这个类，只重写这个方法也可以
    2 权限类中 self.message  会返回给前端
    3 局部配置：放在视图类中：permission_classes = [CommonPermission]
    4 全局配置，配置在配置文件中也可以--》视图类中就没有
    	就会使用：permission_classes = api_settings.DEFAULT_PERMISSION_CLASSES
        优先从你项目的配置文件配置的DEFAULT_PERMISSION_CLASSES取，如果没有
        就会去drf的配置文件DEFAULT_PERMISSION_CLASSES取
# 1 从哪里开始找？
	-继承APIView后，权限是在执行视图类的方法之前执行的
    -执行视图类的方法---》dispath中
        def dispatch(self, request, *args, **kwargs):

        try:
            # 三大认证：认证，权限，频率
            self.initial(request, *args, **kwargs)
            ####执行视图类的方法开始###
            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)
        return self.response
    
#2 找到APIView的initial
    def initial(self, request, *args, **kwargs):
        self.perform_authentication(request)#认证
        self.check_permissions(request)#权限 
        self.check_throttles(request)#频率
        
# 3 self.check_permissions(request)---APIView
    def check_permissions(self, request):
        # self是 视图类的对象
        #self.get_permissions [CommonPermission(),]--->咱们配置的一个个权限类的对象，放到列表中
        # permission 权限类的对象
        for permission in self.get_permissions():
            # 咱们写的权限类，要重写has_permission，传了俩参数
            # 参数：request 是新的request
            # 参数：self 是？视图类的对象，就是咱么在视图类中写的self，它里面有
            # request和action等
            if not permission.has_permission(request, self):
                # 视图类的对象，没有权限
                self.permission_denied(
                    request,
                    # 从权限类的对象中反射了message，就是写的给前端看的文字
                    message=getattr(permission, 'message', None),
                    #响应状态码
                    code=getattr(permission, 'code', None)
                )
                
# 4 self.get_permissions() ---> APIView的
    def get_permissions(self):
        # 咱么视图类上配置的 permission_classes = [CommonPermission]
        # 返回值是 [CommonPermission(),]--->咱们配置的一个个权限类的对象，放到列表中
        return [permission() for permission in self.permission_classes]
    
    
# 5 self.permission_denied  --》APIView中
  def permission_denied(self, request, message=None, code=None):
        if request.authenticators and not request.successful_authenticator:
            raise exceptions.NotAuthenticated()
        # 抛了异常，会被全局异常捕获，detai会放在响应体中，code会放在响应状态码中
        raise exceptions.PermissionDenied(detail=message, code=code)
        

认证类源码

-继承APIView后，权限是在执行视图类的方法之前执行的
    -执行视图类的方法---》dispath中
        def dispatch(self, request, *args, **kwargs):

        try:
            # 三大认证：认证，权限，频率
            self.initial(request, *args, **kwargs)
            ####执行视图类的方法开始###
            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)
        return self.response
    
#2 找到APIView的initial
    def initial(self, request, *args, **kwargs):
        self.perform_authentication(request)#认证
        self.check_permissions(request)#权限 
        self.check_throttles(request)#频率
        
# 3 self.perform_authentication(request)
  def perform_authentication(self, request):
        request.user # 新的request对象
        
        
# 4 Request类中找 user 方法包装成了数据属性
	from rest_framework.request import Request
    @property
    def user(self):
        if not hasattr(self, '_user'):
            with wrap_attributeerrors():
                # self是 新的request对象
                self._authenticate() # 一开始没有，就走了self._authenticate()
        return self._user
    
    
# 5  Request类中找_authenticate()
    def _authenticate(self):
        # 拿出你配置在视图类上一个个认证类的对象  LoginAuth()
        # authenticator就是LoginAuth()
        for authenticator in self.authenticators:
            try:
                # 为什么咱么要重写 authenticate
                #self是谁？request就是认证类的 def authenticate(self, request):
                # 正常返回两个值：return user, user_token
                # 如果抛了异常：AuthenticationFailed--》捕获了APIException
                user_auth_tuple = authenticator.authenticate(self)
            except exceptions.APIException:
                self._not_authenticated()
                raise
            if user_auth_tuple is not None:#正常返回了两个值
                self._authenticator = authenticator
                # 解压赋值：self是request
                #后续在视图类中 request.user 就是当前登录用户
                self.user, self.auth = user_auth_tuple
                return
        self._not_authenticated()
        
        
# 6 咱们视图类中得认证类可以配置多个
	-如果 第一个认证类，就返回了两个值
    -后续的认证类就不走了
    -如果认证类中要返回两个值，视图类中配了多个---》把返回两个值的放在最后
    -返回的两个值，第一个给了request.user,第一个给了request.auth，后续视图类中可以取出来
    
    
# 7 self.authenticators ---》 Request中
# Request类实例化得到对象，传入authenticators 最终给了
def __init__(self, request, parsers=None, authenticators=None,negotiator=None, parser_context=None):
 	self.authenticators = authenticators or ()
    
    
# 8 哪里对Request类实例化了？ APIView中
APIView 中dispatch中---》包装了新的request
request = self.initialize_request(request, *args, **kwargs)
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
        )
        
        
# 9 self.get_authenticators()  在APIView中 self是视图类的对象
    def get_authenticators(self):
        return [auth() for auth in self.authentication_classes]
    
    
# 总结：	
1 写一个类，重写authenticate
2 校验失败抛异常--》捕获
3 通过返回两个值  当前登录用户，token
	不返回两个值--》后续的request.user 不是当前登录用户
4 视图类上局部配置和配置文件全局配置跟 权限一模一样