auth的权限六表分析:
# 1.认证的种类:
# 基于用户权限访问控制的认证 - RBAC - Role-Based Access Control
# 自己了解：基于auth的认证规则
# Django框架采用的是RBAC认证规则，RBAC认证规则通常会分为 三表规则、五表规则，Django采用的是六表规则
# 2.六表的关系:
# 三表：用户表、角色表、权限表
# 五表：用户表、角色表、权限表、用户角色关系表、角色权限关系表
# 六表：用户表、角色表、权限表、用户角色关系表、角色权限关系表、用户权限关系表
# 3.表之间数据的访问:
# 用户表：角色groups，权限user_permissions
# 角色表：用户user_set，权限permissions
# 权限表：用户user_set，角色group_set(使用默认)
# 4.常见Bug解决:
# 如果自定义User表后，再另一个项目中采用原生User表，完成数据库迁移时，可能失败,解决:
# 1）卸载Django重新装
# 2）将django.contrib下面的admin、auth下的数据库迁移记录文件清空
# 常见Bug:
"""
如果使用自定义User表之后,在另一个项目中采用原生User表,在完成数据库迁移时,可能会出现错误,解决方式:
1)卸载Django重新安装
2)将django.contrib下面的admin和auth下的migrations下的数据库迁移记录删除,保留__init__;
"""
三大认证源码入口:
#1）APIView的dispath(self, request, *args, **kwargs)
# 2）dispath方法内 self.initial(request, *args, **kwargs) 进入三大认证
# 认证组件：校验用户 -- 游客、合法用户、非法用户
# 游客：代表校验通过，直接进入下一步校验（权限校验）
# 合法用户：代表校验通过，将用户存储在request.user中，再进入下一步校验（权限校验）
# 非法用户：代表校验失败，抛出异常，返回403权限异常结果
self.perform_authentication(request)
# 权限组件：校验用户权限 - 必须登录、所有用户、登录读写游客只读、自定义用户角色
# 认证通过：可以进入下一步校验（频率认证）
# 认证失败：抛出异常，返回403权限异常结果
self.check_permissions(request)
# 频率组件：限制视图接口被访问的频率次数 - 限制的条件(IP、id、唯一键)、频率周期时间(s、m、h)、频率的次数（3/s）
# 没有达到限次：正常访问接口
# 达到限次：限制时间内不能访问，限制时间达到后，可以重新访问
self.check_throttles(request)
认证组件源码分析:
# 认证组件:
# 1.进入认证组件
self.perform_authentication(request)
# 2.1进入之后发现只有request.user,应当立马分析可知该user是一个类方法
def perform_authentication(self, request):
...
request.user
# 2.2通过分析request可知该request为drf二次封装后的request对象
def dispatch(self, request, *args, **kwargs):
...
request = self.initialize_request(request, *args, **kwargs)
self.request = request
# 2.3 通过最终层层分析可知drf二次封装的request对象来自于rest_framework.request中的Request类对象,
由此可知2.1中的user来自于该类的user的类方法,去向该类方法中继续分析
from rest_framework.request import Request
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
)
# 2.4 该user方法中,__authenticate()中做认证
@property
def user(self):
if not hasattr(self, '_user'):
with wrap_attributeerrors():
self._authenticate() # 入口
return self._user
# 2.5 self.authenticators中存储了很多的认证类对象authenticator,遍历拿到一个个认证器，进行认证
def _authenticate(self):
for authenticator in self.authenticators:
try:
# 认证器(对象)调用认证方法authenticate(认证类对象self, request请求对象)
# 返回值：登陆的用户与认证的信息组成的 tuple
# 该方法被try包裹，代表该方法会抛异常，抛异常就代表认证失败
user_auth_tuple = authenticator.authenticate(self)
except exceptions.APIException:
self._not_authenticated()
raise
# 如果有返回值，就将 登陆用户 与 登陆认证 分别保存到 request.user、request.auth
if user_auth_tuple is not None:
self._authenticator = authenticator
# 此处将user赋值给request对象,之后便可以使用request.user获取登录用户.
self.user, self.auth = user_auth_tuple
return
# 如果返回值user_auth_tuple为空，代表认证通过，但是没有 登陆用户 与 登陆认证信息，代表游客
self._not_authenticated()
# 2.6 self.authenticators来源:_authenticate为Request类对象中的方法,分析2.3中初始化Request类对象时,
authenticators=self.get_authenticators(),可知来源于get_authenticators()方法,由此进入我们熟悉的全局配置或局部配置
def get_authenticators(self):
return [auth() for auth in self.authentication_classes]
# 2.7 api_settings来自于rest_framework.settings
from rest_framework.settings import api_settings
...
class APIView(View):
...
authentication_classes = api_settings.DEFAULT_AUTHENTICATION_CLASSES
# 2.8 默认有两个认证类:基础认证BasicAuthentication和SessionAuthentication认证.
'DEFAULT_AUTHENTICATION_CLASSES': [
'rest_framework.authentication.SessionAuthentication',
'rest_framework.authentication.BasicAuthentication'
]
自定义认证类：
"""
1) 创建继承BaseAuthentication的认证类
2) 重写authenticate方法
3) 重写体根据认证规则 确定游客、非法用户、合法用户
4) 进行全局或局部配置
认证规则:
i.没有认证信息返回None(游客)
ii.有认证信息认证失败抛异常(非法用户)
iii.有认证信息认证成功返回用户与认证信息元组(合法用户)
"""
utils/authentications.py
# 自定义认证类
# 1）继承BaseAuthentication类
# 2）重写authenticate(self, request)方法，自定义认证规则
# 3）认证规则基于的条件：
# 没有认证信息返回None(游客)
# 有认证信息认证失败抛异常(非法用户)
# 有认证信息，认证成功，返回用户与认证信息元组(合法用户)
# 4）完成视图类的全局(settings文件中)或局部(确切的自己的视图类)配置
from rest_framework.authentication import BaseAuthentication
from rest_framework.exceptions import AuthenticationFailed
from . import models
class MyAuthentication(BaseAuthentication):
"""
1.同前台请求头拿认证信息auth（获取认证的字段要与前台约定）
2.没有auth是游客，返回None
3.有auth进行校验
1.失败是非法用户，抛出异常
2.成功是合法用户，返回 (用户, 认证信息)
"""
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()
# 校验合法还是非法用户
if not (len(auth_list) == 2 and auth_list[0].lower() == 'auth'):
raise AuthenticationFailed('认证信息有误，非法用户')
# 合法的用户还需要从auth_list[1]中解析出来
# 注：假设一种情况，信息为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.py中
'DEFAULT_AUTHENTICATION_CLASSES': [
# 'rest_framework.authentication.SessionAuthentication',
# 'rest_framework.authentication.BasicAuthentication',
'api.authentications.MyAuthentication',
]
权限组件源码分析:
# 权限组件
# 1.源码入口:
self.check_permissions(request)
# 2.遍历权限类对象列表得到一个个权限类对象,之后调用.has_permission(request, self)进行权限认证
def check_permissions(self, request):
for permission in self.get_permissions():
# 权限类必须要有一个has_permission方法用来做权限认证
# 参数:权限对象self,请求对象request,视图类对象self
# 返回值:有权限返回Ture,无权限返回False
if not permission.has_permission(request, self):
self.permission_denied(
request, message=getattr(permission, 'message', None)
)
# 3.从self.permission_classes中进行获取权限类并实例化
def get_permissions(self):
return [permission() for permission in self.permission_classes]
# 4.permission_classes来自于APIView,之后可以进行全局或者局部配置
class APIView(View):
...
permission_classes = api_settings.DEFAULT_PERMISSION_CLASSES
# 5.默认配置为允许所有用户访问
'DEFAULT_PERMISSION_CLASSES': [
'rest_framework.permissions.AllowAny',
]
# 6.各种权限认证类
class AllowAny(BasePermission):
def has_permission(self, request, view):
return True
"""
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
)
游客只读，合法用户无限制
"""
系统权限类的使用:
# api/views.py
from rest_framework.permissions import IsAuthenticated
class TestAuthenticatedAPIView(APIView):
permission_classes = [IsAuthenticated]
def get(self, request, *args, **kwargs):
return APIResponse(0, 'test 登录才能访问的接口 ok')
# 默认的全局配置：
# 因为默认全局配置的权限类是AllowAny
# settings.py
REST_FRAMEWORK = {
# 权限类配置
'DEFAULT_PERMISSION_CLASSES': [
'rest_framework.permissions.AllowAny',
],
}
自定义权限类
"""
1) 创建继承BasePermission的权限类
2) 实现has_permission方法
3) 实现体根据权限规则 确定有无权限
4) 进行全局或局部配置
认证规则
i.满足设置的用户条件，代表有权限，返回True
ii.不满足设置的用户条件，代表无权限，返回False
"""
# utils/permissions.py
from rest_framework.permissions import BasePermission
from django.contrib.auth.models import Group
class MyPermission(BasePermission):
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()
r2 = group and groups
r3 = group in groups
# 读接口大家都有权限，写接口必须为指定分组下的登陆用户
return r1 or (r2 and r3)
# 游客只读，登录用户只读，只有登录用户属于 管理员 分组，才可以增删改
from utils.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')