DRF 序列化 和 反序列化_drf关联序列化反序列化

序列化

1. 定义：

序列化：将model模型对象转换为json格式的字符串，我们可以对返回的数据进行过滤（一般是后端构造数据，返回给前端）

继承说明：Django REST framework中的Serializer使用类来定义，须继承自

rest_framework.serializers.Serializer
或
rest_framework.serializers.ModelSerializer
1
2
3

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)
1
2
3
4
5
6

• 我们想为这个模型类提供一个序列化器，在应用中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)
1
2
3
4
5
6
7
8
9
10

• 在试图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<pk>\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)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

• 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)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

• 注意：JsonResponse转换列表时需要给定参数：safe=False，否则会报错

3. 序列化字段类型及参数

常用字段类型：

选项参数：

通用参数：

重点说明：

• 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
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
31
32
33
34
35
36
37
38
39

# 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)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

# 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)
1
2
3
4
5
6
7
8

# urls.py

from django.conf.urls import url
from books import views

urlpatterns = [
    url(r'^heros/(?P<pk>\d+)/$', views.HeroView.as_view()),
]
1
2
3
4
5
6
7
8

// http://127.0.0.1:8000/heros/5/

{
	id: 5,
	hname: "贾宝玉",
	hgender: 0,
	hcomment: null,
	hbook: 1
}
1
2
3
4
5
6
7
8
9

2. 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()
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

// http://127.0.0.1:8000/heros/5/

{
	id: 5,
	hname: "贾宝玉",
	hgender: 0,
	hcomment: null,
	hbook: "红楼梦"
}
1
2
3
4
5
6
7
8
9

3. 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')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

// http://127.0.0.1:8000/heros/5/

{
	id: 5,
	hname: "贾宝玉",
	hgender: 0,
	hcomment: null,
	hbook: "1971-07-01"
}
1
2
3
4
5
6
7
8
9

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

# 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()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

// 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
2
3
4
5
6
7
8
9
10
11
12
13
14

5. 重写to_representation方法

序列化器的每个字段实际都是由该字段类型的to_representation方法决定格式的，可以通过重写该方法来决定格式 
1

注意，to_representations方法不仅局限在控制关联对象格式上，适用于各个序列化器字段类型。
1

自定义一个新的关联字段：
1

# 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)
1
2
3
4
5
6
7
8
9
10
11

指明hbook为BookRelateField类型
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 = BookRelateField(read_only=True)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

使用效果
1

// http://127.0.0.1:8000/heros/5/

{
	id: 5,
	hname: "贾宝玉",
	hgender: 0,
	hcomment: null,
	hbook: "Book: 1 红楼梦"
}
1
2
3
4
5
6
7
8
9

6. 反向序列化（即从一到多：序列化书籍中的英雄对象）

# 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)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

{
	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
		}
	]
}
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
31
32
33
34
35
36
37

5. ModelSerializer（模型类序列化器）使用方式

• 功能同我们上述定义的序列化器，但更简单方便

from rest_framework import ModelSerializer

from .models import BookInfo

class BookInfoSerializer(serializers.ModelSerializer):
    """图书数据序列化器"""
    class Meta:
   		# 指要序列化的模型对象
   		model = BookInfo
   		# 列出要序列化的字段,格式为列表或元组, __all__代表序列化所有字段
   		fields = "__all__"
1
2
3
4
5
6
7
8
9
10
11

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

class BookInfoSerializer(serializers.ModelSerializer):
    """图书数据序列化器"""
    class Meta:
        model = BookInfo
        fields = ('id', 'btitle', 'bpub_date')
1
2
3
4
5

• 使用exclude可以明确排除掉哪些字段，注意：exclude和fields不能同时存在

class BookInfoSerializer(serializers.ModelSerializer):
    """图书数据序列化器"""
    class Meta:
        model = BookInfo
        exclude = ('logo',)
1
2
3
4
5

• 默认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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

# serializers.py

class HeroInfoSerializer(serializers.ModelSerializer):
    class Meta:
        model = HeroInfo
        fields = '__all__'
        depth = 1
1
2
3
4
5
6
7

# 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)
1
2
3
4
5
6
7
8
9
10
11

• 打印结果

{
	'id': 6, 
	'hname': '乔峰', 
	'hgender': 1, 
	'hcomment': '降龙十八掌', 
	'hbook': {
		'id': 2, 
		'btitle': '天龙八部', 
		'bpub_date': '1986-07-24', 
		'bread': 36, 
		'bcomment': 40, 
		'logo': None
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

• 指明只读字段:可以通过read_only_fields指明只读字段，即仅用于序列化输出的字段，在反序列化时不允许修改

class BookInfoSerializer(serializers.ModelSerializer):
    """图书数据序列化器"""
    class Meta:
        model = BookInfo
        fields = ('id', 'btitle', 'bpub_date'， 'bread', 'bcomment')
        read_only_fields = ('id', 'bread', 'bcomment')
1
2
3
4
5
6

• 指明只读字段:可以通过write_only_fields指明只写字段，即仅用于反序列化验证的字段，在序列化时不进行显示

class BookInfoSerializer(serializers.ModelSerializer):
    """图书数据序列化器"""
    class Meta:
        model = BookInfo
        fields = ('id', 'btitle', 'bpub_date'， 'bread', 'bcomment')
        write_only_fields = ('bread', 'bcomment')
1
2
3
4
5
6

• 我们可以使用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
2
3
4
5
6
7
8
9

反序列化

1. 定义：

反序列化：将json格式的字符串转换为对象，我们可以对接收的数据进行校验（一般是后端接收前端传送的数据进行校验后进行数据库相关操作：增加、修改 serializer.save()）

继承说明：Django REST framework中的Serializer使用类来定义，须继承自

rest_framework.serializers.Serializer
或
rest_framework.serializers.ModelSerializer
1
2
3

说明：序列化和反序列化使用同一序列化器，通过指定不同参数来区别是用于序列化还是反序列化

# 所有序列化器基类

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)
1
2
3
4
5
6
7
8
9
10
11

• 当我们只传递一个参数时，且没有指明传递对象，按位置传参，则将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)
1
2
3
4
5
6
7

创建对象

• 当我们传递一个参数并指名对象为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)	
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

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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

更新对象

• 接下来示意**更新**操作

# 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')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

# 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
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
31
32

• 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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

2. 自定义校验

需求1：要求传递过来的书名必须包含 django，那么此时我们就必须自定义验证器
1

1. 单独字段的验证器定义validate_<field_name>

# 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
		
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

需求2：提交的数据中阅读量必须大于评论量，否则不让提交，给出错误
1

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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

需求3：要求传递过来的出版日期必须小于当前日期
1

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)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

4. 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
2
3
4
5
6
7
8
9
10
11
12
13
14

6. 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')
            )
        ]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22