DRF多表关联的序列化和反序列化

DRF多表关联的序列化和反序列化
- 序列化定制字段source
- - 一对多的序列化
- 多表关联的序列化
- - 方式1：在表模型中定义方法
  - 方式2：定制返回格式SerializerMethodField
  - 方式3：子序列化
- 多表关联的反序列化
- - 反序列化保存一对多关联字段
  - - create
    - update
  - 反序列化保存多对多关联字段
  - - create
  - 反序列化保存一对一关联字段
  - - create
    - update
- ModelSerializer类下的序列化和反序列化

序列化定制字段source

# models.py
class Book(models.Model):
    title = models.CharField(max_length=32, null=True)
    price = models.IntegerField(null=True)
    publish = models.ForeignKey(to='Publish', on_delete=models.CASCADE, null=True)
    author = models.ManyToManyField(to='Author', null=True)

# views.py
class book(APIView):
    def get(self, request):
        book_obj = models.Book.objects.all()
        serializer = BookSerializer(instance=book_obj, many=True)

# serializers.py
class BookSerializer(serializers.Serializer):
	book_name = serializers.CharField(source='title')

这是一个serializers的字段，当我要进行序列化时

book_name决定了该字段在前端显示的名字
source = 'title'决定了返回给前端的内容是表中的book表中的title字段属性
因此只要source指定了属性值，book_name可以随便改名

一对多的序列化

表中的publish字段

# models.py
class Book(models.Model):
	publish = models.ForeignKey(to='Publish', on_delete=models.CASCADE)
    
class Publish(models.Model):
    name = models.CharField(max_length=32, null=True)
    email = models.EmailField(null=True)

serializers中的序列化

# serializer.py
publish_name = serializers.CharField(source='publish.name')
publish_email = serializers.EmailField(source='publish.email')

当publish是个对象时直接序列化只能打印它的字典对象
因此需要在source中写跨表查询
注意：所有类型都可以用CharField响应

响应结果：

多表关联的序列化

方式1：在表模型中定义方法

# models.py
class Book(models.Model):
    title = models.CharField()
    price = models.IntegerField()
    publish = models.ForeignKey(to='Publish', on_delete=models.CASCADE)
    author = models.ManyToManyField(to='Author')

    @property
    def publish_detail(self):
        return {'name': self.publish.name, 'email': self.publish.email}
    
    @property
    def author_list(self):
        author_list = []
        for i in self.author.all():
            author_list.append({'name': i.name, 'age': i.age})
        return author_list

class Publish(models.Model):
    name = models.CharField(max_length=32,)
    email = models.EmailField()

# serializers.py
class BookSerializer(serializers.Serializer):
    book_name = serializers.CharField(source='title')
    price = serializers.IntegerField()
    publish_detail = serializers.DictField()
    author_list = serializers.ListField()

publish_detail = serializers.DictField()相当于调用了book表中的publish_detail方法，返回的是一个对象

方式2：定制返回格式SerializerMethodField

# models.py
class Book(models.Model):
    publish = models.ForeignKey(to='Publish', on_delete=models.CASCADE, null=True)
    author = models.ManyToManyField(to='Author', null=True)

# serializers.py
class BookSerializer(serializers.Serializer):
    publish_dict = serializers.SerializerMethodField()

    def get_publish_dict(self, obj):
        return {'name': obj.publish.name, 'email': obj.publish.email}

    author_list = serializers.SerializerMethodField()

    def get_author_list(self, obj):
        author_list = []
        for i in obj.author.all():
            author_list.append({'name': i.name, 'age': i.age})
        return author_list

SerializerMethodField()：允许你在序列化器中定义一个基于方法的字段
方法名必须是get_ +需要定制的序列化字段
obj：相当于将后端定义的表对象传了过来，你可以在里面做跨表查询

方式3：子序列化

# models.py
class Book(models.Model):
    publish = models.ForeignKey(to='Publish', on_delete=models.CASCADE)
    author = models.ManyToManyField(to='Author')

# serializers.py
class PublishSerializer(serializers.Serializer):
    name = serializers.CharField()
    email = serializers.EmailField()
    
class AuthorSerializer(serializers.Serializer):
    name = serializers.CharField()
    age = serializers.IntegerField()

class BookSerializer(serializers.Serializer):
    publish = PublishSerializer()
    author_detail = AuthorSerializer(source='author', many=True)

直接在serializers中新建PublishSerializer类，让publish字段调用这个类就能获取他的所有属性
publish和author_detail可以任意改名，如果改名的话需要source参数对应表中的字段名，否则会报错
因为author字段是一个列表，所以要在参数中加上many=True

多表关联的反序列化

反序列化保存一对多关联字段

create

# models.py
class Book(models.Model):
    title = models.CharField(max_length=32, null=True)
    price = models.IntegerField(null=True)
    publish = models.ForeignKey(to='Publish', on_delete=models.CASCADE, null=True)

publish字段一对多关系绑定了Publish表，因此在Book表中显示的是publish_id

在反序列化校验Book对象时，django并不认识Publish表，因此只会识别publish_id，那么前端发送请求时也要传入publish_id

# serializers.py
class BookSerializer(serializers.Serializer):
    book_name = serializers.CharField(source='title')
    price = serializers.IntegerField()
    publish_detail = PublishSerializer(source='publish', read_only=True)

    publish_id = serializers.IntegerField(write_only=True)

    def create(self, validated_data):
        print(validated_data)
        publish_id = validated_data.pop('publish_id')
        book_obj = models.Book.objects.create(**validated_data, publish_id=publish_id)
        return book_obj

在反序列化校验publish_id时为了不影响原先的序列化校验，要在不需要反序列化校验的参数后面加入read_only=True参数，同时publish_id加入write_only参数只作用于反序列化校验

read_only=True：该字段只会用于序列化校验
write_only=True：该字段只会用于反序列化校验

重写create方法（重点）

此时前端传入的参数应为：

print(validated_data)打印结果为：

{'title': '三体', 'price': 900, 'publish_id': 2}

先不看代码来试一下，如果这是我直接book_obj = models.Book.objects.create(**validated_data)会发生什么？

book_obj = models.Book.objects.create(**validated_data)
print(book_obj.publish_id)
# 结果：None

这是因为，虽然validated_data包含了publish_id字段，但是此时它并不具备外键属性，Django仅将他作为一个普通字段进行反序列化
那么理所当然的后端的序列化结果也不会成功，因为publish_detail是根据外键属性取值的
所以此时这里应该明确用publish_id作为publish_id字段的参数

# 先将publish_id参数从vaildated_data中踢出，让前两个参数以**方式传入后再指定publish_id
publish_id = validated_data.pop('publish_id')

# 左边的publish_id是字段，右边的publish_id是前端传来的数据
book_obj = models.Book.objects.create(**validated_data, publish_id=publish_id)

# 这种方法和上面的含义相同，用其中一种即可
book_obj = models.Book.objects.create(title=validated_data.get('title'), price=validated_data.get('price'), publish_id=publish_id)

传入成功应正确返回序列化后的字段

update

# views.py
def put(self, request, u_id):
    book_obj = models.Book.objects.filter(pk=u_id).first()
    # 改对象必须传data和instance
    serializer = BookSerializer(instance=book_obj, data=request.data)
    if serializer.is_valid():
        serializer.save()
        return Response({'code': '200', 'msg': "修改成功", 'result': serializer.data})
    else:
        return Response({'code': '201', 'msg': serializer.errors})

# serializers.py
def update(self, instance, validated_data):
    instance.publish_id = validated_data.get('publish_id')
	instance.title = validated_data.get('title')
    instance.price = validated_data.get('price')
    instance.save()

    return instance

updata相比于create就多了个instance参数
instance就是views层传过来的模型对象，将要修改的字段保存为validated_data中的数据即可

反序列化保存多对多关联字段

create

首先定义一个author字段，与Author表绑定多对多关系字段

class Book(models.Model):
    title = models.CharField(max_length=32, null=True)
    price = models.IntegerField(null=True)
    author = models.ManyToManyField(to='Author', null=True)

class Author(models.Model):
    name = models.CharField(max_length=10, null=True)
    age = models.SmallIntegerField(null=True)

那么此时的数据便不会存在于Book或Author中，而是自动新建一个book_author表，例如：

def create(self, validated_data):
    author_id = validated_data.pop('author_id')
    book_obj = models.Book.objects.create(**validated_data)
    book_obj.author.add(author_id)
    return book_obj

首先将author_id踢出，然后将其单独插入中间表book_author，具体原因跟一对多关系相同

反序列化保存一对一关联字段

create

# models.py
class Author(models.Model):
    name = models.CharField(max_length=10, null=True)
    age = models.SmallIntegerField(null=True)
    author_detail = models.OneToOneField(to='AuthorDetail', on_delete=models.CASCADE, null=True)

    class Meta:
        db_table = 'author'

    def author_dict(self):
        return {'爱好': self.author_detail.hobby, '地址': self.author_detail.addr}


class AuthorDetail(models.Model):
    hobby = models.CharField(max_length=32, null=True)
    addr = models.CharField(max_length=50, null=True)

# serializers.py
class AuthorSerializer(serializers.Serializer):
    # 序列化和反序列化字段
    name = serializers.CharField()
    age = serializers.IntegerField()
	# 序列化字段（在模型中定义方法）
    author_dict = serializers.DictField()

    # 重写create方法
    def create(self, validated_data):
        print(validated_data)
        author_dict = validated_data.pop('author_dict')
        author_detail = AuthorDetail.objects.create(**author_dict)

        author_obj = Author.objects.create(**validated_data, author_detail=author_detail)

        return author_obj

这里需要将author_dict里需要的字段全部在前端传入，例：

{
        "name": "张三",
        "age": 18,
        "author_dict":{
            "hobby":"run",
            "addr":"北京"
        }
}

update

前面的都不需要动，只需重写update方法

def update(self, instance, validated_data):
    # 与create相同，要在中间表更新数据
    author_dict = validated_data.pop('author_dict')
    AuthorDetail.objects.filter(pk=instance.author_detail.pk).update(**author_dict)
    
    # 其他字段不变，detail_id字段不上传，因为是一对一绑定关系所以没必要
    instance.name = validated_data.get('name')
    instance.age = validated_data.get('age')
    instance.save()

    return instance

instance.author_detail.pk：instance对象获取到中间表author_detail的pk

ModelSerializer类下的序列化和反序列化

# models.py
class Author(models.Model):
    name = models.CharField(max_length=10, null=True)
    age = models.SmallIntegerField(null=True)
    author_detail = models.OneToOneField(to='AuthorDetail', on_delete=models.CASCADE, null=True)

# views.py
class author(APIView):
    def get(self, request):
        author_obj = models.Author.objects.all()
        serializer = AuthorSerializer(instance=author_obj, many=True)
        return Response({'code': '200', 'msg': '查询成功', 'result': serializer.data})

# serializer.py
from app.models import Author

class AuthorSerializer(serializers.ModelSerializer):
    class Meta:
        model = Author
        fields = '__all__'
        extra_kwargs = {
            'name': {'max_length': 8},  # 限制name不能超过8
            'author_detail': {'read_only': True},
        }