drf从入门到精通---day03(APIView执行流程,Request对象源码分析,序列化器介绍和快速使用,反序列化代码总结, 反序列化的校验)

昨日回顾

#1 restful 规范
	-https协议，保证安全
    -接口中带api标识
    	-api.baidu.com
        -www.baidu.com/api
   	-接口中带版本标识
    -接口即资源，尽量用名词，可以复数
    -请求方式决定操作资源的方式
    	-get 查询
        -post 新增
        。。。
    -返回携带错误码
    	-http响应状态码：301  302 404 404
        -自己规定的:
    -返回中带错误信息
    	{code:100,msg:'成功'}
    -返回中带链接
    -接口中带过滤条件(查询条件)
    -返回的数据符合如下规范
    	-查询所有：返回数组或列表
        -查询单个：返回字典，对象
        -修改：返回修改后的数据对象
        -删除：返回空文档
        -增加：返回增加后的对象
        
        
# 2 序列化和反序列化
	-数据格式转换
    -前后端分离：
    	-序列化：查出的模型对象----》转换成json格式字符串形式----》给前端   read
        -反序列化：前端传入的json格式字符串---》转换成对象----》存到数据库  write
        
        
# 3 使用django原生编写5个接口
	-前后端分离了，写的都是接口，接口基本上都是基于这5个的变形
    -查询所有：JsonResponse   HttpResponse
    -新增：request.POST 取出前端传入body的数据,只能取出form-data，urlencoded
    	不能取出josn格式，request.body  --->json--->反序列化成字典，再用
    	name=lqz&age=19
    -查询单个：根据pk查到单个对象，直接序列化后返回给前端
    -修改：put请求放到body中的数据，在request.POST取不出来，只能自己从request.body中取出来
    -删除：pk直接删除
    
# 4 drf介绍
	-djagno的一个app（组件），最新版本 3.x---》支持djagno 3.x以上
    -框架，模块版本不一致导致程序运行不起来
    -方便我们快速的在django框架上编写符合restful规范的接口
    
# 5 快速使用drf写了5个接口
	-路由：自动生成路由----》两个列表相加
    -视图：
    -序列化类：serializer
# 6 cbv源码分析
	-路由中：path('api/v1/books/', views.BookView.as_view())---》路由匹配成功就会执行---》views.BookView.as_view()(request)---->看一下BookView.as_view是怎么写的---》View这个类中的as_view类的绑定方法---》执行结果是view的内存地址[as_view中的内存函数，闭包函数]---》本质请求来了，执行view(request)--->return self.dispatch(request, *args, **kwargs)--->对象，谁的对象，View的对象，咱们从BookView---》View---》self是BookView的对象----》发现BookView没有dispatch---》View类的dispatch
    def dispatch(self, request, *args, **kwargs):
        if request.method.lower() in self.http_method_names:
            # self是BookView的对象，通过字符串get找方法或属性，找到了get方法
            #handler就是BookView类的get方法
            handler = getattr(self, request.method.lower(), self.http_method_not_allowed)
        else:
            handler = self.http_method_not_allowed
        # 执行 BookView的get(request)---->get请求就会执行BookView的get方法，post请求就会执行BookView的post方法
        return handler(request, *args, **kwargs)



# 使用pycharm打开sqlite的问题
	-sqlite文件---》文件(xx.mp4,xx.txt) ---->是一样的
    -我们选择什么软件打开它，看到的东西是不一样的

    -解决：
    	-1  干脆不用pycharm打开，使用navicate打开
        -2 使用pycharm正常连接

今日内容

0 drf 整体内容

# 1 入门规范
	-web开发模式
    -api接口
    -接口测试工具
    -restful规范
    -序列化反序列化
    -drf快速使用
    -APIView，Request类
    -drf把django的好多东西都重写了
# 2 序列化组件(重要)
	-基本序列化类
    -模型类序列化类
    -如何序列化
    -如何反序列化
    -反序列化的数据校验功能

# 3 请求与响应
    -drf的request已经不是原来djagno的request了
    -drf的reponse已经不是原来djagno的reponse了
    -指定可以接收请求的编码方式
    -指定响应格式
    
    
# 4 视图组件（重点）   View
	-两个视图基类
    -5个视图扩展类
    -9个视图子类
    -视图集
    
    
# 5 路由
	-自动生成路由
    
# 6 认证(登录认证)，权限，频率 （重点）

# 7 过滤，排序，分页（次重点）

# 8 自动生成接口文档
----------------------
# 9 JWT 登录认证的，区别与cookie和session，主流
# 10 后台管理美化（django原生的很丑，simpleui二次开发）
# 11 基于角色的访问控制，权限的控制

.
.
.
.

1 APIView执行流程（难，了解）

1.1 基于APIView 加 JsonResponse编写接口

# drf提供给咱们的一个类，以后使用drf写视图类，都是继承这个类及其子类，APIView本身就是继承了Django原生的View
----------------------------------------------------
# 基于APIView加JsonResponse 写接口

class BookView(APIView):
    def get(self, request):
        books = Book.objects.all()
        book_list = []
        for book in books:
            book_list.append({'name': book.name, 'price': book.price, 'publish': book.publish})

        return JsonResponse(book_list, safe=False)

.

1.2 基于APIView+Response 写接口

class BookView(APIView):
    def get(self, request):
        books = Book.objects.all()
        book_list = []
        for book in books:
            book_list.append({'name': book.name, 'price': book.price, 'publish': book.publish})

        return Response(book_list)  # 无论是列表还是字典都可以序列化

.
.
.

1.3 APIView的执行流程

### 一定要注意self，self就是对象，先看看该self怎么来的，当对象调用类里面的方法时，会自动将对象当作第一个参数传给该方法，并被该方法的self行参接收。
### 所以也就是先看看是哪一个对象点的含有该self行参的方法，那么方法里面的self就是该对象
### 换句话说：哪个对象调用的该方法，那么该方法里面self就是哪个对象，和self当前所在的函数所属的类无关！！！

# 路由中写的： path('books/', views.BookView.as_view()),---请求来了执行
# views.BookView.as_view()()----->现在的as_view是APIView的as_view
# 注意是两个括号，先运行函数as_view()并返回另一个函数名view，所以最后走的是view()

# APIView的as_view方法：view还是原来的view，但是以后再也没有csrf认证了

	@classmethod
	def as_view(cls, **initkwargs):
        # 子类调用父类的as_view，父类是django原生的View
        # 把djagno原生View的as_view方法中的闭包函数view拿出来了
        view = super().as_view(**initkwargs)

     # csrf_exempt是一个装饰器函数，当给函数加上装饰器后 变view = csrf_exempt(view)
     # 所以return csrf_exempt(view)虽然返回的还是view，但是实际是装饰器函数的返回值！
        # 相当于在视图类的所有的方法上面加了这个装饰器，以后所有的请求就没有csrf认证了
        return csrf_exempt(view)

# 此处的as_view是APIView类里面的函数，但是在该类里面又用super()调用它的父类View类里面的as_view函数并且加括号运行了，我们知道View类里面的as_view函数执行的返回值是定义在as_view函数里面的view函数的函数名！！！！

# 所以view = super().as_view(**initkwargs)这行代码执行完了，变量名view接收的还是父类View里面的as_view方法中的闭包函数view的函数名！！！
# 所以最后实际上还是djagno原生View的as_view方法中的闭包函数view加括号运行！只是在view（）运行前加了一个装饰器不让它有csrf的认证了！！！
-----------------------------------------------
-----------------------------------------------
-----------------------------------------------
# 路由匹配成功，执行 csrf_exempt(view)(requets)---就是执行View类里面的as_view中的闭包函数view-----还是执行self.dispatch----此时self是视图类BookiView产生的对象------所以找到BookiView的父类APIView里面的dispatch方法了！！！
# 换句话说除非APIView里面没有dispatch方法，才能找到的APIView的父类View里面的dispatch方法，但现在APIView里面有dispatch方法
# 一定要注意：哪个对象调用的该方法，那么该方法里面self就是哪个对象，和self当前所在的函数所属的类无关！！！
# BookView.as_view()() 运行绕了一大圈找到了View里面的dispatch方法，所以self是BookView产生的对象，但是BookView类里面没有dispatch，所以BookView产生的对象从它的父类里面找到dispatch方法！！！

    def dispatch(self, request, *args, **kwargs):
        # 上面括号里面request是django原生的request，老的request
    # 下面这行代码，把老的request包装成了新的request，这个是drf提供的Request类的对象
        request = self.initialize_request(request, *args, **kwargs)
        # initialize_request函数的执行的返回值是个对象被request接收，所以此处的request是新的request
        # 老的request在哪？放到了返回对象里面去了，用request._request 才能拿！！

        # 把新的request放到了self也就是BookView类的对象里面去了
        self.request = request

        try:
            # 执行了三大认证【认证，频率，权限】，使用新的request，暂不读
            self.initial(request, *args, **kwargs)

            # 此处跟之前的View类里面的dispatch里面的代码一模一样
            if request.method.lower() in self.http_method_names:
                handler = getattr(self, request.method.lower(),
                                  self.http_method_not_allowed)
            else:
                handler = self.http_method_not_allowed
          # 把新的request传入了，视图类的方法中get的request也是新的
            response = handler(request, *args, **kwargs)
        except Exception as exc:

 # try这一大段目的,在执行3大认证和视图类中方法的过程中,如果出了异常,都能捕获到--全局异常捕获
            response = self.handle_exception(exc)
        self.response = self.finalize_response(request, response, *args, **kwargs)
        return self.response
--------------------------------------------
--------------------------------------------
--------------------------------------------
# 总结：APIView的执行流程
	1 去除了所有的csrf
    2 包装了新的request，以后在视图类中用的request是新的request  Request类的对象，不是原生的了，原生的在：新的requets._request
    3 在执行视图类的方法之前，执行了3大认证
    4 如果在3大认证或视图函数方法执行过程中出了错，会有异常捕获----》全局异常捕获

     以后视图类方法中的request都是新的了
-----------------------------------------
# 补充：装饰器的基本原理  在不改变被装饰对象原代码和调用方式！！！的情况下给被装饰对象添加新的功能！！！

def auth(func)  # 装饰器
    # 执行被装饰对象之前可以做的额外操作
    inner = func(*args,**kwargs)
    # 执行被装饰对象之后可以做的额外操作
        return res
    return inner

def add()   # 函数

# 使用auth装饰add函数
@auth   #  本质是  add=auth(add)
def add()

# 以后再使用add，其实就是在使用 auth(add) 的返回结果

# 也就是说，想要对一个函数用装饰器装饰，有两种方法，
# 1 直接用 装饰器语法糖在需要的函数上面写个   @装饰器函数名  比如@auth
# 2 或者直接在需要的函数上面写个  add=auth(add)

现在的as_view是APIView类里面的as_view，不是View类里面的as_view了！！！

.
.
APIView类里面dispatch方法里面的代码 request = self.initialize_request(request, *args, **kwargs)

.

所以前面的request变量名接收的是Request类加括号产生的对象

.

所以老的request放到了Request类加括号产生的对象也就是request里面去了，request._request才能拿到

.
对象点一个不存在的属性名=xx就是给该对象添加该xx属性，
所以BookView类产生的对象点request=request 就把右边的request对象也就是新的request添加到BookView类产生的对象里面去了！！！
.
归根结底就是该代码产生了新的request，并且该新的request是Request类产生的对象，老的request还放在了新的request._request里面，总结下来就是把老的request包到新的request里面去了！！！

.
.
.
.
.

2 Request对象源码分析（难，了解）

# 新的Request---区别于老的
# 老的：django.core.handlers.wsgi.WSGIRequest
# 新的：from rest_framework.request import Request
---------------------------------------------------
---------------------------------------------------
# Request源码
	-魔法方法 __getattr__    对象.属性，如果属性不存在，会触发它的执行
	-在视图类的方法中，执行request.method ,新的request是没有method这个属性名时，就触发了新的Request的__getattr__方法的执行，并把不存在的这个属性名当成参数传给该魔法方法

        def __getattr__(self, attr):
            try:
                # self就是新的request,从老的request中反射出 要取的属性
                return getattr(self._request, attr)
            except AttributeError:
                return self.__getattribute__(attr)

# 因为老的request也是一个对象，所以老的request对象也能用反射，反射出method对应的值
-----------------------------------------
-----------------------------------------
@property
    def data(self):

-request.data--->这是个方法，包装成了数据属性
	以后无论post，put..放在body中提交的数据，都从request.data中取，取出来就是字典
	无论是哪种编码格式
-----------------------------------------
@property
def query_params(self):

-request.query_params--->这是个方法，包装成了数据属性
	get请求携带的参数，以后从这里面取
	query_params：查询参数---> restful规范请求地址中带查询参数
-----------------------------------------
@property
def FILES(self):

-request.FILES---> 这是个方法，包装成了数据属性
	前端提交过来的文件，从这里取
-----------------------------------------------
-----------------------------------------------

# Request类总结
-1  新的request用起来，跟之前一模一样，因为新的取不到，会取老的。
-2 request.data  无论什么编码，什么请求方式，只要是body中的数据，就从这里取，取出来就是字典
-3 request.query_params 就是原来的request._request.GET
-4 上传的文件从request.FILES

-----------------------------------------------
-----------------------------------------------
# 补充：python 中有很多魔法方法,在类中，某种情况下触发，会自动执行
	-__str__:打印对象会调用
    -__init__:类() 会调用
    -__call__: 对象() 会调用
    -__new__:
	-__getattr__：对象.属性，如果属性不存在，会触发它的执行

.
.
.
.

3 序列化器介绍和快速使用

# 因为咱么在写接口时，需要序列化，需要反序列化，而且反序列化的过程中要做数据校验
# drf直接提供了固定的写法，只要按照固定写法使用，就能完成上面的三个需求
---------------------------------------------
# 提供了两个类 Serializer ModelSerializer
# 以后咱们只需要写自己的类，继承drf提供的序列化类，使用其中的某些方法，就能完成上面的操作
---------------------------------------------

.

# 使用APIView+序列化类+Response 完成接口的编写

# 先写自己写一个序列化类  serializer.py
from rest_framework import serializers
from rest_framework.exceptions import ValidationError
from .models import Book


class BookSerializer(serializers.Serializer):
    # 序列化某些字段，这里写要序列化的字段
    name = serializers.CharField()    # serializers下大致跟models下的类是对应的
    price = serializers.CharField()
    publish = serializers.CharField()

    def create(self, validated_data):
        # 保存的逻辑
        # validated_data 校验过后的数据 {'name':'lqz','price':123,'publish':'xxx'}
        # 保存到数据库
        book_obj = Book.objects.create(**validated_data)
        # 一定要返回新增的对象
        return book_obj

    def update(self, instance, validated_data):
        # instance 要修改的对象
        # validated_data 校验过后的数据
        instance.name = validated_data.get('name')
        instance.price = validated_data.get('price')
        instance.publish = validated_data.get('publish')
        instance.save()  # orm的单个对象，修改了单个对象的属性，只要调用对象.save,就能把修改保存到数据库

        return instance  # 不要忘了吧修改后的对象，返回

    # 反序列化校验的局部钩子 ，名字不能以sb开头
    # validated_value形参接收的就是字段name对应的值
    def validate_name(self, validated_value):
        # 校验validated_value是否合法
        if validated_value.startswith('sb'):
            # 校验不通过，抛异常
            raise ValidationError('不能以sb开头')
        else:
            return validated_value

    # 全局钩子
    def validate(self, attrs):
        # 校验过后的数据，书名跟出版社名字不能一致
        if attrs.get('name') == attrs.get('publish'):
            raise ValidationError('书名跟出版社名字不能一致')
        else:
            return attrs

.

#  再开始写视图类
from .serializer import BookSerializer

class BookView(APIView):
    def get(self, request):
        book_queryset = Book.objects.all()
        # 使用序列化类来完成---》得有个序列化类
        # instance要序列化的数据book_queryset对象
        # many=True 只要是queryset对象要传many=True，如果是单个对象就不用传
# 这一步已经将要序列化的对象序列化，，就序列化对象的哪个字段
        ser = BookSerializer(instance=books, many=True)
        return Response(ser.data)
# ser.data将要序列化的对象序列化，序列化类里面写哪个字段，
# 并将序列化好的数据返回，无论返回的是列表还是字典都可以

    def post(self, request):
        # requset.data  # 前端提交的要保存的数据----》校验数据---》存
        ser = BookSerializer(data=request.data)  # 把前端传入的要保存的数据，给data参数
        # 校验数据
        if ser.is_valid():
            # 保存---->需要自己写，要在序列化类BookSerializer中写----》create方法
            ser.save()  # 调用ser.save,自动触发咱们写的create，保存起来
            return Response({'code': 100, 'msg': '新增成功', 'result': ser.data})
        else:
            return Response({'code': 101, 'msg': ser.errors})


class BookDetailView(APIView):
    # def get(self, request,pk):
    def get(self, request, *args, **kwargs):
        book = Book.objects.filter(pk=kwargs.get('pk')).first()
        # 序列化
        ser = BookSerializer(instance=book)
        return Response(ser.data)

    def put(self, request, pk):
        book = Book.objects.filter(pk=pk).first()
        # 反序列化保存 ---借助于序列化类
        ser = BookSerializer(data=request.data, instance=book)
        if ser.is_valid():
            ser.save()  # 由于没有重写update，所以这报错
            return Response({'code': 100, 'msg': '修改成功', 'result': ser.data})
        else:
            return Response({'code': 101, 'msg': ser.errors})

    def delete(self, requset, pk):
        Book.objects.filter(pk=pk).delete()
        return Response({'code': 100, 'msg': '删除成功'})

.
.
.

3.1 序列化类基本使用，序列化 查多条数据 代码总结

**serializer.py--BookSerializer类**

from rest_framework import serializers

class BookSerializer(serializers.Serializer):
    # 序列化某些字段，这里写要序列化的字典
    name = serializers.CharField()  # serializers下大致跟models下的类是对应的
    # price = serializers.CharField()
    publish = serializers.CharField()

.

**views.py--->BookView类**

class BookView(APIView):
    def get(self, request):
        # 只是为了验证之前讲过的
        print(request.method)
        print(request._request)
        print(type(self.request))

        books = Book.objects.all()
        # 使用序列化类来完成---》得有个序列化类
        # instance要序列化的数据books queryset对象
        # many=True 只要是queryset对象要传many=True，如果是单个对象就不用传
        ser = BookSerializer(instance=books, many=True)
        return Response(ser.data)  # 无论是列表还是字典都可以序列化

.
.
.
.

3.2 序列化 查单条数据 代码总结

**序列化类---没有动**

from rest_framework import serializers

class BookSerializer(serializers.Serializer):
    # 序列化某些字段，这里写要序列化的字典
    name = serializers.CharField()  # serializers下大致跟models下的类是对应的
    # price = serializers.CharField()
    publish = serializers.CharField()

.

**视图类---BookDetailView**

class BookDetailView(APIView):
    # def get(self, request,pk):
    def get(self, request, *args, **kwargs):
        book = Book.objects.filter(pk=kwargs.get('pk')).first()
        # 序列化
        ser = BookSerializer(instance=book)
        return Response(ser.data)

.

**url加了新的路由**

urlpatterns = [
    path('books/<int:pk>/', views.BookDetailView.as_view()),
]

.
.
.
.
.

4 反序列化

4.1 反序列化 新增数据 代码总结

**视图类**

class BookView(APIView):
    def post(self, request):
        # requset.data  # 前端提交的数据----》先校验数据---》再存
        # 把前端传入的要保存的数据，给data参数
        ser = BookSerializer(data=request.data)

        # 校验数据
        if ser.is_valid():
            # 保存--->需要自己写，要在序列化类BookSerializer中写 create方法
   # 调用ser.save,自动触发咱们写在序列化类里面的的create方法，将数据用ORM保存到数据库
            ser.save()
            return Response({'code': 100, 'msg': '新增成功', 'result': ser.data})
        else:
            return Response({'code': 101, 'msg': ser.errors})

.

**序列化类**

class BookSerializer(serializers.Serializer):
    # 序列化某些字段，这里写要序列化的字典
    name = serializers.CharField()  # serializers下大致跟models下的类是对应的
    price = serializers.CharField()
    publish = serializers.CharField()

    def create(self, validated_data):
        # 保存的逻辑
        # validated_data 校验过后的数据 {name,price,publish}
        # 保存到数据库
        book = Book.objects.create(**validated_data)
        # 一定不要返回新增的对象
        return book

.
.
.
.

4.2 反序列化 修改数据 代码总结

**序列化类**

class BookSerializer(serializers.Serializer):
    # 序列化某些字段，这里写要序列化的字典
    name = serializers.CharField()  # serializers下大致跟models下的类是对应的
    price = serializers.CharField()
    publish = serializers.CharField()

    def create(self, validated_data):
        # 保存的逻辑
        # validated_data 校验过后的数据 {'name':'lqz','price':123,'publish':'xxx'}
        # 保存到数据库
        book = Book.objects.create(**validated_data)
        # 一定不要返回新增的对象
        return book

    def update(self, instance, validated_data):
        # instance 要修改的对象
        # validated_data 校验过后的数据
        instance.name = validated_data.get('name')
        instance.price = validated_data.get('price')
        instance.publish = validated_data.get('publish')
        instance.save()  # orm语句，单个对象修改了单个对象的属性，只要调用对象.save(),就能把修改后的对象保存到数据库中

        return instance  # 不要忘了把修改后的对象，返回出去

.

**视图类**

class BookDetailView(APIView):

    def put(self, request, pk):
        book_obj = Book.objects.filter(pk=pk).first()
        # 反序列化保存 ---借助于序列化类
        # 反序列化生成对象,用前端传过来的数据去改,查出来的对象,生成新的对象
        ser = BookSerializer(data=request.data, instance=book_obj)

        if ser.is_valid():
            ser.save()      # 也需要自己在序列化类中写 update方法
            return Response({'code': 100, 'msg': '修改成功', 'result': ser.data})
        else:
            return Response({'code': 101, 'msg': ser.errors})


# 补充：增与改数据的视图类里面的保存的函数都是用的ser.save()函数，增调用的是序列化类里面的create方法，改调用的是序列化类里面的update方法
# 那么save该方法怎么知道，我们是要增数据还是要改数据的？

save方法源码里面，通过判断序列化类产生的对象有没有instance属性来决定有值调update，没值调create方法！

.
.
.

4.3 删除 单条数据

**视图类**

class BookDetailView(APIView):

    def delete(self, requset, pk):
        Book.objects.filter(pk=pk).delete()
        return Response({'code': 100, 'msg': '删除成功'})

.
.
.
.

5 基于序列化器编写5个接口（重点）

# 上面已经写完了

.
.
.
.
.
.

6 反序列化的校验( 重点！！！ )

新增与修改都会走序列化类里面局部钩子与全局钩子函数！！！
因为都运行了ser = BookSerializer(data=xxx) 把数据反序列化为对象了，
对象点is_valid就会触发序列化类里面的钩子函数！！！

# 序列化类反序列化，数据校验功能--->类比forms组件
	-局部钩子
	-全局钩子

.

class BookSerializer(serializers.Serializer):
    # 序列化某些字段，这里写要序列化的字典
    name = serializers.CharField()  # serializers下大致跟models下的类是对应的
    price = serializers.CharField()
    publish = serializers.CharField()

    def create(self, validated_data):
        # 保存的逻辑
        # validated_data 校验过后的数据 {name,price,publish}
        # 保存到数据库
        book = Book.objects.create(**validated_data)
        # 一定要返回新增的对象
        return book

    def update(self, instance, validated_data):
        # instance 要修改的对象
        # validated_data 校验过后的数据
        instance.name = validated_data.get('name')
        instance.price = validated_data.get('price')
        instance.publish = validated_data.get('publish')
        instance.save()  # orm的单个对象，修改了单个对象的属性，只要调用对象.save,就能把修改保存到数据库

        return instance  # 一定要把修改后的对象，返回


    # 反序列化校验的局部钩子 ，validate_字段名
    # validate_ 后面写哪个字段名，该局部钩子就是校验哪个字段名对应的数据的
    def validate_name(self, validated_value):
        # 校验name字段名对应的值是否合法
        if validated_value.startswith('sb'):
            # 校验不通过，抛异常
            raise ValidationError('不能以sb开头')
        else:
            return name

    # 全局钩子
    def validate(self, attrs):
        # attrs是第一层与第二层校验过后的数据，
        # 要求书名跟出版社名字不能一致
        if attrs.get('name') == attrs.get('publish'):
            raise ValidationError('书名跟出版社名字不能一致')
        else:
            return attrs
---------------------------------
# 局部钩子是对字段的校验，所以局部钩子的函数名必须是validate_字段名
# def validate_name(self, name)  注意括号里面的name是name字段对应的值！！！

.
.

作业

# 1 APIView和Request源码分析，自己分析一遍
# 2  基于序列化器编写5个接口  Publish

# 3 使用局部钩子和全局钩子校验 5个接口
----扩展---部分同学实现
# 3 原生的request  没有data 属性  实现一个原生的 request.data 拿出无论什么编码格式提交的数
	FBV--->写个装饰条
    
    
    def wrapper(func):
        def inner(request,*args,**kwargs):
            request=新的
        	res=func(request)
            return res
        
        return inner
    @wrapper
    def index(request):
        print(request.data)