基于Django实现 RESTful API 之RestFramework框架3

简介: 接下来学习RestFramework框架中的认证、权限、频率组件的使用一、首先实现用户login登录认证功能做用户登录认证功能可以通过session、cookie和token三种形式,下面的login认证基于token实现关键点-- 首先需要...

接下来学习RestFramework框架中的认证、权限、频率组件的使用

一、首先实现用户login登录认证功能

做用户登录认证功能可以通过session、cookie和token三种形式,下面的login认证基于token实现

  • 关键点
    -- 首先需要设计用户表、用户token表,用户表需要包含用户类型,用户token表包含用户的token值
    -- 用户的token值应该是一个随机的、动态的字符串
    -- 用户认证成功需要将用户信息和对应的token值返回,后续访问url就可以通过token值来判断用户的状态

附:models.py

from django.db import models

class Userinfo(models.Model):
    name = models.CharField(max_length=32)
    pwd = models.CharField(max_length=64)
    user_type = models.IntegerField(choices=((1,"common_user"),(2,"VIP_user"),(3,"SVIP_user")))

class UserToken(models.Model):
    user = models.OneToOneField(to="Userinfo")
    token = models.CharField(max_length=128)
  • view.py认证逻辑
from rest_framework.views import APIView
from rest_framework.response import Response
import uuid


class LoginView(APIView):
    """
    1000:成功
    1001:用户名或者密码错误
    1002:异常错误
    """
    def post(self, request):
        #自定义的返回体数据
        ret = {"code": 1000, "msg": None, "user": None}
        try:
            print(request.data)  # 重装后的request,request.data从中取所需的数据
            name = request.data.get("name")#获取前端用户名
            pwd = request.data.get("pwd")#获取前端密码
            #数据库校验用户名密码是否正确
            user_obj = models.Userinfo.objects.filter(name=name, pwd=pwd).first()
            if user_obj:
                #通过uuid模块获得随机字符串作为token值
                random_str = uuid.uuid4()
                #UserToken表中有该用户的信息就用新token值覆盖,没有就创建数据
                models.UserToken.objects.update_or_create(user=user_obj, defaults={"token": random_str})
                ret["user"] = user_obj.name
                ret["token"] = random_str
            else:
                ret["code"] = 1001
                ret["msg"] = "用户名或者密码错误"

        except Exception as e:
            ret["code"] = 1002
            ret["msg"] = str(e)

        return Response(ret)
这样就实现了用户的login认证。。。。。。。。。

二、基于RestFramework的认证组件做视图处理类的user认证

首先看一下UserAuth的具体用法:

  • 关键点:
    --视图处理类下定义名为authentication_classes属性,属性值是一个列表或者元组
    --写一个UserAuth(类名随便)认证的类,将类名添加到authentication_classes列表中
    --UserAuth认证类必须有一个authenticate(self,request)方法,这个方法下写用户认证逻辑,认证成功:可以返回数据,也可以什么都不做。认证失败:,必须抛异常
    -- UserAuth类继承BaseAuthentication类,其实就是给类加了一个authenticate_header方法,没理由,源码要求!

这四点你一定看不懂是什么意思,很正常,这都是RestFramework源码给设定的特定规则,稍后认证源码流程分析会一一分析解答

view.py代码示例:代码实现了book视图类的用户认证功能

from rest_framework.exceptions import AuthenticationFailed
from rest_framework.authentication import BaseAuthentication

#用于认证的类
class UserAuth(BaseAuthentication):
   def authenticate(self, request):
       token = request.query_params.get("token")
       usertoken_obj = models.UserToken.objects.filter(token=token).first()
       if usertoken_obj:
           return usertoken_obj.user, usertoken_obj.token
       else:
           raise AuthenticationFailed("用户认证失败,您无权访问!!!")

# book视图处理类
class Booklist(ModelViewSet):
   authentication_classes = [UserAuth, ]

   queryset = models.Book.objects.all()
   serializer_class = BooklistSerializer

接下来一张图带你透析认证组件:

img_90de2f3503ff9d5572f7821e030885e7.jpe
UserAuth认证源码解析.jpg

- 这样的写法只是给book视图类加上了认证,可以将认证类单独卸载一个py文件中,然后在全局settings中添加对应的配置项,这样就可以做到对所有的视图类添加认证功能了!!!

根据实际需求选择合适的方法!!!

app001-utils-Userauth.py

from app001 import models
from rest_framework.exceptions import AuthenticationFailed
from rest_framework.authentication import BaseAuthentication

class UserAuth(BaseAuthentication):
    def authenticate(self, request):
        token = request.query_params.get("token")
        usertoken_obj = models.UserToken.objects.filter(token=token).first()
        if usertoken_obj:
            return usertoken_obj.user, usertoken_obj.token
        else:
            raise AuthenticationFailed("用户认证失败,您无权访问!!!")

settings.py

REST_FRAMEWORK = {
    'DEFAULT_AUTHENTICATION_CLASSES': (
        'app001.utils.Userauth.UserAuth',
    )
}

view.py

from app001 import models
from app001.serializers.bookserializer import BooklistSerializer

# 重装了APIView
from rest_framework.viewsets import ModelViewSet

# book视图处理类
class Booklist(ModelViewSet):
   queryset = models.Book.objects.all()
   serializer_class = BooklistSerializer

三、基于RestFramework的认证组件做视图处理类的权限认证

首先看一下UserAuth的具体用法:

  • 关键点:
    --视图处理类下定义名为permission_classes属性,属性值是一个列表或者元组
    --写一个UserAuth(类名随便)认证的类,将类名添加到permission_classes列表中
    --UserAuth认证类必须有一个has_permission(self,request,view)方法,这个方法下写用户认证逻辑,认证成功:返回true。认证失败:,返回false。

permission源码执行流程:

img_9bfa09c9420ac0babb6ec3d690469dac.jpe
permission源码解析_副本.jpg

  • app001-utils-permission_class.py
from rest_framework.permissions import BasePermission
class SVIPPermission(BasePermission):
    message="您没有访问权限!"
    def has_permission(self,request,view):
        if request.user.user_type >= 2:
            return True
        return False
  • view.py
from app001 import models
from app001.serializers.bookserializer import BooklistSerializer
# 重装了APIView
from rest_framework.viewsets import ModelViewSet

from app001.utils.permission_class import SVIPPermission

# book视图处理类
class Booklist(ModelViewSet):
    permission_classes = [SVIPPermission,]

    queryset = models.Book.objects.all()
    serializer_class = BooklistSerializer

四、基于RestFramework的认证组件做视图处理类的访问频率限制

1、访问频率限制和认证、权限的执行流程一样,都是restframework源码提供的一种书写格式,再此就不一一赘述。

  • app001-utils-throttle_classes.py
import time
from rest_framework.throttling import BaseThrottle

VISIT_RECORD = {}

class VisitThrottle(BaseThrottle):

    def __init__(self):
        self.history = None

    def allow_request(self, request, view):
        # 1. 拿到用户请求的IP
        # print(request.META)
        ip = request.META.get("REMOTE_ADDR")
        # 2. 当前请求的时间
        now = time.time()
        # 3. 记录访问的历史
        if ip not in VISIT_RECORD:
            VISIT_RECORD[ip] = []

        history = VISIT_RECORD[ip]
        self.history = history
        # [11:07:20, 10:07:11, 10:07:06, 10:07:01]
        while history and now - history[-1] > 60:
            history.pop()
        # 判断用户在一分钟的时间间隔内是否访问超过3次
        if len(history) >= 3:
            return False
        history.insert(0, now)

        return True

    def wait(self):
        # 当前访问时间
        ctime = time.time()
        #  访问时间历史记录 self.history
        return 60 - (ctime - self.history[-1])
  • view.py
from app001 import models
from app001.serializers.bookserializer import BooklistSerializer
# 重装了APIView
from rest_framework.viewsets import ModelViewSet
from app001.utils.throttle_classes import VisitThrottle

# book视图处理类
class Booklist(ModelViewSet):
    throttle_classes = [VisitThrottle, ]

    queryset = models.Book.objects.all()
    serializer_class = BooklistSerializer

2、基于RestFramework给我们提供了几种频率控制组件,省去了我们在自己写了

  • SimpleRateThrottle类,A simple cache implementation, that only requires .get_cache_key()
    to be overridden.
  • AnonRateThrottle类,Limits the rate of API calls that may be made by a anonymous users.
  • UserRateThrottle类,Limits the rate of API calls that may be made by a given user.
  • ScopedRateThrottle类,Limits the rate of API calls by different amounts for various parts of
    the API.

app001-utils-throttle_classes.py

from rest_framework.throttling import SimpleRateThrottle

class VisitThrottle(SimpleRateThrottle):
    scope="visit_rate"

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

settings.py

REST_FRAMEWORK = {
    "DEFAULT_THROTTLE_CLASSES": ("app001.utils.throttle_classes.VisitThrottle",),
    "DEFAULT_THROTTLE_RATES": {
        "visit_rate": "10/m",//频率设置
    },
}

view.py

from app001 import models
from app001.serializers.bookserializer import BooklistSerializer
# 重装了APIView
from rest_framework.viewsets import ModelViewSet
from app001.utils.throttle_classes import VisitThrottle

# book视图处理类
class Booklist(ModelViewSet):
    throttle_classes = [VisitThrottle, ]

    queryset = models.Book.objects.all()
    serializer_class = BooklistSerializer

五、基于RestFramework的视图处理类的分页组件

Restframework提供了几种很好的分页方式:

  • 基于页码的分页的 PageNumberPagination类
  • 基于limit offset 做分页的 LimitOffsetPagination类
  • 基于游标的分页的 CursorPagination类。但这种方式存在性能问题,如果用户吧page给改的很大,查询速度就会很慢。还有一种页码加密的方式

1、PageNumberPagination类的使用

  • 方法一、视图类继承APIView时
    -- 参考的API:
    GET请求:http://127.0.0.1:8000/booklist/?page=2
from rest_framework.views import APIView
from app001 import models
# rest_framework重装的response
from rest_framework.response import Response
from app001.serializers.bookserializer import BooklistSerializer
from rest_framework.pagination import PageNumberPagination

class Booklist(APIView):

    def get(self, request):
        class MyPageNumberPagination(PageNumberPagination):
            page_ size = 2    //指定的每页显示数
            page_query_param = "page"      //url栏的页码参数
            page_size_query_param = "size"     //获取url参数中设置的每页显示数据条数
            max_page_size = 5       //最大支持的每页显示的数据条数

        book_obj = models.Book.objects.all()
        # 实例化
        pnp = MyPageNumberPagination()
        # 分页
        paged_book_list = pnp.paginate_queryset(book_obj, request)
        bs = BooklistSerializer(paged_book_list, many=True)
        data = bs.data  # 序列化接口
        return Response(data)
  • 方式二、视图类继承ModelViewSet时(少用)
from rest_framework.viewsets import ModelViewSet
from rest_framework.pagination import PageNumberPagination
class MyPageNumberPagination(PageNumberPagination):
    page_size = 3

# book视图处理
class Booklist(ModelViewSet):
    pagination_class = MyPageNumberPagination

    queryset = models.Book.objects.all()
    serializer_class = BooklistSerializer

2、LimitOffsetPagination类的使用

  • 这种分页样式反映了查找多个数据库记录时使用的语法。客户端包含 “limit” 和 “offset” 查询参数。limit 表示要返回的 数据 的最大数量,并且等同于其他样式中的 page_size。offset 指定查询的起始位置与完整的未分类 数据 集的关系。多用于返回的内容是静态的,或者不用实时返回数据最新的变化。Google Search 和一些论坛用了这种方式:
  • 参考API:
    GET请求:http://127.0.0.1:8000/booklist/?limit=3&offset=3
    Response响应:{ "count": 7,"next": "http://127.0.0.1:8000/booklist/?limit=3&offset=6", "previous": "http://127.0.0.1:8000/booklist/?limit=3","results": [...]
from app001 import models
from app001.serializers.bookserializer import BooklistSerializer
from rest_framework.views import APIView
from rest_framework.response import Response
from rest_framework.pagination import LimitOffsetPagination

class MyPageNumberPagination(LimitOffsetPagination):
    max_limit = 3  # 最大限制默认是None
    default_limit = 2  # 设置每一页显示多少条
    limit_query_param = 'limit'  # 往后取几条
    offset_query_param = 'offset'  # 当前所在的位置

class Booklist(APIView):

    def get(self, request):
        book_obj = models.Book.objects.all()
        # 实例化
        pnp = MyPageNumberPagination()
        # 分页
        paged_book_list = pnp.paginate_queryset(book_obj, request)
        bs = BooklistSerializer(paged_book_list, many=True)
        data = bs.data  # 序列化接口
        # return Response(data) #不含上一页下一页
        return pnp.get_paginated_response(data)
  • LimitOffsetPagination 类包含一些可以被覆盖以修改分页样式的属性。要设置这些属性,应该继承 LimitOffsetPagination 类,然后像上面那样启用你的自定义分页类。
    default_limit- 一个数字值,指定客户端在查询参数中未提供的 limit 。默认值与 PAGE_SIZE setting key 相同。
    limit_query_param - 一个字符串值,指示 “limit” 查询参数的名称。默认为 'limit'。
    offset_query_param - 一个字符串值,指示 “offset” 查询参数的名称。默认为 'offset'。
    max_limit - 一个数字值,表示客户端可以要求的最大允许 limit。默认为 None。
- 了解LIMIT / OFFSET的实际工作原理。为此,我们举例说明,假如有大约1000个符合要求的结果。你若要前100数据,这很容易,这意味着它只返回与结果集匹配的前100行。但是现在想要900-1000之间的数据。数据库现在必须遍历前900个结果才能开始返回(因为它没有指针告诉它如何获得结果900)。总之,LIMIT / OFFSET在大型结果集上非常慢。

3、CursorPagination类的使用

  • 现在很多场景,查询结果在用户浏览过程中是变化的,例如微博时间线,用户看的时候,可能后一页的某些微博会被删除,而前一页又增添了新的微博。这种情况就不适合用 limitoffset分页方式了。Facebook 和 Twitter 都采用了基于游标的分页方法。
  • 这种方式有以下两个特点:
    -- 1. 查询的结果流可能是动态变化的,例如: 时间线里出现了新的数据,或者删除了数据,这些变化都可以在 “前一页” 或者 “后一页” 上体现出来。
    -- 2. Cursor 体现了排序,是持久化的。一般情况下 Cursor 的顺序是和时间有关。如果你的实体(例如:微博)可能展现给用户多种可能的排序(例如:创建时间或者修改时间),那么则需要创建不同的 Cursor。
    具体实现时,Cursor 可能分别创建自 创建用户 或者 修改用户 字段。Facebook Relay 用了查询名称 + 时间戳 的 Base64 形式来做 Cursor。
  • CursorPagination 类包含一些可以被覆盖以修改分页样式的属性。
    要设置这些属性,你应该继承 CursorPagination 类,然后像上面那样启用你的自定义分页类。
    -- page_size = 指定页面大小的数字值。如果设置,则会覆盖 PAGE_SIZE 设置。默认值与 PAGE_SIZE setting key 相同。
    -- cursor_query_param = 一个字符串值,指定 “游标” 查询参数的名称。默认为 'cursor'.
    -- ordering = 这应该是一个字符串或字符串列表,指定将应用基于游标的分页的字段。例如: ordering = 'slug'。默认为 -created。该值也可以通过在视图上使用 OrderingFilter 来覆盖。
-关于限制偏移量和游标分页的分析 请参考:http://cra.mr/2011/03/08/building-cursors-for-the-disqus-api

六、基于RestFramework的视图处理类响应器

  • restframework可以根据url的不同来源做出不同的响应,比如说,当来自浏览器端的请求,会返回一个页面,当请求来自于postman等请求软件时,返回的是json数据,这样的效果是restframework的响应器在控制,settings中可以按需配置:
REST_FRAMEWORK={
    'DEFAULT_RENDERER_CLASSES': (
        'rest_framework.renderers.JSONRenderer',  //响应json
        'rest_framework.renderers.BrowsableAPIRenderer',   //响应页面
    ),
}

七、基于RestFramework的视图处理类的url注册器

url注册器只是适用于视图类继承ModelViewSet类的写法:
url注册器会生成四条url:
^ ^booklist/$ [name='book-list']
^ ^booklist\.(?P<format>[a-z0-9]+)/?$ [name='book-list'] //可以指定数据类型
^ ^booklist/(?P<pk>[^/.]+)/$ [name='book-detail']
^ ^booklist/(?P<pk>[^/.]+)\.(?P<format>[a-z0-9]+)/?$ [name='book-detail'] //可以指定单个数据数据类型
urls.py

from rest_framework import routers
router = routers.DefaultRouter() //实例化
router.register("booklist", views.Booklist)   //注册

urlpatterns = [
    url(r'^', include(router.urls)),
]

view.py

from app001 import models
from app001.serializers.bookserializer import BooklistSerializer
# 重装了APIView
from rest_framework.viewsets import ModelViewSet

# book视图处理类
class Booklist(ModelViewSet):

    queryset = models.Book.objects.all()
    serializer_class = BooklistSerializer
相关文章
|
8天前
|
JSON Java API
如何设计可扩展的RESTful API?
如何设计可扩展的RESTful API?
|
3天前
|
分布式计算 API 对象存储
Ray是一个开源的分布式计算框架,用于构建和扩展分布式应用。它提供了简单的API,使得开发者可以轻松地编写并行和分布式代码,而无需担心底层的复杂性。
Ray是一个开源的分布式计算框架,用于构建和扩展分布式应用。它提供了简单的API,使得开发者可以轻松地编写并行和分布式代码,而无需担心底层的复杂性。
25 11
|
1天前
|
消息中间件 API 数据库
在微服务架构中,每个服务通常都是一个独立运行、独立部署、独立扩展的组件,它们之间通过轻量级的通信机制(如HTTP/RESTful API、gRPC等)进行通信。
在微服务架构中,每个服务通常都是一个独立运行、独立部署、独立扩展的组件,它们之间通过轻量级的通信机制(如HTTP/RESTful API、gRPC等)进行通信。
11 2
|
2天前
|
安全 前端开发 API
深入理解RESTful API设计原则与实践
【7月更文挑战第14天】在数字化时代的浪潮中,后端开发扮演着至关重要的角色,而RESTful API作为现代Web服务通信的基石,其设计质量直接影响到应用的性能与可维护性。本文将通过剖析RESTful API的核心设计原则,结合实际案例,探讨如何构建高效、易于理解和扩展的API。我们将从资源定位、请求方法、状态码使用等方面入手,揭示良好API设计的秘诀,并分享一些最佳实践和常见陷阱,旨在指导开发者打造更加健壮和友好的后端服务接口。
|
8天前
|
开发框架 监控 JavaScript
使用Node.js 框架( Express.js)来创建一个简单的 API 端点
【7月更文挑战第5天】使用Node.js 框架( Express.js)来创建一个简单的 API 端点
11 3
|
4天前
|
XML 缓存 API
深入理解RESTful API设计原则与最佳实践
【7月更文挑战第12天】本文将探索RESTful API设计的核心原则和实用的最佳实践。我们将从REST的基本概念入手,逐步深入到API设计的高级话题,如版本控制、状态码的正确使用以及如何提高API的安全性。此外,我们还将探讨一些常见的设计挑战和解决方案,以帮助开发者构建更加健壮、可维护和用户友好的后端服务。
|
6天前
|
数据采集 存储 算法
ScrapySharp框架:小红书视频数据采集的API集成与应用
ScrapySharp框架:小红书视频数据采集的API集成与应用
|
8天前
|
Java API 数据库
使用Spring Boot构建RESTful API
使用Spring Boot构建RESTful API
|
API 持续交付 jenkins
Api自动化框架分享
前言 嗨咯!兄弟们!乡亲们!好久没有发帖了!今天把我最近的一点小小的收获分享给到大家,希望能给大家一点帮助和启发…当然最需要的还是大家的意见!  今天给大家分享的是最近开发的一个API自动化框架: 框架定位 1,数据驱动  2,简单流程覆盖,快速迭代  3,组合Case不需要Coding
2239 0
|
12天前
|
NoSQL 安全 API
如何有效提升 API 接口的安全性?
**API安全关键在于验证和防刷。通过排序参数、生成签名和MD5加密确保请求合法性。使用Redis限制请求频率,防止接口被恶意刷取。验证和防刷策略结合,保护API免受攻击和滥用。**
31 0