drf 权限认证

目录

• 复习
• 前期准备
• 三大认证简介
• AbstracUser源码分析
• 自定义User下的权限六表
  • models.py
  • 到settings.py中注册
  • 注意点：
  • 执行数据迁移的俩条命令
  • 创建超级用户
• 源码分析

复习

"""
视图家族
1、视图类：APIView、GenericAPIView
    APIView：作为drf的基础view；as_view()禁用csrf；dispatch()二次封装request、三大认证、解析、渲染、响应、异常等模块；一堆类属性，可以用来做全局或局部插拔配置
    GenericAPIView：继承APIView；三个方法三个属性(obj,queryset,serializer)

2、视图工具集：mixin五大工具类(六个方法)
    list：群查
    retrieve：单查
    create：单增
    destroy：单删
    update：单整体改
    partial_update：单局部改
    前提：工具类都是由GenericAPIView的子类来继承

3、工具视图：Generic各种子类
    ListAPIView(ListModelMixin, GenericAPIView):继承该类的视图类，只需要提供几个类属性，就可以完成群查，不需要书写get方法
    ListCreateAPIView(ListModelMixin, CreateModelMixin, GenericAPIView)

4、视图集：ViewSet、GenericViewSet
    ViewSetMixin：重写as_view()，可以将请求方法与视图类中的自定义函数名完成映射
        as_view({'get': 'list', 'post': 'my_post'})

    GenericViewSet：可以自定义请求映射的Model操作视图集

    ViewSet：可以自定义请求映射的任意操作视图集（一般与Model操作不是那么密切相关）
        登陆的post并非新增、短信的验证码(get或post)都和model无关
"""

前期准备

创建django项目，应用名api；

创建数据库，django:1.settings中修改连接mysql配置，2.__init__文件中import pymysql pymysql.install_as_MySQLdb(),测试连接；

settings.py中注册app ‘rest_framework‘ ; 修改LANGUAGE_CODE = ‘zh-hans‘ ，TIME_ZONE = ‘Asia/Shanghai‘ ，USE_TZ = False，配置media路径MEDIA_URL = ‘/media/‘ ，MEDIA_ROOT = os.path.join(BASE_DIR, ‘media‘)

路由分发项目路由re_path(r‘^api/‘, include(‘api.urls‘)), re_path(r‘^media/(?P.*)‘, serve, {‘document_root‘: settings.MEDIA_ROOT}),

路由分发应用api下的创建url.py

根目录下创建utils, 两个文件夹exception.py写自定义异常和response.py写自定义响应

根目录下创建script,写脚本测试文件，

根目录下创建media

三大认证简介

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

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

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

APIView中的dispatch方法self.initial(request, *args, **kwargs)

AbstracUser源码分析

自定义user表继承AbstracUser
1.from django.contrib.auth.models import AbstractUser
  class User(AbstractUser):
          pass
2.settings文件夹中配置
AUTH_USER_MODEL = 'api.User'

点击AbstracUser进入看源码,定位文件
在资源文件models.py中，有基础的三表：Group类，Permission类，User(AbstractUser)
1.先查看Group类：group角色拥有权限

class Group(models.Model):
    # permissions权限，在这里就是角色group拥有的权限
    permissions = models.ManyToManyField( #多对多
        Permission,  #类名
        verbose_name=_('permissions'),
        blank=True,
    )

2.查看User类
class User(AbstractUser):
    .....
点击AbstractUser
class AbstractUser(AbstractBaseUser, PermissionsMixin):
    .....
点击AbstractBaseUser，。。。
点击PermissionsMixin，最终在这找到了groups,user_permissions
class PermissionsMixin(models.Model):
    """
    Add the fields and methods necessary to support the Group and Permission
    models using the ModelBackend.
    """
    is_superuser = models.BooleanField(
        _('superuser status'),
        default=False,
        help_text=_(
            'Designates that this user has all permissions without '
            'explicitly assigning them.'
        ),
    )
    groups = models.ManyToManyField(
        Group, #类名
        verbose_name=_('groups'),
        blank=True,
        help_text=_( #文本提示
            'The groups this user belongs to. A user will get all permissions '
            'granted to each of their groups.'
        ),
        related_name="user_set", #反向查询的字段
        related_query_name="user",
    )
    #用户权限关系表
    user_permissions = models.ManyToManyField(
        Permission,
        verbose_name=_('user permissions'),
        blank=True,
        help_text=_('Specific permissions for this user.'),
        related_name="user_set", #反向查询字段
        related_query_name="user",
    )

    class Meta:
        abstract = True
#（用户表与角色表的多对多的关键字段在User表中，用户表与权限表的多对多的关键字段在User表中）
# 用户表：正向查询角色表字段groups，正向查询用户权限表字段user_permissions
#（角色表与权限表的多对多字段在Group表中）
# 角色表：反向查询用户表字段user_set，正向查询角色权限表字段permissions
# 权限表：反向查询用户表字段user_set，反向查询角色表字段group_set

自定义User下的权限六表

models.py

from django.db import models

# Create your models here.

from django.contrib.auth.models import AbstractUser

class User(AbstractUser):
    mobile = models.CharField(max_length=11, unique=True)

    class Meta:
        db_table = 'api_user'
        verbose_name = '用户表'
        verbose_name_plural = verbose_name

    def __str__(self):
        return self.username

到settings.py中注册

# 配置自定义user表
AUTH_USER_MODEL = 'api.User'

注意点：

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

补充：全局配置
class APIView(View):

    # The following policies may be set at either globally, or per-view.
    renderer_classes = api_settings.DEFAULT_RENDERER_CLASSES
    parser_classes = api_settings.DEFAULT_PARSER_CLASSES
    authentication_classes = api_settings.DEFAULT_AUTHENTICATION_CLASSES
    throttle_classes = api_settings.DEFAULT_THROTTLE_CLASSES
    permission_classes = api_settings.DEFAULT_PERMISSION_CLASSES
    content_negotiation_class = api_settings.DEFAULT_CONTENT_NEGOTIATION_CLASS
    metadata_class = api_settings.DEFAULT_METADATA_CLASS
    versioning_class = api_settings.DEFAULT_VERSIONING_CLASS

以上以这个为例renderer_classes=[..]这是自定义类中的局部配置，全局配置就是
点击api_settings,APISettings实例化的对象
api_settings = APISettings(None, DEFAULTS, IMPORT_STRINGS)
DEFAULTS点击：发现是系统的默认配置，
IMPORT_STRINGS是自己的settings.py的文件路径
点击APISettings：
 def __init__(self, user_settings=None, defaults=None, import_strings=None):产生的实例化

执行数据迁移的俩条命令

python manage.py mekamigrations

python manage.py migrate

auth_permission这张表codename就是权限的名字，content_type_id就是属于哪张表的权限 ， django_content_type这张表的里的app_label就是应用名，model字段就是对应的一张表

创建超级用户

Tools中执行命令createsuperuser

数据库中的auth_group添加数据，api_user_groups绑定两者关系

在测试文件t_models.py中进行测试

t_model.py

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

from api import models

user = models.User.objects.first()
# 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()
# print(p_16.user_set.first().username)
# p_17 = Permission.objects.filter(pk=17).first()
# print(p_17.group_set.first().name)

数据库各表录入数据

源码分析

1）url.py路由re_path(r'^test/$', views.TestAPIView.as_view()),  view.py视图class TestAPIView(APIView):pass   路由访问TestAPIView的as_view（）方法，TestAPIView没有，父类APIView获取，as_view()返回csrf_exempt(view)禁用csrf,而view是view = super(APIView, cls).as_view(**initkwargs)调用父类的View的方法，走View中的view，然后到dispatch的时候走回自己的APIView的dispatch方法，三大认证模块 self.initial(request, *args, **kwargs)入口，在此之前request = self.initialize_request(request, *args, **kwargs)已经封装了
APIView的dispatch(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)

3) 点击认证组件self.perform_authentication(request)，返回的request.user，request是drf封装的request对象，request.user觉得是登录用户，但是认证的时候没有用户，所以是属性或者是封装成属性方法，然后再资源drf的request.py文件中的Request类中的user(self)方法（self是request的对象，所以是直接拿到前端发来的数据），还要一个user(self,value)这个是设置值，所以user(self)才是获取值
  if not hasattr(self, '_user'):# 判断是否有用户
            with wrap_attributeerrors():
                #没有用户认证出用户
                self._authenticate()
        #有用户直接返回用户 ,如果是游客的话request.user = AnonymousUser,所以也是有值的
        return self._user

 点击self._authenticate()
    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()

点击self.authenticators查看不了，回到APIView中的dispatch方法二次封装request的地方
request = self.initialize_request(request, *args, **kwargs) ，点击进入，
 return Request(
            request,
            parsers=self.get_parsers(),
            #认证产生
            authenticators=self.get_authenticators(),
            negotiator=self.get_content_negotiator(),
            parser_context=parser_context
        )
点击 authenticators=self.get_authenticators()  返回return [auth() for auth in self.authentication_classes]
authentication_classes可以是局部设置，也可以settings中全局设置

全局设置settings.py
# drf配置
REST_FRAMEWORK = {
    # 认证类配置
    'DEFAULT_AUTHENTICATION_CLASSES': [
        'rest_framework.authentication.SessionAuthentication',
        'rest_framework.authentication.BasicAuthentication',
    ],
}
找到资源文件authentication文件中的SessionAuthentication类重写的
    def authenticate(self, request):

        # Get the session-based user from the underlying HttpRequest object
        #原生django的request中获取user
        user = getattr(request._request, 'user', None)
        #拿用户，用户如果为空或非活跃状态就返回空，代表游客，不需要csrf校验
        # Unauthenticated, CSRF validation not required
        if not user or not user.is_active:
            return None

        #解析出用户，重新启用csrf认证，如果csrf认证失败，就会出现异常，就是非法用户
        self.enforce_csrf(request)

        # CSRF passed with authenticated user
        #csrf认证通过，代表合法用户
        return (user, None)

找到资源文件authentication文件中的BasicAuthentication类重写的
class BasicAuthentication(BaseAuthentication):
    """
    HTTP Basic authentication against username/password.
    """
    www_authenticate_realm = 'api'

    def authenticate(self, request):
        """
        Returns a `User` if a correct username and password have been supplied
        using HTTP Basic authentication.  Otherwise returns `None`.
        """
        #获取认证信息auth是元组
        auth = get_authorization_header(request).split()

        if not auth or auth[0].lower() != b'basic': #二进制
            return None  #代表游客

        if len(auth) == 1: #长度等于一，代表认证信息错误，抛异常
            msg = _('Invalid basic header. No credentials provided.')
            raise exceptions.AuthenticationFailed(msg)
        elif len(auth) > 2:#长度大于二，代表认证信息错误，抛异常
            msg = _('Invalid basic header. Credentials string should not contain spaces.')
            raise exceptions.AuthenticationFailed(msg)

        try:
            #做处理
            auth_parts = base64.b64decode(auth[1]).decode(HTTP_HEADER_ENCODING).partition(':')
        except (TypeError, UnicodeDecodeError, binascii.Error):
            #错误的话就抛异常
            msg = _('Invalid basic header. Credentials not correctly base64 encoded.')
            raise exceptions.AuthenticationFailed(msg)
        #将用户和密码解析出来
        userid, password = auth_parts[0], auth_parts[2]
        #将userid, password, request丢进去
        return self.authenticate_credentials(userid, password, request)

    #return self.authenticate_credentials(userid, password, request)
    #将userid, password, request=None传入
def authenticate_credentials(self, userid, password, request=None):
        """
        Authenticate the userid and password against username and password
        with optional request for context.
        """
        credentials = {
            get_user_model().USERNAME_FIELD: userid,
            'password': password
        }
        #获取user
        user = authenticate(request=request, **credentials)
        #如果用户为空抛异常
        if user is None:
            raise exceptions.AuthenticationFailed(_('Invalid username/password.'))
        #用户为非活跃
        if not user.is_active:
            raise exceptions.AuthenticationFailed(_('User inactive or deleted.'))
        #返回合法user
        return (user, None)

自定义认证类

"""
1) 创建继承BaseAuthentication的认证类
2) 实现authenticate方法
3) 实现体根据认证规则 确定游客、非法用户、合法用户
4) 进行全局或局部配置

认证规则
i.没有认证信息返回None(游客)
ii.有认证信息认证失败抛异常(非法用户)
iii.有认证信息认证成功返回用户与认证信息元组(合法用户)
"""

api / urls.py

from django.urls import re_path
from . import views
urlpatterns = [

re_path(r'^test/$', views.TestAPIView.as_view()),
]

api / views.py

from django.shortcuts import render

# Create your views here.
from rest_framework.views import APIView
from utils.response import APIResponse

class TestAPIView(APIView):
    def get(self, request, *args, **kwargs):
        print(request.user)
        return APIResponse(0, 'test get ok ')

settings.py

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

}

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):
    """
    同前台请求头拿认证信息auth（获取认证的字段要与前台约定）
    没有auth是游客，返回None
    有auth进行校验
        失败是非法用户，抛出异常
        成功是合法用户，返回 (用户, 认证信息)
    """
    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)

# 家庭作业
# 1) 可以采用脚本基于auth组件创建三个普通用户：models.User.objects.create_user()
#       注：直接写出注册接口更好
# 2) 自定义session表：id,u_id,token，为每个用户配置一个固定人认证字符串，可以直接操作数据库
#       注：在注册接口中实现更好
# 3) 自定义认证类，不同的token可以校验出不同的登陆用户

权限类源码

APIView中的dispatch方法，然后就是self.initial(request, *args, **kwargs)，点击self.check_permissions(request)
4) 权限组件
    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)

系统权限类

# 因为默认全局配置的权限类是AllowAny
# settings.py
REST_FRAMEWORK = {
    # 权限类配置
    'DEFAULT_PERMISSION_CLASSES': [
        'rest_framework.permissions.AllowAny',
        'rest_framework.permissions.IsAuthenticated'，
        'rest_framework.permissions.IsAdminUser'，
        'rest_framework.permissions.IsAuthenticatedOrReadOnly'，
    ],
}

查找permissions.py中的以下四个类
AllowAny，IsAuthenticated，IsAdminUser，IsAuthenticatedOrReadOnly
分析他们各自的功能，在settings文件中配置全局，或视图类中可局部permission_classes = [MyPermission]
"""
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
        )
        游客只读，合法用户无限制
"""

自定义权限类（在utils文件下创建permissions.py）

"""
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)
    

api/urls.py

from django.conf.urls import url
from . import views
urlpatterns = [
    url(r'^test/$', views.TestAPIView.as_view()),
    url(r'^test1/$', views.TestAuthenticatedAPIView.as_view()),
    url(r'^test2/$', views.TestAuthenticatedOrReadOnlyAPIView.as_view()),
    url(r'^test3/$', views.TestAdminOrReadOnlyAPIView.as_view()),
]

settings.py

# drf配置
REST_FRAMEWORK = {
    # 认证类配置
    'DEFAULT_AUTHENTICATION_CLASSES': [
        'api.authentications.MyAuthentication',
    ],

}

api/ views.py

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

# 只有登录后才能访问
from rest_framework.permissions import IsAuthenticated
class TestAuthenticatedAPIView(APIView):
    permission_classes = [IsAuthenticated]

    def get(self, request, *args, **kwargs):
        return APIResponse(0, 'test 登录才能访问的接口 ok')

# 游客只读，登录无限制
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')

# 游客只读，登录用户只读，只有登录用户属于 管理员 分组，才可以增删改
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')

原文地址：https://www.cnblogs.com/huangxuanya/p/11764156.html