DRF的版本、认证、权限

DRF的版本

版本控制是做什么用的, 我们为什么要用

首先我们要知道我们的版本是干嘛用的呢~~大家都知道我们开发项目是有多个版本的~~

当我们项目越来越更新~版本就越来越多~~我们不可能新的版本出了~以前旧的版本就不进行维护了~~~

那我们就需要对版本进行控制~~这个DRF也给我们提供了一些封装好的版本控制方法~~

版本控制怎么用

之前我们学视图的时候知道APIView,也知道APIView返回View中的view函数,然后调用的dispatch方法~

执行self.initial方法之前是各种赋值,包括request的重新封装赋值,下面是路由的分发,那我们看下这个方法都做了什么~~

我们可以看到,我们的version版本信息赋值给了 request.version  版本控制方案赋值给了 request.versioning_scheme~~

其实这个版本控制方案~就是我们配置的版本控制的类~~

也就是说,APIView通过这个方法初始化自己提供的组件~~

我们接下来看看框架提供了哪些版本的控制方法~~在rest_framework.versioning里~~

详细用法

a. 基于url的get传参方式

如:/users?version=v1

REST_FRAMEWORK = {
    ‘DEFAULT_VERSION‘: ‘v1‘,            # 默认版本
    ‘ALLOWED_VERSIONS‘: [‘v1‘, ‘v2‘],   # 允许的版本
    ‘VERSION_PARAM‘: ‘version‘          # URL中获取值的key
}

settings.py

from django.conf.urls import url, include
from web.views import TestView

urlpatterns = [
    url(r‘^test/‘, TestView.as_view(),name=‘test‘),
]

urls.py

#!/usr/bin/env python
# -*- coding:utf-8 -*-
from rest_framework.views import APIView
from rest_framework.response import Response
from rest_framework.versioning import QueryParameterVersioning

class TestView(APIView):
    versioning_class = QueryParameterVersioning

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

        # 获取版本
        print(request.version)
        # 获取版本管理的类
        print(request.versioning_scheme)

        # 反向生成URL
        reverse_url = request.versioning_scheme.reverse(‘test‘, request=request)
        print(reverse_url)

        return Response(‘GET请求,响应内容‘)

    def post(self, request, *args, **kwargs):
        return Response(‘POST请求,响应内容‘)

    def put(self, request, *args, **kwargs):
        return Response(‘PUT请求,响应内容‘)

views.py

views.py

b. 基于url的正则方式

如:/v1/users/

REST_FRAMEWORK = {
    ‘DEFAULT_VERSION‘: ‘v1‘,            # 默认版本
    ‘ALLOWED_VERSIONS‘: [‘v1‘, ‘v2‘],   # 允许的版本
    ‘VERSION_PARAM‘: ‘version‘          # URL中获取值的key
}

settings.py

from django.conf.urls import url, include
from web.views import TestView

urlpatterns = [
    url(r‘^(?P<version>[v1|v2]+)/test/‘, TestView.as_view(), name=‘test‘),
]

urls.py

urls.py

#!/usr/bin/env python
# -*- coding:utf-8 -*-
from rest_framework.views import APIView
from rest_framework.response import Response
from rest_framework.versioning import URLPathVersioning

class TestView(APIView):
    versioning_class = URLPathVersioning

    def get(self, request, *args, **kwargs):
        # 获取版本
        print(request.version)
        # 获取版本管理的类
        print(request.versioning_scheme)

        # 反向生成URL
        reverse_url = request.versioning_scheme.reverse(‘test‘, request=request)
        print(reverse_url)

        return Response(‘GET请求,响应内容‘)

    def post(self, request, *args, **kwargs):
        return Response(‘POST请求,响应内容‘)

    def put(self, request, *args, **kwargs):
        return Response(‘PUT请求,响应内容‘)

views.py

views.py

c. 基于 accept 请求头方式

如:Accept: application/json; version=1.0

REST_FRAMEWORK = {
    ‘DEFAULT_VERSION‘: ‘v1‘,            # 默认版本
    ‘ALLOWED_VERSIONS‘: [‘v1‘, ‘v2‘],   # 允许的版本
    ‘VERSION_PARAM‘: ‘version‘          # URL中获取值的key
}

settings.py

from django.conf.urls import url, include
from web.views import TestView

urlpatterns = [
    url(r‘^test/‘, TestView.as_view(), name=‘test‘),
]

urls.py

#!/usr/bin/env python
# -*- coding:utf-8 -*-
from rest_framework.views import APIView
from rest_framework.response import Response
from rest_framework.versioning import AcceptHeaderVersioning

class TestView(APIView):
    versioning_class = AcceptHeaderVersioning

    def get(self, request, *args, **kwargs):
        # 获取版本 HTTP_ACCEPT头
        print(request.version)
        # 获取版本管理的类
        print(request.versioning_scheme)
        # 反向生成URL
        reverse_url = request.versioning_scheme.reverse(‘test‘, request=request)
        print(reverse_url)

        return Response(‘GET请求,响应内容‘)

    def post(self, request, *args, **kwargs):
        return Response(‘POST请求,响应内容‘)

    def put(self, request, *args, **kwargs):
        return Response(‘PUT请求,响应内容‘)

views.py

d. 基于主机名方法

如:v1.example.com

ALLOWED_HOSTS = [‘*‘]
REST_FRAMEWORK = {
    ‘DEFAULT_VERSION‘: ‘v1‘,  # 默认版本
    ‘ALLOWED_VERSIONS‘: [‘v1‘, ‘v2‘],  # 允许的版本
    ‘VERSION_PARAM‘: ‘version‘  # URL中获取值的key
}

settings.py

from django.conf.urls import url, include
from web.views import TestView

urlpatterns = [
    url(r‘^test/‘, TestView.as_view(), name=‘test‘),
]

urls.py

#!/usr/bin/env python
# -*- coding:utf-8 -*-
from rest_framework.views import APIView
from rest_framework.response import Response
from rest_framework.versioning import HostNameVersioning

class TestView(APIView):
    versioning_class = HostNameVersioning

    def get(self, request, *args, **kwargs):
        # 获取版本
        print(request.version)
        # 获取版本管理的类
        print(request.versioning_scheme)
        # 反向生成URL
        reverse_url = request.versioning_scheme.reverse(‘test‘, request=request)
        print(reverse_url)

        return Response(‘GET请求,响应内容‘)

    def post(self, request, *args, **kwargs):
        return Response(‘POST请求,响应内容‘)

    def put(self, request, *args, **kwargs):
        return Response(‘PUT请求,响应内容‘)

views.py

e. 基于django路由系统的namespace

如:example.com/v1/users/

REST_FRAMEWORK = {
    ‘DEFAULT_VERSION‘: ‘v1‘,  # 默认版本
    ‘ALLOWED_VERSIONS‘: [‘v1‘, ‘v2‘],  # 允许的版本
    ‘VERSION_PARAM‘: ‘version‘  # URL中获取值的key
}

settings.py

from django.conf.urls import url, include
from web.views import TestView

urlpatterns = [
    url(r‘^v1/‘, ([
                      url(r‘test/‘, TestView.as_view(), name=‘test‘),
                  ], None, ‘v1‘)),
    url(r‘^v2/‘, ([
                      url(r‘test/‘, TestView.as_view(), name=‘test‘),
                  ], None, ‘v2‘)),

]

urls.py

#!/usr/bin/env python
# -*- coding:utf-8 -*-
from rest_framework.views import APIView
from rest_framework.response import Response
from rest_framework.versioning import NamespaceVersioning

class TestView(APIView):
    versioning_class = NamespaceVersioning

    def get(self, request, *args, **kwargs):
        # 获取版本
        print(request.version)
        # 获取版本管理的类
        print(request.versioning_scheme)
        # 反向生成URL
        reverse_url = request.versioning_scheme.reverse(‘test‘, request=request)
        print(reverse_url)

        return Response(‘GET请求,响应内容‘)

    def post(self, request, *args, **kwargs):
        return Response(‘POST请求,响应内容‘)

    def put(self, request, *args, **kwargs):
        return Response(‘PUT请求,响应内容‘)

views.py

f. 全局使用

REST_FRAMEWORK = {
    ‘DEFAULT_VERSIONING_CLASS‘:"rest_framework.versioning.URLPathVersioning",
    ‘DEFAULT_VERSION‘: ‘v1‘,
    ‘ALLOWED_VERSIONS‘: [‘v1‘, ‘v2‘],
    ‘VERSION_PARAM‘: ‘version‘
}

settings.py

DRF的认证

上面讲版本的时候我们知道~在dispatch方法里~执行了initial方法~~那里初始化了我们的版本~~

如果我们细心我们能看到~版本的下面其实就是我们的认证,权限,频率组件了~~

我们先看看我们的认证组件~~

我们进去我们的认证看下~~

我们这个权限组件返回的是request.user,那我们这里的request是新的还是旧的呢~~

我们的initial是在我们request重新赋值之后的~所以这里的request是新的~也就是Request类实例对象~~

那这个user一定是一个静态方法~我们进去看看~~

很明显,有传参

我们通过上面基本可以知道我们的认证类一定要实现的方法~~以及返回值类型~~以及配置的参数authentication_classes~

DRF的权限

权限是什么

大家之前都应该听过权限~那么我们权限到底是做什么用的呢~~

大家都有博客~或者去一些论坛~一定知道管理员这个角色~

比如我们申请博客的时候~一定要向管理员申请~也就是说管理员会有一些特殊的权利~是我们没有的~~

这些对某件事情决策的范围和程度~我们叫做权限~~权限是我们在项目开发中非常常用到的~~

那我们看DRF框架给我们提供的权限组件都有哪些方法~~

权限组件源码

我们之前说过了DRF的版本和认证~也知道了权限和频率跟版本认证都是在initial方法里初始化的~~

其实我们版本,认证,权限,频率控制走的源码流程大致相同~~大家也可以在源码里看到~~

我们的权限类一定要有has_permission方法~否则就会抛出异常~~这也是框架给我提供的钩子~~

我们先看到在rest_framework.permissions这个文件中~存放了框架给我们提供的所有权限的方法~~

我这里就不带着大家详细去看每一个了~大家可以去浏览一下每个权限类~看看每个都是干嘛的~~

这里主要说下BasePermission 这个是我们写权限类继承的一个基础权限类~~~

认证权限的详细用法

用户url传入的token认证

from django.db import models

# Create your models here.

class User(models.Model):
    name = models.CharField(max_length=32)
    pwd = models.CharField(max_length=32)
    token = models.UUIDField(null=True, blank=True)#随机字符串
    CHOICES = ((1, "vip"), (2, "普通用户"), (3, "vvip"))
    type = models.IntegerField(choices=CHOICES, default=2)

DRFDemo/AuthDemo/models.py

执行:makemigrations AuthDemo
migrate AuthDemo

from django.conf.urls import url, include
from django.contrib import admin

urlpatterns = [
    url(r‘^admin/‘, admin.site.urls),
    url(r‘^book/‘, include("SerDemo.urls")),
    url(r‘^api/user/‘, include("AuthDemo.urls")),
    url(r‘^api/(?P<version>[v1|v2]+)/‘, include("VersionDemo.urls")),
]        

DRFDemo/DRFDemo/urls.py

from django.conf.urls import url, include
from django.contrib import admin
from .views import RegisterView, LoginView, TestView, PermissionView

urlpatterns = [
    url(r‘^register‘, RegisterView.as_view()),
    url(r‘^login‘, LoginView.as_view()),
    url(r‘^test‘, TestView.as_view()),
    url(r‘^permission‘, PermissionView.as_view()),

]        

DRFDemo/AuthDemo/urls.py

from django.shortcuts import render
from rest_framework.views import APIView
from rest_framework.response import Response
from .models import User
import uuid
from utils.auth import MyAuth
from utils.permission import MyPermission

# Create your views here.

class RegisterView(APIView):
    def post(self, request):
        name = request.data.get("name", "")
        pwd = request.data.get("pwd", "")
        if name and pwd:
            User.objects.create(name=name, pwd=pwd)
            return Response("注册成功")
        return Response("用户名或密码不合法")        

class LoginView(APIView):
    def post(self, request):
        name = request.data.get("name", "")
        pwd = request.data.get("pwd", "")
        user_obj = User.objects.filter(name=name, pwd=pwd).first()
        if user_obj:
            # 登录成功 创建一个token并给前端返回
            token = uuid.uuid4()
            user_obj.token = token
            user_obj.save()
            return Response(token)
        return Response("用户名或密码错误")        

class TestView(APIView):
    authentication_classes = [MyAuth, ]

    def get(self, request):
        print(request.user)
        print(request.user.name)
        print(request.auth)
        return Response("登录后发送的数据")

class PermissionView(APIView):
    authentication_classes = [MyAuth, ]
    permission_classes = [MyPermission, ]

    def get(self, request):
        # 这个接口只能vip或者vvip访问
        return Response("权限测试接口")        

DRFDemo/AuthDemo/views.py

REST_FRAMEWORK = {
    # "DEFAULT_VERSIONING_CLASS": "utils.version.MyVersion",
    "DEFAULT_VERSIONING_CLASS": "rest_framework.versioning.URLPathVersioning",
    ‘DEFAULT_VERSION‘: "v1",
    ‘ALLOWED_VERSIONS‘: ["v1", "v2"],
    ‘VERSION_PARAM‘: ‘version‘,
    # 配置认证类
    # "DEFAULT_AUTHENTICATION_CLASSES": ["utils.auth.MyAuth", ]
}

DRFDemo/DRFDemo/settings.py

from rest_framework import permissions

class MyPermission(permissions.BasePermission):
    message = "请充VIP,999一年"

    def has_permission(self, request, view):
        # 判断用户是否有权限
        if request.user.type in [1, 3]:
            return True
        return False
        

DRFDemo/utils/permission.py

原文地址:https://www.cnblogs.com/yuncong/p/10122857.html

时间: 2024-11-02 17:21:25

DRF的版本、认证、权限的相关文章

版本,认证,权限

版本 DRF中版本 导入 from rest_framework.versioning import 全局配置版本控制系统 /v1/books/    是在 URL加查询参数 # DRF的配置 REST_FRAMEWORK = { # 配置默认使用的版本控制类 'DEFAULT_VERSIONING_CLASS': 'rest_framework.versioning.URLPathVersioning', 'DEFAULT_VERSION': 'v1', # 默认的版本 'ALLOWED_VE

DRF 版本 认证

DRF的版本 版本控制是做什么用的, 我们为什么要用 首先我们要知道我们的版本是干嘛用的呢~~大家都知道我们开发项目是有多个版本的~~ 当我们项目越来越更新~版本就越来越多~~我们不可能新的版本出了~以前旧的版本就不进行维护了~~~ 那我们就需要对版本进行控制~~这个DRF也给我们提供了一些封装好的版本控制方法~~ 版本控制怎么用 之前我们学视图的时候知道APIView,也知道APIView返回View中的view函数,然后调用的dispatch方法~ 那我们现在看下dispatch方法~~看下

SAP云解决方案和企业本地部署(On-Premise)混合架构下的安全认证权限管理

SAP提供了用户认证.权限管理和单点登录等安全相关的解决方案.但是随着云平台的兴起,企业已经部署的安全解决方案如何与云平台的安全解决方案集成呢?这是摆在我们面前的一个问题,而且是一个至关重要.需要认真思考的问题. 本文将探讨SAP提供的本地部署和云平台的安全解决方案产品集:SAP Single Sign-On, SAP Cloud Platform Identity Authentication, SAP Identity Management, 和SAP Cloud Platform Iden

自定义路由组件,Django的admin后台管理,DRF的三大认证,jwt认证

目录 一.自定义路由组件 1. 为什么要自定义路由组件 2. 自定义路由组件实例 二.Django的admin后台管理 三.DRF的三大认证组件概括 1. 认证组件 2. 权限组件 3. 频率组件 四.Django中的用户权限管理 五.jwt认证 1. jwt认证和普通session认证的区别 2. jwt认证介绍 (1)jwt的原理 (2)jwt三部分的内容 3. jwt的签发算法 (1)第一步:头部算法 (2)第二步:载荷部分的算法 (3)第三步:签名部分的算法 (4)第四步:连接生成tok

drf之三大认证

一.前言 ? 我们知道drf的APIView类的as_view直接对原生django的csrf进行了禁用,是什么让drf有如此底气?从之前对drf的源码分析可以看到,三条语句. self.perform_authentication(request) self.check_permissions(request) self.check_throttles(request) 这就是drf的三大认证. 二.用户认证 1.drf的用户认证 ? 我们的某些接口需要对用户进行辨别,那么我们该如何区分A用户

C#.NET 大型通用信息化系统集成快速开发平台 4.1 版本 - 数据权限增强、范围权限增强

并不是不想做B\S的管理工具,只是精力实在不够,由于用户权限管理组件是基础组件.所以C\S的也无妨,不会有几个人在乎Oracle,SQLServer是否不b\s的,注重的是功能性能,请大家不要纠结与是否B\S还是C\S上. 实现的方法.设计的界面.数据库结构的设计.底层DLL方法的函数调用,都可以参考,毕竟自己全部实现一个,耗费太多精力,不如拿过来用用参考,按自己的需要修改几下就可以用了,省心省事省力,腰不疼腿不酸,没必要浪费生命. 由于公司的组织机构庞大.网点非常多,所以数据权限的设置也非常复

【原】无脑操作:IDEA + maven + Shiro + SpringBoot + JPA + Thymeleaf实现基础认证权限

开发环境搭建参见<[原]无脑操作:IDEA + maven + SpringBoot + JPA + Thymeleaf实现CRUD及分页> 需求: ① 除了登录页面,在地址栏直接访问其他URL,均跳转至登录页面 ② 登录涉及帐号和密码,帐号错误提示帐号错误,密码错误提示密码错误 ③ 登录成功跳转至首页,首页显示登录者帐号信息,并有注销帐号功能,点击注销退出系统 ------------------------------------------------------------------

drf框架 8 系统权限类使用 用户中心信息自查 token刷新机制 认证组件项目使用:多方式登录 权限组件项目使用:vip用户权限 频率组件 异常组件项目使用

系统权限类使用 图书接口:游客只读,用户可增删改查权限使用 from rest_framework.permissions import IsAuthenticatedOrReadOnly class BookViewSet(ModelViewSet): # 游客只读,用户可增删改查 permission_classes = [IsAuthenticatedOrReadOnly] queryset = models.Book.objects.all() serializer_class = se

基于asp.net MVC 的服务器和客户端的交互(二)之获取Oauth 2.0认证权限

基本Web API的ASP.NET的Oauth2认证 增加Token额外字段 增加Scope授权字段 持久化Token 设计Token的时间间隔 刷新Token后失效老的Token 自定义验证[重启IIS池Token失效,验证权限] Oauth2 认证的流程 客户端发送口令(grant_type,client_id,client_secret)到服务端请求,认证返回access token ,然后客户端跟据获得的access token,根据Access Token获得权限去访问Web API.