序列化和反序列化

重点

  • 序列化
    • 基本使用
    • 关联对象嵌套序列化
  • 反序列化
    • 验证
    • 保存
  • ModelSerialization
    • 使用
    • 指定字段

与项目一的模式对比

Serializer字段和选项

字段

1. 定义Serializer类

Django REST framework中的Serializer使用类来定义,须继承自rest_framework.serializers.Serializer。

例如,我们已有了一个数据库模型类BookInfo

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class BookInfo(models.Model):
name = models.CharField(max_length=20, verbose_name='名称') #图书名称
pub_date = models.DateField(verbose_name='发布日期') #发布日期
readcount = models.IntegerField(default=0, verbose_name='阅读量') #阅读量
commentcount = models.IntegerField(default=0, verbose_name='评论量') #评论量
is_delete = models.BooleanField(default=False, verbose_name='逻辑删除') #逻辑删除
image = models.ImageField(upload_to='book/', verbose_name='图片', null=True)
#元类信息 : 修改表名
class Meta:
db_table = 'bookinfo' # 指明数据库表名
verbose_name = '图书' # 在admin站点中显示的名称
verbose_name_plural = verbose_name # 显示的复数名称

def __str__(self):
"""定义每个数据对象的显示信息"""
return self.name

我们想为这个模型类提供一个序列化器,可以定义如下:

1
2
3
4
5
6
7
8
9
from rest_framework import serializers

class BookInfoSerializer(serializers.Serializer):
"""图书数据序列化器"""
id = serializers.IntegerField(label='ID')
name = serializers.CharField(label='名称')
pub_date = serializers.DateField(label='发布日期')
readcount = serializers.IntegerField(label='阅读量')
commentcount = serializers.IntegerField(label='评论量')

注意:serializer不是只能为数据库模型类定义,也可以为非数据库模型类的数据定义。serializer是独立于数据库之外的存在。

2. 字段与选项

常用字段类型
字段 字段构造方式
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)
ListField ListField(child=, min_length=None, max_length=None)
DictField DictField(child=)
通用参数:
参数名称 说明
read_only 表明该字段仅用于序列化输出,默认False
write_only 表明该字段仅用于反序列化输入,默认False
required 表明该字段在反序列化时必须输入,默认True
default 反序列化时使用的默认值
label 用于HTML展示API页面时,显示的字段名称

选项参数:

参数名称 作用
max_length 最大长度
min_lenght 最小长度
allow_blank 是否允许为空
max_value 最大值
min_value 最小值

3. 创建Serializer对象

定义好Serializer类后,就可以创建Serializer对象了。

Serializer的构造方法为:

1
Serializer(instance=None, data=empty, **kwarg)

说明:

1)用于序列化时,将模型类对象传入instance参数

1
2
3
serializer = BookInfoSerializer(instance=book)
#或者
serializer = BookInfoSerializer(book)

2)用于反序列化时,将要被反序列化的数据传入data参数

1
serializer = BookInfoSerializer(data={'name':'xxxx','pub_date':'2000-01-10'})

序列化使用

我们在django shell中来学习序列化器的使用。

1
python manage.py shell

基本使用

1) 先查询出一个图书对象

1
2
3
from book.models import BookInfo

book = BookInfo.objects.get(id=4)

2) 构造序列化器对象

1
2
3
from book.serializers import BookInfoSerializer

serializer = BookInfoSerializer(book)

3)获取序列化数据

通过data属性可以获取序列化后的数据

1
2
3
serializer.data

# {'is_delete': False, 'pub_date': '1987-11-11', 'readcount': 58, 'image': None, 'id': 4, 'commentcount': 24, 'name': '雪山飞狐'}

4)如果要被序列化的是包含多条数据的查询集QuerySet,可以通过添加many=True参数补充说明

1
2
3
4
5
books = BookInfo.objects.all()
serializer = BookInfoSerializer(books, many=True)
serializer.data

# [OrderedDict([('id', 3), ('name', '笑傲江湖'), ('pub_date', '1995-12-24'), ('readcount', 28), ('commentcount', 18), ('is_delete', False), ('image', None)]), OrderedDict([('id', 4), ('name', '雪山飞狐'), ('pub_date', '1987-11-11'), ('readcount', 58), ('commentcount', 24), ('is_delete', False), ('image', None)]), OrderedDict([('id', 5), ('name', '新射雕英雄传'), ('pub_date', '2000-05-01'), ('readcount', 0), ('commentcount', 0), ('is_delete', False), ('image', None)]), OrderedDict([('id', 7), ('name', 'python入门'), ('pub_date', '2018-05-12'), ('readcount', 0), ('commentcount', 0), ('is_delete', False), ('image', None)]), OrderedDict([('id', 9), ('name', 'python运维'), ('pub_date', '2018-05-12'), ('readcount', 0), ('commentcount', 0), ('is_delete', False), ('image', 'book/1.png')])]

关联对象嵌套序列化

串行关系

如果需要序列化的数据中包含有其他关联对象,则对关联对象数据的序列化需要指明

例如,在定义人物数据的序列化器时,外键book(即所属的图书)字段如何序列化

我们先定义PeopleInfoSerialzier除外键字段外的其他部分

1
2
3
4
5
6
class PeopleInfoSerializer(serializers.Serializer):
"""英雄数据序列化器"""
id = serializers.IntegerField(label='ID')
name = serializers.CharField(label='名字')
password=serializers.CharField(label='密码')
description = serializers.CharField(label='描述信息')

对于关联字段,可以采用以下几种方式

1.IntegerField

需求数据

1
{'id': 10, 'book_id': 3, 'description': '独孤九剑', 'gender': 1, 'name': '令狐冲'}

此字段将被序列化为关联对象的主键。

1
book_id = serializers.IntegerField(label='书籍id')

使用效果:

1
2
3
4
5
6
>>> from book.models import PeopleInfo
>>> from book.serializers import PeopleInfoSerializer
>>> person = PeopleInfo.objects.get(id=10)
>>> serializer = PeopleInfoSerializer(instance=person)
>>> serializer.data
{'id': 10, 'book_id': 3, 'description': '独孤九剑', 'gender': 1, 'name': '令狐冲'}

2.PrimaryKeyRelatedField

需求数据

1
{'id': 10, 'book': 3, 'description': '独孤九剑', 'gender': 1, 'name': '令狐冲'}

此字段将被序列化为关联对象的主键。

1
2
3
book = serializers.PrimaryKeyRelatedField(label='图书',read_only=True)
#或者
book = serializers.PrimaryKeyRelatedField(label='图书',queryset=BookInfo.objects.all())

指明字段时需要包含read_only=True或者queryset参数:

  • 包含read_only=True参数时,该字段将不能用作反序列化使用
  • 包含queryset参数时,将被用作反序列化时参数校验使用

使用效果:

1
2
3
4
5
6
>>> from book.models import PeopleInfo
>>> from book.serializers import PeopleInfoSerializer
>>> person = PeopleInfo.objects.get(id=10)
>>> serializer = PeopleInfoSerializer(instance=person)
>>> serializer.data
{'id': 10, 'book': 3, 'description': '独孤九剑', 'gender': 1, 'name': '令狐冲'}

3.StringRelatedField

需求数据

1
{'description': '独孤九剑', 'name': '令狐冲', 'gender': 1, 'book': '笑傲江湖', 'id': 10}

此字段将被序列化为关联对象的字符串表示方式(即str方法的返回值)

1
book = serializers.StringRelatedField(label='图书')

使用效果

1
2
3
4
5
6
>>> from book.models import PeopleInfo
>>> from book.serializers import PeopleInfoSerializer
>>> person = PeopleInfo.objects.get(id=10)
>>> serializer = PeopleInfoSerializer(instance=person)
>>> serializer.data
{'description': '独孤九剑', 'name': '令狐冲', 'gender': 1, 'book': '笑傲江湖', 'id': 10}

问题:如果我写成如下这样,会怎么样?

1
2
book = serializers.StringRelatedField(label='图书')
book_id = serializers.IntergerField(label='书籍id')

4.使用关联对象的序列化器

需求数据获取书籍以及书籍关联的人物

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
{
"id": 1,
"name": "射雕英雄传",
"pub_date": "1980-05-01",
"readcount": 12,
"commentcount": 34,
"people": [
{
"id": 1,
"name": "郭靖",
"password": "123456abc",
"description": "降龙十八掌"
},
{
"id": 2,
"name": "黄蓉",
"password": "123456abc",
"description": "打狗棍法"
}
]
}

BookInfoSerializer中添加关联字段

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
from rest_framework import serializers

class PeopleInfoSerializer(serializers.Serializer):
"""英雄数据序列化器"""
id = serializers.IntegerField(label='ID')
name = serializers.CharField(label='名字')
password=serializers.CharField(label='密码')
description = serializers.CharField(label='描述信息')


class BookInfoSerializer(serializers.Serializer):
"""图书数据序列化器"""
id = serializers.IntegerField(label='ID')
name = serializers.CharField(label='名称')
pub_date = serializers.DateField(label='发布日期')
readcount = serializers.IntegerField(label='阅读量')
commentcount = serializers.IntegerField(label='评论量')
#一本书籍关联多个人物
people=PeopleInfoSerializer(many=True)

使用效果

1
2
3
4
5
6
>>> from book.serializers import BookInfoSerializer                                                                                  
>>> from book.models import BookInfo
>>> book=BookInfo.objects.get(id=1)
>>> s = BookInfoSerializer(book)
>>> s.data
>>> {'id': 1, 'name': '射雕英雄传', 'pub_date': '1980-05-01', 'readcount': 12, 'commentcount': 34, 'people': [Or

反序列化使用

验证

使用序列化器进行反序列化时,需要对数据进行验证后,才能获取验证成功的数据或保存成模型类对象。

在获取反序列化的数据前,必须调用is_valid()方法进行验证,验证成功返回True,否则返回False。

验证失败,可以通过序列化器对象的errors属性获取错误信息,返回字典,包含了字段和字段的错误。

验证成功,可以通过序列化器对象的validated_data属性获取数据。

在定义序列化器时,指明每个字段的序列化类型和选项参数,本身就是一种验证行为。

如我们前面定义过的BookInfoSerializer

1
2
3
4
5
6
7
class BookInfoSerializer(serializers.Serializer):
"""图书数据序列化器"""
id = serializers.IntegerField(label='ID')
name = serializers.CharField(label='名称')
pub_date = serializers.DateField(label='发布日期')
readcount = serializers.IntegerField(label='阅读量')
commentcount = serializers.IntegerField(label='评论量')

通过构造序列化器对象,并将要反序列化的数据传递给data构造参数,进而进行验证

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
正确
>>> from book.serializers import BookInfoSerializer
>>>
>>> data = {
... 'name':'Python高级',
... 'pub_date':'2020-1-1',
... 'readcount':100,
... 'commentcount':200
... }
>>>
>>> serializer = BookInfoSerializer(data=data)
>>>
>>> from book.serializers import BookInfoSerializer
>>>
>>> data = {
... 'id':100,
... 'name':'Python高级',
... 'pub_date':'2020-1-1',
... 'readcount':100,
... 'commentcount':200
... }
>>>
>>> serializer = BookInfoSerializer(data=data)
>>>
>>> serializer.is_valid()
True
>>>
>>> serializer.errors
{}
>>>

is_valid()方法还可以在验证失败时抛出异常serializers.ValidationError,可以通过传递raise_exception=True参数开启,REST framework接收到此异常,会向前端返回HTTP 400 Bad Request响应。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
>>> from book.serializers import BookInfoSerializer
>>>
>>> data = {
... 'id':100,
... 'name':'Python高级',
... 'pub_date':'2020',
... 'readcount':100,
... 'commentcount':200
... }
>>>
>>> serializer = BookInfoSerializer(data=data)
>>>
>>> serializer.is_valid()
False
>>>
>>> serializer.errors
{'pub_date': [ErrorDetail(string='Date has wrong format. Use one of these formats instead: YYYY-MM-DD.', code='invalid')]}

如果觉得这些还不够,可以使用以下几种方法验证:

1.字段类型

2.字段选项

3.validate_fieldname

4.validate

字段类型

常用字段类型

字段 字段构造方式
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)
ListField ListField(child=, min_length=None, max_length=None)
DictField DictField(child=)

在序列化器中,定义的readcount为IntegerField类型

1
2
3
4
5
6
7
class BookInfoSerializer(serializers.Serializer):
"""图书数据序列化器"""
id = serializers.IntegerField(label='ID')
name = serializers.CharField(label='名称')
pub_date = serializers.DateField(label='发布日期')
readcount = serializers.IntegerField(label='阅读量')
commentcount = serializers.IntegerField(label='评论量')

如果我们传递一个与定义类型不一致的会怎么样呢?

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
>>> from book.serializers import BookInfoSerializer
>>>
>>> data = {
... 'id':100,
... 'name':'Python高级',
... 'pub_date':'2020',
... 'readcount':100,
... 'commentcount':200
... }
>>>
>>> serializer = BookInfoSerializer(data=data)
>>>
>>> serializer.is_valid()
False
>>>
>>> serializer.errors
{'pub_date': [ErrorDetail(string='Date has wrong format. Use one of these formats instead: YYYY-MM-DD.', code='invalid')]}

字段选项

通用参数
参数名称 说明
read_only 表明该字段仅用于序列化输出,默认False
write_only 表明该字段仅用于反序列化输入,默认False
required 表明该字段在反序列化时必须输入,默认True
default 反序列化时使用的默认值
label 用于HTML展示API页面时,显示的字段名称
allow_null 表明该字段是否允许传入None,默认是False
选项参数
参数名称 作用
max_length 最大长度
min_lenght 最小长度
allow_blank 是否允许为空
max_value 最大值
min_value 最小值

在序列化器中,定义的字段选项默认是required。

1
2
3
4
5
6
7
class BookInfoSerializer(serializers.Serializer):
"""图书数据序列化器"""
id = serializers.IntegerField(label='ID')
name = serializers.CharField(label='名称')
pub_date = serializers.DateField(label='发布日期')
readcount = serializers.IntegerField(label='阅读量')
commentcount = serializers.IntegerField(label='评论量')

如果我们传递数据缺失一个id会怎么样呢?

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
>>> from book.serializers import BookInfoSerializer
>>>
>>> data = {
... 'name':'Python高级',
... 'pub_date':'2020-01-01',
... 'readcount':100,
... 'commentcount':200
... }
>>>
>>> serializer = BookInfoSerializer(data=data)
>>>
>>> serializer.is_valid(raise_exception=True)
Traceback (most recent call last):
File "<console>", line 1, in <module>
File "/home/ubuntu/.virtualenvs/py3_django_2_2_5/lib/python3.6/site-packages/rest_framework/serializers.py", line 242, in is_valid
raise ValidationError(self.errors)
rest_framework.exceptions.ValidationError: {'id': [ErrorDetail(string='This field is required.', code='required')]}
>>>

read_only

像id这样的主键值,一般我们都是让数据库自动生成,所以一般不会传入。则需要设置为 read_only

1
id = serializers.IntegerField(label='ID',read_only=True)
write_only

只写入。我们在进行反序列化的时候,必须要求传入该字段。在进行序列化操作的时候不会获取到该字段的值。

1
password = serializers.IntegerField(label='密码',read_only=True)

read_only=True

write_only=True

1
2
3
id = serializers.IntegerField(label='ID',read_only=True)    表明该字段仅用于序列化输出

password = serializers.IntegerField(label='ID',write_only=True) 表明该字段仅用于反序列化输入

read__onlywrite__only会一起出现吗?

值不一样呢?

validate_fieldname

<field_name>字段进行验证,如

1
2
3
4
5
6
7
8
9
10
11
12
class BookInfoSerializer(serializers.Serializer):
"""图书数据序列化器"""
id = serializers.IntegerField(label='ID', read_only=True)
name = serializers.CharField(label='名称', max_length=20)
pub_date = serializers.DateField(label='发布日期', required=False)
readcount = serializers.IntegerField(label='阅读量', required=False)
commentcount = serializers.IntegerField(label='评论量', required=False)

def validate_readcount(self,value):
if value < 0:
raise serializers.ValidationError('阅读数量不能为负数')
return value

测试

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
>>> from book.serializers import BookInfoSerializer
>>>
>>> data = {
... 'name':'Python高级',
... 'pub_date':'2020-01-01',
... 'readcount':-100,
... 'commentcount':200
... }
>>>
>>> serializer = BookInfoSerializer(data=data)
>>>
>>> serializer.is_valid(raise_exception=True)
Traceback (most recent call last):
File "<console>", line 1, in <module>
File "/home/ubuntu/.virtualenvs/py3_django_2_2_5/lib/python3.6/site-packages/rest_framework/serializers.py", line 242, in is_valid
raise ValidationError(self.errors)
rest_framework.exceptions.ValidationError: {'readcount': [ErrorDetail(string='阅读数量不能为负数', code='invalid')]}
>>>

validate

在序列化器中需要同时对多个字段进行比较验证时,可以定义validate方法来验证,如

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class BookInfoSerializer(serializers.Serializer):
"""图书数据序列化器"""
id = serializers.IntegerField(label='ID', read_only=True)
name = serializers.CharField(label='名称', max_length=20)
pub_date = serializers.DateField(label='发布日期', required=False)
readcount = serializers.IntegerField(label='阅读量', required=False)
commentcount = serializers.IntegerField(label='评论量', required=False)

def validate(self, attrs):
readcount = attrs['readcount']
commentcount = attrs['commentcount']
if commentcount > readcount:
raise serializers.ValidationError('评论量不能大于阅读量')
return attrs

测试

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
>>> from book.serializers import BookInfoSerializer
>>>
>>> data = {
... 'name':'Python高级',
... 'pub_date':'2020-01-01',
... 'readcount':100,
... 'commentcount':200
... }
>>>
>>> serializer = BookInfoSerializer(data=data)
>>>
>>> serializer.is_valid(raise_exception=True)
Traceback (most recent call last):
File "<console>", line 1, in <module>
File "/home/ubuntu/.virtualenvs/py3_django_2_2_5/lib/python3.6/site-packages/rest_framework/serializers.py", line 242, in is_valid
raise ValidationError(self.errors)
rest_framework.exceptions.ValidationError: {'non_field_errors': [ErrorDetail(string='评论量不能大于阅读量', code='invalid')]}
>>>

保存

文档

如果在验证成功后,想要基于validated_data完成数据对象的创建,可以通过实现create()和update()两个方法来实现。

1.保存新数据

将数据保存到数据库中,则可以进行如下修改

1
2
3
4
5
6
7
8
9
10
11
12
13
class BookInfoSerializer(serializers.Serializer):

"""图书数据序列化器"""
id = serializers.IntegerField(label='ID', read_only=True)
name = serializers.CharField(label='名称', max_length=20)
pub_date = serializers.DateField(label='发布日期', required=False)
readcount = serializers.IntegerField(label='阅读量', required=False)
commentcount = serializers.IntegerField(label='评论量', required=False)


def create(self, validated_data):
"""新建"""
return BookInfo.objects.create(**validated_data)

实现了上述方法后,在反序列化数据的时候,就可以通过save()方法返回一个数据对象实例了

1
book = serializer.save()

如果创建序列化器对象的时候,没有传递instance实例,则调用save()方法的时候,create()被调用。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
>>> from book.serializers import BookInfoSerializer
>>>
>>> data = {
... 'name':'Python高级',
... 'pub_date':'2020-01-01',
... 'readcount':100,
... 'commentcount':20
... }
>>>
>>> serializer = BookInfoSerializer(data=data)
>>>
>>> serializer.is_valid(raise_exception=True)
True
>>>
>>> serializer.save()
<BookInfo: Python高级>

2.更新数据

想要更新数据,则可以进行如下修改

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class BookInfoSerializer(serializers.Serializer):

"""图书数据序列化器"""
id = serializers.IntegerField(label='ID', read_only=True)
name = serializers.CharField(label='名称', max_length=20)
pub_date = serializers.DateField(label='发布日期', required=False)
readcount = serializers.IntegerField(label='阅读量', required=False)
commentcount = serializers.IntegerField(label='评论量', required=False)

def update(self, instance, validated_data):
"""更新,instance为要更新的对象实例"""
instance.name = validated_data.get('name', instance.name)
instance.pub_date = validated_data.get('pub_date', instance.pub_date)
instance.readcount = validated_data.get('readcount', instance.readcount)
instance.commentcount = validated_data.get('commentcount', instance.commentcount)
instance.save()
return instance

实现了上述方法后,在反序列化数据的时候,就可以通过save()方法返回一个数据对象实例了

1
book = serializer.save()

如果创建序列化器对象的时候,如果传递了instance实例,则调用save()方法的时候,update()被调用。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
>>> from book.serializers import BookInfoSerializer
>>> from book.models import BookInfo
>>>
>>> book = BookInfo.objects.get(id=5)
>>>
>>> data = {
... 'name':'Django高级',
... 'pub_date':'2020-01-01',
... 'readcount':100,
... 'commentcount':20
... }
>>>
>>> serializer = BookInfoSerializer(instance=book,data=data)
>>>
>>> serializer.is_valid(raise_exception=True)
True
>>>
>>> serializer.save()
<BookInfo: Django高级>
>>>

两点说明:

1) 在对序列化器进行save()保存时,可以额外传递数据,这些数据可以在create()和update()中的validated_data参数获取到

1
serializer.save(user=request.user)

2)默认序列化器必须传递所有required的字段,否则会抛出验证异常。但是我们可以使用partial参数来允许部分字段更新

1
serializer = BookInfoSerializer(instance=book, data={'pub_date': '2999-1-1'}, partial=True)

模型类序列化器ModelSerializer

如果我们想要使用序列化器对应的是Django的模型类,DRF为我们提供了ModelSerializer模型类序列化器来帮助我们快速创建一个Serializer类。

ModelSerializer与常规的Serializer相同,但提供了:

  • 基于模型类自动生成一系列字段
  • 包含默认的create()和update()的实现

1. 定义

比如我们创建一个BookInfoModelSerializer

1
2
3
4
5
6
7
8
from rest_framework import serializers
from book.models import BookInfo

class BookInfoModelSerializer(serializers.ModelSerializer):

class Meta:
model = BookInfo
fields = '__all__'
  • model 指明参照哪个模型类
  • fields 指明为模型类的哪些字段生成

我们可以在python manage.py shell中查看自动生成的BookInfoModelSerializer的具体实现

1
2
3
4
5
6
7
8
9
10
>>> from book.serializers import BookInfoModelSerializer
>>> BookInfoModelSerializer()
BookInfoModelSerializer():
id = IntegerField(label='ID', read_only=True)
name = CharField(label='名称', max_length=20)
pub_date = DateField(allow_null=True, label='发布日期', required=False)
readcount = IntegerField(label='阅读量', max_value=2147483647, min_value=-2147483648, required=False)
commentcount = IntegerField(label='评论量', max_value=2147483647, min_value=-2147483648, required=False)
is_delete = BooleanField(label='逻辑删除', required=False)
image = ImageField(allow_null=True, label='图片', max_length=100, required=False)

2. 指定字段

1) 使用fields来明确字段,__all__表名包含所有字段,也可以写明具体哪些字段,如

1
2
3
4
5
class BookInfoModelSerializer(serializers.ModelSerializer):

class Meta:
model = BookInfo
fields = '__all__'

2) 使用exclude可以明确排除掉哪些字段

1
2
3
4
5
class BookInfoModelSerializer(serializers.ModelSerializer):

class Meta:
model = BookInfo
exclude = ('image',)

3) 显示指明字段,如:

1
2
3
4
5
class BookInfoModelSerializer(serializers.ModelSerializer):

class Meta:
model = BookInfo
fields = ('id','name', 'readcount', 'commentcount')

4) 指明只读字段

可以通过read_only_fields指明只读字段,即仅用于序列化输出的字段

1
2
3
4
5
6
class BookInfoModelSerializer(serializers.ModelSerializer):

class Meta:
model = BookInfo
fields = ('id','name', 'readcount', 'commentcount')
read_only_fields = ('id', 'readcount', 'commentcount')

3. 添加额外参数

我们可以使用extra_kwargs参数为ModelSerializer添加或修改原有的选项参数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
class BookInfoModelSerializer(serializers.ModelSerializer):

class Meta:
model = BookInfo
fields = ('id','name', 'readcount', 'commentcount')
read_only_fields = ('id', 'readcount', 'commentcount')
extra_kwargs = {
'readcount': {'min_value': 0, 'required': True},
'commentcount': {'max_value': 0, 'required': True},
}

>>> from book.serializers import BookInfoModelSerializer
>>> BookInfoModelSerializer()
BookInfoModelSerializer():
id = IntegerField(label='ID', read_only=True)
name = CharField(label='名称', max_length=20)
readcount = IntegerField(label='阅读量', min_value=0, read_only=True)
commentcount = IntegerField(label='评论量', max_value=0, read_only=True)

反序列化进阶使用

准备工作

定义2个ModelSerializer

1
2
3
4
5
6
7
8
9
10
11
12
13
14
from rest_framework import serializers
from book.models import PeopleInfo,BookInfo
class PeopleInfoModelSerializer(serializers.ModelSerializer):

class Meta:
model = PeopleInfo
fields = ['id']


class BookInfoModelSerializer(serializers.ModelSerializer):

class Meta:
model = BookInfo
fields = '__all__'

1.保存1个人物信息

1.1前端传递的数据如下所示

1
2
3
4
5
data = {
'book':1,
'name': '靖哥哥',
'password': '123456abc',
}

我们该定义什么样的序列化器?

定义的序列化器为

1
2
3
4
5
6
7
8
9
from rest_framework import serializers
from book.models import PeopleInfo
class PeopleInfoModelSerializer(serializers.ModelSerializer):
class Meta:
model = PeopleInfo
fields = ['id','book','name','password']
extra_kwargs = {
'password': {'write_only':True}
}
结论

write_only表明该字段仅用于反序列化输入。在序列化输出时忽略该字段。

1.2前端传递的数据如下所示

1
2
3
4
5
data = {
'book_id':1,
'name': '靖哥哥',
'password': '123456abc'
}

我们该定义什么样的序列化器?

定义的序列化为

1
2
3
4
5
6
7
8
9
10
11
from rest_framework import serializers
from book.models import PeopleInfo
class PeopleInfoModelSerializer(serializers.ModelSerializer):
book_id=serializers.IntegerField()

class Meta:
model = PeopleInfo
fields = ['id','book_id','name','password']
extra_kwargs = {
'password': {'write_only':True}
}

或者

1
2
3
4
5
6
7
8
9
10
11
12
from rest_framework import serializers
from book.models import PeopleInfo
class PeopleInfoModelSerializer(serializers.ModelSerializer):
book_id=serializers.IntegerField(required=False)
book=serializers.StringRelatedField()

class Meta:
model = PeopleInfo
fields = ['id','book_id','book','name','password']
extra_kwargs = {
'password': {'write_only':True}
}
结论

外键book或者book_id都可以保存数据。主要看前端传递过来的数据形式

1.3前端传递的数据如下所示

1
2
3
4
5
6
data = {
'book_id':1,
'name': '靖哥哥',
'password': '123456abc',
'is_delete': 1
}

我们该定义什么样的序列化器?

定义的序列化为

1
2
3
4
5
6
7
8
9
10
11
12
13
from rest_framework import serializers
from book.models import PeopleInfo,BookInfo
class PeopleInfoModelSerializer(serializers.ModelSerializer):
book_id=serializers.IntegerField(required=False)
book=serializers.StringRelatedField()

class Meta:
model = PeopleInfo
fields = ['id','book_id','book','name','password','is_delete']
extra_kwargs = {
'password': {'write_only':True},
'is_delete': {'read_only':True}
}
结论

read_only表明该字段仅用于序列化输出。反序列化时忽略次字段。

1.4前端传递的数据如下所示

1
2
3
4
5
6
7
data = {
'book_id':1,
'name': '靖哥哥',
'password': '123456abc',
'description': '描述',
'is_delete': 1
}

如果定义的序列化为以下代码。会出现什么问题?

1
2
3
4
5
6
7
8
9
10
11
12
13
from rest_framework import serializers
from book.models import PeopleInfo,BookInfo
class PeopleInfoModelSerializer(serializers.ModelSerializer):
book_id=serializers.IntegerField(required=False)
book=serializers.StringRelatedField()

class Meta:
model = PeopleInfo
fields = ['id','book_id','book','name','password','is_delete']
extra_kwargs = {
'password': {'write_only':True},
'is_delete': {'read_only':True}
}
结论

description没有在序列化器中定义字段。如果需要验证或保存某一个字段是必须要在序列化器中定义该字段

2.保存n个人物信息

前端传递的数据如下所示

1
2
3
4
5
6
7
8
9
10
11
12
[
{
'book_id': 1,
'name': '靖妹妹~~~',
'password':'123456abc'
},
{
'book_id': 1,
'name': '靖表哥~~~',
'password': '123456abc'
}
]

定义的序列化器为

1
2
3
4
5
6
7
8
9
10
11
12
13
from rest_framework import serializers
from book.models import PeopleInfo
class PeopleInfoModelSerializer(serializers.ModelSerializer):
book_id=serializers.IntegerField(required=False)
book=serializers.StringRelatedField()

class Meta:
model = PeopleInfo
fields = ['id','book_id','book','name','password','is_delete']
extra_kwargs = {
'password': {'write_only':True},
'is_delete': {'read_only':True}
}

结论

进行反序列化也可以保存字典列表,需要设置many=True

3.保存1本新书籍和n个新人物信息

前端传递的数据如下所示

1
2
3
4
5
6
7
8
9
10
11
12
13
{
'name':'离离原上草',
'people':[
{
'name': '靖妹妹111',
'password': '123456abc'
},
{
'name': '靖表哥222',
'password': '123456abc'
}
]
}

我们该定义什么样的序列化器?

定义的序列化器为

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
from rest_framework import serializers
from book.models import PeopleInfo,BookInfo
class PeopleInfoModelSerializer(serializers.ModelSerializer):
class Meta:
model = PeopleInfo
fields = ['name','password']
extra_kwargs = {
'password': {'write_only':True},
'is_delete': {'read_only':True}
}

class BookInfoModelSerializer(serializers.ModelSerializer):
people=PeopleInfoModelSerializer(many=True)
class Meta:
model = BookInfo
fields = ['people','name']


def create(self, validated_data):

people=validated_data.pop('people')

book=BookInfo.objects.create(**validated_data)

for person in people:
PeopleInfo.objects.create(book=book,**person)
return book

文档说明

默认情况下,嵌套串行器是只读的。如果要支持对嵌套序列化器字段的写操作,则需要创建create()update()方法,以明确指定应如何保存数据。

需要我们在新增数据时,实现create方法


本博客所有文章除特别声明外,均采用 CC BY-SA 3.0协议 。转载请注明出处!