• 序列化类常用字段类和字段参数

常用字段类型：

选项参数：

通用参数：

补充：

read_only	表明该字段仅用于序列化输出，默认False,如果设置成True，postman中可以看到该字段，修改时，不需要传该字段
write_only	表明该字段仅用于反序列化输入，默认False，如果设置成True，postman中看不到该字段，修改时，该字段需要传

• 序列化类高级用法之source，修改序列化字段名字

# source的使用
	不使用source参数时，会默认  序列化表名.字段名
    	使用source参数时，序列化表名.source的参数  下方以Book表为例
class BookSerializer(serializers.Serializer):
    name_detail = serializers.CharField(max_length=8, min_length=3,source='name')  # 可以改字段名字
    # 或
    publish_name = serializers.CharField(max_length=8, min_length=3,source='publish.name') # 可以.跨表查
    # 或
    xx = serializers.CharField(max_length=8, min_length=3,source='xx') # 可以执行方法

• 序列化类高级用法之定制序列化字段的两种方式

# 前端显示形式
{
        "name": "西游记",
        "price": 33,
        "publish": {name:xx,city:xxx,email:sss}
}

# 第一种：在【序列化类】中写SerializerMethodField
    publish = serializers.SerializerMethodField()
    def get_publish(self, obj):
        # obj 是当前序列化的对象
        return {'name': obj.publish.name, 'city': obj.publish.city, 'email': obj.publish.email}
# 第二种：在【表模型】中写方法（又多一些）  
    def publish_detail(self):
        return {'name': self.publish.name, 'city': self.publish.city, 'email': self.publish.email}
    在序列化中取
    publish_detail=serializers.DictField()

方式一：使用SerializerMethodField

class BookSerializer(serializers.Serializer):
    name = serializers.CharField(max_length=8, min_length=3)
    price = serializers.IntegerField(min_value=10, max_value=99)
    publish_date = serializers.DateField()
    # publish要序列化成 {name:北京出版社，city：北京，email:[email protected]}
    # 方式一：SerializerMethodField必须配合一个方法(get_字段名,需要接受一个参数)，方法返回什么，这个字段就是什么
    publish = serializers.SerializerMethodField()
    def get_publish(self, obj):
        # obj 是当前序列化的对象
        return {'name': obj.publish.name, 'city': obj.publish.city, 'email': obj.publish.email}

    # 练习，用方式一，显示所有作者对象  []
    authors = serializers.SerializerMethodField()
    def get_authors(self, obj):
        res_list = []
        for author in obj.authors.all():
            res_list.append({'id': author.id, 'name': author.name, 'age': author.age})
        return res_list

方式二：在表模型中写

# 表模型中
class Book(models.Model):
    name = models.CharField(max_length=32)
    price = models.DecimalField(max_digits=5, decimal_places=2)
    publish_date = models.DateField(null=True)

    publish = models.ForeignKey(to='Publish', on_delete=models.CASCADE)
    authors = models.ManyToManyField(to='Author')

    # 写了个方法，可以包装成数据属性，也可以不包
    def publish_detail(self):
        return {'name': self.publish.name, 'city': self.publish.city, 'email': self.publish.email}

    def author_list(self):
        res_list = []
        for author in self.authors.all():
            res_list.append({'id': author.id, 'name': author.name, 'age': author.age})
        return res_list

有关联关系表的反序列化的保存

# 1 序列化字段和反序列化字段不一样  【序列化类中】
	# 反序列化用的
    publish = serializers.CharField(write_only=True)
    authors = serializers.ListField(write_only=True)
	#序列化用的
    publish_detail = serializers.DictField(read_only=True)
    author_list = serializers.ListField(read_only=True)
    
# 2 一定要重写create  【序列化类中】
	    def create(self, validated_data): 
            # validated_data 校验过后的数据  
              {"name":"三国1演义",
                "price":19,
                "publish_date": "2022-09-27",
                "publish":1,
                "authors":[1,2]
                }
            book = Book.objects.create(name=validated_data.get('name'),
                                       price=validated_data.get('price'),
                                       publish_date=validated_data.get('publish_date'),
                                       publish_id=validated_data.get('publish'),
                                       )
            authors = validated_data.get('authors')
            book.authors.add(*authors)
            return book

• 反序列化之数据校验

# 跟forms很像
	-字段自己的校验规则
    -局部钩子
    -全局钩子
    
    
# 字段自己的校验规则
	-如果继承的是Serializer，写法如下
    	name=serializers.CharField(max_length=8,min_length=3,error_messages={'min_length': "太短了"})
    -如果继承的是ModelSerializer，写法如下
       extra_kwargs = {
            'name': {'max_length': 8, 'min_length': 3, 'error_messages': {'min_length': "太短了"}},
        }
        
        
# 局部钩子
    -如果继承的是Serializer，写法一样
    -如果继承的是ModelSerializer，写法一样
	def validate_name(self, name):
        if name.startswith('sb'):
            # 校验不通过，抛异常
            raise ValidationError('不能以sb卡头')
        else:
            return name

        
# 全局钩子
	-如果继承的是Serializer，写法一样
    -如果继承的是ModelSerializer，写法一样
	def validate(self, attrs):
        if attrs.get('name') == attrs.get('publish_date'):
            raise ValidationError('名字不能等于日期')
        else:
            return attrs

• 模型类序列化器(ModelSerializer)的使用

class BookModelSerializer(serializers.ModelSerializer): #ModelSerializer继承Serializer
    # 不需要写字段了，字段从表模型映射过来
    class Meta:
        model = Book  # 要序列化的表模型
        # fields='__all__' # 所有字段都序列化
        fields = ['name', 'price', 'publish_date', 'publish', 'authors', 'publish_detail',
                  'author_list']  # 列表中有什么，就是序列化哪个字段
        # 给authors和publish加write_only属性
        # name加max_len属性
        extra_kwargs = {
            'name': {'max_length': 8},
            'publish': {'write_only': True},
            'authors': {'write_only': True},
        }

总结

#  如何使用
	1 定义一个类继承ModelSerializer
    2 类内部写内部内 class Meta:
    3 在内部类中指定model(要序列化的表)
    4 在内部类中指定fields(要序列化的字段，写__all__表示所有，不包含方法，写[一个个字段])
    5 在内部类中指定extra_kwargs，给字段添加字段参数的
    6 在序列化类中，可以重写某个字段，优先使用你重写的
        name = serializers.SerializerMethodField()
    	def get_name(self, obj):
        	return 'sb---' + obj.name
 
    7 以后不需要重写create和update了
    	-ModelSerializer写好了，兼容性更好，任意表都可以直接存

• 反序列化数据校验源码分析(了解)

# 先校验字段自己的规则(最大，最小)，走局部钩子校验，走全局钩子
# 局部：validate_name，全局叫：validate 为什么？
入口：从哪开始看，哪个操作，执行了字段校验ser.is_valid()
-BaseSerializer内的is_valid()方法
    def is_valid(self, *, raise_exception=False):
        if not hasattr(self, '_validated_data'):
            try:
                # 真正的走校验，如果成功，返回校验过后的数据
                self._validated_data = self.run_validation(self.initial_data)
            except ValidationError as exc:
        return not bool(self._errors)

-内部执行了：self.run_validation(self.initial_data)---》本质执行的Serializer的
	-如果你按住ctrl键，鼠标点击，会从当前类中找run_validation，找不到会去父类找
	-这不是代码的执行，代码执行要从头开始找，从自己身上再往上找
	    def run_validation(self, data=empty):
            #局部钩子的执行
            value = self.to_internal_value(data)
            try:
                # 全局钩子的执行，从根上开始找着执行，优先执行自己定义的序列化类中得全局钩子
                value = self.validate(value)
            except (ValidationError, DjangoValidationError) as exc:
                raise ValidationError(detail=as_serializer_error(exc))

            return value

-全局钩子看完了，局部钩子---》 self.to_internal_value---》从根上找----》本质执行的Serializer的

def to_internal_value(self, data):

for field in fields: # fields：序列化类中所有的字段，for循环每次取一个字段对象

# 反射：去self：序列化类的对象中，反射 validate_字段名 的方法

validate_method = getattr(self, 'validate_' + field.field_name, None)

try:

# 这句话是字段自己的校验规则（最大最小长度）

validated_value = field.run_validation(primitive_value)

# 局部钩子

if validate_method is not None:

validated_value = validate_method(validated_value)

except ValidationError as exc:

errors[field.field_name] = exc.detail
    return ret

你自己写的序列化类---》继承了ModelSerializer---》继承了Serializer---》BaseSerializer---》Field