DRF 序列化 和 反序列化
序列化
1. 定义：
序列化：将model模型对象转换为json格式的字符串，我们可以对返回的数据进行过滤（一般是后端构造数据，返回给前端）
继承说明：Django REST framework中的Serializer使用类来定义，须继承自
rest_framework.serializers.Serializer
或
rest_framework.serializers.ModelSerializer
2. Serializers使用方式
- 例如，我们已有了一个数据库模型类BookInfo
class BookInfo(models.Model):
btitle = models.CharField(max_length=20, verbose_name='名称')
bpub_date = models.DateField(verbose_name='发布日期', null=True)
bread = models.IntegerField(default=0, verbose_name='阅读量')
bcomment = models.IntegerField(default=0, verbose_name='评论量')
image = models.ImageField(upload_to='booktest', verbose_name='图片', null=True)
- 我们想为这个模型类提供一个序列化器，在应用中
models.py同级目录创建serializers.py文件，定义内容如下：
from rest_framework import serializers
class BookInfoSerializer(serializers.Serializer):
"""图书数据序列化器"""
id = serializers.IntegerField(label='ID', read_only=True)
btitle = serializers.CharField(label='名称', max_length=20)
bpub_date = serializers.DateField(label='发布日期', required=False)
bread = serializers.IntegerField(label='阅读量', required=False)
bcomment = serializers.IntegerField(label='评论量', required=False)
logo = serializers.ImageField(label='图片', required=False)
- 在试图
views.py文件中使用如下：
from django.views import View
from .models import BookInfo
from .serializers import BookInfoSerializer
# http://127.0.0.1:8000/books/id
# url(r'^books/(?P\d*)/$', views.BookView.as_view())
class BookView(View):
def get(self, request, pk):
book = BookInfo.objects.get(pk=pk)
# 构建序列化对象，将模型对象传入，将其转换为json格式字符串
# 转换后的格式：{"id": 1, ....}, 键为serializers序列化器中定义的所有字段
serializer = BookInfoSerializer(book)
# 转换后的字符串对象保存在serializer的data属性中
return JsonResponse(serializer.data)
- serializer序列化器说明：
- BookInfoSerializer：默认只能接收单个对象，如果想要接收一个
queryset对象，并对其进行转换，需要设定参数：many=True
from django.views import View
from .models import BookInfo
from .serializers import BookInfoSerializer
# http://127.0.0.1:8000/books/
# url(r'^books/$', views.BookView.as_view())
class BookView(View):
def get(self, request):
books = BookInfo.objects.all()
# 构建序列化对象，将模型对象传入，将其转换为json格式字符串
serializer = BookInfoSerializer(books, many=True)
# 转换后的字符串对象保存在serializer的data属性中
# 转换后的格式：[{}, {}, ...], 内部字典数据同上，注意该数据并非json，仅仅是长得像json格式的字符串
return JsonResponse(serializer.data, safe=False)
- 注意：JsonResponse转换列表时需要给定参数：
safe=False，否则会报错
3. 序列化字段类型及参数
常用字段类型：
| 字段 | 字段构造方式 |
|---|---|
| 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: 小数点位置 |
| 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=) |
选项参数：
| 参数名称 | 作用 |
|---|---|
| max_length | 最大长度：在反序列化时进行输入最大长度校验 |
| min_lenght | 最小长度：在反序列化时进行输入最小长度校验 |
| allow_blank | 是否允许为空：在反序列化时允许传空白字符串，默认不允许 |
| trim_whitespace | 是否截断左右空白字符，默认True |
| max_value | 最小值：在反序列化时进行输入最大值校验 |
| min_value | 最大值：在反序列化时进行输入最小值校验 |
通用参数：
| 参数名称 | 作用 |
|---|---|
| read_only | 表明该字段仅用于序列化输出，默认False |
| write_only | 表明该字段仅用于反序列化输入，默认False |
| required | 表明该字段在反序列化时必须输入，默认True |
| default | 反序列化时使用的默认值，如果不指明，在传递时默认值为0 |
| allow_null | 表明该字段是否允许传入None，默认False |
| validators | 该字段使用的验证器 |
| error_messages | 包含错误编号与错误信息的字典 |
| label | 用于HTML展示API页面时，显示的字段名称 |
| help_text | 用于HTML展示API页面时，显示的字段帮助提示信息 |
重点说明：
read_only：在进行序列化输出时进行显示，但在反序列化验证时不做校验write_only：在反序列化时进行校验，但在序列化时不进行输出该字段
4. 序列化的高级使用
1. 关联对象的序列化
PrimaryKeyRelatedField：返回关联对象的主键id
# models.py
from django.db import models
class BookInfo(models.Model):
btitle = models.CharField(max_length=128, verbose_name='书名')
pbublic_date = models.DateField(verbose_name='发布日期')
bread = models.IntegerField(default=0, verbose_name='阅读量')
bcomment = models.IntegerField(default=0, verbose_name='评论量')
is_delete = models.BooleanField(default=0, verbose_name='逻辑删除')
logo = models.ImageField(upload_to='booktest', verbose_name='封面图', null=True)
class Meta:
db_table = 'tb_books'
verbose_name = '图书'
verbose_name_plural = verbose_name
def __str__(self):
return self.btitle
class HeroInfo(models.Model):
GENDER_CHOICES = (
(0, 'male'),
(1, 'female')
)
hname = models.CharField(max_length=36, verbose_name='名字')
hgender = models.SmallIntegerField(choices=GENDER_CHOICES, default=0, verbose_name='性别')
hcomment = models.CharField(max_length=200, null=True, verbose_name='描述信息')
hbook = models.ForeignKey(BookInfo, on_delete=models.CASCADE, verbose_name='图书')
class Meta:
db_table = 'tb_heros'
verbose_name = '英雄'
verbose_name_plural = verbose_name
def __str__(self):
return self.hname
# serializers.py
from rest_framework import serializers
from books.models import BookInfo
class HeroInfoSerializer(serializers.Serializer):
"""英雄数据序列化器"""
GENDER_CHOICES = (
(0, 'male'),
(1, 'female')
)
id = serializers.IntegerField(label='ID', read_only=True)
hname = serializers.CharField(label='名字', max_length=20)
hgender = serializers.ChoiceField(choices=GENDER_CHOICES, label='性别', required=False)
hcomment = serializers.CharField(label='描述信息', max_length=200, required=False, allow_null=True)
# 英雄关联到的书籍对象，此处必须指定关联到的对象queryset或者指定参数 read_only=True
# hbook = serializers.PrimaryKeyRelatedField(queryset=BookInfo.objects.all())
hbook = serializers.PrimaryKeyRelatedField(read_only=True)
# views.py
# http://127.0.0.1:8000/heros/1
class HeroView(View):
def get(self, request, pk):
hero = HeroInfo.objects.get(pk=pk)
seralizer = HeroInfoSerializer(hero)
return JsonResponse(seralizer.data)
# urls.py
from django.conf.urls import url
from books import views
urlpatterns = [
url(r'^heros/(?P\d+)/$' , views.HeroView.as_view()),
]
// http://127.0.0.1:8000/heros/5/
{
id: 5,
hname: "贾宝玉",
hgender: 0,
hcomment: null,
hbook: 1
}
StringRelatedField：返回关联对象模型类中定义的__str__方法返回值
# serializers.py
from rest_framework import serializers
from books.models import BookInfo
class HeroInfoSerializer(serializers.Serializer):
"""英雄数据序列化器"""
GENDER_CHOICES = (
(0, 'male'),
(1, 'female')
)
id = serializers.IntegerField(label='ID', read_only=True)
hname = serializers.CharField(label='名字', max_length=20)
hgender = serializers.ChoiceField(choices=GENDER_CHOICES, label='性别', required=False)
hcomment = serializers.CharField(label='描述信息', max_length=200, required=False, allow_null=True)
# 返回关联对象模型类中定义的__str__方法返回值
# 为什么此处不需要指定read_only=True，因为此方法内部自己将其封装进去了
"""
class StringRelatedField(RelatedField):
def __init__(self, **kwargs):
kwargs['read_only'] = True
super(StringRelatedField, self).__init__(**kwargs)
def to_representation(self, value):
return six.text_type(value)
"""
hbook = serializers.StringRelatedField()
// http://127.0.0.1:8000/heros/5/
{
id: 5,
hname: "贾宝玉",
hgender: 0,
hcomment: null,
hbook: "红楼梦"
}
SlugRelatedField：显示关联对象的某一个字段
# serializers.py
from rest_framework import serializers
from books.models import BookInfo
class HeroInfoSerializer(serializers.Serializer):
"""英雄数据序列化器"""
GENDER_CHOICES = (
(0, 'male'),
(1, 'female')
)
id = serializers.IntegerField(label='ID', read_only=True)
hname = serializers.CharField(label='名字', max_length=20)
hgender = serializers.ChoiceField(choices=GENDER_CHOICES, label='性别', required=False)
hcomment = serializers.CharField(label='描述信息', max_length=200, required=False, allow_null=True)
# 显示关联对象pbublic_date字段值
hbook = serializers.SlugRelatedField(label='图书', read_only=True, slug_field='pbublic_date')
// http://127.0.0.1:8000/heros/5/
{
id: 5,
hname: "贾宝玉",
hgender: 0,
hcomment: null,
hbook: "1971-07-01"
}
使用关联对象的序列化器
# serializers.py
from rest_framework import serializers
from books.models import BookInfo
class HeroInfoSerializer(serializers.Serializer):
"""英雄数据序列化器"""
GENDER_CHOICES = (
(0, 'male'),
(1, 'female')
)
id = serializers.IntegerField(label='ID', read_only=True)
hname = serializers.CharField(label='名字', max_length=20)
hgender = serializers.ChoiceField(choices=GENDER_CHOICES, label='性别', required=False)
hcomment = serializers.CharField(label='描述信息', max_length=200, required=False, allow_null=True)
# 显示关联对象的序列化后的数据
hbook = BookInfoSerializer()
// http://127.0.0.1:8000/heros/5/
{
id: 5,
hname: "贾宝玉",
hgender: 0,
hcomment: null,
hbook: {
id: 1,
btitle: "红楼梦",
bread: 0,
bcomment: 0,
logo: null
}
}
- 重写
to_representation方法
序列化器的每个字段实际都是由该字段类型的to_representation方法决定格式的，可以通过重写该方法来决定格式
注意，to_representations方法不仅局限在控制关联对象格式上，适用于各个序列化器字段类型。
自定义一个新的关联字段：
# serializers.py
from rest_framework import serializers
from books.models import BookInfo
class BookRelateField(serializers.RelatedField):
"""自定义用于处理图书的字段"""
def to_representation(self, value):
return 'Book: %d %s' % (value.id, value.btitle)
指明hbook为BookRelateField类型
# serializers.py
from rest_framework import serializers
from books.models import BookInfo
class HeroInfoSerializer(serializers.Serializer):
"""英雄数据序列化器"""
GENDER_CHOICES = (
(0, 'male'),
(1, 'female')
)
id = serializers.IntegerField(label='ID', read_only=True)
hname = serializers.CharField(label='名字', max_length=20)
hgender = serializers.ChoiceField(choices=GENDER_CHOICES, label='性别', required=False)
hcomment = serializers.CharField(label='描述信息', max_length=200, required=False, allow_null=True)
# 显示我们上述自定义的类对象的返回值
hbook = BookRelateField(read_only=True)
使用效果
// http://127.0.0.1:8000/heros/5/
{
id: 5,
hname: "贾宝玉",
hgender: 0,
hcomment: null,
hbook: "Book: 1 红楼梦"
}
反向序列化（即从一到多：序列化书籍中的英雄对象）
# serializers.py
from rest_framework import serializers
from books.models import BookInfo
class BookInfoSerializer(serializers.Serializer):
"""图书数据序列化器"""
id = serializers.IntegerField(label='ID', read_only=True)
btitle = serializers.CharField(label='名称', max_length=20)
bpub_date = serializers.DateField(label='发布日期', required=False)
bread = serializers.IntegerField(label='阅读量', required=False)
bcomment = serializers.IntegerField(label='评论量', required=False)
is_delete = serializers.BooleanField(write_only=True)
logo = serializers.ImageField(label='图片', required=False)
# 使用关联对象的序列化器,将书本反向关联的英雄序列化输出
# 注意 many=True，一定不能省略
heroinfo_set = HeroInfoSerializer(many=True)
{
id: 2,
btitle: "西游记",
bread: 0,
bcomment: 0,
logo: null,
heroinfo_set: [
{
id: 1,
hname: "孙悟空",
hgender: 0,
hcomment: null,
hbook: 2
},
{
id: 2,
hname: "猪八戒",
hgender: 0,
hcomment: null,
hbook: 2
},
{
id: 3,
hname: "沙悟净",
hgender: 0,
hcomment: null,
hbook: 2
},
{
id: 4,
hname: "唐僧",
hgender: 0,
hcomment: null,
hbook: 2
}
]
}
5. ModelSerializer（模型类序列化器）使用方式
- 功能同我们上述定义的序列化器，但更简单方便
from rest_framework import ModelSerializer
from .models import BookInfo
class BookInfoSerializer(serializers.ModelSerializer):
"""图书数据序列化器"""
class Meta:
# 指要序列化的模型对象
model = BookInfo
# 列出要序列化的字段,格式为列表或元组, __all__代表序列化所有字段
fields = "__all__"
- 使用
fields来明确字段，__all__表名包含所有字段，也可以写明具体哪些字段，如
class BookInfoSerializer(serializers.ModelSerializer):
"""图书数据序列化器"""
class Meta:
model = BookInfo
fields = ('id', 'btitle', 'bpub_date')
- 使用
exclude可以明确排除掉哪些字段，注意：exclude和fields不能同时存在
class BookInfoSerializer(serializers.ModelSerializer):
"""图书数据序列化器"""
class Meta:
model = BookInfo
exclude = ('logo',)
- 默认ModelSerializer使用主键作为关联字段，但是我们可以使用
depth来简单的生成嵌套表示，depth应该是整数，表明嵌套的层级数量。如：现在有一个英雄model，与上述model是多对一关系（即一本书中会有多个英雄）
# models.py
from books import models
class HeroInfoSerializer(serializers.Serializer):
"""英雄数据序列化器"""
GENDER_CHOICES = (
(0, 'male'),
(1, 'female')
)
id = models.IntegerField(label='ID', read_only=True)
hname = models.CharField(label='名字', max_length=20)
hgender = models.ChoiceField(choices=GENDER_CHOICES, label='性别', required=False)
hcomment = models.CharField(label='描述信息', max_length=200, required=False, allow_null=True)
book = models.ForeignKey(BookInfo, related_name='book')
class Meta:
db_table = 'tb_heros'
verbose_name = '英雄'
verbose_name_plural = verbose_name
def __str__(self):
return self.hname
# serializers.py
class HeroInfoSerializer(serializers.ModelSerializer):
class Meta:
model = HeroInfo
fields = '__all__'
depth = 1
# views.py
from booktest.serializers import HeroInfoSerializer
from booktest.models import HeroInfo
class HeroView(View):
def get(self, request, pk):
hero = HeroInfo.objects.get(id=6)
serializer = HeroInfoSerializer(hero)
print(serializer.data)
- 打印结果
{
'id': 6,
'hname': '乔峰',
'hgender': 1,
'hcomment': '降龙十八掌',
'hbook': {
'id': 2,
'btitle': '天龙八部',
'bpub_date': '1986-07-24',
'bread': 36,
'bcomment': 40,
'logo': None
}
}
- 指明只读字段:可以通过
read_only_fields指明只读字段，即仅用于序列化输出的字段，在反序列化时不允许修改
class BookInfoSerializer(serializers.ModelSerializer):
"""图书数据序列化器"""
class Meta:
model = BookInfo
fields = ('id', 'btitle', 'bpub_date'， 'bread', 'bcomment')
read_only_fields = ('id', 'bread', 'bcomment')
- 指明只读字段:可以通过
write_only_fields指明只写字段，即仅用于反序列化验证的字段，在序列化时不进行显示
class BookInfoSerializer(serializers.ModelSerializer):
"""图书数据序列化器"""
class Meta:
model = BookInfo
fields = ('id', 'btitle', 'bpub_date'， 'bread', 'bcomment')
write_only_fields = ('bread', 'bcomment')
- 我们可以使用
extra_kwargs参数为ModelSerializer添加或修改原有的选项参数 - 比如在数据库声明时未指定字段的最大值与最小值，就可以通过该属性动态添加
class BookInfoSerializer(serializers.ModelSerializer):
"""图书数据序列化器"""
class Meta:
model = BookInfo
fields = ('id', 'btitle', 'bpub_date'， 'bread', 'bcomment')
extra_kwargs = {
'bread': {'min_value': 0, 'required': True}},
'bcomment': {'max_value': 0, 'required': True}},
}
反序列化
1. 定义：
反序列化：将json格式的字符串转换为对象，我们可以对接收的数据进行校验（一般是后端接收前端传送的数据进行校验后进行数据库相关操作：增加、修改 serializer.save()）
继承说明：Django REST framework中的Serializer使用类来定义，须继承自
rest_framework.serializers.Serializer
或
rest_framework.serializers.ModelSerializer
说明：序列化和反序列化使用同一序列化器，通过指定不同参数来区别是用于序列化还是反序列化
# 所有序列化器基类
class BaseSerializer(Field):
def __init__(self, instance=None, data=empty, **kwargs):
self.instance = instance
if data is not empty:
self.initial_data = data
self.partial = kwargs.pop('partial', False)
self._context = kwargs.pop('context', {})
kwargs.pop('many', None)
super(BaseSerializer, self).__init__(**kwargs)
- 当我们只传递一个参数时，且没有指明传递对象，按位置传参，则将book对象传递给
instance，此时默认为进行序列化输出
# views.py
class BooksView(View):
def get(self, request, pk):
book = Book.objects.get(pk=pk)
# 构建序列化对象，将模型对象传入，将其转换为json格式字符串
# serializer = BookInfoSerializer(instance=book)
serializer = BookInfoSerializer(book)
创建对象
- 当我们传递一个参数并指名对象为
data时，默认做反序列化验证，示意**创建**
# views.py
import json
from books.serializers import BookInfoSerializer
class BooksView(View):
def post(self, request):
# 获取前端传递的json数据
json_bytes = request.body # 默认或渠道字节类型数据
json_str = json_bytes.decode() # 将其转换为字符类型
book = json.loads(json_str) # 将json数据转换为字典
# 进行字段校验
serializer = BookInfoSerializer(data=book)
# 校验成功的数据保存在 serializer.validated_data 中，是一个有序字典对象
# print(serializer.validated_data)
# 判断校验是否成功，校验失败时抛出异常，终止往下执行
success = serializer.is_valid(raise_exception=True)
if success:
# 重点强调：此处save会调用序列化器中的create()方法，此方法需要我们自己定义实现
serializer.save()
# 我们也可以直接在此处进行保存操作
# BookInfo(**serializer.validated_data).save()
else:
print(serializer.error)
from rest_framework import serializers
from books.models import BookInfo
class BookInfoSerializer(serializers.Serializer):
"""图书数据序列化器"""
id = serializers.IntegerField(label='ID', read_only=True)
btitle = serializers.CharField(label='名称', max_length=20)
bpub_date = serializers.DateField(label='发布日期', required=False)
bread = serializers.IntegerField(label='阅读量', required=False)
bcomment = serializers.IntegerField(label='评论量', required=False)
logo = serializers.ImageField(label='图片', required=False)
def create(self, validated_data):
# validated_data: 校验成功的数据
book_info = BookInfo(**validated_data).save()
# 重点强调，此处必须返回保存成功后的对象
return book_info
更新对象
- 接下来示意
**更新**操作
# serializers.py
class BookView(View):
def put(self, request, pk):
try:
book = BookInfo.objects.get(pk=pk)
except Exception as e:
raise Http404
# 获取前端传递的json数据
json_bytes = request.body # 默认或渠道字节类型数据
json_str = json_bytes.decode() # 将其转换为字符类型
book_dict = json.loads(json_str) # 将json数据转换为字典
# 进行字段校验, 当instance和data同时传递时表示修改操作
# partial=True 表示前端并不需要将所有字段都传递回来，可以选择性传递要修改的字段
serializer = BookInfoSerializer(instance=book, data=book_dict, partial=True)
success = serializer.is_valid(raise_exception=True)
if success:
# 重点强调：此处save会调用序列化器中的update()方法，此方法需要我们自己定义实现
serializer.save()
return HttpResponse('update success')
# serializers.py
from rest_framework import serializers
from books.models import BookInfo
class BookInfoSerializer(serializers.Serializer):
"""图书数据序列化器"""
id = serializers.IntegerField(label='ID', read_only=True)
btitle = serializers.CharField(label='名称', max_length=20)
bpub_date = serializers.DateField(label='发布日期', required=False)
bread = serializers.IntegerField(label='阅读量', required=False)
bcomment = serializers.IntegerField(label='评论量', required=False)
logo = serializers.ImageField(label='图片', required=False)
def create(self, validated_data):
# validated_data: 校验成功的数据
book_info = BookInfo(**validated_data).save()
# 重点强调，此处必须返回保存成功后的对象
return book_info
def update(self, instance, validated_data):
"""更新，instance为要更新的对象实例"""
# 说明，当用户更新时，并不一定更新所有字段，所以，用户未传递过来进行更新的字段我们将其原有的数据进行填充
instance.btitle = validated_data.get('btitle', instance.btitle)
instance.bpub_date = validated_data.get('bpub_date', instance.bpub_date)
instance.bread = validated_data.get('bread', instance.bread)
instance.bcomment = validated_data.get('bcomment', instance.bcomment)
instance.logo = validated_data.get('logo', instance.logo)
instance.save()
return instance
serializer.save()源码解析
def save(self, **kwargs):
validated_data = dict(
list(self.validated_data.items()) +
list(kwargs.items())
)
# self 即我们创建的序列化器的实例对象
# self.instance 即我们传递的对象
# serializer = BookInfoSerializer(data=book)
# 当我们传递了instance对象，则调用update方法进行数据更新
if self.instance is not None:
self.instance = self.update(self.instance, validated_data)
assert self.instance is not None, (
'`update()` did not return an object instance.'
)
# 当我们没有传递instance对象时，则调用create方法进行对象创建
else:
self.instance = self.create(validated_data)
assert self.instance is not None, (
'`create()` did not return an object instance.'
)
return self.instance
2. 自定义校验
需求1：要求传递过来的书名必须包含 django，那么此时我们就必须自定义验证器
- 单独字段的验证器定义
validate_
# serializers.py
from rest_framework import serializers
class BookInfoSerializer(serializers.Serializer):
"""图书数据序列化器"""
id = serializers.IntegerField(label='ID', read_only=True)
btitle = serializers.CharField(label='名称', max_length=20)
bpub_date = serializers.DateField(label='发布日期', required=False)
bread = serializers.IntegerField(label='阅读量', required=False)
bcomment = serializers.IntegerField(label='评论量', required=False)
def validate_btitle(self, value):
# value:前端传递过来存储在字典中的数据
if 'django' not in value.lower():
raise serializers.ValidationError("图书不是关于Django的")
return value
需求2：提交的数据中阅读量必须大于评论量，否则不让提交，给出错误
- 同时对多个字段进行比较验证时，可以定义
validate方法来验证
# serializers.py
from rest_framework import serializers
class BookInfoSerializer(serializers.Serializer):
"""图书数据序列化器"""
id = serializers.IntegerField(label='ID', read_only=True)
btitle = serializers.CharField(label='名称', max_length=20)
bpub_date = serializers.DateField(label='发布日期', required=False)
bread = serializers.IntegerField(label='阅读量', required=False)
bcomment = serializers.IntegerField(label='评论量', required=False)
def validate(self, attrs):
# attrs:前端传递过来存储在字典对象
bread = attrs['bread']
bcomment = attrs['bcomment']
if bread < bcomment:
raise serializers.ValidationError('阅读量小于评论量')
return attrs
需求3：要求传递过来的出版日期必须小于当前日期
- 通过
validators参数自定义验证器函数
# serializers.py
from django.utils import timezone
from rest_framework import serializers
def bpub_date(value):
if value > timezone.now().date():
raise serializers.ValidationError("出版日期大于当前时间")
return value
class BookInfoSerializer(serializers.Serializer):
"""图书数据序列化器"""
id = serializers.IntegerField(label='ID', read_only=True)
btitle = serializers.CharField(label='名称', max_length=20)
bpub_date = serializers.DateField(label='发布日期', required=False, validators=[bpub_date])
bread = serializers.IntegerField(label='阅读量', required=False)
bcomment = serializers.IntegerField(label='评论量', required=False)
UniqueValidator唯一性检验
# serializers.py
from django.utils import timezone
from rest_framework import serializers
class BookInfoSerializer(serializers.Serializer):
"""图书数据序列化器"""
id = serializers.IntegerField(label='ID', read_only=True)
# 该字段不允许重复
btitle = serializers.CharField(label='名称', max_length=20, validators=[UniqueValidator])
bpub_date = serializers.DateField(label='发布日期', required=False, validators=[])
bread = serializers.IntegerField(label='阅读量', required=False)
bcomment = serializers.IntegerField(label='评论量', required=False)
UniqueTogetherValidation联合唯一
# serializers.py
from django.utils import timezone
from rest_framework import serializers
class BookInfoSerializer(serializers.Serializer):
"""图书数据序列化器"""
id = serializers.IntegerField(label='ID', read_only=True)
# 该字段不允许重复
btitle = serializers.CharField(label='名称', max_length=20)
bpub_date = serializers.DateField(label='发布日期', required=False, validators=[])
bread = serializers.IntegerField(label='阅读量', required=False)
bcomment = serializers.IntegerField(label='评论量', required=False)
class Meta:
# 要求书名和出版日期不能同时一致
validators = [
UniqueTogetherValidator(
fields=('btitle', 'bpub_date')
)
]