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')@propertydef publish_detail(self):return {'name': self.publish.name, 'email': self.publish.email}@propertydef author_list(self):author_list = []for i in self.author.all():author_list.append({'name': i.name, 'age': i.age})return author_listclass 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和instanceserializer = 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 Authorclass AuthorSerializer(serializers.ModelSerializer):class Meta:model = Authorfields = '__all__'extra_kwargs = {'name': {'max_length': 8}, # 限制name不能超过8'author_detail': {'read_only': True},}- 此时序列化类中就不需要一个个写字段了，
ModelSerializer会自动跟表做对应关系 model：需要对应的表fields：用于指定需要被序列化的字段，'__all__'为全部['name', 'age']为指定extra_kwargs：类似钩子函数，将对应字段加上限制
