Django框架深入了解——DRF之认证组件、权限组件、频率组件、token

Django框架深入了解——DRF之认证组件、权限组件、频率组件、token

一、认证组件

使用方法：

①写一个认证类，新建文件：my_examine.py

# 导入需要继承的基类BaseAuthentication
from rest_framework.authentication import BaseAuthentication
from rest_framework.exceptions import AuthenticationFailed
from app01 import models

# 创建认证类，继承BaseAuthentication
class MyAuth(BaseAuthentication):
    # 固定写一个authenticate方法用于定义具体认证内容
    def authenticate(self, request):
        # 写认证逻辑代码
        # 比如说假设token数据存在后端数据库中，前端发送的请求需要认证token
        token = request.GET.get('token')
        token_obj = models.Token.objects.filter(token=token).first()
        if token_obj:
            # 有值代表token校验通过
            # 可以使用token_obj.user取到当前登录的user对象
            
            # 这里需要返回2个数据
            return token_obj.user, token_obj
        else:
            raise AuthenticationFailed('未授权')

局部使用：在视图类中添加认证：

from app01.my_examine import MyAuth
# Create your views here.

class Books(APIView):
    # 给Books视图类添加token认证
    authentication_classes = [MyAuth, ]
    def get(self, request):
        response = {'code': 100, 'msg': '查询成功'}
        books = models.Book.objects.all()
        books_ser = BookSer(instance=books, many=True)
        response['data'] = books_ser.data
        return Response(response)

全局认证使用方法设置：

在settings.py中配置

REST_FRAMEWORK={
                "DEFAULT_AUTHENTICATION_CLASSES":["app01.my_examine.MyAuth",]
            }

全局认证已设置，视图中的所有类都会进行设置值的认证，这显然是不符合实际的，因为有些视图不能设置认证，比如注册，登录

所以需要局部对认证进行认证禁用，方法：

在局部认证的视图类位置添加下述代码，完成局部禁用
authentication_classes = []

小结：（通过分析源码）

-如果在项目的setting.py中配置了REST_FRAMEWORK，默认先从项目的setting中取
            -如果取不到，才去默认的drf配置文件中取
            -如果用户在视图类中配置了某个，先去用户配置的取
            
            总结：
                先取视图类中配置的----》项目setting中取----》默认配置

token简单描述：

token实现过程：用户登录成功后会在服务端通过自己的加密算法算出用户相关的并且唯一的一串字符串(token)连同响应的数据一起发给前端，前端进行保存，在下次用户访问发送请求的时候会将token数据一并发给后端服务器，后端服务器首先就会对token进行校验(这个校验的地方可以是中间件也可以在视图中),校验的过程大致就是再次通过用户相关数据进行加密算法算出这个用户的token字符串，拿现在算出来的token与保存在前端用户发送过来的token进行匹配，如果一致则代表用户认证登录成功，当然这个token是可以设置有效时间的。在一定程度上缓解了服务器的压力。

token产生过程：

比如说我用HMAC-SHA256 算法，加上一个只有我才知道的密钥， 对数据做一个签名， 把这个签名和数据一起作为token ， 由于密钥别人不知道， 就无法伪造token了。

这个token服务端不保存， 前端发送请求时候会捎带这个token，我再用同样的HMAC-SHA256 算法和同样的密钥，对数据再计算一次签名， 和token中的签名做个比较， 如果相同， 我就知道用户已经登录过了，并且可以直接取到用户的user id , 如果不相同， 数据部分肯定被人篡改过， 我就告诉前端用户： 对不起，没有认证。

Token 中的数据是明文保存的（虽然我会用Base64做下编码， 但那不是加密）， 还是可以被别人看到的， 所以我不能在其中保存像密码这样的敏感信息。

当然， 如果一个人的token 被别人偷走了， 那我也没办法， 我也会认为小偷就是合法用户， 这其实和一个人的session id 被别人偷走是一样的。

点我查看更多token相关信息。

应用token编写登录接口：

models.py

# models.py

class User(models.Model):
    name = models.CharField(max_length=32)
    password = models.CharField(max_length=64)
    choices = (('1', 'Super_Admin'), ('2', 'General_Admin'), ('3', 'General_User') )
    user_type = models.CharField(max_length=6, choices=choices, default='3')

#跟User表做一对一关联
class Token(models.Model):
    token = models.CharField(max_length=64)
    user = models.OneToOneField(to='User')

views.py

# views.py

from rest_framework.response import Response
from app01.my_examine import MyAuth
# Create your views here.

from uuid import uuid4
from django.core.exceptions import ObjectDoesNotExist
class Login(APIView):
    def post(self, request):
        response = {'code': 100, 'msg': '登录成功'}
        name = request.data.get('name')
        password = request.data.get('password')
        try:
            # 使用get方法，get方法只能取一条数据，如果是多条或者取不到，则会抛异常
            user = models.User.objects.filter(name=name, password=password).get()
            # 通过try方法捕获异常，如果走到这里说明没有异常，get方法取到用户对象，用户登录成功
            # 登录成功需要进行token表的数据保存(这里先假设token是保存在服务端数据库中)
            # 生成一个卫衣的id，使用uuid模块
            token = uuid4()
            # token如果在用户数据库中存在则更新，没有的话则创建
            # 使用update_or_create方法
            models.Token.objects.update_or_create(user=user, defaults={'token': token})
            # 将token放入返回的字典中
            response['token'] = token
        # 捕获一个特别的异常，user对象如果不存在则会走此处
        except ObjectDoesNotExist as e:
            response['code'] = 101
            response['msg'] = '用户名或密码错误'
        # 捕获其它异常
        except Exception as e:
            response['code'] = 102
            response['msg'] = '未知错误'
        # 返回前端数据
        return Response(response)

添加路由：

url(r'^login/', views.Login.as_view()),

二、权限组件

权限组件的使用方法和认证组件基本相同：

使用方法：

①写一个权限类，仍然在my_examine.py中：

from rest_framework.permissions import BasePermission
# 创建认证类，BasePermission
class MyPermission(BasePermission):
    message = '权限不足，无法查看'
    # 固定写一个has_permission方法用于定义具体权限内容
    def has_permission(self, request, view):
        # #因为权限在认证之后执行的，所有能取到reuqest.user
        if request.user.user_type == '1':
            return True
        else:
            return False

局部使用：

-在视图类中写
permission_classes=[MyPermision,]

全局使用：

在settings.py中配置
REST_FRAMEWORK={
    "DEFAULT_PERMISSION_CLASSES":["app01.my_examine.MyPermision",]
}

局部禁用：

-在视图类中写
permission_classes = []

这里可以设置添加一个代码让返回显示中文提示：

# 在MyPermision类下面添加
message = '权限不足，无法查看'

三、频率组件

使用方法：

①写一个频率类，仍然在my_examine.py中：

from rest_framework.throttling import SimpleRateThrottle
class Throttle(SimpleRateThrottle):
    scope = 'info'
    def get_cache_key(self, request, view):
        return self.get_ident(request)

要点：继承SimpleRateThrottle，重写get_cache_key，返回self.get_ident(request)，必须配置一个scop=字符串

② 在settings.py中配置：

REST_FRAMEWORK = {
    # 一分钟内只能访问6次
    'DEFAULT_THROTTLE_RATES': {'info': '6/m'}
}

③使用：

局部使用： 在视图类中配置：

from app01.my_examine import Throttle

from app01.my_examine import Throttle
class PublishView(APIView):
    throttle_classes = [Throttle, ]
    def get(self, request):

        publish_list = models.Publish.objects.all()
        bs = PublishSer(publish_list, many=True)
        return Response(bs.data)

全局使用：在setting中配置

'DEFAULT_THROTTLE_CLASSES':['自己定义的频率类'],

局部禁用

throttle_classes=[]