2.drf- serializers (序列化器)

作用：

发送出去 要序列化 把python的对象转换为字符串

接受数据 要反序列化，把字符串转为python能操作的对象

from rest_framework import serializers

序列化基础使用：

1.字段声明

class Student1Serializer(serializers.Serializer):
  # 1.要转换的数据声明
    id=serializers.IntegerField()
    name=serializers.CharField()
    sex=serializers.BooleanField()
    age=serializers.IntegerField()
    description=serializers.CharField()

2.编写视图函数

class StundentView(View):
    def get(self,request):
        #1.获取数据库中的数据集
        student_list=Stundet.objects.all()
        #2.实例化序列化器，得到序列化对象
        serializer=Student1Serializer(instance=student_list,many=True) #设置many=True，表示要序列化多个对象
        #3.调用序列化对象属性方法获得转换后的数据
        data=serializer.data

        #4.返回json响应数据
        return JsonResponse(data=data,status=200,safe=False)

3.添加路由

urlpatterns = [
path('student1/',views.StundentView.as_view())
]

#序列化器学习1

结果

.assets/image-20220921182222128.png)

实例化serializer对象说明

.assets/image-20220921183325062.png)

反序列化基础使用：

1.字段声明

class Student2Serializer(serializers.Serializer):
  # 1.要转换的数据声明
    id=serializers.IntegerField(read_only=True) #只在序列化时提交数据 反序列化不提交
    name=serializers.CharField(required=True)#反序列化提交时必填
    sex=serializers.BooleanField(default=True) #反序列化时，客户没提交就用默认值
    age=serializers.IntegerField(max_value=120 ,min_value=0,error_messages={'min_value':"超过最小值"}) #反序列化提交时设置最大值最小值
    description=serializers.CharField(allow_null=True,allow_blank=True)#提交时允许为空

2.自定义验证数据

(写在serializers.py)

1.验证来自客户端的所有数据

def validate(self, attrs):
    #验证来自客户端的所有数据,attrs是序列化器实例化时，传递的data选项数据
    if attrs.get('name')=='lly' and not attrs.get('sex'):
        raise serializers.ValidationError(detail='女性罗某不能入内', code='validate')
    return attrs

2.验证单个字段

def validate_name(self,data):
    #验证单个字段 方法名的格式必须是 validate_<字段名> 
    if data in ['python','django']:
      raise serializers.ValidationError(detail='学生名不能是python或django',code='validate_name')
    return data

3.validators 外部验证函数选项

 def check_classment(data):
    #外部验证函数
    if len(data) !=3:
        raise serializers.ValidationError(detail='班级格式不正确！',code=check_classment)
    return data
    
classmeta=serializers.CharField(validators=[check_classment])# 调用外部验证函数check_classment

3.编写视图函数

反序列化-采用字段选项验证数据（验证失败不抛出异常）

    def get(self,request):
        # 反序列化-采用字段选项验证数据（验证失败不抛出异常）

        # 1.接收客户端提交的数据
        #data=json.dumps(request.body)
        # 模拟来自客户端的数据
        data={
            "name":'hyq',
            "age":12,
            "sex":True,
            "classmate":'301',
            "description":'这里没有dyd'
        }
        #1.1 实例化序列化器，获取序列化对象
        serializer=PersonSerializer(data=data)
        #1.2 调用序列化器进行数据验证
        ret=serializer.is_valid()#raise_exception=True 如果数据反序列化错误，抛出异常,不会继续向下进行
        #1.3 获取验证后的结果
        if ret:
            return JsonResponse(dict(serializer.validated_data))
        else:
            return JsonResponse(dict(serializer.errors))
        #2.操作数据库

        #3.返回数据
        #return JsonResponse({})

反序列化-采用字段选项验证数据（错误抛出异常，常用）

    def get(self, request):
        # 反序列化-采用字段选项验证数据（错误抛出异常，常用）
        # 1.接收客户端提交的数据
        # data=json.dumps(request.body)
        # 模拟来自客户端的数据
        data = {
            "id":2,
            "name": 'pytho1n',
            "age": 12,
            "sex": True,
            "classmeta": '301',
            "description": '这里没有dyd'
        }
        # 1.1 实例化序列化器，获取序列化对象
        serializer = PersonSerializer(data=data)
        # 1.2 调用序列化器进行数据验证
        serializer.is_valid(raise_exception=True)  # raise_exception=True 如果数据反序列化错误，抛出异常
        # 1.3 获取验证后的结果
        print(serializer.validated_data)

        # 2.操作数据库

        # 3.返回数据
        return JsonResponse(dict(serializer.validated_data))

更新与保存数据

（Serializers类中的create和update方法）

1.保存数据(create)

    def create(self, validated_data):
        # 向数据库添加数据操作 方法名固定为create，固定参数validated_data就是验证后的结果

        student = User.objects.create(**validated_data)
        return student

    def get(self, request):  # 反序列化完成后 添加数据入库
        # 1.接收客户端提交的数据
        # data=json.dumps(request.body)
        # 模拟来自客户端的数据
        data = {
            "name": '2lly',
            "age": 12,
            "sex": True,
            "classmeta": '301',
            "description": '这里没有dyd',
            "id": 102,
            "haha": "helo"
        }
        # 1.1 实例化序列化器，获取序列化对象
        serializer = PersonSerializer(data=data)
        # 1.2 调用序列化器进行数据验证
        serializer.is_valid(raise_exception=True)  # raise_exception=True 如果数据反序列化错误，抛出异常

        # 2.获取验证后的结果后，操作数据库
        serializer.save()
        '''
         会根据实例化序列化器时，是否传入instance属性来自动调用create或update方法
         传入instance属性，调用update，没传入instance属性，调用create
        '''
        # 3.返回数据
        return JsonResponse(dict(serializer.data))

2.提交数据(update)

    def update(self, instance, validated_data):
        # 更新数据操作，方法名固定为update 固定参数instance为实例化序列化器对象时，必须传入的模型对象 validated_data为验证成功后的结果
        # 更新数据后 自动实现从字典数据变成模型对象的过程
        instance.name = validated_data.get('name')
        instance.age = validated_data.get('age')
        instance.sex = validated_data.get('sex')
        instance.classmate = validated_data.get('classmate')
        instance.description = validated_data.get('description')
        instance.save()
        return instance

    def get(self,request): #反序列化完成后 更新数据入库
        #1.根据客户端访问的url地址获取pk值
      	# 模拟pk值
        pk=1
        try:
            student=User.objects.get(pk=pk)
        except User.DoesNotExist:
            return JsonResponse({"errors":'当前学生不存在'},status=400)
        # 2.接收客户端提交的数据
        #data=json.dumps(request.body)
        # 模拟来自客户端的数据
        data={
            "name":'2222ly',
            "age":77,
            "sex":True,
            "classmeta":'301',
            "description":'这里没有ggg',
            "haha":"helo"
        }
        #3 修改操作中的实例化序列化器
        serializer=PersonSerializer(instance=student,data=data)
        #4 数据验证
        serializer.is_valid(raise_exception=True)#raise_exception=True 如果数据反序列化错误，抛出异常

        #5.保存数据库
        serializer.save()
        '''        
         会根据实例化序列化器时，是否传入instance属性来自动调用create或update方法
         传入instance属性，调用update，没传入instance属性，调用create
        '''
        #6.返回数据
        return JsonResponse(dict(serializer.data))

ModelSerializer

class PersonModelSerializer(serializers.ModelSerializer):
    # 1.要转换的数据声明 如果是继承的ModelSeralizer，则需要声明调用的模型信息
    class Meta:
        model=User #必填
        fields="__all__" #必填
        read_only_fields=['id'] #选填 只读列表，只会在序列化阶段采用
        extra_kwargs={ #选填 字段额外声明
        "age":{
            "min_value":5,
            "max_value":120,
            "error_messages":{
                "min_value":'年龄最小值大于等于5',
                "max_value":'年龄最大值小于等于120'
            }
        },
        }

    '''
    2.数据验证方法
    '''
    def validate(self, attrs):
      # 验证来自客户端的所有数据,attrs是序列化器实例化时，传递的data选项数据
      if attrs.get('name') == 'lly' and not attrs.get('sex'):
        raise serializers.ValidationError(detail='女性罗某不能入内', code='validate')
      return attrs


    def validate_name(self, data):
      # 验证单个字段 方法名的格式必须是 validate_<字段名>
      if data in ['python', 'django']:
        raise serializers.ValidationError(detail='学生名不能是python或django', code='validate_name')
      return data

    '''
    3.模型操作方法
    '''
    def create(self, validated_data):
        # 向数据库添加数据操作 方法名固定为create，固定参数validated_data就是验证后的结果

        student = User.objects.create(**validated_data)
        return student

    def update(self, instance, validated_data):
        # 更新数据操作，方法名固定为update 固定参数instance为实例化序列化器对象时，必须传入的模型对象 validated_data为验证成功后的结果
        # 更新数据后 自动实现从字典数据变成模型对象的过程
        instance.name = validated_data.get('name')
        instance.age = validated_data.get('age')
        instance.sex = validated_data.get('sex')
        instance.classmate = validated_data.get('classmate')
        instance.description = validated_data.get('description')
        instance.save()
        return instance