restframework节流

请求数据进行校验
    QuerySet不能用HttpResponse返回给前端
    QuerySet只能进行序列化处理后返回给前端

内容回顾

谈谈面向对象？
面向对象的三大特性！
    封装
        封装主要体现在类封装到对象中，把字段封装到对象个中！
    封装的特性在代码中哪里使用过？
    自定义分页的时候，把当前页的数据通过封装的方法
    start_config封装
    标准封装：
        django restframework 源码中体现的就是对request的封装
    标准继承：
        多继承， 经典类 和新式类

    将公共的功能放到基类中，让我们继承的时候可使用的方法多样化

    多态：
    鸭子模型： 只要听到鸭子呱呱叫，我就认为是鸭子，鹦鹉呱呱叫 我也认为是鸭子！

    多态体现
    class a:
        def send():
            pass
    class b:
        def send():
            pass
    class func(arg):
        arg.send()
    obj = a:
    func(obj)

Django的生命周期： 一个请求首先经过wsgi ref模块 它是python的内置模块 wsgi 跟django没有任何关系！ 只是django利用wsgi做了一个socket wsgi是干嘛的？ wsgi与django应用之间的约束规范的一种协议 wsgiref是干嘛的？ wsgiref是实现了wsgi协议的一个模块，模块本质：一个socket服务端 uwsgi在公司将项目部署的时候使用uwsgi

werkzug 实现了wsgi协议的一个模块，一个socket服务端
tornado 是实现wsfi协议到一个模块
web server 有两个参数 environ start_response响应参数
穿过所有的中间件后进行路由匹配
视图函数通过ORM拿取数据模板拿模板进行渲染 数据通过json返回给模板展现出来

视图里进行dispatch
完整的说法：
前端请求进来，通过 wsgi后，然后穿过所有的中间件进行路由匹配的时候先执行在函数里嵌套的as.view(),相当于执行了as.views里面的view内置函数！view函数里执行dispatch

为什么执行dispatch?
因为路由里的as_view帮我们做的
先执行请求的封装，认证 权限 节流 通过反射找到函数进行执行

中间件&装饰器 中间件用于统一做所有请求批量做操作方法要中间件来做

你用中间件做过什么？

认证(rbac)
权限(基于权限的用户控制)
csrf_token
    csrf_token原理
        第一次来的时候服务端给随机字符串，再来的时候把随机字符串带过来，服务端进行验证
session原理
    请求进来将相关的数据交给服务端，服务端拿到数据取数据库去查
session里有 process_request和process_response方法
session也是基于中间件设计的

中间件的使用场景

基于角色的权限控制

    用户认证

    csrf 说原理

    session 说原理

    黑名单

    日志记录

rest 框架原理

认证流程
    请求进来 -dispatch -封装request
    把所有的认证对象封装到了request 进入到perform_authentication 调用request.user
    在request.user里面又调用我我们自己写的authentication方法
认证类里面有几个方法
    一共两个方法
        authenticate
        authenticate_header
权限流程
    请求进来-走dispatch 封装request 直接去列表生成式执行权限的方法
权限有几种方法
    has_permission

节流流程
    匿名的时候根据IP/代理唯一标识进行节流进行节流
    通过类的获取表示get_ident的方法得到IP或者代理获取到
    使用用户使用用户名进行节流

restframework 版本

自定义版本
URL中通过GET传参
 views.py
 class ParamVersion(object):
    def determine_version(self,request,*args,**kwargs)：
        version = request.query_params.get('version')
        return version
class UserView(APIView):
    versioning_class = ParamVersion
    def get(self,request,*args,**kwargs):
    pass

使用restframework 版本写好的使用方法
在自己的settings里

在URL中传参（推荐使用）

urlpatterns = [
            # url(r'^admin/', admin.site.urls),
            url(r'^(?P<version>[v1|v2]+)/users/$', views.UsersView.as_view()),
        ]

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

        class UsersView(APIView):

            def get(self,request,*args,**kwargs):
                print(request.version)
                return HttpResponse('用户列表')

总结：

使用：
            配置文件：
                REST_FRAMEWORK = {
                    "DEFAULT_VERSIONING_CLASS":"rest_framework.versioning.URLPathVersioning",
                    "DEFAULT_VERSION":'v1',
                    "ALLOWED_VERSIONS":['v1','v2'],
                    "VERSION_PARAM":'version',
                }
            路由系统：

                urlpatterns = [
                    # url(r'^admin/', admin.site.urls),
                    url(r'^api/', include('api.urls')),
                ]

                urlpatterns = [
                    # url(r'^admin/', admin.site.urls),
                    url(r'^(?P<version>[v1|v2]+)/users/$', views.UsersView.as_view(),name='uuu'),
                ]

            视图：

                class UsersView(APIView):

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

                    # 1. 获取版本
                    print(request.version)

                    # 2. 获取处理版本的对象
                    print(request.versioning_scheme)

                    # 3. 反向生成URL（rest framework）
                    u1 = request.versioning_scheme.reverse(viewname='uuu',request=request)
                    print(u1)

                    # 4. 反向生成URL
                    u2 = reverse(viewname='uuu',kwargs={'version':2})
                    print(u2)

                    return HttpResponse('用户列表')

restframework 解析器

前戏：django:request.POST/ request.body
        1. 请求头要求：
            Content-Type: application/x-www-form-urlencoded
            PS: 如果请求头中的 Content-Type: application/x-www-form-urlencoded，request.POST中才有值（去request.body中解析数据）。
        2. 数据格式要求：
              name=alex&age=18&gender=男

        如：
            a. form表单提交
                <form method...>
                    input...

                </form>

            b. ajax提交
                $.ajax({
                    url:...
                    type:POST,
                    data:{name:alex,age=18} # 内部转化 name=alex&age=18&gender=男
                })

                情况一：
                    $.ajax({
                        url:...
                        type:POST,
                        headers:{'Content-Type':"application/json"}
                        data:{name:alex,age=18} # 内部转化 name=alex&age=18&gender=男
                    })
                    # body有值；POST无
                情况二：
                    $.ajax({
                        url:...
                        type:POST,
                        headers:{'Content-Type':"application/json"}
                        data:JSON.stringfy({name:alex,age=18}) # {name:alex,age:18...}
                    })
                    # body有值；POST无
                    # json.loads(request.body)

    rest_framework 解析器，对请求体数据进行解析

    总结：
        使用：
            配置：
                REST_FRAMEWORK = {
                    "DEFAULT_VERSIONING_CLASS":"rest_framework.versioning.URLPathVersioning",
                    "DEFAULT_VERSION":'v1',
                    "ALLOWED_VERSIONS":['v1','v2'],
                    "VERSION_PARAM":'version',

                    "DEFAULT_PARSER_CLASSES":['rest_framework.parsers.JSONParser','rest_framework.parsers.FormParser']
                }

            使用：
                class ParserView(APIView):
                    # parser_classes = [JSONParser,FormParser,]
                    """
                    JSONParser:表示只能解析content-type:application/json头
                    JSONParser:表示只能解析content-type: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('ParserView')

        源码流程 & 本质：
            a. 本质
                请求头 :...
                状态码: ...
                请求方法:...
            b. 源码流程
                - dispatch: request封装
                - request.data

restframework 序列化(重要)

​ 序列化有两大功能 ：

​ 1.对请求数据的校验

​ 2.对QuerySet验证

​ 序列化demo

​ 创建serializers.py文件

此demo只是入门级demo，一般开发的时候不是下面这种写法！

下面这种写法只是给刚接触restframework的朋友提供思路

下面的写法也可以实现项目中的需求

models.py
from django.db import models

class RoleModels(models.Model):
    title = models.CharField(max_lentch=32,verbase_name='名称')
    def __str__(self):
        return self.title
    class Meta:
        db_table = 'Role'
        verbose_name = verbose_name_plural = '角色'

serializers.py
from rest_framework.serializers import Serializer
from .models import RoleModels

class RoleSerializer(Serializer)
    title = serializer.CharField()
    class Meta:
        model = RoleModels
        fields = ('id', 'title')

views.py
from django.http import HttpResponse
from .serializers import RoleSerializer
from .models import RoleModels
from rest_framework.views import APIView
import json
class RolesView(APIView):
    def get(self,request,*args,**kwargs):
        roles = RoleModels.objects.all()
        ser = RoleSerializer(instance=roles,many=True)
        ret = json.dumps(ser.data,ensure_asii=False)
        return HttpResponse(ret)

代码里序列化中的many=True 意思是 roles = models.RoleModels.objects.all() 这段代码

roles拿到的是多条数据 ，所以在序列化中

要使用many=True 如果我们要取单条数据的写法是 role = models.RoleModels.objects.all().first()

序列化中把many改为many=False

因为Django的ORM取到的数据是QuerySet

所以需要通过序列化才能把数据返回给前端，如果不进行序列化就把数据返回出去就会报错

方式2
models.py
from django.db import models

class UserInfoModels(models.Model):
    user_type_choices = (
        (1,'普通用户'),
        (2,'VIP'),
        (3,'VVIP'),
    )
    user_type = models.IntegerField(choices=user_type_choices)
    username = models.CharField(max_length=32,unique=True)
    password = models.CharField(max_length=64)
       Roles = models.ManyToManyField("Role")
    def __str__(self):
        return self.username
    class Meta:
        db_table = 'UserInfo'
        verbose_name = verbose_name_plural = '用户'

serializers.py

from rest_framework.serializers import Serializer
from .models import UserInfoModels

class UserInfoSerializer(Serializer)
    username = serializer.CharField()
    password = serializer.CharField()
    class Meta:
        model = UserInfoModels
        fields = ('id', 'username','password')

views.py

from django.http import HttpResponse
from .serializers import UserInfoSerializer
from .models import UserInfoModels
from rest_framework.views import APIView
import json

class UserInfoView(APIView):
    def get(self,request,*args,**kwargs):
        users = UserInfoModels.Objects.all()
        ser = UserInfoSerializer(instance=users,many=True)
        ret = json.dumps(ser.data,ensure_asii=False)
        return HttpResponse(ret)

知识点

如何将user_type 从数字 显示成中文，不要显示user_type的键，显示它的值

我们要在序列化中声明字段

models.py
from django.db import models

class UserInfoModels(models.Model):
    user_type_choices = (
        (1,'普通用户'),
        (2,'VIP'),
        (3,'VVIP'),
    )
    user_type = models.IntegerField(choices=user_type_choices)
    username = models.CharField(max_length=32,unique=True)
    password = models.CharField(max_length=64)
       Roles = models.ManyToManyField("Role")
    def __str__(self):
        return self.username
    class Meta:
        db_table = 'UserInfo'
        verbose_name = verbose_name_plural = '用户'

serializers.py

from rest_framework.serializers import Serializer
from .models import UserInfoModels

class UserInfoSerializer(Serializer)
    xxxx = serializer.CharField(source="get_user_type_display")
    username = serializer.CharField()
    password = serializer.CharField()
    class Meta:
        model = UserInfoModels
        fields = ('id', 'username','password','xxxx')

无论我们给这个字段起个xxxx的名字还是其他的名字 只要这个source是对的，就可以把中文展示出来，这里的get_user_type_display 之后get_ 和_display是固定的，中间的字段是你models里的字段,我们的UserInfoModels是不是有user_type这个字段，所以要写成get_user_type_display

如果你的models里的字段是oooo ,那就写get_oooo_display,如果是username 那就写get_username_display 希望看到这里你能明白

这个source也适用于Models中的ForeignKey，但是不适用于ManyToManyField

如果要必须要使用ManyToManyField，我们只能在序列化中创建字段xxx = serializers.SerializerMethodField ，xxx是你models里ManyToManyField的字段名（这里只是演示说字段名是xxx）然后还需要在序列化下方定义一个函数

如果通过source取不到 用下面这个方法

serializer.py

#我们以角色表为例子
from rest_framework.serializers import Serializer
from .models import RoleModels

class RoleSerializer(Serializer)
    title = serializer.CharField()
    xxxx = serializerSerializerMethodField()
    def get_xxxx(self,row):
        role_obj_list = row.roles.all()
        ret = []
        for item in role_obj_list:
            ret.append({'id':item.id,'title':item.title})
        return ret
    class Meta:
        model = RoleModels
        fields = ('id', 'title')

实际开发中我们会在序列化中引用ModelSerializer，很少使用Serializer

models.py
from django.db import models

class RoleModels(models.Model):
    title = models.CharField(max_lentch=32,verbase_name='名称')
    def __str__(self):
        return self.title
    class Meta:
        db_table = 'Role'
        verbose_name = verbose_name_plural = '角色'

serializers.py
from rest_framework.serializers import ModelSerializer
from .models import RoleModels

class RoleSerializer(ModelSerializer)

    class Meta:
        model = RoleModels
        fields = ('__all__')

views.py
from django.http import HttpResponse
from .serializers import RoleSerializer
from .models import RoleModels
from rest_framework.views import APIView
import json
class RolesView(APIView):
    def get(self,request,*args,**kwargs):
        roles = RoleModels.objects.all()
        ser = RoleSerializer(instance=roles,many=True)
        ret = json.dumps(ser.data,ensure_asii=False)
        return HttpResponse(ret)

部分总结：

1. 写类

1. class RolesSerializer(serializers.Serializer):
   id = serializers.IntegerField()
   title = serializers.CharField()

               class UserInfoSerializer(serializers.ModelSerializer):
                   class Meta:
                       model = models.UserInfo
                       # fields = "__all__"
                       fields = ['id','username','password',]
       2. 字段
           a. title = serializers.CharField(source="xxx.xxx.xx.xx")
           b. title = serializers.SerializerMethodField()
              class UserInfoSerializer(serializers.ModelSerializer):
                   rls = serializers.SerializerMethodField()  # 自定义显示
   
                   class Meta:
                       model = models.UserInfo
                       fields = ['id','username','password','rls',]
   
                   # 自定义方法
                   def get_rls(self, row):
                       role_obj_list = row.roles.all()
   
                       ret = []
                       for item in role_obj_list:
                            ret.append({'id':item.id,'title':item.title})
                       return ret</code></pre></li>

    class UserInfoSerializer(serializers.ModelSerializer):
                    class Meta:
                        model = models.UserInfo
                        fields = ("__all__")
                      #  fields=['id','use**rname','password','group','roles']
                        depth = 1 # 0~ 10



4. 生成链接

class UserInfoSerializer(serializers.ModelSerializer):                                    group=serializers.HyperlinkedIdentityField(
        view_name='gp',
        lookup_field='group_id',
        lookup_url_kwarg='xxx'
   )
    class Meta:
        model = models.UserInfo
        # fields = ("__all__")
        fields = ['id','username','password','group','roles']
        depth = 0 # 0 ~ 10

class UserInfoView(APIView):
    def get(self,request,*args,**kwargs):
        users = models.UserInfo.objects.all()
        ser = UserInfoSerializer(
            instance=users,
            many=True,
            context={
                'request': request
            }
        )
        ret = json.dumps(ser.data, ensure_ascii=False)
        return HttpResponse(ret)

        源码：
            对象， Serializer类处理；
            QuerySet，ListSerializer类处理；
            # ser.data

请求数据校验：

class XXValidator(object):
    def __init__(self, base):
        self.base = base

    def __call__(self, value):
        if not value.startswith(self.base):
            message = '标题必须以 %s 为开头。' % self.base
            raise serializers.ValidationError(message)
            def set_context(self, serializer_field):
                """
                    This hook is called by the serializer instance,
                    prior to the validation call being made.
                    """
                # 执行验证之前调用,serializer_fields是当前字段对象
                pass

class UserGroupSerializer(serializers.Serializer):
    title = serializers.CharField(
        error_messages={
            'required':'标题不能为空'
        },
        validators=[
            XXValidator('老男人'),
        ]
    )



#验证数据
class UserGroupView(APIView):

    def post(self,request,*args,**kwargs):
        ser = UserGroupSerializer(data=request.data)
        if ser.is_valid():
            print(ser.validated_data['title'])
            else:
                print(ser.errors)

                return HttpResponse('提交数据')

from rest_framework.pagination import PageNumberPagination
class MyPageNumberPagination(PageNumberPagination):
    page_size = 2
    page_size_query_param = 'size'
    max_page_size = 5
    page_query_param = 'page'

class Pager1View(APIView):
    def get(self,request,*args,**kwargs):
        # 获取所有数据
                    roles = models.Role.objects.all()

                    # 创建分页对象
                    # pg = MyPageNumberPagination()
                    pg = PageNumberPagination()

                    # 在数据库中获取分页的数据
                    pager_roles = pg.paginate_queryset(queryset=roles,request=request,view=self)

                    # 对数据进行序列化
                    ser = PagerSerialiser(instance=pager_roles, many=True)

                    return Response(ser.data)
                    # return pg.get_paginated_response(ser.data)

        b. 分页，在n个位置，向后查看n条数据；

                from api.utils.serializsers.pager import PagerSerialiser
                from rest_framework.response import Response
                from rest_framework.pagination import PageNumberPagination,LimitOffsetPagination

                class MyLimitOffsetPagination(LimitOffsetPagination):
                    default_limit = 2
                    limit_query_param = 'limit'
                    offset_query_param = 'offset'
                    max_limit = 5

                class Pager1View(APIView):

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

                        # 获取所有数据
                        roles = models.Role.objects.all()

                        # 创建分页对象
                        # pg = MyLimitOffsetPagination()
                        pg = LimitOffsetPagination()

                        # 在数据库中获取分页的数据
                        pager_roles = pg.paginate_queryset(
                            queryset=roles,request=request,view=self
                        )

                        # 对数据进行序列化
                        ser = PagerSerialiser(instance=pager_roles, many=True)

                        return Response(ser.data)
                        # return pg.get_paginated_response(ser.data)

url(r'^(?P<version>[v1|v2]+)/v1/$', views.View1View.as_view({'get': 'list','post':'create'})),

url(r'^(?P<version>[v1|v2]+)/v1/(?P<pk>\d+)/$', views.View1View.as_view({'get': 'retrieve','delete':'destroy','put':'update','patch':'partial_update'})),

a. 过去
class Pager1View(View):
    pass

b. 现在
class Pager1View(APIView): # View
    pass

c. 无用

from api.utils.serializsers.pager import PagerSerialiser
from rest_framework.generics import GenericAPIView

class View1View(GenericAPIView): # APIView
    queryset = models.Role.objects.all()
    serializer_class = PagerSerialiser
    pagination_class = PageNumberPagination
    def get(self,request,*args,**kwargs):
        # 获取数据
        roles = self.get_queryset() # models.Role.objects.all()

                    # [1, 1000,]     [1,10]
        pager_roles = self.paginate_queryset(roles)

                    # 序列化
        ser = self.get_serializer(instance=pager_roles,many=True)

        return Response(ser.data)

d. GenericViewSet(ViewSetMixin, generics.GenericAPIView):

路由：
    url(r'^(?P<version>[v1|v2]+)/v1/$', views.View1View.as_view({'get': 'list'})),

视图：
from api.utils.serializsers.pager import PagerSerialiser
from rest_framework.viewsets import GenericViewSet
class View1View(GenericViewSet):
    queryset = models.Role.objects.all()
    serializer_class = PagerSerialiser
    pagination_class = PageNumberPagination

def list(self, request, *args, **kwargs):
# 获取数据
    roles = self.get_queryset()  # models.Role.objects.all()

                        # [1, 1000,]     [1,10]
    pager_roles = self.paginate_queryset(roles)

                        # 序列化
    ser = self.get_serializer(instance=pager_roles, many=True)

    return Response(ser.data)

from api.utils.serializsers.pager import PagerSerialiser
                from rest_framework.viewsets import GenericViewSet,ModelViewSet
                from rest_framework.mixins import ListModelMixin,CreateModelMixin

                class View1View(ModelViewSet):
                    queryset = models.Role.objects.all()
                    serializer_class = PagerSerialiser
                    pagination_class = PageNumberPagination

                PS: class View1View(CreateModelMixin,GenericViewSet):
        总结：
            a. 增删改查 ModelViewSet
            b. 增删     CreateModelMixin,DestroyModelMixin  GenericViewSet
            c. 复杂逻辑  GenericViewSet 或 APIView 

            PS: 还债：
                GenericAPIView.get_object
                    check_object_permissions
                        has_object_permission

在settings.py的INSTALLED_APPS 增加'rest_framework'
from rest_framework.renderers import JSONRenderer,BrowsableAPIRenderer
class TestView(APIView):
            # renderer_classes = [JSONRenderer,BrowsableAPIRenderer]
            def get(self, request, *args, **kwargs):
                # 获取所有数据
                roles = models.Role.objects.all()

                # 创建分页对象
                # pg = CursorPagination()
                pg = MyCursorPagination()

                # 在数据库中获取分页的数据
                pager_roles = pg.paginate_queryset(queryset=roles, request=request, view=self)

                # 对数据进行序列化
                ser = PagerSerialiser(instance=pager_roles, many=True)

                return Response(ser.data)

        REST_FRAMEWORK = {
            "DEFAULT_VERSIONING_CLASS":"rest_framework.versioning.URLPathVersioning",
            "DEFAULT_VERSION":'v1',
            "ALLOWED_VERSIONS":['v1','v2'],
            "VERSION_PARAM":'version',
            "DEFAULT_PARSER_CLASSES":['rest_framework.parsers.JSONParser','rest_framework.parsers.FormParser'],
            "PAGE_SIZE":2,

            "DEFAULT_RENDERER_CLASSES":[
                'rest_framework.renderers.JSONRenderer',
                'rest_framework.renderers.BrowsableAPIRenderer',
            ]
        }