def test_body(request):
    print('POST--->', request.POST)  # POST---> <QueryDict: {'username': ['jingzhiz']}>
    print('File--->',
          request.FILES)  # File---> <MultiValueDict: {'myfile': [<InMemoryUploadedFile: 10001.jpg (image/jpeg)>]}>
    # print('body--->', request.body)   request.body不能接收大文件，http基于TCP的流式协议
 
    from django.core.files.uploadedfile import InMemoryUploadedFile
    myfile = request.FILES.get('myfile')
    print(myfile.size)  # 286995
    print(myfile.name)  # 10001.jpg
    # print('body--->', request.body)
    print(type(myfile))  # <class 'django.core.files.uploadedfile.InMemoryUploadedFile'>
    BASE_DIR = settings.BASE_DIR
    file_path = os.path.join(BASE_DIR, 'img')

原生文件对象
    with open(f'{file_path}/{myfile.name}', 'wb') as f:
        print(type(f))  # <class '_io.BufferedWriter'>
        for line in myfile:
            f.write(line)
 
    return JsonResponse({'code': 100, 'msg': '请求成功'})

def warpper_request(func):
    def inner( *args, **kwargs):
        # 在执行被装饰函数前执行
        res = func(*args, **kwargs)
        # 在执行被装饰函数后执行
        return res
    return inner

　 　1.数据安全性，一般使用https，因为https比http更安全
　　2.数据具有api标志
　　3.数据就是资源，前后端交互的数据就是资源
　　4.响应状态码
　　5.不同的请求方式，返回标准不同
　　6.响应状态码带有错误信息
　　7.URL中具有版本信息，也就是多版本共存
　　8.url带有过滤条件（但是只针对查询）
　　9.资源操作有请求方式决定
　　10.响应中带连接

@classonlymethod
def as_view(cls, **initkwargs):
    # 闭包函数
    def view(request, *args, **kwargs):
        self = cls(**initkwargs) # 类实例化得到对象：BookView的对象
        # 调用对象的绑定方法 dispath---》去BookView中找dispatch--》找不到去父类---》View中的dispatch
        return self.dispatch(request, *args, **kwargs) # 对象的方法
    return view
    
# 执行：BookView.as_view()(request)---》本质是执行 View中as_view内部的view方法，传入了reuqest----》在执行View的dispatch方法，传入了request

# 看 ：View.dispatch---》源码
    def dispatch(self, request, *args, **kwargs):
        if request.method.lower() in self.http_method_names: # 判断请求方式是否在那个固定的列表中[get, post...]--->
            # 反射：通过字符串 动态的  操作对象的属性或方法
            # 假设是get请求---》去BookView中取出 get方法赋值给handler
            handler = getattr(self, request.method.lower(), self.http_method_not_allowed)
        else:
            handler = self.http_method_not_allowed
        # 执行handler加括号，传入了request
        # 本质是执行 get(request)
        return handler(request, *args, **kwargs)

from rest_framework.views import APIView
    class PublishView(APIView):
        def get(self, request):
            return JsonResponse({'code': 999})

 path('publish/', PublishView.as_view()),

@classmethod
    def as_view(cls, **initkwargs):
        # 调用父类的as_view得到返回值赋值给view---》django的View的as_view【看过】---》返回View的as_view的闭包函数 view
        view = super().as_view(**initkwargs)  # 现在这个view就是原来看的View的as_view的view
        # 去除了csrf认证----》局部禁用csrf---》在视图函数上加 装饰器csrf_exempt
        # 加了装饰器的本质：    被装饰的函数=装饰器(被装饰的函数)
        return csrf_exempt(view)
    
    
    -PublishView.as_view()(request)--》执行了禁用掉csrf的View的as_view的view---》self.dispath--->APIView的dispath
     def dispatch(self, request, *args, **kwargs):
        # 1 包装了新的request对象
        request = self.initialize_request(request, *args, **kwargs)
        # 把新的request，赋值给了 self.request
        # self 是 PublishView的对象 
        self.request = request
        try:
            # 2 执行了3大认证
            self.initial(request, *args, **kwargs)
            
            ######开始### 跟之前View的dispath是一样的---》根据请求方式执行类中同名方法
            ###执行视图类的方法
            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

            response = handler(request, *args, **kwargs)
            ######结束###
            
            
        # 执行三大认证和视图类的方法，如果出了异常，抛了错，会被捕获，统一处理
        except Exception as exc:
            response = self.handle_exception(exc)

        self.response = self.finalize_response(request, response, *args, **kwargs)
        return self.response

urlpatterns = [
    path('users/', UserView.as_view()),
    path('users/<int:pk>', UserDetailView.as_view()),
]

from .models import User
from .serializer import UserSerializer
from rest_framework.response import Response
class UserView(APIView):
    def get(self,request):
        users=User.objects.all()
        # 之前用for循环，现在用序列化类
        # 传了两个参数：instance 要序列化的对象(qs，单个对象)   many=True表示序列化多条，如果不写就是序列化一条
        ser=UserSerializer(instance=users,many=True)
        # 拿到序列化后的数据  ser.data--->多条就是列表  单条字典
        return Response(ser.data)

class UserDetailView(APIView):
    def get(self,request,pk):
        user=User.objects.all().filter(pk=pk).first()
        # 传了两个参数：instance 要序列化的对象   many=True表示序列化多条
        ser=UserSerializer(instance=user)
        return Response(ser.data)

# 写序列化类
from rest_framework import serializers


class UserSerializer(serializers.Serializer):
    # 写要序列化的字段
    name = serializers.CharField()
    # hobby = serializers.CharField()
    # password=serializers.CharField()
    age=serializers.IntegerField()

ser.save()---》必须序列化类中重写 create--》自己定保存到哪个表
　　def create(self, validated_data): # validated_data:前端传入，校验过后的数据
　　　　user = User.objects.create(**validated_data)
　　　　return user

from .models import User
from .serializer import UserSerializer
from rest_framework.response import Response


class UserView(APIView):
    def get(self, request):
        users = User.objects.all()
        # 之前用for循环，现在用序列化类
        # 传了两个参数：instance 要序列化的对象(qs，单个对象)   many=True表示序列化多条，如果不写就是序列化一条
        ser = UserSerializer(instance=users, many=True)
        # 拿到序列化后的数据  ser.data--->多条就是列表  单条字典
        return Response(ser.data)

    def post(self, request):
        # 前端提交过来的数据 request.data
        ser = UserSerializer(data=request.data)
        # 校验数据--》3层： 1 字段自己的校验规则(字段类的属性上)  2 局部钩子(给某个字段加校验规则)  3 全局钩子
        if ser.is_valid():
            # 保存
            ser.save()  # 会报错，序列化类中重写create方法

            return Response({'code': 100, 'msg': '保存成功'})
        else:  # ser.errors 校验失败错误的数据
            return Response({'code': 101, 'msg': ser.errors})


class UserDetailView(APIView):
    def get(self, request, pk):
        user = User.objects.all().filter(pk=pk).first()
        # 传了两个参数：instance 要序列化的对象   many=True表示序列化多条
        ser = UserSerializer(instance=user)
        return Response(ser.data

# 写序列化类
from rest_framework import serializers
from rest_framework.exceptions import ValidationError
from .models import User


class UserSerializer(serializers.Serializer):
    # 写要序列化的字段
    # 字段自己
    name = serializers.CharField(max_length=8, min_length=3, required=True)
    hobby = serializers.CharField()
    password = serializers.CharField()
    age = serializers.IntegerField()

    # 局部钩子
    # 写一个方法  validate_字段名，传入要校验的数据--》前端传入的
    def validate_name(self, value):
        if value.startswith('sb'):
            raise ValidationError('不能以sb开头')  # 如果校验失败，抛ValidationError
        return value  # 如果校验通过，返回 value，后续继续用

    # 全局钩子
    # 名字和hobby不能一致   多个字段的同时校验
    def validate(self, attrs):  # 前端传入的所有数据，校验过后attrs 字典
        name = attrs.get('name')
        hobby = attrs.get('hobby')
        if name == hobby:
            raise ValidationError('名字和爱好不能一样')
        else:
            return attrs

    # 重写create方法
    def create(self, validated_data):  # validated_data:前端传入，校验过后的数据
        user = User.objects.create(**validated_data)
        return user

urlpatterns = [
    path('users/', UserView.as_view()),
    path('users/<int:pk>', UserDetailView.as_view()),
]