十大组件

十大组件包括:认证 权限(授权) 用户访问的次数/斌率的限制 版本 解析器 序列化 分页 路由系统 视图 渲染器

models.py

from django.db import models
#用户组的分类
class UserGroup(models.Model):

    titile = models.CharField(max_length=64, verbose_name="用户组名称")
#用户角色的分类
class Role(models.Model):

    titile = models.CharField(max_length=64, verbose_name="角色")


#用户类
class UserInfo(models.Model):
    """"用户表 1.普通  2.vip   3.svip"""
    user_type_choices = (
        (1, "普通用户"),
        (2, "vip"),
        (3, "svip")
    )
    user_type = models.IntegerField(choices=user_type_choices,help_text="用户类型")
    username = models.CharField(max_length=64,unique=True)
    password = models.IntegerField(max_length=256)
    group = models.ForeignKey(UserGroup, verbose_name="用户组")
    role = models.ManyToManyField(Role, verbose_name="角色")

#token的类
class UserToken(models.Model):
    token = models.CharField(max_length=256)
    user = models.OneToOneField(UserInfo)

认证:

from rest_framework.authentication import BaseAuthentication
from rest_framework.exceptions import AuthenticationFailed
from myapp.models import UserToken, UserInfo
# 自定义的认证类
class MyAuthication(BaseAuthentication):
    # authenticate 必须是这个名字
    def authenticate(self, request):
        # 取用户的前端token
        # request加强以后的       _requestn 原生request
        token = request._request.GET.get("token")
        # 聪明和数据中查找
        token_obj = UserToken.objects.filter(token=token).first()
        if not token:  #不存在
            raise AuthenticationFailed("对不起,用户认证失败")
        #    token_obj.user  用户模型列   token_obj
        return token_obj.user, token_obj

权限

from rest_framework.permissions import BasePermission
class MyPermission(BasePermission):
    message = "无权限"
    def has_permission(self, request, view):
#判断用户的类型
        if request.user.user_type != 3:
            return False  # 不继续往下执行
            # return JsonResponse({"error": "没有权限访问"})
        return True
class VipPermission(BasePermission):
    message = "必须具有vip"
    def has_permission(self, request, view):
        if request.user.user_type != 2:
            return False
        return True

限流

"""限流  =====>登录"""
# 自定义一个限流的组件
from rest_framework.throttling import BaseThrottle, SimpleRateThrottle
import time

class MyVistThottle2(SimpleRateThrottle):
    """匿名用户"""
    scope = "login"   #标识
    def get_cache_key(self, request, view):
        return request.META.get("REMOTE_ADDR")


class MyVistThottle3(SimpleRateThrottle):
    """认证只有的用户"""
    scope = "auth"
    def get_cache_key(self, request, view):
        #
        return request.user.username

# 用来装数据的字典
VISIT_RECODE ={}
class MyVistThottle(object):
# ""针对匿名用户的组件"""
    def allow_request(self, request, view):
        # 限流的逻辑
        # 1.获取IP地址
        remote_addr = request.META.get("REMOTE_ADDR")
        # 2.获取当前时间
        ctime = time.time()
        # 判断ip地址 在不在   访问记录里面
        if remote_addr not in VISIT_RECODE:
            # 第一访问   新添加一条记录
            VISIT_RECODE[remote_addr] = [ctime,]
            return True
        #  从历史记录里面吧remote_addr 提取出来[]
        self.history = VISIT_RECODE.get(remote_addr)
        # 判断 历史记录有没有 和   最新时间小于  时间-60
        while self.history and self.history[-1] < ctime - 60:
            self.history.pop()
        #     如果历史记录小于三次
        if len(self.history) < 3:
            self.history.insert(0, ctime)
        return False
    def wait(self):
        # 等待多少秒可以访问
        ctime = time.time()
        return 60 - (ctime - self.history[-1])

版本

from rest_framework.versioning import QueryParameterVersioning, URLPathVersioning
class MyURLPathVersioning(URLPathVersioning):
    default_version = 'v99'  #默认参数的名称
    allowed_versions = ['v1', "v2"]#可以访问的版本
    version_param = 'v' #版本的参数
class UserView(APIView):
    authentication_classes = []
    permission_classes = []
    throttle_classes = []
    versioning_class = MyURLPathVersioning
#请求方式  # 127.0.0.1.8000/api/v1/users/
    def get(self,request,*args, **kwargs):

        from django.urls import reverse
        u1 = request.versioning_scheme.reverse(viewname = "user", request= request)
        return JsonResponse({"version": request.version})

解释器

"""解释器"""
from django.shortcuts import HttpResponse
from rest_framework.views import APIView
import json
from django.core.handlers.wsgi import WSGIRequest
from rest_framework.parsers import JSONParser, FormParser,MultiPartParser
class DjangoView(APIView):

    # JSONParser  FormParser   MultiPartParser解释器
    parser_classes = [JSONParser, FormParser,  MultiPartParser]
    def post(self, request, *args, **kwargs):
        print(type(request._request))
        """
        为什么 request.POST.get 里面取大不到    json传过来的数据
        因为前端 传过来的时候json格式 但我们 调用 request._request.POST
        1.self._load_post_and_files()
        2. if self.content_type == 'multipart/form-data':
         elif self.content_type == 'application/x-www-form-urlencoded':
        
        
        解析器 :就是把客服端传过来的数据类型  转化成服务端  需要认识的数据类型 组件
        django     'application/x-www-form-urlencoded':
        drf 强大  所有类型
        """



        return JsonResponse({'b': request.data.get("username")})

序列化

序列化 两大功能:请求数据的验证 对queryset的序列化
序列化 两种继承方式 Serializers ModelSerializer
三种情况下 的自定义显示方式=======>1. choice情况 ====> source=get_字段名_display
2. 一对多外键 source = 模型名.字段名
3.多对多 自定义放发
改进:深度控制 depth = 1 # 1表示往下取1层数据 官方数据最多取3~5层 choice不能用深度控制

校验 前端 request.data 反序列化(校验的一个环节)'
is_vaiald() #校验
errors 去获取失败信息 失败信息我们可以自定义

from rest_framework import serializers
#序列
# 封装越高层越不灵活
class UserInfoSeriaializer(serializers.ModelSerializer):
    user_type = serializers.CharField(source='get_user_type_display')  # 获取这个字段对应的具体choice的值
    class Meta:
        model = UserInfo
        fields = "__all__"
#         深度控制
        depth = 1   # 1表示往下取1层数据    官方数据最多取3~5层

class UserInfoView(APIView):
    def get(self,request, *args, **kwargs):
        user = UserInfo.objects.all()
        ser = UserInfoSeriaializer(user,many=True)
        return HttpResponse(json.dumps(ser.data))
"""数据校验"""
class UserGroupSerializers(serializers.Serializer):
    title = serializers.CharField(error_messages={"required": "title这个字段必须提交", "blank":"该字段不能为空"})

class UserGroupView(APIView):
    def post(self,request,*args, **kwargs):
        print(request.data)
        ser = UserGroupSerializers(data=request.data)
        if ser.is_valid():
            print("成功,数据为{}".format(ser.validated_data))
        else:
            print(ser.errors)
        return HttpResponse("数据接收成功")

url.py

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


urlpatterns = [
    url(r'^users/$',views.UserView.as_view()),
    url(r'^myclass/', views.MyClassView.as_view()),
    url(r'^api/v1/auth/$', views.AuthView.as_view()),
    #     api 当前api接口    v1版本    auth 认证
    url(r'^api/v1/order/$', views.OrderView.as_view()),
    url(r'(?P<v>[v1|v2]+)/users/$', views.UserView.as_view(), name="user"),
    url(r'(?P<v>[v1|v2]+)/dj/$', views.DjangoView.as_view(),name="dj"),
    url(r'(?P<v>[v1|v2]+)/role/$', views.RolesView.as_view(),name="role"),
    url(r'(?P<v>[v1|v2]+)/userinfo/$', views.UserInfoView.as_view()),
    url(r'(?P<v>[v1|v2]+)/usergroup/$', views.UserGroupView.as_view()),

]

分页

分页的分类
1.页码 + 每页显示长度
2.偏移量 + 偏移长度
3.加密分页 （上一页 ，下一页）

from rest_framework import serializers
from rest_framework.pagination import PageNumberPagination,LimitOffsetPagination,CursorPagination
class PagerSerializer(serializers.ModelSerializer):
    class Meta:
        model = Role  # 角色信息
        fields = "__all__"

"""第一种"""
class MyPageNumberPagination(PageNumberPagination):
    page_size = 1   # 每页的长度
    page_query_param = 'page'     # 默认每页显示一条，我们可以通过page1/？page=2&size4 改变显示的个数
    page_size_query_param = "size"   # 控制每页的长度
    max_page_size = 3   # 最大长度

"""第二种"""
class MyLimitOffsetPagination(LimitOffsetPagination):
    default_limit = 1  #默认显示个数
    limit_query_param = 'limit'   #显示偏移量的长度  参数名称
    offset_query_param = 'offset'  # 偏移量  参数名称
    max_limit = 3  # 最大长度偏移量

"""第三种方式"""
class MyCursorPagination(CursorPagination):
    cursor_query_param = 'cursor'  #加密所使用的参数
    page_size = 2
    ordering = 'id'  #排序
    page_size_query_param = None
    max_page_size = None

class Pang1View(APIView):
    def get(self,request,*args,**kwargs):
        #     # 角色信息  显示出来
        roles = Role.objects.all()
        #     # 创建分页对象、
        pg = MyCursorPagination()
        #     #获取分页对象数据
        page_roles = pg.paginate_queryset(queryset=roles, request=request, view=self)
        # 对分页以后的数据进行训练化
        ser = PagerSerializer(page_roles, many=True)
        return pg.get_paginated_response(ser.data)   #默认显示上一页下一页

视图

from rest_framework.viewsets import ModelViewSet
class MyView(ModelViewSet):

    renderer_classes = [JSONRenderer]   #渲染器  可以不写因为源码已经写了
    queryset = Role.objects.all()  #数据源
    serializer_class = PagerSerializer  #  序列化的类
    pagination_class = MyPageNumberPagination  # 使用所有分组的租件

路由

在url.py

from rest_framework.routers import DefaultRouter
# 路由组件
router = DefaultRouter()
router.register(r'myview', views.MyView)


urlpatterns = [
    url(r'^(?P<version>[v1|v2]+)/', include(router.urls)),
]