Django rest framework源码分析（2）----权限

时间  2019-12-08
标签 django rest framework 源码 分析 权限 栏目 Python 繁體版
原文   原文链接

权限的使用场景

有时候咱们的用户分为普通用户，VIP用户和超级VIP用户，有些接口咱们须要针对不一样的用户设定不一样的权限python

经常使用的作法以下：django

 

简单的表结构设计以下：api

from django.db import models

class UserInfo(models.Model):
    user_type_choices = (
        (1,'普通用户'),
        (2,'VIP'),
        (3,'SVIP'),
    )
    user_type = models.IntegerField(choices=user_type_choices)
    username = models.CharField(max_length=32,unique=True)
    password = models.CharField(max_length=64)

class UserToken(models.Model):
    user = models.OneToOneField(to='UserInfo')
    token = models.CharField(max_length=64)

 

 

写一个接口只容许登录后的 SVIP用户 才能访问，代码以下app

class OrderView(APIView):
    """
    订单相关业务(只有SVIP用户有权限)
    """

    def get(self,request,*args,**kwargs):
        # request.user
        # request.auth
        # self.dispatchdispatch
        if request.user.user_type != 3:
            return HttpResponse("无权访问")

        ret = {'code':1000,'msg':None,'data':None}
        try:
            ret['data'] = ORDER_DICT
        except Exception as e:
            pass
        return JsonResponse(ret)

 

 

为其添加 url 函数

    url(r'^api/v1/order/$', views.OrderView.as_view()),

　　

 

添加一个用户登录的接口，视图函数代码以下：post

class AuthView(APIView):
    """
    用于用户登陆认证
    """
    authentication_classes = []

    def post(self,request,*args,**kwargs):

        ret = {'code':1000,'msg':None}
        try:
            user = request._request.POST.get('username')
            pwd = request._request.POST.get('password')
            obj = models.UserInfo.objects.filter(username=user,password=pwd).first()
            if not obj:
                ret['code'] = 1001
                ret['msg'] = "用户名或密码错误"
            # 为登陆用户建立token
            token = md5(user)
            # 存在就更新，不存在就建立
            models.UserToken.objects.update_or_create(user=obj,defaults={'token':token})
            ret['token'] = token
        except Exception as e:
            ret['code'] = 1002
            ret['msg'] = '请求异常'

        return JsonResponse(ret)

 

 

为其添加 url 测试

    url(r'^api/v1/auth/$', views.AuthView.as_view()),

　　

 进行全局认证的配置，在配置文件中添加以下代码：ui

REST_FRAMEWORK = {
    # 全局使用的认证类
    "DEFAULT_AUTHENTICATION_CLASSES":['api.utils.auth.Authtication', ]
}

 

 

 根据上面配置中的路径，添加认证函数，在应用  api 下建立utils/auth.py 代码以下:this

class Authtication(BaseAuthentication):
    def authenticate(self,request):
        token = request._request.GET.get('token')
        print(token)
        token_obj = models.UserToken.objects.filter(token=token).first()
        if not token_obj:
            raise exceptions.AuthenticationFailed('用户认证失败')
        # 在rest framework内部会将整个两个字段赋值给request，以供后续操做使用
        return (token_obj.user, token_obj)

    def authenticate_header(self, request):
        return 'Basic realm="api"'

 

 

 好了，上面就是一般咱们在视图函数中对不一样的用户进行区分的，简单的测试下，首先登录生成token值url

 

 

 携带上述生成的token值去访问只能SVIP用户才能访问的接口

用于zhangtao 这个用户是SVIP的用户因此它生成的token，携带它是能够访问的，假如咱们使用的不是SVIP用户生成的token去访问该接口是不嫩访问的以下：

 

 以上基本的功能是实现了，可是把一些处理的逻辑都冗杂在处理函数中，显得相对的冗余，那么是否能够经过在视图函数中简单的配置就能实现上述的功能呢，答案确定是能够的，

先直接上代码，有一个清晰的认识，在分析其源码

 

在应用 api 下 的utils 目录下建立 permission.py 代码 以下

from rest_framework.permissions import BasePermission

#  校验 SVIP 用户 才能访问的验证
class SVIPPermission(BasePermission):
    message = "必须是SVIP才能访问"
    def has_permission(self,request,view):
        if request.user.user_type != 3:
            return False
        return True

# 除了 SVIP用户均可以访问的验证
class MyPermission1(BasePermission):

    def has_permission(self,request,view):
        if request.user.user_type == 3:
            return False
        return True

 

 

 

根据使用场景的不一样，只需在须要认证的类视图中，添加类属性   permission_classes =  [ 须要须要的权限认证函便可  ]

 

咱们把上面只能SVIP用户才能访问的视图作下简单的配置就能够实现相同的效果，修改后的代码以下

from api.utils.permission import SVIPPermission
from api.utils.permission import MyPermission1


class OrderView(APIView):
    """
    订单相关业务(只有SVIP用户有权限)
    """
    permission_classes = [SVIPPermission,]
    def get(self,request,*args,**kwargs):

        ret = {'code':1000,'msg':None,'data':None}
        try:
            ret['data'] = ORDER_DICT
        except Exception as e:
            pass
        return JsonResponse(ret)

 

 

 上面的接口只用SVIP用户才能够访问，咱们在写一个接口除了SVIP用户，其余的用户均可以访问，代码以下

class UserInfoView(APIView):
    """
    订单相关业务（普通用户、VIP）
    """
    permission_classes = [MyPermission1, ]

    def get(self,request,*args,**kwargs):
        return HttpResponse('用户信息')

 

为其添加 url 

    url(r'^api/v1/info/$', views.UserInfoView.as_view()),

 

添加一个VIP用户 zhangyangcheng

 

 

进行测试的结果以下:

 

 

权限的源码流程 

入口 dispatch

    def dispatch(self, request, *args, **kwargs):
        """
        `.dispatch()` is pretty much the same as Django's regular dispatch,
        but with extra hooks for startup, finalize, and exception handling.
        """
        self.args = args
        self.kwargs = kwargs
        # 对原生的request进行封装
        request = self.initialize_request(request, *args, **kwargs)
        self.request = request
        self.headers = self.default_response_headers  # deprecate?

        try:
            self.initial(request, *args, **kwargs)

            # Get the appropriate handler method
            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)

        self.response = self.finalize_response(request, response, *args, **kwargs)
        return self.response

 

 

追踪  initial 代码以下

    def initial(self, request, *args, **kwargs):
        """
        Runs anything that needs to occur prior to calling the method handler.
        """
        self.format_kwarg = self.get_format_suffix(**kwargs)

        # Perform content negotiation and store the accepted info on the request
        neg = self.perform_content_negotiation(request)
        request.accepted_renderer, request.accepted_media_type = neg

        # Determine the API version, if versioning is in use.
        version, scheme = self.determine_version(request, *args, **kwargs)
        request.version, request.versioning_scheme = version, scheme

        # Ensure that the incoming request is permitted
        # 实现认证
        self.perform_authentication(request)
        # 权限判断
        self.check_permissions(request)
        self.check_throttles(request)

 

 

咱们能够看到最下面  self.check_permissions(request) 检测权限，追踪其代码以下

    def check_permissions(self, request):
        """
        Check if the request should be permitted.
        Raises an appropriate exception if the request is not permitted.
        """
        for permission in self.get_permissions():
            if not permission.has_permission(request, self):
                self.permission_denied(
                    request, message=getattr(permission, 'message', None)
                )

 

 

大体意思是在权限认证的对象中若是没有经过认证就会抛出异常，若是经过权限的认证，就不作处理，  因此这时候咱们就知道了，为何咱们在写权限认证类中要重写  has_permission 方法了，message是一个类属性，在认证失败的时候，抛出的提示信息

 

咱们来追踪  for 循环中的self.get_permissions() 看其代码以下：

    def get_permissions(self):
        """
        Instantiates and returns the list of permissions that this view requires.
        """
        # 权限的对象列表
        return [permission() for permission in self.permission_classes]

 

 

到这里咱们就能够看到  返回的是一个权限认证的对象列表，这也就说明了为何咱们在视图中若是使用咱们本身配置的权限，只需简单的设置类属性 permission_class  =  [  须要认证的权限   ]  便可 

 

进行全局的权限认证的配置

在上面的源码中让咱们来继续追踪   self.permission_class 的代码以下

 

 

继续追踪   permission_classes 咱们能够看到 

api_settings = APISettings(None, DEFAULTS, IMPORT_STRINGS)


def reload_api_settings(*args, **kwargs):
    setting = kwargs['setting']
    if setting == 'REST_FRAMEWORK':
        api_settings.reload()

 

 

经过上面的源码追踪，因此咱们若是想要进行全局权限认证配置的话，只需在配置文件中对  REST_FRAMEWORK 中添加 权限认证类视图的路径（DEFAULT_PERMISSION_CLASSES）便可 ，配置的代码以下：

默认的是只有SVIP用户才能够进行访问

REST_FRAMEWORK = {
    # 全局使用的认证类
    "DEFAULT_AUTHENTICATION_CLASSES":['api.utils.auth.FirstAuthtication','api.utils.auth.Authtication', ],
    "UNAUTHENTICATED_USER":lambda :"匿名用户",
    "UNAUTHENTICATED_TOKEN":None,
    "DEFAULT_PERMISSION_CLASSES":['api.utils.permission.SVIPPermission'],# 默认的权限认证
}

 

 

若是咱们在定义只有SVIP用户才能访问的接口是，则不须要在设置类属性的认证，代码以下

class OrderView(APIView):
    """
    订单相关业务(只有SVIP用户有权限)
    """
    def get(self,request,*args,**kwargs):

        ret = {'code':1000,'msg':None,'data':None}
        try:
            ret['data'] = ORDER_DICT
        except Exception as e:
            pass
        return JsonResponse(ret)

 

 

若是咱们在默认使用全局是对SVIP才能访问的状况下，添加一个视图函数除了SVIP用户全部的用户均可以访问，根据类的性质，只需使用咱们本身的权限认证，就不会使用父类的，代码以下

class UserInfoView(APIView):
    """
    订单相关业务（普通用户、VIP）
    """
    permission_classes = [MyPermission1, ]

    def get(self,request,*args,**kwargs):
        self.dispatch()
        return HttpResponse('用户信息')

 

内置权限

 django-rest-framework内置权限BasePermission

默认是没有限制权限

class BasePermission(object):
    """
    A base class from which all permission classes should inherit.
    """

    def has_permission(self, request, view):
        """
        Return `True` if permission is granted, `False` otherwise.
        """
        return True

    def has_object_permission(self, request, view, obj):
        """
        Return `True` if permission is granted, `False` otherwise.
        """
        return True

 

 

咱们本身写的权限类，为了规范建议都应该去继承BasePermission

总结：

（1）使用

  • 本身写的权限类：1.必须继承BasePermission类；  2.必须实现：has_permission方法

（2）返回值

  • True   有权访问
  • False  无权访问

（3）局部

  • permission_classes = [MyPremission,] 

 （4）全局

REST_FRAMEWORK = {
   #权限
    "DEFAULT_PERMISSION_CLASSES":['API.utils.permission.SVIPPremission'],
}
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程