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. 关联对象的序列化

  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
}
  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: "红楼梦"
}
  1. 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"
}
  1. 使用关联对象的序列化器
# 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
	}
}
  1. 重写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 红楼梦"
}
  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,那么此时我们就必须自定义验证器
  1. 单独字段的验证器定义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:提交的数据中阅读量必须大于评论量,否则不让提交,给出错误
  1. 同时对多个字段进行比较验证时,可以定义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:要求传递过来的出版日期必须小于当前日期
  1. 通过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)
  1. 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)
  1. 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')
            )
        ]

你可能感兴趣的:(Django,RESTFramework)