drf框架

1.三大认证工作原理简介

2.权限六表分析和自定义User下的权限六表

3.六表数据之间的访问测试

4.认证组件源码分析

5.自定义认证类

6.权限组件与系统权限组件

7.自定义权限类

一.三大认证工作原理简介

1）APIView的dispath(self, request, *args, **kwargs)
2）dispath方法内 self.initial(request, *args, **kwargs) 进入三大认证

self.perform_authentication(request)
1.认证组件：校验用户 - 游客，合法用户，非法用户
游客：代表校验通过，直接进入下一步校验（权限校验）
合法用户：代表校验通过，将用户存储在request.user中，再进入下一步校验（权限校验）
非法用户：代表校验失败，抛出异常，返回403权限异常错误

self.check_permissions(request)
2.权限组件：校验用户权限 - 必须登录，所有用户，登录读写游客只读，自定义用户角色
认证通过：可以进入下一步校验（频率认证）
认证失败：抛出异常，返回403权限异常结果

self.check_throttles(request)
3.频率组件：限制视图接口被访问的频率次数 - 限制的条件（IP，id，唯一键），频率周期时间（s,m,h），频率的次数（3/s）
# 没有达到限次：正常访问接口
# 达到限次：限制时间内不能访问，限制时间达到后，可以重新访问

二.权限六表分析和自定义User下的权限六表

基于用户权限访问控制的认证：RBAC - Role-Based Access Control
需要自己了解的：基于auth的认证规则

Django框架采用的是RBAC认证规则，RBAC认证规则通常会分为：三表规则，五表规则，但是Django采用的是六表规则

三表：用户表，角色表，权限表
五表：用户表，角色表，权限表，用户角色关系表，角色权限关系表
六表：用户表，角色表，权限表，用户角色关系表，角色权限关系表，用户权限表

表与表之间的查询方式：正查与反查
反查加上_set 正查加s  或者加上user_
# 用户表：角色groups，权限user_permissions
# 角色表：用户user_set，权限permissions
# 权限表：用户user_set，角色group_set

重点：如果自定义User表后，再另一个项目中采用原生User表，完成数据库迁移时，可能失败
解决方案：
1.卸载Django重新装
2.将django.contrib下面的admin，auth下的数据库迁移记录文件清空即可

三.六表数据之间的访问测试

根目录下/script/t_model测试文件

# django脚本话启动
import os, django
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "drf5.settings")
django.setup()

from api import models

user = models.User.objects.first()  # type: models.User
print(user.username)
# 拿角色名
print(user.groups.first().name)
# 拿到这个用户的权限
print(user.user_permissions.first().name)



from django.contrib.auth.models import Group
group = Group.objects.first()
print(group.name)
# 角色拿用户
print(group.user_set.first().username)
# 拿到这个角色的权限
print(group.permissions.first().name)


from django.contrib.auth.models import Permission
p_16 = Permission.objects.filter(pk=16).first()
# 拿到权限16的用户
print(p_16.user_set.first().username)
p_17 = Permission.objects.filter(pk=17).first()
# 拿到权限17的角色
print(p_17.group_set.first().name)

四.认证组件源码分析

 认证组件
    Request类的 方法属性 user 的get方法 => self._authenticate() 完成认证
    
    认证的细则：
    # 做认证
    def _authenticate(self):
        # 遍历拿到一个个认证器，进行认证
        # self.authenticators配置的一堆认证类产生的认证类对象组成的 list
        for authenticator in self.authenticators:
            try:
                # 认证器(对象)调用认证方法authenticate(认证类对象self, request请求对象)
                # 返回值：登陆的用户与认证的信息组成的 tuple
                # 该方法被try包裹，代表该方法会抛异常，抛异常就代表认证失败
                user_auth_tuple = authenticator.authenticate(self)
            except exceptions.APIException:
                self._not_authenticated()
                raise

            # 返回值的处理
            if user_auth_tuple is not None:
                self._authenticator = authenticator
                # 如何有返回值，就将 登陆用户 与 登陆认证 分别保存到 request.user、request.auth
                self.user, self.auth = user_auth_tuple
                return
        # 如果返回值user_auth_tuple为空，代表认证通过，但是没有 登陆用户 与 登陆认证信息，代表游客
        self._not_authenticated()

五.自定义认证类

"""
1.创建继承BaseAuthentication的认证类
2.实现authenticate方法
3.实现体根据认证规则来确定 是游客 ，非法用户，合法用户
4.完成视图类的全局(settings文件中)或局部(完成确切的视图类)配置

认证规则： 
1.没有认证信息返回None（游客） 
2.有认证信息认证失败抛异常（非法用户） 
3.有认证信息认证成功返回用户与认证信息元组（合法用户） 
"""

api/authentications.py

# 自定义认证类

# 1.继承BaseAuthentication类
# 2.重新authenticate(self,request)方法，自定义认证规则
# 3.认证规则基于的条件：
#   没有认证信息返回None(游客)
#   没认证信息认证失败抛异常(非法用户)
#   有认证信息认证成功返回用户与认证信息元组(合法用户)
# 完成视图类的全局(settings文件中)或局部(完成确切的视图类)配置
from rest_framework.authentication import BaseAuthentication
# 出现异常需要导入的模块
from rest_framework.exceptions import AuthenticationFailed
from . import models

class MyAuthentication(BaseAuthentication):
    def authenticate(self, request):
        # 前台在请求头携带认证信息，
        # 且默认规范用Authorization字段携带认证信息
        # 后台固定在请求对象的META字段中 HTTP_AUTHORIZATION 获取
        auth = request.META.get('HTTP_AUTHORIZATION',None)

        # 处理游客
        if auth is None:
            return None
        # 设置一下认证字段小规则(俩段式)："auth 认证字符串"
        auth_list = auth.split()
        # 校验是合法还是非法用户
        '''
        因为校验数据分为俩段了，首先判断数据的长度是否为2，
        在取0号位比对是不是auth
        '''
        if not (len(auth_list) == 2 and auth_list[0].lower() == 'auth'):
            raise AuthenticationFailed('认证信息有误，非法用户')

        # 合法的用户还需要从auth_list[1]中解析出来
        # ps：假设一种情况，情况为abc.123.xyz，就可以解析出来admin用户，
        # 实际开发，该逻辑一定是校验用户的正常逻辑
        if auth_list[1] != 'abc.123.xyz': # 不等于就是校验失败
            raise AuthenticationFailed('用户校验失败，非法用户')

        # 如果校验成功，有认证信息认证成功返回用户与认证信息元组(
        user = models.User.objects.filter(username='admin').first()
        # 也有可能这个用户也没有这个数据
        if not user:
            raise AuthenticationFailed('用户数据有误，非法用户')
        return (user,None)

完成视图类的全局(settings文件中)或局部(完成确切的视图类)配置

REST_FRAMEWORK = {
    # 全局配置异常模块
    'EXCEPTION_HANDLER': 'utils.exception.exception_handler',
    # 认证类配置
    # 认证类配置
    'DEFAULT_AUTHENTICATION_CLASSES': [
        # 'rest_framework.authentication.SessionAuthentication',
        # 'rest_framework.authentication.BasicAuthentication',
        # 自定义认证类配置
        'api.authentications.MyAuthentication',
    ],
}

api/views.py视图层

from rest_framework.views import APIView
from rest_framework.generics import GenericAPIView
from rest_framework.viewsets import GenericViewSet,ViewSet
from utils.response import APIResponse

class TestAPIView(APIView):
    def get(self,request,*args,**kwargs):
　　　　# 如果通过了认证组件，request.user就一定有值
　　　　# 游客：AnonymousUser
　　　　# 用户：User表中的具体用户对象
　　　　　print（request.user）
　　　　　return APIResponse(0,'text get ok')

api/urls.py路由层

from django.conf.urls import url
from . import views

urlpatterns = [
    url(r'^text/$',views.TestAPIView.as_view()),

]

六.权限组件分析与系统权限组件

权限组件分析
    self.check_permissions(request)
    认证细则：
    def check_permissions(self, request):
        # 遍历权限对象列表得到一个个权限对象(权限器)，进行权限认证
        for permission in self.get_permissions():
            # 权限类一定有一个has_permission权限方法，用来做权限认证的
            # 参数：权限对象self、请求对象request、视图类对象
            # 返回值：有权限返回True，无权限返回False
            if not permission.has_permission(request, self):
                self.permission_denied(
                    request, message=getattr(permission, 'message', None)
                )

系统权限类组件

分为四种：
1.游客与登陆用户都有所有权限 2.游客没有任何权限，登陆用户才有权限
3.游客没有任何权限，登陆用户才有权限 4. 游客只读，合法用户无限制

1）AllowAny：
    认证规则全部返还True：return True
        游客与登陆用户都有所有权限

2) IsAuthenticated：
    认证规则必须有登陆的合法用户：return bool(request.user and request.user.is_authenticated)
        游客没有任何权限，登陆用户才有权限
    
3) IsAdminUser：
    认证规则必须是后台管理用户：return bool(request.user and request.user.is_staff)
        游客没有任何权限，登陆用户才有权限

4) IsAuthenticatedOrReadOnly
    认证规则必须是只读请求或是合法用户：
        return bool(
            request.method in SAFE_METHODS or
            request.user and
            request.user.is_authenticated
        )
        游客只读，合法用户无限制

案例：

# settings.py配置（********************************************************************）

# 因为默认全局配置的权限类是AllowAny,因为这个用的比较多，如果要是想用其他的权限类校验规则，
　　可以在局部设置permission_classes = []
# settings.py
REST_FRAMEWORK = {
    # 权限类配置
    'DEFAULT_PERMISSION_CLASSES': [
        'rest_framework.permissions.AllowAny',
    ],
}

1.# 只有登录后才能访问

views.py视图层

from rest_framework.views import APIView
from utils.response import APIResponse

# 只有登录后才能访问
# 1.因为现在用的是全局的，所以都可以访问，
# 2.我们需要在局部设置他自己的权限类的设置
# 3.导入只有登录才能访问的系统权限类
from rest_framework.permissions import IsAuthenticated
class TestAuthenticatedAPIView(APIView):
    # 配置局部的权限类校验规则
    permission_classes = [IsAuthenticated]
    def get(self,request,*args,**kwargs):
        return APIResponse(0,'test 登录才能访问的接口')

api/urls.py路由层

from django.conf.urls import url
from . import views
urlpatterns = [
    url(r'^text1/$',views.TestAuthenticatedAPIView.as_view()),
]

2.# 游客只能读数据，只有登录后没有限制

views.py视图层

# 游客只能读数据，只有登录后没有限制
from rest_framework.permissions import IsAuthenticatedOrReadOnly
class TestAuthenticatedOrReadOnlyAPIView(APIView):
    # 配置局部的权限类校验规则
    permission_classes = [IsAuthenticatedOrReadOnly]
    def get(self,request,*args,**kwargs):
        return APIResponse(0,'读 OK')

    def post(self,request,*args,**kwargs):
        return APIResponse(0,'写 OK')

api/urls.py路由层

from django.conf.urls import url
from . import views

urlpatterns = [
    url(r'^text2/$',views.TestAuthenticatedOrReadOnlyAPIView.as_view()),

]

七.自定义权限类

"""
1) 创建继承BasePermission的权限类
2) 实现has_permission方法
3) 实现体根据权限规则 确定有无权限
4) 进行全局或局部配置

认证规则
i.满足设置的用户条件，代表有权限，返回True
ii.不满足设置的用户条件，代表有权限，返回False
"""

api/permissions.py

from rest_framework.permissions import BasePermission
from django.contrib.auth.models import Group
class MyPermission(BasePermission):
    # 重写has_permissions方法
    def has_permission(self, request, view):
         # 然后自定义校验规则
        # 只读接口判断
        r1 = request.method in ('GET', 'HEAD', 'OPTIONS')
        # group为有权限的分组
        group = Group.objects.filter(name='管理员').first()
        # groups为当前用户所属的所有分组
        groups = request.user.groups.all()
        # 判断group和groups都要有值
        r2 = group and groups
        # 判断拿出来的管理员跟groups的用户是否关联
        r3 = group in groups
         # 读接口大家都有权限，写接口必须为指定分组下的登录用户
        # 要么只要是这个接口就可以登录，要么就必须是登录用户且是管理员
        return r1 or (r2 and r3)

api/views.py

# 自定义权限类校验规则
# 游客只读，登录用户只读，只有登录用户属于 管理员角色，才可以增删改
from .permissions import MyPermission
class TestAdminOrReadOnlyAPIView(APIView):
    # 配置局部的自定义权限类校验规则
    permission_classes = [MyPermission]
    # 所有用户都可以访问
    def get(self, request, *args, **kwargs):
        return APIResponse(0, '自定义读 OK')
    # 必须是 自定义“管理员”分组 下的用户
    def post(self, request, *args, **kwargs):
        return APIResponse(0, '自定义写 OK')

api/urls.py

from django.conf.urls import url
from . import views

urlpatterns = [
    url(r'^text3/$',views.TestAdminOrReadOnlyAPIView.as_view()),

]