DRF进阶之序列化器

发表于 分类于 ，
本文字数： 11k 阅读时长 ≈ 10 分钟

1.DRF 序列化器

作用：

  1. 序列化,序列化器会把模型对象转换成字典,将来提供给视图经过response以后变成json字符串
  2. 反序列化,把客户端发送过来的数据,经过视图调用序列化器以后变成python字典,序列化器可以把字典转成模型
  3. 反序列化,完成数据校验功能和操作数据库

1. 构建序列化器

我们在已有的一个数据库模型类 StudentsInfo：

1
2
3
4
5
6
7
8
9
10
11
12
13
# models.py

class StudentsInfo(models.Model):
		'''
		学生信息模型
		'''
    s_name = models.CharField(max_length=8, verbose_name='学生姓名') 
    s_age = models.IntegerField(verbose_name='学生年龄')
    s_number = models.CharField(max_length=16, verbose_name='学号')
    class Meta:
        db_table="tb_student"
        verbose_name = "学生"
        verbose_name_plural = verbose_name

构建此模型的序列化器，可按如下操作构建：

1
2
3
4
5
6
7
8
9
10
11
12
# serializers.py

from rest_framework import serializers

class StudentsSerializer(serializers.Serializer):
		'''
		学生信息序列化器
		'''
    id = serializers.IntegerField(label='ID', read_only=True)
    s_name = serializers.CharField(label='姓名', max_length=8)
    s_age = serializers.IntegerField(label='年龄', required=True)
    s_number = serializers.CharField(label='学号', max_length=16)

注意：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(max_length=50, minlength=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=)

选项参数：

参数名称 作用
max_length 最大长度
min_lenght 最小长度
allow_blank 是否允许为空
trim_whitespace 是否截断空白字符
max_value 最大值
min_value 最小值

通用参数：

参数名称 说明
read_only 表明该字段仅用于序列化输出，默认False
write_only 表明该字段仅用于反序列化输入，默认False
required 表明该字段在反序列化时必须输入，默认True
default 反序列化时使用的默认值
allow_null 表明该字段是否允许传入None，默认False
validators 该字段使用的验证器
error_messages 包含错误编号与错误信息的字典
label 用于HTML展示API页面时，显示的字段名称
help_text 用于HTML展示API页面时，显示的字段帮助提示信息

3. 创建Serializer对象

定义好 Serializer 类后，就可以创建 Serializer 对象了。Serializer 的构造方法为：

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

说明：

  • 用于序列化时，将模型类对象传入 instance 参数；
  • 用于反序列化时，将要被反序列化的数据传入 data 参数；
  • 除了 instance 和 data 参数外，在构造 Serializer 对象时，还可通过 context 参数额外添加数据，如：
1
serializer = StudentsSerializer(student, context={'request': request})

通过 context 参数附加的数据，可以通过 Serializer 对象的 context 属性获取。

  1. 使用序列化器的时候一定要注意，序列化器声明了以后，不会自动执行，需要我们在视图中进行调用才可以。
  2. 序列化器无法直接接收数据，需要我们在视图中创建序列化器对象时把使用的数据传递过来。
  3. 序列化器的字段声明类似于我们前面使用过的表单系统。
  4. 开发restful api时，序列化器会帮我们把模型数据转换成字典.
  5. drf提供的视图会帮我们把字典转换成json,或者把客户端发送过来的数据转换字典.

4. 序列化器使用流程

序列化器的使用分两个阶段：

  1. 在客户端请求时，使用序列化器可以完成对数据的反序列化。
  2. 在服务器响应时，使用序列化器可以完成对数据的序列化。

为了更好理解序列化器的原理，我们通过终端来演示序列化器的使用：

1
python manage.py shell
  1. 通过查询获取需要序列化的学生对象：
1
2
3
from App01.models import StudentsModel

student = StudentsModel.objects.get(pk=2)
  1. 实例化序列化器，构造序列化器对象：
1
2
3
from App01.serializers import StudentsSerializer

serializer = StudentsSerializer(student)
  1. 获取序列化数据，通过序列化器对象的 data 属性，可以获取序列化后的数据：
1
2
3
serializer.data
# {'id': 1, 's_name': '小明', 's_age': 18, 's_number': '001'}

  1. 如果要被序列化的是包含多条数据的查询集 QuerySet，可以通过添加 many=True 参数实现序列化
1
2
3
4
5
6
7
8
9
10
student_qs = StudentsModel.objects.all()
serializer = StudentsSerializer(student_qs, many=True)
serializer.data
"""
[OrderedDict([('id', 1), ('s_name', '小明'), ('s_age', 18), ('s_number', '001')]), OrderedDict([('id', 3), ('s_name', '小王'), ('s_age', 11), ('s_number', '003')]), OrderedDict([('id', 4), ('s_name', '小白'), ('s_age', 10), ('s_number', '004')])]
OrderedDict是python内置的高级数据类型，表示有序字典，因为普通数据类型中的字典是无序的.
        有序字典的成员读取方式，和无序字典一样
        导入路径：from collections import OrderedDict
"""

完整视图代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class StudentAPIView(View):
    def get(self,request):
        """返回一个学生信息"""
        # 读取模型对象
        student = Student.objects.get(pk=1)
        # 实例化序列化器
        serializer = StudentSerializer(instance=student)
        
        # student_list = Student.objects.all()
        # serializer = StudentSerializer(instance=student_list, many=True)
        print( serializer.data )
        """打印效果：
        {'id': 1, 's_name': '小明', 's_age': 18, 's_number': '001'}
        """
        return JsonResponse(serializer.data)

5.反序列化使用

5.1 数据验证

序列化是将数据库中的数据进行解析，返回前端需要的数据形式（如 json），而前端发来的数据，经过验证和处理，变为数据库需要的数据形式，这个过程称为反序列化。

为了保证数据符合数据模型的要求，对前端发来的数据，根据字段类别、字段限制首先进行验证。在序列化器中，可以调用 is_valid() 方法进行验证，验证成功返回 True，否则返回 False。

验证失败，可以通过序列化器对象的errors属性获取错误信息，返回字典，包含了字段和字段的错误。如果是非字段错误，可以通过修改REST framework配置中的NON_FIELD_ERRORS_KEY来控制错误字典中的键名。

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

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

1
2
3
4
5
6
7
8
9
10
11
# serializers.py

from rest_framework import serializers

class StudentsSerializer(serializers.Serializer):

    id = serializers.IntegerField(label='ID', read_only=True)
    s_name = serializers.CharField(label='姓名', max_length=8)
    s_age = serializers.IntegerField(label='年龄', required=True)
    s_number = serializers.CharField(label='学号', max_length=16)

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

1
2
3
4
5
6
7
8
9
10
11
from AppDemo.serializers import StudentsSerializer
data = {'s_name': '小黄', 's_age': 15, 's_number': '004'}
serializer = StudentsSerializer(data=data) 
# raise_exception=True 表示终断程序，直接抛出错误
serializer.is_valid(raise_exception=True)  
# 返回True
serializer.errors
# {}
serializer.validated_data  # 验证通过的数据
# OrderedDict([('s_name', '小黄'), ('s_age', 15), ('s_number', '004')])

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

validate_字段名，单个验证

对<field_name>字段进行验证，如

1
2
3
4
5
6
7
def validate_s_age(self, data):
    """"""
    if data < 18:
        raise serializers.ValidationError("年龄小于18岁")
    # 验证通过以后，必须要返回验证的结果数据，否则序列化器的validated_data无法得到当前字段的结果
    return data

validate，多字段验证

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

1
2
3
4
5
6
7
8
9
10
11
12
class StudentsSerializer(serializers.Serializer):
    # 多个字段的验证，必须方法名叫 "validate"
    # data 表示客户端发送过来的所有数据，字典格式
    def validate(self, data):
        # 判断图书的阅读量不能低于评论量
        xxx = data.get("xxx")
        yyy = data.get("yyy")
        if 条件:
            raise serializers.ValidationError("xxx")

        return data

validators

在字段中添加validators选项参数，也可以补充验证行为

1
2
3
4
5
6
7
8
9
10
# 可以把验证函数进行多次使用，提供不同的字段或者不同的序列化器里面使用
def age_vaildate(data):
    if data < 18 :
        raise serializers.ValidationError("年龄小于18岁")
    # 返回验证以后的数据
    return data
class StudentsSerializer(serializers.Serializer):
    # 这里声明的字段用于进行反序列化器
    s_age = models.IntegerField(verbose_name='学生年龄',validators=[age_vaildate], label="年龄", help_text="年龄")

1
2
3
4
1. 先执行了字段内置的验证选项
2. 再执行了validators自定义选项
3. 最后执行了validate自定义验证方法[包含了validate_<字段>, validate]

5.2 数据保存

数据验证通过后，如果需要将验证通过的数据（validated_data）进行存储或更新，需要对序列化器进行改造，增加 create() 和 update() 两个方法来实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
from rest_framework import serializers
from AppDemo.models import StudentsModel

class StudentsSerializer(serializers.Serializer):

    id = serializers.IntegerField(label='ID', read_only=True)
    s_name = serializers.CharField(label='姓名', max_length=8)
    s_age = serializers.IntegerField(label='年龄', required=True)
    s_number = serializers.CharField(label='学号', max_length=16)

    def create(self, validated_data):
        """存储新数据"""
        return StudentsModel.objects.create(**validated_data)

    def update(self, instance, validated_data):
        """更新，instance为要更新的对象实例"""
        instance.s_name = validated_data.get('s_name', instance.s_name)
        instance.s_age = validated_data.get('s_age', instance.s_age)
        instance.s_number = validated_data.get('s_number', instance.s_number)
        instance.save()
        return instance

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

1
2
3
4
5
6
7
8
9
10
student = serializer.save()
"""
serailzier对象调用的save方法是什么？怎么做到自动调用update和create?
1. 这里的save不是数据库ORM模型对象的save，是BaseSerializer定义的。
2. save方法中根据实例化serializer时是否传入instance参数来判断执行update还是create的
当传入instance时，则instance.save调用的就是update方法
没有传入instance，则instance.save调用的就是create方法
3. serializer.save使用前提是必须在序列化器中声明create或者update方法，否则报错！！！
"""

说明：

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

1
2
serializer.save(owner=request.user)

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

1
2
3
# partial=True 设置序列化器只是针对客户端提交的字段进行验证，没有提交的字段，即便有验证选项或方法也不进行验证。
serializer = BookInfoSerializer(book, data=data, partial=True)

6. 模型类序列化器 ModelSerializer

Django REST framework 为我们提供了 ModelSerializer 模型类序列化器。

ModelSerializer 与常规的 Serializer 相同，不再需要声明每一个字段，它提供了：

  • 基于模型类自动生成一系列字段
  • 基于模型类自动为Serializer生成validators，比如unique_together
  • 包含默认的 create() 和 update() 的实现

6.1 构建模型类序列化器（ModelSerializer）

将上述序列化器改造为模型类序列化器 StudentsSerializer：

1
2
3
4
5
6
7
8
9
10
11
# serializers.py

from rest_framework import serializers
from AppDemo.models import StudentsModel

class StudentsSerializer(serializers.ModelSerializer):

    class Meta:
        model = StudentsModel
        fields = '__all__'

  • model 指明与序列化器相对应的数据模型；
  • fields 指明为模型类中要序列化（反序列化）的字段。

6.2 指定字段

  1. 在构建序列化器时，fields 除了可以指定 __all__ 外，还可以选择性地指定需要序列化的字段。
  2. 使用 exclude 用来指定哪些字段不需要进行序列化
  3. 指明只读字段，有些字段仅需序列化时输出，此时可以通过read_only_fields指明只读字段
  4. 使用extra_kwargs参数为ModelSerializer添加或修改原有的选项参数
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# serializers.py

from rest_framework import serializers
from AppDemo.models import StudentsModel

class StudentsSerializer(serializers.ModelSerializer):

    class Meta:
        model = StudentsModel
        fields = ('id', 's_name', 's_age')
        exclude = ('s_number',)
        read_only_fields = ('id')
        extra_kwargs = {
            's_name': {'min_value': 2, 'required': True},
            's_age': {'required': True},
        }
相关文章推荐
都看到这里了，不赏点银子吗^v^