【一】序列化常见字段

​ 序列化类中有很多多字段，如CharField IntegerField,他们会跟models里面的字段一一对应，除了这些，序列化类还多出了两个字段ListField和DictField，非常重要

【二】序列化字段的常见参数

​ 字段类的括号里面可以填很多参数，他们的作用是用来作反序列化保存校验的，如max_length等等

通用字段参数

1. required 表明该字段在反序列化时必须输入，默认True
2. default 反序列化时使用的默认值
3. allow_null 表明该字段是否允许传入None，默认False
4. validators 该字段使用的验证器--》字段自己的校验[1 max_lenght 2 validators ]，局部钩子，全局钩子
   name=serializer.CharField(validators=[valida_name])
5. error_messages 包含错误编号与错误信息的字典
6. label 用于HTML展示API页面时，显示的字段名称
7. help_text 用于HTML展示API页面时，显示的字段帮助提示信息

十分重要的参数

1. read_only 表明该字段仅用于序列化输出，默认False
2. write_only 表明该字段仅用于反序列化输入，默认False

CharField

1. max_length 最大长度
2. min_lenght 最小长度
3. allow_blank 是否允许为空
4. trim_whitespace 是否截断空白字符

IntegerField

1. max_value 最小值
2. min_value 最大值

django翻译补充

​ django有自带的翻译函数，前提是要在配置文件中做好国际化

# 翻译函数---》做好国际化
from django.utils.translation import gettext_lazy as _
def index(request):
    res=_('Not a valid string')
    print(res)
    return HttpResponse(res)

【三】多表关联序列化和反序列化

【1】定制返回格式之source

定制返回字段名

# 定制返回字段名，就是可以自定义前端的字段，比如原本是model中是name的字段，可以把他在前端显示成author_name,source的值必须是model表中的字段名
book_name = serializers.CharField(source='name')

可以跨表查询

# 比如此时我需要让前端显示出版社的名称，而不是原本的id，
publish_name = serializers.CharField(source='publish.name')

所有字段都可以转换成CharField

# 所有的字段都可以转换成CharField，但是最好还是用对应的字段，以符合规范

【2】定制返回字段

​ 问题：当后期想要实现如下格式返回的数据{name:书名,price:价格,publish:{name:出版社名,addr:地址},authors:[{},{}]}

方法1 表模型定义方法

​ 在表模型中定义方法，在序列化类中以该方法名作为字段名,需要用到ListField和DictField

models.py

class Book(models.Model):
    title = models.CharField(max_length=15)
    price = models.DecimalField(decimal_places=2, max_digits=5)
    publish_time = models.TimeField(auto_now_add=True)
    publish = models.ForeignKey(to='Publish', on_delete=models.CASCADE)
    authors = models.ManyToManyField(to='Author')

    def publish_detail(self):
        return {
            'name': self.publish.name,
            'addr': self.publish.addr
        }

    def author_list(self):
        li = []
        for author in self.authors.all():
            data = {
                'name': author.name,
                'phone': author.phone,
                'email': author.email
            }
            li.append(data)
        return li

serialize.py

class BookSerializer(serializers.Serializer):
    name = serializers.CharField()
    price = serializers.DecimalField(max_digits=5, decimal_places=2)
    publish_date = serializers.DateField()
    # 出版社对象
    # publish = serializers.CharField()  # 如果这样写，会把publish对象，打印的样子返回给前端
    publish_detail = serializers.DictField() 

    # 所有作者
    authors_list = serializers.ListField()  

方法2SerializerMethodField

​ 通过SerializerMethodField，看这个名字就知道，是需要通过序列化组件里的方法来定义，也就是在序列化组件里面重写某个方法，这个方法是get_字段名

class BookSerializer(serializers.Serializer):
    book_name = serializers.SerializerMethodField()
    def get_book_name(self,obj):
        return obj.name+'ssssb'
    price = serializers.DecimalField(max_digits=5, decimal_places=2)
    publish_date = serializers.DateField()
    # 一定要配合一个方法--》get_字段名
    publish_detail = serializers.SerializerMethodField()
    def get_publish_detail(self,obj):
        # obj 就是当前序列化到的book对象
        return {'name':obj.publish.name,'city':obj.publish.city,'id':obj.pk}

    authors_list = serializers.SerializerMethodField()
    def get_authors_list(self,obj):
        l=[]
        for author in obj.authors.all():
            l.append({'name':author.name,'age':author.age,'id':author.id})
        return l

方法3 子序列化

​ 子序列化就是通过 重新写一个序列化类，在这个类中自定义想要的样式

class PublishSerializer(serializers.Serializer):
    id = serializers.IntegerField()
    name = serializers.CharField()
    city = serializers.CharField()
    email = serializers.EmailField()


class AuthorSerializer(serializers.Serializer):
    id = serializers.IntegerField()
    name = serializers.CharField()
    age = serializers.CharField()


class BookSerializer(serializers.Serializer):
    name = serializers.CharField()
    price = serializers.DecimalField(max_digits=5, decimal_places=2)
    publish_date = serializers.DateField()
    # 子序列化
    publish_detail = PublishSerializer(source='publish')

    # 多条 many=True
    authors_list = AuthorSerializer(source='authors',many=True)

【四】反序列化保存

​ 在做反序列化保存时就有一个问题了，因为前面我们自定义的样式的字段publish_detail和authors_list都只是用来序列化输出的，并不想将这两个字段也保存，这就犯难了，难道我们需要重新写一个序列化类单独用作反序列化保存吗？

​ 当然是不需要的，drf提供了两个字段参数，分别是write_only,read_only

​ 在 Django REST Framework (DRF) 的序列化器中，read_only 和 write_only 是两个常用的参数，用于控制字段在序列化和反序列化过程中的行为。

read_only

​ 当一个字段设置了read_only=True时，该字段仅在序列化时可见，在反序列化操作（更新，添加）时会被自动忽略

write_only

​ 反之，当一个字段设置了write_only=True时，该字段只在反序列化（更新，添加）等操作可见

class BookSerializer(serializers.Serializer):
    name = serializers.CharField()
    price = serializers.DecimalField(max_digits=5, decimal_places=2)
    publish_date = serializers.DateField(required=False,default=datetime.now)
    #### 序列化的字段和反序列化字段不一致####
    ## 1 笨办法：再写个序列化类，单独用来反序列化
    ## 2 通过 read_only write_only	控制

    # 这个字段用来做序列化
    publish_detail = PublishSerializer(source='publish',read_only=True)
    # 这个字段用来做序列化
    authors_list = AuthorSerializer(source='authors', many=True,read_only=True)

    # 反序列化字段--》只用来保存---》多表关联
    publish=serializers.IntegerField(write_only=True) # 前端传入数字---》自动跟出版社id做对应
    authors=serializers.ListField(write_only=True)

    # 反序列化字段-->可以随意命名，跟表字段没关系--》但是后续保存和修改要对应好才行
    # publish_id=serializers.IntegerField(write_only=True) # 前端传入数字---》自动跟出版社id做对应
    # authors_xx=serializers.ListField(write_only=True)
    # 保存
    def create(self, validated_data):
        publish_id=validated_data.pop('publish')
        authors=validated_data.pop('authors')
        book=Book.objects.create(**validated_data,publish_id=publish_id)
        book.authors.add(*authors) # 向中间表中插入数据
        return book

    # 更新
    def update(self, instance, validated_data):
        publish_id=validated_data.pop('publish')
        authors=validated_data.pop('authors')
        book_qs=Book.objects.filter(pk=instance) # 查询qs对象
        book_qs.update(**validated_data,publish_id=publish_id) # 使用qs更新
        instance=book_qs.first() # 单个对象
        instance.authors.set(authors) # 向中间表中插入数据
        # instance.author.clear()
        # instance.authors.add(*authors)
        return instance

【五】ModelSerializer使用

​ ModelSerializer 是 Django REST Framework（DRF）提供的一个强大工具，用于简化与 Django 模型相关的序列化器的编写。它自动为您创建序列化器，并根据模型的字段自动生成字段。以下是 ModelSerializer 的主要特点和用法：

​ 在之前没有使用ModelSerializer时，我们都没有显示指定跟哪个模型表一一对应，而用了ModelSerializer之后就必须要和某一张模型表做对应。

​ 在书写校验钩子函数的时候和以前一样写就行

from .models import Book
class BookSerializer(serializers.ModelSerializer):
    class Meta:
        model=Book
        fields='__all__'
        # fields=['id','name','publish_detail','authors_list']

        extra_kwargs={
            'name':{'max_length':8}, # 限制name不能超过8
            'publish':{'write_only':True},
            'authors':{'write_only':True},
        }

    # 自己再重写的字段
    # 这个字段用来做序列化
    publish_detail = PublishSerializer(source='publish',read_only=True)
    # 这个字段用来做序列化
    authors_list = AuthorSerializer(source='authors', many=True,read_only=True)

    # 不需要写create了，但是字段必须是：publish和authors