反序列化之Serializers，ModelSerializers

 Sourse

可以指定字段（name   publish.name），可以指定方法

但是不能name和source指定的name不能重名

还可以用source出版社地址，

还可以指定一个方法

如果需要拿中文

get_字段名_display

models.py定义一个字段

 xx=models.IntegerField(choices=((0,'文学类'),(1,'情感类')),default=1,null=True)

rest-framework序列化之Serializer

这里要穿两个参数

返回作者信息

还可以再用个序列化的类

返回结果都是一样的

write_only

write_only序列化的时候，该字段不显示，后端序列化到前端不显示

read_only

反序列化的时候，该字段不传，本表字段必须要加read_only=True  就是前段传给后端可以不传，

把数据反序列化保存起来

instance是序列化的对象，data是反序列化的字典

重写create方法，实现序列化

在序列化类当中

如果不写的话调父类的，直接进入父类的create人家什么都不写直接抛异常，必须要你重写create，

会把校验通过的数据传过来，然后再return

    def create(self, validated_data):
        ret = models.Book.objects.create(**validated_data)
        return ret

使用继承了Serializers序列化类的对象，反序列化

ef post(self,request):
     #实例化产生一个类的对象
    bookser = BookSerializer(data=request.data)
    if bookser.is_valid():
        # 清洗通过的数据
        ret = bookser.create(bookser.validated_data)
    return Response()

用postman新增数据

rest-framework序列化之ModelSerializer

 指定了表模型，使用serializer需要些好多字段，就要使用ModelSerializer，跟表模型对应上

fileds=('nid','name') 指定序列化某几个字段

这样写也麻烦就用到depth,可以拿到所有字段的所有详情，没有办法控制它，必须要重写

官方建议，不要超过10，个人建议不要超过3

使用继承了ModelSerializers序列化类的对象，反序列化新增数据

反序列化校验（局部校验，全局校验）

 

 总结

序列化组件
        -使用drf的序列化组件
            -1 新建一个序列化类继承Serializer
            -2 在类中写要序列化的字段
            
        -在视图中使用序列化的类
            -1 实例化序列化的类产生对象,在产生对象的时候，传入需要序列化的对象（queryset）
            -2 对象.data
            -3 return Response(对象.data)
        -高级用法：
            -source：可以指定字段（name   publish.name），可以指定方法，
            -SerializerMethodField搭配方法使用（get_字段名字）
                publish_detail=serializers.SerializerMethodField(read_only=True)
                def get_publish_detail(self,obj):
                    return {'name':obj.publish.name,'city':obj.publish.city}
            -read_only:反序列化时，不传
            -write_only：序列化时，不显示
            
            
    -序列化的两种方式
        -Serializers:没有指定表模型
            -source：指定要序列化哪个字段，可以是字段，可以是方法
            - SerializerMethodField的用法
                authors=serializers.SerializerMethodField()
                def get_authors(self,obj):
                     ret=AuthorSerializer(instance=obj.authors.all(),many=True)
                     return ret.data
            
        -ModelSerializers：指定了表模型
            class Meta:
                model=表模型
                #要显示的字段
                fields=('__all__')
                fields=('id','name')
                #要排除的字段
                exclude=('name')
                #深度控制
                depth=1
            -重写某个字段
                在Meta外部，重写某些字段，方式同Serializers
    -反序列化
        -使用继承了Serializers序列化类的对象，反序列化
            -在自己写的序列化类中重写create方法
            -重写create方法，实现序列化
                -在序列化类中：
                    def create(self, validated_data):
                        ret=models.Book.objects.create(**validated_data)
                        return ret
                -在视图中：
                    def post(self,request):
                        bookser=BookSerializer(data=request.data)
                        if bookser.is_valid():
                            ret=bookser.create(bookser.validated_data)
                        return Response()
            
        -使用继承了ModelSerializers序列化类的对象，反序列化
            -在视图中：
                def post(self,request):
                    bookser=BookSerializer(data=request.data)
                    if bookser.is_valid():
                        ret=bookser.save()
                    return Response()
            
    -反序列化的校验
        -validate_字段名(self,value):
            -如果校验失败，抛出ValidationError（抛出的异常信息需要去bookser.errors中取）
            -如果校验通过直接return value
        -validate(self,attrs)
            -attrs所有校验通过的数据，是个字典
            -如果校验失败，抛出ValidationError
            -如果校验通过直接return attrs
            
    -读一读源码
        -全局和局部钩子源码部分
        -在序列化的时候，传many=True和many=False,生成的对象并不是一个对象
        -bookser.data
            -之前执行过，直接返回
            -get_attribute(instance, self.source_attrs)
                -self.source_attrs 是source指定的通过 . 切分后的列表
                -instance 当前循环到的book对象