Restful 4 -- 认证组件、权限组件、频率组件、url注册器、响应器、分页器

时间  2019-12-06
标签 restful 认证 组件 权限 频率 url 注册 响应 分页 栏目 HTTP/TCP 繁體版
原文   原文链接

1、认证组件、权限组件、频率组件总结： 

　　只有认证经过的用户才能访问指定的url地址，好比：查询课程信息，须要登陆以后才能查看，没有登陆，就不能查看，这时候须要用到认证组件python

一、认证组件格式

写一个认证类
        from rest_framework.authentication import BaseAuthentication
        class MyAuth(BaseAuthentication):
            def authenticate(self,request):
        #         request  是封装后的
                token = request.query_params.get('token')
                ret = models.UserToken.objects.filter(token=token).first()
                if ret:
        #             认证经过
                    return
                else:
                    raise AuthenticationFailed('认证失败')
            #能够不写了
            def authenticate_header(self,ss):
                pass
局部使用
        authentication_classes=[MyAuth,MyAuth2]
全局使用
        查找顺序：自定义的APIView里找---》项目settings里找---》内置默认的
        REST_FRAMEWORK={
            'DEFAULT_AUTHENTICATION_CLASSES':['utils.common.MyAuth',]

        }
View Code

二、权限组件格式

写一个类
        class MyPermission():
            def has_permission(self,request,view):
                token=request.query_params.get('token')
                ret=models.UserToken.objects.filter(token=token).first()
                if ret.user.type==2:
                # 超级用户能够访问
                    return True
                else:
                    return False
局部使用：
        permission_classes=[MyPermission,]
全局使用：
            REST_FRAMEWORK={
            'DEFAULT_PERMISSION_CLASSES':['utils.common.MyPermission',]
        }
View Code

三、频率组建格式

写一个类：
        from rest_framework.throttling import SimpleRateThrottle
        class VisitThrottle(SimpleRateThrottle):
            scope = 'xxx'
            def get_cache_key(self, request, view):
                return self.get_ident(request)
在setting里配置：
            'DEFAULT_THROTTLE_RATES':{
                'xxx':'5/h',
            }
局部使用
        throttle_classes=[VisitThrottle,]
全局使用
        REST_FRAMEWORK={
            'DEFAULT_THROTTLE_CLASSES':['utils.common.MyPermission',]
        }
View Code

四、实例简介：

　　只有认证经过的用户才能访问指定的url地址，好比：查询课程信息，须要登陆以后，没有登陆，就不能查看，这时候须要认证组件数据库

　　结构目录：

　　1.mode层

class UserInfo(models.Model):
    name=models.CharField(max_length=32)
    pwd=models.CharField(max_length=32)
    ss=((1,'超级用户'),(2,'普通用户'),(3,'二逼用户'))
    type=models.IntegerField(choices=ss,null=True)

class UserToken(models.Model):
    user=models.OneToOneField(to='UserInfo')
    token=models.CharField(max_length=64)
View Code

　　2.views层

from django.shortcuts import render,HttpResponse

# Create your views here.

import json
from rest_framework.views import APIView
from app01 import models
from utils.common import *
from rest_framework.response import Response

#登陆类
class Login(APIView):
    def post(self,request,*args,**kwargs):

        #实例化响应状态函数（添加登陆成功后的状态信息）
        response=MyResponse()

        #判断用户名、密码是否正确
        name=request.data.get('name')
        pwd=request.data.get('pwd')
        user=models.UserInfo.objects.filter(name=name,pwd=pwd).first()

        #若是登陆成功生成一个随机字符串
        if user:
            #生成一个随机字符串
            token=get_token(name)
            #token表里面的信息，若是不存在，会建立，若是存在会更新token值（由于进行了随机时间加盐）,使用的是update_or_create
            ret=models.UserToken.objects.update_or_create(user=user,defaults={'token':token})
            # ret=models.UserInfo.objects.update_or_create(id=1,defaults={'token':token}) 不是只能写user或者能够写id

            response.status=100
            response.msg='登陆成功'
            response.token=token
            print(response.get_dic())
        else:
            response.msg="用户名密码错误"
            # response.data='ddd'  最后response.get_dic()，均可以把这些信息返回

        #里面须要传入个字典
        return Response(response.get_dic())


#查看课程类
class Course(APIView):
    #局部登陆认证
    authentication_classes = [MyAuth,]
    #局部权限认证
    permission_classes = [Mypermission,]
    #局部频率认证
    throttle_classes = [VisitThrottle,]
    def get(self,request):
        print(request.user)
        print(request.auth)
        return HttpResponse(json.dumps({'name':'python'}))
View Code

　　3.url与settings

#url
from django.conf.urls import url
from django.contrib import admin
from app01 import views
urlpatterns = [
    url(r'^admin/', admin.site.urls),
    url(r'^course/', views.Course.as_view()),
    url(r'^login/', views.Login.as_view()),
]


#settings
#全局使用认证
REST_FRAMEWORK={
    #登陆认证，全局的登陆认证刚开始不要加，若是添加后初始登陆也会要求认证，那时数据库尚未数据，会有问题（因此能够在认证类里面设置局部的认证并设置为空）
    # 'DEFAULT_AUTHENTICATION_CLASSES':['utils.common.MyAuth',],
    #频率
    'DEFAULT_THROTTLE_RATES':{
            # 'xxx':'5/m',
            'xxx':'5/hdddddddddddddddddddddddddddddd',
        }

} 


例如解决全局配置后login初始登陆会验证的问题：
class Login(APIView):
    #为了能够在全局里面统一设置，并不影响初始这里的登陆
    authentication_classes=[]

    def post(self,request,*args,**kwargs):
　　　　...
　　　　...
View Code

　　4.utils-common配置（组件类）

登陆状态信息django

#帐户登陆状态信息
class MyResponse():
    def __init__(self):
        #1001表示失败
        self.status = 1001
        self.msg = None

    def get_dic(self):
        #返回是字典格式的属性信息
        return self.__dict__

随机验证码：json

#传入用户名生成一个随机验证码token
def get_token(name):
    md = hashlib.md5()
    md.update(name.encode('utf-8'))
    md.update(str(time.time()).encode('utf-8'))
    return md.hexdigest()
View Code

认证组件类：浏览器

from rest_framework.authentication import BaseAuthentication
from app01 import models
from rest_framework.exceptions import APIException,AuthenticationFailed
#认证组件
class MyAuth(BaseAuthentication):
    def authenticate(self, request):
        #拿到的是随机token的值
        token = request.query_params.get('token')
        ret = models.UserToken.objects.filter(token=token).first()
        if ret:
            #认证经过
            return ret.user,ret
        else:
            #认证失败
            raise AuthenticationFailed('认证失败')
View Code

权限组件类：服务器

#权限组件
from rest_framework.permissions import BasePermission
class Mypermission(BasePermission):
    message = '不是超级用户，查看不了'

    def has_permission(self, request, view):
        token = request.query_params.get('token')
        ret = models.UserToken.objects.filter(token=token).first()

        #拿到userinfo表格对应的type字段，输出models里面userinfo表格里面type数字对应的“超级用户”等字符串信息
        print(ret.user.get_type_display())
        if ret.user.type==1:
            return True

        #若是是Flase的状况就会，打印上面的message信息
        else:
            return False
View Code

频率组件类：app

#频率组件
from rest_framework.throttling import SimpleRateThrottle
class VisitThrottle(SimpleRateThrottle):
    scope = 'xxx'
    def get_cache_key(self, request, view):
        return self.get_ident(request)
View Code

运行效果展现：ide

准备工做：函数

1.userinfo数据表先添加2条数据，作演示post

状况1：未登陆状况下发送get请求，会提示认证失败（由于没有带token信息）

状况2：post请求登陆login，用户信息写入数据库，同时生成将出入的name+time盐，写入UserToken表token字段

 状况3：get请求携带token字符串，从而验证权限认证、频率认证

 

 

自定义频率类：

自定义逻辑

1
2
3
4
5
#（1）取出访问者ip
# （2）判断当前ip不在访问字典里，添加进去，而且直接返回True,表示第一次访问，在字典里，继续往下走
# （3）循环判断当前ip的列表，有值，而且当前时间减去列表的最后一个时间大于60s，把这种数据pop掉，这样列表中只有60s之内的访问时间，
# （4）判断，当列表小于3，说明一分钟之内访问不足三次，把当前时间插入到列表第一个位置，返回True，顺利经过
# （5）当大于等于3，说明一分钟内访问超过三次，返回False验证失败 
class MyThrottles():
    VISIT_RECORD = {}
    def __init__(self):
        self.history=None
    def allow_request(self,request, view):
        #（1）取出访问者ip
        # print(request.META)
        ip=request.META.get('REMOTE_ADDR')
        import time
        ctime=time.time()
        # （2）判断当前ip不在访问字典里，添加进去，而且直接返回True,表示第一次访问
        if ip not in self.VISIT_RECORD:
            self.VISIT_RECORD[ip]=[ctime,]
            return True
        self.history=self.VISIT_RECORD.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])
View Code

2、url注册器、响应器、分页器

一、url注册器

　　经过DRF的视图组件，数据接口逻辑被咱们优化到最后剩下一个类，接下来，咱们使用DRF的url控制器来帮助咱们自动生成url，使用步骤以下：

from django.urls import re_path, include

# 1.导入模块
from rest_framework import routers

from serializer import views
# 2.实例化一个router对象
router = routers.DefaultRouter()

# 3.将须要自动生成url的接口注册到router中
router.register('books', views.BookView)

# 4.生成url
urlpatterns = [
    re_path('^', include(router.urls))
]

二、响应器

　　以前咱们使用DRF的Response类来将数据响应给客户端，不论是POSTMAN仍是浏览器，都能浏览到通过格式化后的漂亮的数据，DRF是怎么作的呢？其实就是经过响应器组件。

　　若是咱们不须要使用DRF提供给浏览器的格式化后的数据，只须要禁止该响应方式便可：

from rest_framework.renderers import JSONRenderer

class BookView(ModelViewSet):
    
    renderer_classes = [JSONRenderer]
    
    queryset = Book.objects.all()
    serializer_class = BookSerializer

　　这样，浏览器再次访问，接收到的就是普通的json格式数据，而不是通过DRF格式化后的数据，renderer_classes的查找逻辑与以前的解析器等组件是彻底同样的。

三、分页器

　　为了服务器性能考虑，也为了用户体验，咱们不该该一次将全部的数据从数据库中查询出来，返回给客户端浏览器，若是数据量很是大，这对于服务器来说，能够说是性能灾难，而对于用户来说，加载速度将会很是慢。

　　因此，咱们须要控制每次返回给客户端多少数据，这就须要用到分页器。

一、接下来，介绍一下DRF的局部实现分页器组件

# 1.导入模块
from rest_framework.pagination import PageNumberPagination

# 自定义分页器类，继承PageNumberPagination
class MyPagination(PageNumberPagination):
    page_size = 3
    page_query_param = 'p'
    page_size_query_param = 'size'
    max_page_size = 5


class BookView(APIView):

    def get(self, request):
        # 2.获取数据
        queryset = Book.objects.all()
        # 3.建立分页器对象
        paginater = MyPagination()
        # 4.开始分页
        paged_books = paginater.paginate_queryset(queryset, request)
        # 5.将分页后的数据进行序列化
        serializer_books = BookSerializer(paged_books, many=True)
        # 6.返回数据
        return Response(serializer_books.data)
View Code

二、参数介绍

page_size：用来控制每页显示多少条数据（全局参数名为PAGE_SIZE）；
page_query_param：用来提供直接访问某页的数据；
page_size_query_param：临时调整当前显示多少条数据；
max_page_size：控制page_size_query_param参数能调整的最大条数；

三、在ModelViewSet中使用分页器

from rest_framework.viewsets import ModelViewSet
from rest_framework.pagination import PageNumberPagination

# 自定义分页器类
class MyPagination(PageNumberPagination):
    page_size = 3
    page_query_param = 'p'
    page_size_query_param = 'size'
    max_page_size = 5


class BookView(ModelViewSet):
    
    pagination_class = MyPagination      # 指定分页器类

    queryset = Book.objects.all()
    serializer_class = BookSerializer
View Code

四、分页器全局配置

REST_FRAMEWORK = {
    'DEFAULT_PAGINATION_CLASS': 'rest_framework.pagination.PageNumberPagination',
    'PAGE_SIZE': 10  # 每页数目
}
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程