目录
- 序列化类常用字段和字段参数
- 序列化类高级用法之source,修改序列化字段名字
- 序列化类高级用法之定制序列化字段的俩种方式
- 反序列化之数据校验
- 模型类序列化器（ModelSerializer）的使用
- 反序列化数据校验源码分析（了解）
- 断言assert
序列化类常用字段和字段参数
常用字段类
# BooleanField BooleanField()
# NullBooleanField NullBooleanField()
# CharField CharField(max_length=None, min_length=None, allow_blank=False, trim_whitespace=True)
# EmailField EmailField(max_length=None, min_length=None, allow_blank=False)
# RegexField RegexField(regex, max_length=None, min_length=None, allow_blank=False)
# SlugField SlugField(maxlength=50, min_length=None, allow_blank=False) 正则字段，验证正则模式 [a-zA-Z0-9-]+
# URLField URLField(max_length=200, min_length=None, allow_blank=False)
# 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"
# IPAddressField IPAddressField(protocol=’both’, unpack_ipv4=False, **options)
# IntegerField IntegerField(max_value=None, min_value=None)
# FloatField FloatField(max_value=None, min_value=None)
# DecimalField DecimalField(max_digits, decimal_places, coerce_to_string=None, max_value=None, min_value=None) max_digits: 最多位数 decimal_palces: 小数点位置
# DateTimeField DateTimeField(format=api_settings.DATETIME_FORMAT, input_formats=None)
# DateField DateField(format=api_settings.DATE_FORMAT, input_formats=None)
# TimeField TimeField(format=api_settings.TIME_FORMAT, input_formats=None)
# DurationField DurationField()
# ChoiceField ChoiceField(choices) choices与Django的用法相同
# MultipleChoiceField MultipleChoiceField(choices)
# FileField FileField(max_length=None, allow_empty_file=False, use_url=UPLOADED_FILES_USE_URL)
# ImageField ImageField(max_length=None, allow_empty_file=False, use_url=UPLOADED_FILES_USE_URL)
需要记住的字段类
CharField
BooleanField
IntegerField
DecimalField
ListField
DictField
常用字段参数
1 给CharField字段类使用的参数
max_length 最长长度
min_length 最小长度
allow_blank 是否允许为空
trim_whitespace 是否截断空白字段
2 给IntegerField字段类使用的参数
max_value 最小值
min_value 最大值
3 通用参数，放在哪个字段类上都可以
required 表明该字段在反序列化时必须输入，默认True
default 反序列化时使用的默认值
allow_null 表明该字段是否允许传入None，默认False
validators 该字段使用的验证器
error_messages 包含错误编码与错误信息的字典
label 用于HTML展示API页面时，显示的字段名称
help_text 用于Html展示API页面时，显示的字段帮助提示信息
4 重点
read_only 表明该字段仅仅用于序列化输出，默认时False
write_only 表明该字段仅用于反序列化输入，默认False
序列化类高级用法之source,修改序列化字段名字
使用source，字段参数，可以指定序列化表中得哪个字段
source指定的可以是字段，也可以是方法，用于重命名
source可以做跨表查询，通过外键字段，表名点外键出去的字段名字
小坑：不能够指定它原本的名字
总结代码演示
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') #source的xx表示表模型中得方法
序列化类高级用法之定制序列化字段的俩种方式
方式一：在【序列化类】中写SerializerMethodField
必须配合一个方法(get_字段名,需要传一个字段名接受一个参数)，方法返回什么，这个字段就是什么
class BookSerializer(serializers.Serializer):
name = serializers.CharField(max_length=8, min_length=3)
price = serializers.IntegerField(max_value=300, min_value=10)
# publish = serializers.CharField(max_length=8, min_length=3)
# 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} # 基于对象的跨表查询
# 练习一
author = serializers.SerializerMethodField()
def get_author(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
方式二：在【表模型】中写方法（又多一些）
publish_detail = serializers.CharField()
def publish_detail(self):
return {'name': self.publish.name,'city': self.publish.city, 'email': self.publish.email}
但是这么写不好看，可以进一步改变一下
# publish_detail = serializers.CharField(),这里用CharField()会强行将它改成字符串
publish_detail = serializers.DictField()
练习题：显示所有作者
author_list = serializers.ListField()
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
在表模型类中写逻辑代码，称之为ddd, 领域驱动模型
有关联关系表的反序列化的保存
# 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
使用继承Serializer的序列化类保存需要重写create方法
# 缺点
1 在序列化中每个字段都要写，无论是序列化还是反序列化
2 如果新增或者修改，在序列化类中都需要重写create或update
# 解决这个缺点，使用ModelSerializer来做
反序列化之数据校验
# 跟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):
# 与表有关联不需要写字段了
# 必须要有这个，必须是这个
class Meta:
# 这个序列化类BookModelSerializer与Book建立了表模型关系
model = Book
# 表示我要序列化哪些字段
# 方式一：
# fields = ['name', 'price', 'publish_date', 'publish', 'authors', 'publish_detail', 'author_list'] # 表示序列化所有
# 方式二：
fields = ['name', 'price', 'publish_date', 'publish', 'authors', 'publish_de', 'author_li']
# 给'publish', 'authors'加write_only属性
extra_kwargs = {
'publish': {'write_only': True},
'authors': {'write_only': True},
}
# # 方式一：
# publish_detail = serializers.SerializerMethodField(read_only=True)
#
# def get_publish_detail(self, obj):
# # obj 就是当前序列化的对象
# return {'name': obj.publish.name, 'city': obj.publish.city, 'email': obj.publish.email} # 基于对象的跨表查询
#
# author_list = serializers.SerializerMethodField(read_only=True)
#
# def get_author_list(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
# 方式二：在表模型中写
"""
表模型中已经写好了：
def publish_de(self):
return {'name': self.publish.name, 'city': self.publish.city, 'email': self.publish.email}
def author_li(self):
res_list = []
for author in self.authors.all():
res_list.append({'id': author.id, 'name': author.name, 'age': author.age})
return res_list
"""
反序列化数据校验源码分析（了解）
# 先校验字段自己的规则(最大，最小)，走局部钩子校验，走全局钩子
# 局部：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
断言assert
# 框架的源码中，大量使用断言
# assert :断言，作用的判断，断定一个变量必须是xx，如果不是就报错
# 你的土鳖写法
# name = 'lqz1'
# if not name == 'lqz':
# raise Exception('name不等于lqz')
#
# print('程序执行完了')
# assert的断言写法
name = 'lqz1'
assert name == 'lqz', 'name不等于lqz'
print('程序执行完了')