权限类使用、频率类使用、认证源码分析、权限源码分析、补充知识：鸭子类型

权限类使用

主要用途：用户登录了，某个接口可能只有超级管理员才能访问，普通用户不能访问

案列：出版社的所有接口，必须登录，而且是超级管理员才能访问

分析步骤

第一步：写一个类，继承BasePermission
第二步：重写has_permission方法
第三步：在方法校验用户时候有权限（request.user就是当前登录用户）
第四步：如果有权限，返回True,没有权限，返回FALSE
第五步：self.message 是给前端的提示信息
第六步：局部使用，全局使用，局部禁用

model.py

class User(models.Model):
    username = models.CharField(max_length=32)
    password = models.CharField(max_length=32)
    user_type = models.IntegerField(default=3, choices=((1, '超级管理员'), (2, '普通用户'), (3, '2b用户')))

    def __str__(self):
        return self.username

permission.py

from rest_framework.permissions import BasePermission


class UserTypePermission(BasePermission):
    def has_permission(self, request, view):
        # 只有超级管理员有权限
        if request.user.user_type == 1:
            return True  # 有权限
        else:
            """
            self.message = '普通用户和2b用户都没有权限'
            self.message = '您是：%s 用户，您没有权限'%request.user.get_user_type_display()
            """
            return False  # 没有权限

"""
self.message = '普通用户和2b用户都没有权限' 
    返回给前端的提示是什么样

self.message = '您是：%s 用户，您没有权限'%request.user.get_user_type_display()
    使用了choice后，user.user_type 拿到的是数字类型，想变成字符串 user.get_user_type_display()
"""

view.py

# 导入我们所写的那个权限文件
from .permission import UserTypePermission
# 要验证必须要登录，下面的这种方式是局部权限使用
class PublishView(ViewSetMixin, ListCreateAPIView):
    # 登录验证
    authentication_classes = [LoginAuth, ]
    # 权限验证
    permission_classes = [UserTypePermission, ]
    queryset = Publish.objects.all()
    serializer_class = PublishSerializer


class PublishDetailView(ViewSetMixin, RetrieveUpdateDestroyAPIView):
    # 登录验证
    authentication_classes = [LoginAuth, ]
    # 权限验证
    permission_classes = [UserTypePermission, ]
    queryset = Publish.objects.all()
    serializer_class = PublishSerializer

settings.py

全局权限验证：（要在setting.py文件中配置）

全局验证需要注意的是在登录的时候需要添加局部禁用
    permission_classes = []
    authentication_classes = []


REST_FRAMEWORK = {
    # 'DEFAULT_AUTHENTICATION_CLASSES': ['app01.auth.LoginAuth', ]
    'DEFAULT_PERMISSION_CLASSES': ['app01.permission.UserTypePermission', ]
}

# 全局的加上以后局部的就可以注释掉了

频率类使用

认证，权限都通过以后，我们可以限制某个接口的访问频率，防止有人恶意攻击网站，一般根据ip或者用户限制

案例：无论是否登录和是否有权限，都要限制访问的频率，比如一分钟访问3次

分析步骤

第一步：写一个类：继承SimpleRateThrottle
第二步：重写get_cache_key,返回唯一的字符串，会以这个字符串做频率限制
第三步：写一个类属性scope=‘随便写’，必须要跟配置文件对象
第四步：配置文件中写
    'DEFAULT_THROTTLE_RATES': {
        '随意写': '3/m'  # 3/h  3/s  3/d
        }
第五步：局部配置，全局配置，局部禁用

throttling.py(SimpleRateThrottle)

from rest_framework.throttling import BaseThrottle, SimpleRateThrottle


# 我们继承SimpleRateThrottle去写，而不是继承BaseThrottle去写
class TimeThrottling(SimpleRateThrottle):
    # 类属性,这个类属性可以随意命名，但要跟配置文件对应
    scope = 'throttling'
    
    def get_cache_key(self, request, view):
        """
        # 返回什么，频率就以什么做限制
        # 可以通过用户id限制
        # 可以通过ip地址限制
        """
        return request.META.get('REMOTE_ADDR')

局部配置

class PublishView(ViewSetMixin, ListCreateAPIView):
    authentication_classes = [LoginAuth, ]
    # permission_classes = [UserTypePermission, ]
    # 局部频率验证，每分钟只能访问五次
    throttle_classes = [TimeThrottling, ]
    queryset = Publish.objects.all()
    serializer_class = PublishSerializer


class PublishDetailView(ViewSetMixin, RetrieveUpdateDestroyAPIView):
    authentication_classes = [LoginAuth, ]
    # permission_classes = [UserTypePermission, ]
    # 局部频率验证，每分钟只能访问五次
    throttle_classes = [TimeThrottling, ]
    queryset = Publish.objects.all()
    serializer_class = PublishSerializer

全局配置

REST_FRAMEWORK = {
    'DEFAULT_THROTTLE_CLASSES': ['app01.throttling.TimeThrottling', ],
    'DEFAULT_THROTTLE_RATES': {
        'throttling': '5/m'  # 一分钟访问5次
    }
}

认证源码分析

# 写个认证类，重写某个方法，配置在视图类上，就有认证了---》认证类加了，在视图类的方法中，request.user就是当前登录用户---》猜认证类的执行，是在在视图类的方法之前执行的
# 源码分析：
    -之前咱们读APIView的执行流程---》包装了新的request，执行了3大认证，执行视图类的方法，处理了全局异常
    -入口：APIView的dispatch
    -APIView的dispatch的496行上下：self.initial(request, *args, **kwargs)
    -APIView的initial
    -413行上下：有三句话，分别是:认证，权限，频率
        self.perform_authentication(request)
        self.check_permissions(request)
        self.check_throttles(request)
    -读认证类的源码---》APIView的perform_authentication(request)，315行上下
        def perform_authentication(self, request):
            request.user  # 新的request
    -request是新的request---》Request类中找user属性(方法)，是个方法包装成了数据属性
    -来到Request类中找：220行
       def user(self):
            if not hasattr(self, '_user'): # Request类的对象中反射_user
                with wrap_attributeerrors():
                    self._authenticate()  # 第一次会走这个代码
            return self._user
    -Request的self._authenticate()---》373行
        def _authenticate(self):
            for authenticator in self.authenticators: # 配置在视图类中所有的认证类的对象 
                try:
                    #（user_token.user, token）
                    user_auth_tuple = authenticator.authenticate(self) # 调用认证类对象的authenticate
                except exceptions.APIException:
                    self._not_authenticated()
                    raise

                if user_auth_tuple is not None:
                    self._authenticator = authenticator # 忽略
                    self.user, self.auth = user_auth_tuple # 解压赋值
                    return
              # 认证类可以配置多个，但是如果有一个返回了两个值，后续的就不执行了
            self._not_authenticated()

    # 总结：认证类，要重写authenticate方法，认证通过返回两个值或None，认证不通过抛AuthenticationFailed（继承了APIException）异常

权限源码分析

-先读最简单的权限执行流程---》APIView的check_permissions(request)，325行上下
    def check_permissions(self, request):
        for permission in self.get_permissions():
            # permission是咱们配置在视图类中权限类的对象，对象调用它的绑定方法has_permission
            # 对象调用自己的绑定方法会把自己传入(权限类的对象,request,视图类的对象)
            if not permission.has_permission(request, self):
                self.permission_denied(
                    request,
                    message=getattr(permission, 'message', None),
                    code=getattr(permission, 'code', None)
                )
                
   -APIVIew的self.get_permissions()，273行上下
	return [permission() for permission in self.permission_classes]
   -self.permission_classes 就是咱们在视图类中配的权限类的列表
   -所以这个get_permissions返回的是 咱们在视图类中配的权限类的对象列表[UserTypePermession(),]


# 总结：权限类源码
    -为什么要写一个类，重写has_permission方法，有三个参数，为什么一定要return True或False，messgage可以做什么用

浅读一下频率类源码

# 源码分析：
	-之前咱们读APIView的执行流程---》包装了新的request，执行了3大认证，执行视图类的方法，处理了全局异常
    -入口：APIView的dispatch
    -APIView的dispatch的496行上下：self.initial(request, *args, **kwargs)
    -APIView的initial
    -413行上下：有三句话，分别是:认证，权限，频率
    	self.perform_authentication(request)
        self.check_permissions(request)
        self.check_throttles(request)
    -APIView的check_throttles：351上下
        def check_throttles(self, request):
            throttle_durations = []
            for throttle in self.get_throttles():
                if not throttle.allow_request(request, self):
                    throttle_durations.append(throttle.wait())
                    
                    
   -总结：要写频率类，必须重写allow_request方法，返回True（没有到频率的限制）或False（到了频率的限制）

鸭子类型

class duck():
    def walk(self):
        print('I walk, i am a duck')

    def swim(self):
        print('i swim,i am a duck')

class geese():
    def walk(self):
        print('i walk like a duck')

    def swim(self):
        print('i swim like a duck')
class person():
    def walk(self):
        print('this one walk like a duck')

    def swim(self):
        print('this one walk like a duck')

def watch_duck(a):
    a.walk()
    a.swim()

small_duck = duck()
watch_duck(small_duck)

duck_like_geese = geese()
watch_duck(duck_like_geese)

duck_like_man = person()
watch_duck(duck_like_man)

运行结果

I walk, i am a duck
i swim,i am a duck
i walk like a duck
i swim like a duck
this one walk like a duck
this one walk like a duck

鸭子类型要求每个class要有相同的方法

从上面可以看出，只要有watch_duck函数接收这个类的对象，然后并没有检查对象的类型，而是直接调用这个对象的walk和swim方法，
从上面可以看出，python鸭子类型的灵活性在于它关注的是这个所调用的对象是如何被使用的，而没有关注对象类型的本身是什么

总结

浅浅的了解：
    走路像鸭子，说话像鸭子，它就是鸭子

正儿八经的对鸭子类型：
    指的是面向对中，子类不需要显示的继承某个类，只要有某个的方法和属性，那我就属于这个类

详细解释：
    假设有个鸭子类Duck类，有两个方法，walk，swim方法
    假设又有一个普通鸭子类,PDuck，如果它也是鸭子，它需要继承Duck类，只要继承了鸭子类，什么都不需要写，普通鸭子类的对象就是鸭子这种类型；如果不继承，普通鸭子类的对象就不是鸭子这种类型
    假设又有一个唐老鸭子类,TDuck，如果它也是鸭子，它需要继承Duck类，只要继承了鸭子类，什么都不需要写，唐老鸭子类的对象就是鸭子这种类型；如果不继承，唐老鸭子类的对象就不是鸭子这种类型

# python不推崇这个，它推崇鸭子类型，指的是
不需要显示的继承某个类，只要我的类中有run和speak方法，我就是鸭子这个类

# 有小问题：
    如果使用python鸭子类型的写法，如果方法写错了，它就不是这个类型了，会有问题

# python为了解决这个问题：
    方式一：abc模块，装饰后，必须重写方法，不重写就报错
    方式二：drf源码中使用的：父类中写这个方法，但没有具体实现，直接抛异常

注意

choice

其实choice本质就是有关联，后期不会修改的情况下使用choice，后期会增加或减少用户类型的情况下，要使用另一个表

实现这种操作的话，还可以使用外键的关联

关于settings.py文件中模块的导入

# django的配置文件不要乱导入。乱导入可能会报错

"""
django的运行是在加载玩配置文件后才能运行
因为模块的导入会执行那个模块，而这个模块又有别的导入，别的导入必须django运行起来才能使用
"""

作业

1 编写图书和出版社的5个接口，所有接口都要有一分钟访问5次的频率限制

view.py

from .auth import LoginAuth
from .throttling import TimeThrottling

# book的所有接口要登录后才能访问
class BookView(ViewSetMixin, GenericAPIView, ListModelMixin, CreateModelMixin):
    # 登录认证
    authentication_classes = [LoginAuth, ]
    # throttle_classes = [TimeThrottling, ]
    queryset = Book.objects.all()
    serializer_class = BookSerializer

    def get(self, *args, **kwargs):
        return self.list(*args, **kwargs)

    def post(self, *args, **kwargs):
        return self.create(*args, **kwargs)


class BookDetailView(ViewSetMixin, GenericAPIView, RetrieveModelMixin, UpdateModelMixin, DestroyModelMixin):
    # 登录认证
    authentication_classes = [LoginAuth, ]
    # throttle_classes = [TimeThrottling, ]
    queryset = Book.objects.all()
    serializer_class = BookSerializer

    def get(self, request, *args, **kwargs):
        return self.retrieve(request, *args, **kwargs)

    def put(self, request, *args, **kwargs):
        return self.update(request, *args, **kwargs)

    def delete(self, request, *args, **kwargs):
        return self.destroy(request, *args, **kwargs)


from .permission import UserTypePermission


class PublishView(ViewSetMixin, ListCreateAPIView):
    authentication_classes = [LoginAuth, ]
    queryset = Publish.objects.all()
    serializer_class = PublishSerializer


class PublishDetailView(ViewSetMixin, RetrieveUpdateDestroyAPIView):
    authentication_classes = [LoginAuth, ]
    queryset = Publish.objects.all()
    serializer_class = PublishSerializer

throttling.py(自己写的一个类)

from rest_framework.throttling import BaseThrottle, SimpleRateThrottle


# 我们继承SimpleRateThrottle去写，而不是继承BaseThrottle去写
class TimeThrottling(SimpleRateThrottle):
    # 类属性,这个类属性可以随意命名，但要跟配置文件对应
    scope = 'throttling'

    # 重写get_cache_key，不重写的话就会抛异常
    def get_cache_key(self, request, view):
        """
        # 返回什么，频率就以什么做限制
        # 可以通过用户id限制
        # 可以通过ip地址限制
        """
        return request.META.get('REMOTE_ADDR')

settings.py文件中的配置

REST_FRAMEWORK = {
    # 'DEFAULT_AUTHENTICATION_CLASSES': ['app01.auth.LoginAuth', ]
    'DEFAULT_PERMISSION_CLASSES': ['app01.permission.UserTypePermission', ],
    'DEFAULT_THROTTLE_CLASSES': ['app01.throttling.TimeThrottling', ],
    'DEFAULT_THROTTLE_RATES': {
        'throttling': '5/m'  # 一分钟访问5次
    }
}

2 图书的接口需要登录才能方法，出版社的接口需要登录，并且是超级用户才能访问

view.py

import uuid

from django.shortcuts import render

# Create your views here.
from rest_framework.decorators import action
from rest_framework.generics import GenericAPIView
from rest_framework.response import Response

from .models import Book, Publish, User, UserToken
from rest_framework.viewsets import ViewSetMixin, ModelViewSet, ViewSet
from rest_framework.mixins import ListModelMixin, CreateModelMixin, RetrieveModelMixin, DestroyModelMixin, \
    UpdateModelMixin

from rest_framework.generics import ListAPIView, CreateAPIView, RetrieveAPIView, DestroyAPIView, UpdateAPIView
from rest_framework.generics import ListCreateAPIView, RetrieveUpdateDestroyAPIView, RetrieveDestroyAPIView, \
    RetrieveUpdateAPIView
from .serializer import BookSerializer, PublishSerializer
from .auth import LoginAuth
from .throttling import TimeThrottling

# book的所有接口要登录后才能访问
class BookView(ViewSetMixin, GenericAPIView, ListModelMixin, CreateModelMixin):
    # 登录认证
    authentication_classes = [LoginAuth, ]
    # 局部禁用权限认证
    permission_classes = []
    # 使用了全局频率验证，这里注释掉了局部的频率验证
    # throttle_classes = [TimeThrottling, ]
    queryset = Book.objects.all()
    serializer_class = BookSerializer

    def get(self, *args, **kwargs):
        return self.list(*args, **kwargs)

    def post(self, *args, **kwargs):
        return self.create(*args, **kwargs)


class BookDetailView(ViewSetMixin, GenericAPIView, RetrieveModelMixin, UpdateModelMixin, DestroyModelMixin):
    # 登录认证
    authentication_classes = [LoginAuth, ]
    # 局部禁用权限认证
    permission_classes = []
    # 使用了全局频率验证，这里注释掉了局部的频率验证
    # throttle_classes = [TimeThrottling, ]
    queryset = Book.objects.all()
    serializer_class = BookSerializer

    def get(self, request, *args, **kwargs):
        return self.retrieve(request, *args, **kwargs)

    def put(self, request, *args, **kwargs):
        return self.update(request, *args, **kwargs)

    def delete(self, request, *args, **kwargs):
        return self.destroy(request, *args, **kwargs)


from .permission import UserTypePermission


class PublishView(ViewSetMixin, ListCreateAPIView):
    authentication_classes = [LoginAuth, ]
    queryset = Publish.objects.all()
    serializer_class = PublishSerializer


class PublishDetailView(ViewSetMixin, RetrieveUpdateDestroyAPIView):
    authentication_classes = [LoginAuth, ]
    queryset = Publish.objects.all()
    serializer_class = PublishSerializer


class UserView(ViewSet):
    # 全局验证需要注意的是在登录的时候需要添加局部禁用
    permission_classes = []
    authentication_classes = []
    @action(methods=['POST', ], detail=False, url_name='login')
    def login(self, request):
        # 取出前段传入的用户名和密码，校验、通过，返回登录成功·，失败就返回用户名密码错误
        username = request.data.get('username')
        password = request.data.get('password')
        user = User.objects.filter(username=username, password=password).first()
        # 登录成功，不同人生成的token是不一样的，谁登录的，就把token存到UserToken表中
        if user:
            token = str(uuid.uuid4())
            UserToken.objects.update_or_create(defaults={'token': token}, user=user)
            return Response({'code': 100, 'msg': '登录成功', 'token': token})
        else:
            return Response({'code': 101, 'msg': '用户名或密码错误'})

permission.py

from rest_framework.permissions import BasePermission


class UserTypePermission(BasePermission):
    def has_permission(self, request, view):
        # 只有超级管理员有权限
        if request.user.user_type == 1:
            return True  # 有权限
        else:
            self.message = '普通用户和2b用户都没有权限'  # 返回给前端的提示是什么样
            # 使用了choice后，user.user_type 拿到的是数字类型，想变成字符串 user.get_user_type_display()
            # self.message = '您是：%s 用户，您没有权限'%request.user.get_user_type_display()
            return False  # 没有权限

model.py(user)

class User(models.Model):
    username = models.CharField(max_length=32)
    password = models.CharField(max_length=32)
    user_type = models.IntegerField(default=3, choices=((1, '超级管理员'), (2, '普通用户'), (3, '2b用户')))

    def __str__(self):
        return self.username

settings.py

REST_FRAMEWORK = {
    'DEFAULT_PERMISSION_CLASSES': ['app01.permission.UserTypePermission', ],
}

3 继承BaseThrottle编写频率类

class TimeThrottling(BaseThrottle):
    dict = {}  # 记录访问者的大字典

    def __init__(self):
        self.history = None

    def allow_request(self, request, view):
        # 自定义的逻辑  {ip:[时间1，时间2]}
        # （1）取出访问者ip
        ip = request.META.get('REMOTE_ADDR')
        import time
        ctime = time.time()
        # （2）判断当前ip不在访问字典里，添加进去，并且直接返回True,表示第一次访问，在字典里，继续往下走
        if ip not in self.dict:
            self.dict[ip] = [ctime, ]
            return True
        self.history = self.dict.get(ip, [])
        # （3）循环判断当前ip的列表，有值，并且当前时间减去列表的最后一个时间大于60s，把这种数据pop掉，这样列表中只有60s以内的访问时间，
        while self.history and ctime - self.history[-1] > 60:
            self.history.pop()
        # （4）判断，当列表小于3，说明一分钟以内访问不足三次，把当前时间插入到列表第一个位置，返回True，顺利通过
        # （5）当大于等于3，说明一分钟内访问超过三次，返回False验证失败
        if len(self.history) < 3:
            self.history.insert(0, ctime)
            return True
        else:
            return False

    def wait(self):
        import time
        ctime = time.time()
        # return 60 - (ctime - self.history[-1])
        return 1