Python高级技术之：`Django Rest Framework`的序列化器（`Serializer`）：如何处理复杂的数据结构。 - 智猿学院-前后端，数据库，人工智能，云计算等领域前沿技术讲座

各位朋友，大家好！我是你们的老朋友，今天咱们来聊聊 Django Rest Framework (DRF) 里的一个关键角色：Serializer（序列化器）。这玩意儿就像个数据界的变形金刚，能把复杂的数据结构玩转得溜溜的。咱们今天就深入研究一下，看看它怎么处理那些让人头疼的复杂数据。

开场白：Serializer 的重要性

想象一下，你的 Django 后端就像一个辛勤的厨师，负责烹饪各种数据佳肴。而前端呢，就像嗷嗷待哺的食客，等着享用美味。但是，厨师做出来的东西，食客不一定能直接吃，得有个翻译或者转换的过程，这就是 Serializer 的作用。它负责把 Python 对象（比如 Django 模型实例）转换成前端能理解的 JSON 或 XML 等格式，反过来也能把前端传来的数据转换成 Python 对象，方便后端处理。

如果没有 Serializer，你的后端和前端就只能鸡同鸭讲，谁也听不懂谁的。所以，Serializer 在 DRF 中扮演着至关重要的角色。

第一部分：Serializer 的基本用法

首先，咱们从最基础的用法开始，温习一下 Serializer 的基本概念。

from rest_framework import serializers

class MyModelSerializer(serializers.Serializer):
    id = serializers.IntegerField(read_only=True)
    name = serializers.CharField(max_length=100)
    description = serializers.CharField(required=False, allow_blank=True)
    created_at = serializers.DateTimeField(read_only=True)

    def create(self, validated_data):
        # 创建对象的逻辑
        return MyModel.objects.create(**validated_data)

    def update(self, instance, validated_data):
        # 更新对象的逻辑
        instance.name = validated_data.get('name', instance.name)
        instance.description = validated_data.get('description', instance.description)
        instance.save()
        return instance

这段代码定义了一个简单的 Serializer，它包含几个字段：id, name, description, created_at。每个字段都指定了类型和一些参数，比如 read_only=True 表示该字段只读，required=False 表示该字段可选，allow_blank=True 表示允许为空字符串。create 和 update 方法分别用于创建和更新对象。

第二部分：处理嵌套关系

现在，咱们开始玩点高级的。假设你的数据模型之间存在嵌套关系，比如一个作者可以有多篇文章，一篇文章可以有多个评论。这时候，就需要用到嵌套 Serializer。

class AuthorSerializer(serializers.Serializer):
    id = serializers.IntegerField(read_only=True)
    name = serializers.CharField(max_length=100)
    email = serializers.EmailField()

class ArticleSerializer(serializers.Serializer):
    id = serializers.IntegerField(read_only=True)
    title = serializers.CharField(max_length=200)
    content = serializers.CharField()
    author = AuthorSerializer(read_only=True)  # 嵌套 AuthorSerializer

class CommentSerializer(serializers.Serializer):
    id = serializers.IntegerField(read_only=True)
    text = serializers.CharField()

class ArticleDetailSerializer(serializers.Serializer):
    id = serializers.IntegerField(read_only=True)
    title = serializers.CharField(max_length=200)
    content = serializers.CharField()
    author = AuthorSerializer(read_only=True)
    comments = CommentSerializer(many=True, read_only=True) # 嵌套 CommentSerializer 列表

在上面的代码中，ArticleSerializer 嵌套了 AuthorSerializer，ArticleDetailSerializer 嵌套了 AuthorSerializer 和 CommentSerializer。这样，在序列化文章时，就可以同时包含作者的信息和评论的信息。many=True 参数表示这是一个列表类型的嵌套。

第三部分：使用 PrimaryKeyRelatedField 和 HyperlinkedRelatedField 处理关联

除了嵌套 Serializer，还可以使用 PrimaryKeyRelatedField 和 HyperlinkedRelatedField 来处理关联关系。这两种方式更加轻量级，只返回关联对象的 ID 或 URL。

class ArticleSerializer(serializers.Serializer):
    id = serializers.IntegerField(read_only=True)
    title = serializers.CharField(max_length=200)
    content = serializers.CharField()
    author = serializers.PrimaryKeyRelatedField(read_only=True)  # 只返回作者 ID
    # author = serializers.HyperlinkedRelatedField(view_name='author-detail', read_only=True) # 返回作者详情 URL

class CommentSerializer(serializers.Serializer):
    id = serializers.IntegerField(read_only=True)
    text = serializers.CharField()
    article = serializers.PrimaryKeyRelatedField(queryset=Article.objects.all()) # 用于 POST/PUT

PrimaryKeyRelatedField 返回关联对象的 ID，HyperlinkedRelatedField 返回关联对象的 URL。view_name 参数指定了关联对象的详情视图的名称。在使用 PrimaryKeyRelatedField 进行反序列化（POST/PUT）时，需要指定 queryset 参数，告诉 Serializer 从哪个查询集中查找关联对象。

第四部分：处理多对多关系

多对多关系比一对多关系稍微复杂一些。假设一篇文章可以有多个标签，一个标签可以被多篇文章使用。

class TagSerializer(serializers.Serializer):
    id = serializers.IntegerField(read_only=True)
    name = serializers.CharField(max_length=50)

class ArticleSerializer(serializers.Serializer):
    id = serializers.IntegerField(read_only=True)
    title = serializers.CharField(max_length=200)
    content = serializers.CharField()
    tags = TagSerializer(many=True, read_only=True)  # 嵌套 TagSerializer 列表 (只读)
    # tags = serializers.PrimaryKeyRelatedField(many=True, queryset=Tag.objects.all()) # 用于 POST/PUT

    def create(self, validated_data):
        tags_data = validated_data.pop('tags', [])
        article = Article.objects.create(**validated_data)
        for tag_data in tags_data:
            article.tags.add(tag_data)
        return article

    def update(self, instance, validated_data):
        tags_data = validated_data.pop('tags', None)
        instance.title = validated_data.get('title', instance.title)
        instance.content = validated_data.get('content', instance.content)
        instance.save()

        if tags_data is not None:
            instance.tags.clear()
            for tag_data in tags_data:
                instance.tags.add(tag_data)

        return instance

在上面的代码中，ArticleSerializer 使用 TagSerializer 的列表来表示文章的标签。如果只是读取标签，可以使用 read_only=True。如果要创建或更新文章时同时更新标签，需要重写 create 和 update 方法。注意，在 create 和 update 方法中，需要先从 validated_data 中移除 tags 字段，然后手动处理多对多关系。如果使用 PrimaryKeyRelatedField，则可以避免重写这两个方法，但前端需要传递标签的 ID 列表。

第五部分：使用 ModelSerializer 简化代码

上面的代码虽然可以工作，但是比较冗长。DRF 提供了 ModelSerializer，可以根据 Django 模型自动生成 Serializer。

from rest_framework import serializers

class AuthorSerializer(serializers.ModelSerializer):
    class Meta:
        model = Author
        fields = '__all__'  # 包含所有字段
        # fields = ['id', 'name', 'email']  # 只包含指定字段
        # exclude = ['password']  # 排除指定字段

class ArticleSerializer(serializers.ModelSerializer):
    author = AuthorSerializer(read_only=True) #嵌套serializer
    class Meta:
        model = Article
        fields = '__all__'
        # depth = 1  # 嵌套深度

class TagSerializer(serializers.ModelSerializer):
    class Meta:
        model = Tag
        fields = '__all__'

class ArticleDetailSerializer(serializers.ModelSerializer):
    author = AuthorSerializer(read_only=True)
    tags = TagSerializer(many=True, read_only=True)
    class Meta:
        model = Article
        fields = '__all__'

ModelSerializer 可以根据模型的字段自动生成 Serializer 的字段。只需要在 Meta 类中指定 model 和 fields 或 exclude 即可。depth 参数可以指定嵌套深度，但是不建议使用，因为它会一次性加载所有关联对象，可能导致性能问题。

第六部分：自定义字段

有时候，默认的字段类型不能满足需求，需要自定义字段。

class UppercaseCharField(serializers.CharField):
    def to_representation(self, value):
        return value.upper()

class ArticleSerializer(serializers.ModelSerializer):
    title = UppercaseCharField(max_length=200)  # 使用自定义字段

    class Meta:
        model = Article
        fields = '__all__'

上面的代码定义了一个自定义的 UppercaseCharField，它会将字符串转换为大写。to_representation 方法用于将 Python 对象转换为 JSON 格式。

class CustomDateField(serializers.DateField):
    def to_representation(self, value):
        return value.strftime('%Y-%m-%d')

    def to_internal_value(self, value):
        try:
            return datetime.strptime(value, '%Y-%m-%d').date()
        except ValueError:
            raise serializers.ValidationError("Invalid date format. Use YYYY-MM-DD.")

class EventSerializer(serializers.ModelSerializer):
    event_date = CustomDateField()

    class Meta:
        model = Event
        fields = ['id', 'name', 'event_date']

这段代码定义了一个 CustomDateField，用于处理日期格式。 to_representation 方法将日期对象格式化为 YYYY-MM-DD 字符串，to_internal_value 方法将 YYYY-MM-DD 字符串解析为日期对象。如果日期格式不正确，则抛出一个验证错误。

第七部分：使用 SerializerMethodField 获取计算值

有时候，需要在 Serializer 中返回一些计算值，而不是模型中直接存在的字段。

class ArticleSerializer(serializers.ModelSerializer):
    comment_count = serializers.SerializerMethodField()  # 使用 SerializerMethodField

    def get_comment_count(self, obj):
        return obj.comment_set.count()

    class Meta:
        model = Article
        fields = '__all__'

上面的代码定义了一个 comment_count 字段，它通过 get_comment_count 方法计算文章的评论数量。get_<field_name> 方法的第一个参数是模型实例。

第八部分：使用 validators 进行数据验证

Serializer 提供了多种方式进行数据验证。可以使用内置的验证器，也可以自定义验证器。

from rest_framework import serializers
from rest_framework.validators import UniqueValidator

class ArticleSerializer(serializers.Serializer):
    title = serializers.CharField(max_length=200,
                                  validators=[UniqueValidator(queryset=Article.objects.all())])  # 使用内置验证器

    def validate_title(self, value):
        if 'spam' in value.lower():
            raise serializers.ValidationError("Title cannot contain the word 'spam'.")
        return value
    def validate(self, data):
        if data['title'] == data['content']:
            raise serializers.ValidationError("Title and content can't be the same.")
        return data
    #...其他字段

上面的代码使用 UniqueValidator 验证文章标题的唯一性。validate_<field_name> 方法用于验证单个字段的值。validate 方法用于验证多个字段之间的关系。

第九部分：使用 ReadOnlyField 和 HiddenField

ReadOnlyField 和 HiddenField 用于控制字段的读写权限。

class ArticleSerializer(serializers.ModelSerializer):
    author_name = serializers.ReadOnlyField(source='author.name') #只读字段，来源于author的name字段
    created_by = serializers.HiddenField(default=serializers.CurrentUserDefault())#隐藏字段，默认值为当前用户

    class Meta:
        model = Article
        fields = '__all__'

ReadOnlyField 用于只读字段，HiddenField 用于隐藏字段。ReadOnlyField 可以指定 source 参数，表示字段的值来源于模型的哪个属性。HiddenField 可以指定 default 参数，表示字段的默认值。CurrentUserDefault 是 DRF 提供的默认值，表示当前用户。

第十部分：总结和最佳实践

Serializer 是 DRF 中非常重要的一个组件，它可以帮助我们轻松地处理复杂的数据结构。在使用 Serializer 时，需要注意以下几点：

尽量使用 ModelSerializer 简化代码。
合理使用嵌套 Serializer、PrimaryKeyRelatedField 和 HyperlinkedRelatedField 处理关联关系。
重写 create 和 update 方法时，要注意处理多对多关系。
使用自定义字段和 SerializerMethodField 获取计算值。
使用 validators 进行数据验证。
使用 ReadOnlyField 和 HiddenField 控制字段的读写权限。
考虑性能问题，避免一次性加载所有关联对象。

希望今天的讲座能帮助你更好地理解和使用 DRF 的 Serializer。记住，熟能生巧，多练习才能真正掌握这些技巧。好了，今天就到这里，咱们下次再见!

发表回复 取消回复

发表回复取消回复