Django的web框架Django Rest_Framework精讲（二）

#全局钩子，多字段同时校验
# 方法名时固定的,用于验证多个字段,参数就是实例化序列化器类时的data参数
# 先通过data将数据取出来，data就是request.data用户提交上来的字典类型数据  OrderedDict
def validate(self, data):
    #将各个字段先取出来
    age = data.get('age')
    description = data.get('description')
    # if not age >= 18 or "天河" in description:
    #     raise serializers.ValidationError('年龄必须大于等于18岁 或者 个性签名不能包含天河')

    if not age >= 18:
        raise serializers.ValidationError('年龄必须大于等于18岁')
    if '天河' in description:
        raise serializers.ValidationError('个性签名不能包含天河')
    return data

is_valid()方法还可以在验证失败时抛出异常serializers.ValidationError，可以通过传递**raise_exception=True**参数开启，REST framework接收到此异常，会向前端返回HTTP 400 Bad Request响应。
# Return a 400 response if the data was invalid.
serializer.is_valid(raise_exception=True)

        #保存数据，方式1 直接调用模型类对象进行保存
        models.Student.objects.create(
            **serializer_obj.validated_data
        )

#定义一个create方法，方法名固定写法，是调用了父类的create方法
def create(self, validated_data):
    #此时的validated_data 就是校验成功后的序列化器对象的validated_data
    #在方法里面调用模型类对象
    student = models.Student.objects.create(**validated_data)
    #将模型类对象返回
    return student

# 更新学生的部分字段信息，当数据库允许为空，但是序列化器要求必须字段填写的时候，可以使用以下方式避开
serializer = StudentSerializer(instance=instance, data=data, partial=True)

视图类 先定义个put函数，用来接收put请求，更新数据

    #后台写个put方法，来定义更新逻辑
    def put(self,request):
        #默认序列化器必须传递所有required的字段，否则会抛出验证异常。但是我们可以使用partial参数来允许部分字段更新
        serializer_obj = StudentSerializer3(data=request.data, partial=True)
        if serializer_obj.is_valid():
            print('校验成功的数据',serializer_obj.validated_data)
            #序列化器中id设置了read_only=True 反序列化就不校验id, 所以校验成功的值validated_data中不包含id    只有通过校验的数据，才放到validated_data
            # user_id = serializer_obj.validated_data.get('id')
            #通过request.data用户提交的数据中拿到
            user_id = request.data.get('id')
            print('id',user_id)
            obj = models.Student.objects.filter(id=user_id)
            obj.update(**serializer_obj.validated_data)
            new_obj = obj.first()
            obj = StudentSerializer3(instance=new_obj)
            return JsonResponse(obj.data,safe=False, json_dumps_params={'ensure_ascii': False})
        else:
            #打印校验失败信息
            print(serializer_obj.errors)
            #校验失败，返回错误信息，并修改状态码
            return JsonResponse({'error':'校验失败'},status=400)

序列化器类中定义update方法
    #更新方法2，通过save方法更新
    def update(self, instance, validated_data):
        # instance表示当前更新的记录对象,validated_data是用户提交数据验证成功后的字典类型数据
        #根据用户传递的id拿到模型类对象已经传递进来
        print('旧的instance',instance)
        print('验证后的数据',validated_data)
        #通过模型类对象更新数据
        instance.name = validated_data.get('name')
        #这个是orm通过模型类对象保存数据的方法
        instance.save()
        #此时返回的就是更新后的instance
        return instance

#后台写个put方法，来定义更新逻辑
def put(self,request):
    #默认序列化器必须传递所有required的字段，否则会抛出验证异常。但是我们可以使用partial参数来允许部分字段更新
    #更新方式1
    # serializer_obj = StudentSerializer3(data=request.data, partial=True)

    #更新方式2
    #先根据提交id将用户模型类对象拿出来
    obj = models.Student.objects.filter(id=request.data.get('id')).first()
    #将模型类对象作为参数传给序列化器,   instance的值是模型类对象
    serializer_obj = StudentSerializer3(data=request.data, partial=True, instance=obj)

    if serializer_obj.is_valid():
        print('校验成功的数据',serializer_obj.validated_data)

        #更新数据方式1:
        #序列化器中id设置了read_only=True 反序列化校验成功的值中不包含id
        # user_id = serializer_obj.validated_data.get('id')
        #通过request.data用户提交的数据中拿到
        # user_id = request.data.get('id')
        # print('id',user_id)
        # obj = models.Student.objects.filter(id=user_id)
        # obj.update(**serializer_obj.validated_data)
        # new_obj = obj.first()
        # obj = StudentSerializer3(instance=new_obj)


        #更新数据方式2:
        #因为实例化序列化器对象时，传递了instance对象，所以此时执行save方法，调用的是序列化类中的update方法
        #如果不传递instance模型类对象，执行save方法，调用的就是序列化类中的create方法
        obj = serializer_obj.save()
        new_obj = StudentSerializer3(instance=obj)

        return JsonResponse(new_obj.data,safe=False, json_dumps_params={'ensure_ascii': False})
    else:
        #打印校验失败信息
        print(serializer_obj.errors)
        #校验失败，返回错误信息，并修改状态码
        return JsonResponse({'error':'校验失败'},status=400)

from rest_framework.serializers import ModelSerializer

#还是用ser中的模型类
from ser import models

class StudentModelSerializer(ModelSerializer):
    #ModelSerializer根据Meta中model定义的字段，自动地将模型类中的字段转化成序列化器中的字段
    class Meta:
        model = models.Student
        #fields定义需要序列化，反序列化模型类中的字段，__all__表示所有字段都序列化和反序列化
        # fields = '__all__'
        #fields字段还可以指定序列化指定字段，用列表或元祖包裹
        fields = ['name','age']

read_only_fields
可以通过read_only_fields指明只读字段，即仅用于序列化输出的字段
write_only_fields。仅用于反序列化校验
这俩很少用，通过extra_kwargs更方便一些
class StudentModelSerializer(serializers.ModelSerializer):
    """学生数据序列化器"""
    class Meta:
        model = Student
        fields = ['id', 'age', 'name',"description"]
        read_only_fields = ('id',)
        #write_only_fields = ('sex',)


添加额外参数
extra_kwargs
我们可以使用extra_kwargs参数为ModelSerializer添加或修改原有的选项参数
 额外字段声明,必须在fields里面也要声明上去,否则序列化器不会调用
extra_kwargs 用字典包裹
from rest_framework import serializers
from students.models import Student
class StudentModelSerializer(serializers.ModelSerializer):
    # 额外字段声明,必须在fields里面也要声明上去,否则序列化器不会调用
    # password2 = serializers.CharField(write_only=True,required=True)

    # 如果模型类序列化器,必须声明本次调用是哪个模型,模型里面的哪些字段
    class Meta:
        model = Student
        # fields = ["id","name","age","description","sex","password2"]
        fields = ["id","name","age","description","sex"]
        # fields = "__all__" # 表示操作模型中的所有字段
        # 添加额外的验证选项，比如额外的字段验证
        extra_kwargs = {
            "sex":{"write_only":True,},
            "id":{"read_only":True,}
        }

def create(self, validated_data):
    print(validated_data)
    validated_data.pop('password')
    print('提出后的数据',validated_data)
    #调用父类create方法保存
    instance = super().create(validated_data)

    return instance

def post(self,request):
    data = request.data
    ser_obj = StudentModelSerializer(data=data)
    if ser_obj.is_valid():
        # obj = models.Student.objects.create(**ser_obj.validated_data)
        #ModelSerializer自动创建了create，update方法，不用自己再创建。可以直接调用
        obj = ser_obj.save()
        # obj = ser_obj.validated_data
        print('校验成功后的数据==》',obj)
        new_obj = StudentModelSerializer(instance=obj)
        print('序列化之后的数据',new_obj.data)
        return JsonResponse(new_obj.data,safe=False,json_dumps_params={'ensure_ascii':False})
    else:
        #打印校验失败信息
        print(ser_obj.errors)
        #校验失败，返回错误信息，并修改状态码
        return JsonResponse({'error':'校验失败'},status=400)

def post(self,request):
    data = request.data
    ser_obj = StudentModelSerializer(data=data)
    if ser_obj.is_valid():
        # obj = models.Student.objects.create(**ser_obj.validated_data)
        #ModelSerializer封装了create，update方法，不用自己再创建。可以直接调用。找到序列化器中的Meta中model指向的模型类，并将校验后的数据保存进去
        obj = ser_obj.save()
        new_obj = StudentModelSerializer(instance=obj)
        return JsonResponse(new_obj.data,safe=False,json_dumps_params={'ensure_ascii':False})
    else:
        #打印校验失败信息
        print(ser_obj.errors)
        #校验失败，返回错误信息，并修改状态码
        return JsonResponse({'error':'校验失败'},status=400)