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

权限的使用场景

有时候我们的用户分为普通用户，VIP用户和超级VIP用户，有些接口我们需要针对不同的用户设定不同的权限

常用的做法如下：

 

简单的表结构设计如下：

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用户 才能访问，代码如下

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()),

　　

 

添加一个用户登陆的接口，视图函数代码如下：

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()),

　　

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

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

 

 

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

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值

 

 

 携带上述生成的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'],
}