内容概要
- 序列化类常用 字段/参数
- 序列化高级用法之source
- 序列化定制字段名字(两种方式)
- 多表关联反序列化保存
- 反序列化字段校验
- ModelSerializer基本使用
序列化类常用 字段/参数
'序列化类'
from app01 import models
from rest_framework import serializers
class BookSerializer(serializers.Serializer):
name = serializers.CharField()
price = serializers.CharField()
其中CharField就相当于是序列化的字段，序列化类与forms组件很相似
接下来集合一些常见字段
#1 BooleanField BooleanField()
#2 NullBooleanField NullBooleanField()
#3 CharField CharField(max_length=None, min_length=None, allow_blank=False, trim_whitespace=True)
#4 EmailField EmailField(max_length=None, min_length=None, allow_blank=False)
#5 RegexField RegexField(regex, max_length=None, min_length=None, allow_blank=False)
#6 SlugField SlugField(max_length=50, min_length=None, allow_blank=False) 正则字段，验证正则模式 [a-zA-Z0-9-]+
#7 URLField URLField(max_length=200, min_length=None, allow_blank=False)
#8 UUIDField UUIDField(format=’hex_verbose’) format: 1) 'hex_verbose' 如"5ce0e9a5-5ffa-654b-cee0-1238041fb31a" 2） 'hex' 如 "5ce0e9a55ffa654bcee01238041fb31a" 3）'int' - 如: "123456789012312313134124512351145145114" 4）'urn' 如: "urn:uuid:5ce0e9a5-5ffa-654b-cee0-1238041fb31a"
#9 IPAddressField IPAddressField(protocol=’both’, unpack_ipv4=False, **options)
#10 IntegerField IntegerField(max_value=None, min_value=None)
#11 FloatField FloatField(max_value=None, min_value=None)
#12 DecimalField DecimalField(max_digits, decimal_places, coerce_to_string=None, max_value=None, min_value=None) max_digits: 最多位数 decimal_palces: 小数点位置
#13 DateTimeField DateTimeField(format=api_settings.DATETIME_FORMAT, input_formats=None)
#14 DateField DateField(format=api_settings.DATE_FORMAT, input_formats=None)
#15 TimeField TimeField(format=api_settings.TIME_FORMAT, input_formats=None)
#16 DurationField DurationField()
#17 ChoiceField ChoiceField(choices) choices与Django的用法相同
#18 MultipleChoiceField MultipleChoiceField(choices)
#19 FileField FileField(max_length=None, allow_empty_file=False, use_url=UPLOADED_FILES_USE_URL)
#20 ImageField ImageField(max_length=None, allow_empty_file=False, use_url=UPLOADED_FILES_USE_URL)
#21 ListField ListField(child=, min_length=None, max_length=None)
#22 DictField DictField(child=)
常见且重要的:
CharField IntegerField DecimalField DateTimeField BooleanField ListField DictField
字段常见参数：
选项参数：
# CharField及其子类的(EmailField) ---》 反序列化的校验,字段自己的规则
max_length 最大长度
min_lenght 最小长度
allow_blank 是否允许为空
trim_whitespace 是否截断空白字符
# IntegerField
max_value 最小值
min_value 最大值
# 所有字段类都有的
required 表明该字段在反序列化时必须输入，默认True
default 反序列化时使用的默认值
allow_null 表明该字段是否允许传入None，默认False
validators 该字段使用的验证器
error_messages 包含错误编号与错误信息的字典
label 用于HTML展示API页面时，显示的字段名称
help_text 用于HTML展示API页面时，显示的字段帮助提示信息
# 重点：
read_only 表明该字段仅用于序列化输出，默认False
write_only 表明该字段仅用于反序列化输入，默认False
反序列化校验流程：
1.先执行字段参数校验，(最大长度，最小长度，是否可以为空，...)
2.执行字段参数中的 validator=[方法名] 参数，相当于单独给字段添加校验规则
3.执行局部钩子校验
4.执行全局钩子校验
序列化高级用法之source
首先我们在models.py中创建一些文件和数据
from django.db import models
# Create your models here.
class Book(models.Model):
name = models.CharField(max_length=32)
price = models.CharField(max_length=32)
publish = models.ForeignKey(to='Publish', on_delete=models.CASCADE)
authors = models.ManyToManyField(to='Author')
class Publish(models.Model):
name = models.CharField(max_length=32)
address = models.CharField(max_length=32)
class Author(models.Model):
name = models.CharField(max_length=32)
age = models.IntegerField()
author_detail = models.OneToOneField(to='AuthorDetail', on_delete=models.CASCADE)
class AuthorDetail(models.Model):
phone = models.CharField(max_length=32)
home = models.CharField(max_length=32)
1.序列化定制字段名字
# source可以指定序列化字段的名字
from rest_framework import serializers
class BookSerializer(serializers.Serializer):
name = serializers.CharField(max_length=8)
price = serializers.CharField()
在这个我们自定义的序列化类中 我们可以name字段重新命名，只需要在
name = serializers.CharField(max_length=8,source='name')
加上source='name'即可
注意：source='name' name必须是 book这个类拥有的字段
定制有关联关系字段
我们正常去用get请求访问路由查询所有图书，如果字段都填写上，返回的结果如图所示
前端页面显示
但是这种数据对前端无用，所以我们应该想办法将数据处理成方便前端获取的数据
对于关联字段我们可以使用 source(一对多，一对一)
publish = serializers.CharField(source='publish.name')
但是多对多的字段不能使用 source去帮助我们正常显示
总结：
# 序列化类
class BookSerializer(serializers.Serializer):
# 字段参数，通用的，所有字段都可以写 通过source指定哪个字段
# 自有字段，直接写字段名字
book_name = serializers.CharField(max_length=8, source='name')
price = serializers.CharField()
# 关联字段，一对多的关联，直接点
publish = serializers.CharField(source='publish.name')
#多对多，搞不了,source不能用
authors=serializers.CharField(source='authors.all') # 报错
序列化高级用法之定制字段的两种方式
# 定制关联字段的显示形式
一对多，显示字典
多对多，显示列表套字典
1.在序列化类中使用SerializerMethodField定制
在序列化类中 使用serializers.SerializerMethodField()
必须跟一个 函数 与serializers.SerializerMethodField()名字相同
publish_detail = serializers.SerializerMethodField()
并且在get_publish_detail()中需要携带一个obj，这个obj就是
Book类产生的对象
def get_publish_detail(self, obj):
return {'name': obj.publish.name, 'addr': obj.publish.address}
def get_author_list(self, obj):
# print(obj.authors.)
author_list = [{'name': author.name, 'age': author.age} for author in obj.authors.all()]
return author_list
2.在模型中定制
序列化类
只需要编写 需要序列化的字段
publish_detail = serializers.DictField()
author_list = serializers.ListField()
我们在模型类编写函数，对应上序列化字段名字，函数的返回值就会被序列化
模型类
def publish_detail(self):
return {'name': self.publish.name, 'addr': self.publish.address}
def author_list(self):
return [{'name': author.name, 'age': author.age} for author in self.authors.all()]
我们也可以编写
publish_detail = serializers.CharField()
author_list = serializers.CharField()
但是数据到前端就会被显示成为 字符串！
!
多表关联反序列化新增
前端会传输数据到后端，我们需要对其进行反序列化进行保存操作
我们之前编写的是 判断数据是否合法后就将其保存了
并且在序列化类中，我们需要重写create方法
'路由层'
path('book/<int:pk>/', views.BookDetailView.as_view())
"视图层"
class BookView(APIView):
def post(self, request): # 反序列化 新增一条
serializer_obj = serializer.BookSerializer(data=request.data)
if serializer_obj.is_valid():
serializer_obj.save()
return Response({"code": 100, 'msg': '新增成功'})
return Response({"code": 101, 'msg': serializer_obj.errors})
"序列化类"
class BookSerializer(serializers.Serializer):
book_name = serializers.CharField(max_length=8, source='name')
price = serializers.CharField()
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) # 只进行序列化
def create(self, validated_data):
book_obj = models.Book.objects.create(
name=validated_data.get('name'),
price=validated_data.get('price'),
publish_id=validated_data.get('publish'),)
book_obj.authors.add(*validated_data.get('authors'))
return book_obj
'模型层'
def publish_detail(self):
return {'name': self.publish.name, 'addr': self.publish.address}
def author_list(self):
return [{'name': author.name, 'age': author.age} for author in self.authors.all()]
多表关联反序列化存储
'路由层'
path('book/<int:pk>/', views.BookDetailView.as_view())
"序列化类"
存储数据与上述 一致，只需要在序列化类中重写update方法即可
def update(self, instance, validated_data):
instance.name = validated_data.get('name')
instance.price = validated_data.get('price')
instance.publish_id = validated_data.get('publish')
author_list = validated_data.get('authors')
instance.authors.clear()
instance.authors.add(*author_list)
instance.save()
return instance
"视图层"
class BookDetailView(APIView):
def put(self, request, pk): # 序列化+反序列化 查询数据
# 先查询到需要修改的数据对象，
book_obj = models.Book.objects.filter(pk=pk).first()
print(book_obj.publish_id)
# 序列化 book_obj 反序列化 请求体里携带的request.data数据
serializer_obj = serializer.BookSerializer(instance=book_obj, data=request.data)
# 校验新增数据是否合法
if serializer_obj.is_valid():
serializer_obj.save()
return Response({'code': 1001, 'msg': '修改成功', 'data': serializer_obj.data})
return Response({'code': 1002, 'msg': serializer_obj.errors})
反序列化字段校验
反序列化校验顺序：
1.序列化类中字段数据进行校验
2.参数 validators=[方法] 进行校验
3.序列化类中局部钩子函数进行校验
4.序列化类中全局钩子函数进行校验
ModelSerializer 基本使用
# ModelSerializer 继承自Serializer，帮咱们完成了很多操作
使用 ModelSerializer 在序列化中进行编写:
class BookSerializer(serializers.ModelSerializer):
class Meta:
model = models.Book # 强行绑定Book表
# fields = '__all__' # 代表序列化所有字段
# fields = [''] # 也可以选择需要 序列化/反序列化 的字段加入到这个列表当中
fields = ['name', 'publish_detail', 'price', 'publish', 'author_list', 'authors']
# 给字段类加属性
extra_kwargs = {'name': {"max_length": 8},
'publish': {'write_only': True},
'authors': {'write_only': True},
'author_list': {'read_only': True},
'publish_detail': {'read_only': True},
}
# 自定义序列化字段内容
publish_detail = serializers.SerializerMethodField()
def get_publish_detail(self, obj):
return {'name': obj.publish.name, 'addr': obj.publish.address}
author_list = serializers.SerializerMethodField()
def get_author_list(self, obj):
return [{'name': author_obj.name, 'age': author_obj.age,'phone':author_obj.author_detail.phone} for author_obj in obj.authors.all()]
使用ModelSerializer编写序列化类就不需要重新写update和create方法了
