认证&权限

认证和权限是一起配合使用的。
可以再配置文件中settings配置全局默认的认证&权限

REST_FRAMEWORK = {
    # python中认证的配置
    'DEFAULT_AUTHENTICATION_CLASSES': (
        'rest_framework.authentication.BasicAuthentication',   # 基本认证
        'rest_framework.authentication.SessionAuthentication',  # session认证
    )
    # python中权限的配置，如果没有指明，系统默认的权限是允许所有人访问的
    'DEFAULT_PERMISSION_CLASSES': (
        'rest_framework.permissions.AllowAny',
    )
}

也可以在每个视图中通过设置authentication_classess属性来设置

# 从DRF框架中导入包authentication
from rest_framework.authentication import SessionAuthentication, BasicAuthentication
from rest_framework.views import APIView

class ExampleView(APIView):
    # 在子应用中定义authentication_classes，可以写一个也可以写多个
    # authentication_classes = (SessionAuthentication, BasicAuthentication)
    # 配合权限来使用我们写一个。
    authentication_classes = [SessionAuthentication]
  

认证失败会有两种可能的返回值：

401 Unauthorized 未认证
403 Permission Denied 权限被禁止

也可以在具体的视图中通过permission_classes属性来设置，如

from rest_framework.permissions import IsAuthenticated
from rest_framework.views import APIView

class ExampleView(APIView):
    # 设置允许登录用户来进行访问。
    permission_classes = (IsAuthenticated,)
    ...

提供的权限

1.AllowAny 允许所有用户
2.IsAuthenticated 仅通过认证的用户
3.IsAdminUser 仅管理员用户
4.IsAuthenticatedOrReadOnly 认证的用户可以完全操作，否则只能get读取

我们也可以自己定义权限

如需自定义权限，需继承rest_framework.permissions.BasePermission父类，并实现以下两个任何一个方法或全部

.has_permission(self, request, view)

是否可以访问视图， view表示当前视图对象，如果没有设置的话默认的是True，如果设置
False则表示所有的用户都不能访问该视图

.has_object_permission(self, request, view, obj)

是否可以访问数据对象， view表示当前视图， obj为数据对象，控制视图能够访问添加了权限控制类的数据对象

class MyPermission(BasePermission):
    def has_permission(self, request, view)
        """让所有用户都有权限"""
        return True
    def has_object_permission(self, request, view, obj):
        """用户是否有权限访问添加了权限控制类的数据对象"""
        # 需求：用户能够访问id为1，3的对象，其他的不能够访问
        if obj.id in (1, 3):
            return True
        else:
            return False

class BookInfoViewSet(ModelViewSet):
    queryset = BookInfo.objects.all()
    serializer_class = BookInfoSerializer
    # 表示登录有权限
    permission_classes = [IsAuthenticated]
    # 表示所有用户都有权限，只能够访问id 为1，3的数据
    permission_classes = [MyPermission]
   

节流

源码流程

和认证的流程一样，进入initial(request)
其中check_throttles(request)是节流的函数
allow_request()就是节流函数（要复写）（get_throttles循环所有节流类)
VisitThrottle自定义权限类
allow_request()返回值：

True, 允许访问
False, 访问太频繁
wait()返回值：
返回一个整数,表示下次还有多久可以访问

使用自定义类

class VisitThrottle(BaseThrottle):
    def __init__(self):
        self.history = []

    def allow_request(self, request, view):
        remote_addr = request.META.get('REMOTE_ADDR')
        ctime = time.time()
        if remote_addr not in VISIT_RECORD:
            print("没有此IP")
            VISIT_RECORD[remote_addr] = [ctime, ]
            return True

        history = VISIT_RECORD.get(remote_addr)

        print(history)

        while history and history[-1] < ctime-8:
            history.pop()

        self.history = history
        if len(history) < 3:
            history.insert(0, ctime)
            return True

    def wait(self):

        ctime = time.time()
        return 8-(ctime-self.history[-1])

在定义的类中复写allow_request方法，返回True或者False表示可以访问或者访问频率太高
引入

1.全局

# settings.py
'DEFAULT_THROTTLE_CLASSES': ['apps.api.utils.throttle.UserThrottle'],

2.局部

class AuthView(APIView):
    """
    用于用户登录认证
    """
    throttle_classes = [VisitThrottle,]

自定义类继承内置类

# throttle.py
from rest_framework.throttling import  SimpleRateThrottle
class VisitThrottle(SimpleRateThrottle):
    scope = "Vistor"

    def get_cache_key(self, request, view):
        return self.get_ident(request)

class UserThrottle(SimpleRateThrottle):
    scope = "User"

    def get_cache_key(self, request, view):
        return self.user.username

scope从settings.py中寻找DEFAULT_THROTTLE_RATES字典的Key,就是访问频率限制，scope可以区分不同的函数的不同限制；get_cache_key(self, request, view)返回一个唯一标示用以区分不同的用户，对于匿名用户返回IP保存到缓存中限制访问，对于注册的用户取用户名（唯一）来区分就可以。

# settings.py
    'DEFAULT_THROTTLE_RATES': {
      'Vistor': '3/m',
      'User': '10/m'
    },

版本

源码流程

1.和认证的流程一样，进入initial(request)
在认证，权限，节流前先执行了这两句函数,获取到version,scheme，并分别赋值给request对象的version, versioning_scheme属性

# 获取版本(version)和scheme
        version, scheme = self.determine_version(request, *args, **kwargs) 
        request.version, request.versioning_scheme = version, scheme

进入determine_version()函数

  scheme = self.versioning_class()
        return (scheme.determine_version(request, *args, **kwargs), scheme)

在这里获取到scheme就是api_settings.DEFAULT_VERSIONING_CLASS,系统默认版本控制类，那scheme.determine_version(request, *args, kwargs) 就是该类下的一个方法
查看rest_framework库的一个自带类中的determine_version方法

class QueryParameterVersioning(BaseVersioning):
    """
    GET /something/?version=0.1 HTTP/1.1
    Host: example.com
    Accept: application/json
    """
    invalid_version_message = _('Invalid version in query parameter.')

    def determine_version(self, request, *args, **kwargs):
        version = request.query_params.get(self.version_param, self.default_version)
        if not self.is_allowed_version(version):
            raise exceptions.NotFound(self.invalid_version_message)
        return version

返回的是版本号。于是version, scheme分别是版本号和一个版本控制类，并分别赋值给request对象的version, versioning_scheme属性。

使用

1.定义一个版本类，重写determine_version方法，返回版本号

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

        version = request.query_params.get('version')
        return version

2.局部使用
相关业务

class UsersView(APIView):
    versioning_class = ParamVersion

    def get(self, request, *args, **kwargs):
        # 获取版本
        self.dispatch
        print(request.version)
        # 获取版本处理对象
        # print(request.versioning_scheme)
        # u1 = request.versioning_scheme.reverse('api:uuu', request=request)
        # print("u1:", u1)
        # u2 = reverse('api:uuu', kwargs={'version': 1})
        # print("u2:", u2)
        return HttpResponse('用户列表')

3.全局使用

  'DEFAULT_VERSIONING_CLASS': 'rest_framework.versioning.URLPathVersioning', # 默认版本类
    'DEFAULT_VERSION': 'v1',  # 默认版本
    'ALLOWED_VERSIONS': ['v1', 'v2'],  # 允许的版本
    'VERSION_PARAM': 'version'  ，# URL中获取值的key
}

内置类的使用

1.放到url后作为get参数

http://127.0.0.1:8000/api/users/?version=v1

from rest_framework.versioning import QueryParameterVersioning
class UsersView(APIView):
    versioning_class = QueryParameterVersioning

    def get(self, request, *args, **kwargs):
        # 获取版本
        self.dispatch
        print(request.version)
        # 获取版本处理对象
        # print(request.versioning_scheme)
        # u1 = request.versioning_scheme.reverse('api:uuu', request=request)
        # print("u1:", u1)
        # u2 = reverse('api:uuu', kwargs={'version': 1})
        # print("u2:", u2)
        return HttpResponse('用户列表')

2.用正则匹配

 re_path(r'^(?P<version>[v1|v2]+)/users/', views.UsersView.as_view(), name="uuu"),

from rest_framework.versioning import URLPathVersioning
class UsersView(APIView):
    versioning_class = URLPathVersioning

    def get(self, request, *args, **kwargs):
        # 获取版本
        self.dispatch
        print(request.version)
        # 获取版本处理对象
        # print(request.versioning_scheme)
        # u1 = request.versioning_scheme.reverse('api:uuu', request=request)
        # print("u1:", u1)
        # u2 = reverse('api:uuu', kwargs={'version': 1})
        # print("u2:", u2)
        return HttpResponse('用户列表')

request.versioning_scheme.reverse方法可以获取路由，是drf中的方法
django.urls.reverse 是django中的反向获取路由方法

u1: http://127.0.0.1:8000/api/v1/users/
u2: /api/1/users/

解析器

1.本质
· 请求头
· 状态吗
· 请求方法
2.源码流程
· dispatch : request封装
· request.data

使用

1.局部

from rest_framework.parsers import JSONParser, FormParser
class ParserView(APIView):
    parser_classes = [JSONParser]
    """
    JSONParser: 表示只能解析 application/json 请求头
    FormParser: 表示只能解析 application/x-www-form-urlencoded 请求头
    """
    def post(self, request, *args, **kwargs):
        """
        允许用户发送JSON格式的数据
            a. content-type: application/json
            b. {"name": 'alex', "age": 18}
        :param request:
        :param args:
        :param kwargs:
        :return:
        """
        """
        1. 获取用户请求
        2. 获取用户请求体
        3. 根据用户请求头和 parser_classes = [JSONParser, FormParser] 中支持的请求头进行比较
        4. JSONParser对象中去请求体
        5. request.data
        """
        print(request.data)
        return HttpResponse('JSON测试')

2.全局

# 全局使用
REST_FRAMEWORK = {
"DEFAULT_PARSER_CLASSES":  ["rest_framework.JSONParser", "rest_framework.FormParser"]
}