如何让Django Serializer支持多类型序列化列表及混合对象？

Django REST Framework原生不支持直接通过||语法指定多类型序列化器，需要通过自定义字段或重写序列化逻辑实现需求，以下是两种可行方案：

方案一：自定义多类型列表字段（通用型） #

通过继承DRF的Field和ListSerializer，实现支持多序列化器的列表字段，同时处理序列化和反序列化逻辑：

from rest_framework import serializers

class MultiTypeListSerializer(serializers.ListSerializer):
    def __init__(self, child_serializers, *args, **kwargs):
        self.child_serializers = child_serializers
        super().__init__(child=None, *args, **kwargs)

    def to_representation(self, data):
        # 序列化：根据对象所属模型匹配对应序列化器
        representations = []
        for item in data:
            for serializer_cls in self.child_serializers:
                if isinstance(item, serializer_cls.Meta.model):
                    serializer = serializer_cls(context=self.context)
                    representations.append(serializer.to_representation(item))
                    break
        return representations

    def to_internal_value(self, data):
        # 反序列化：尝试用每个子序列化器验证数据，匹配成功则保留
        internal_values = []
        for item in data:
            validated_data = None
            for serializer_cls in self.child_serializers:
                try:
                    serializer = serializer_cls(data=item, context=self.context)
                    serializer.is_valid(raise_exception=True)
                    validated_data = serializer.validated_data
                    break
                except serializers.ValidationError:
                    continue
            if not validated_data:
                raise serializers.ValidationError(f"无法识别的标识符类型: {item}")
            internal_values.append(validated_data)
        return internal_values

class MultiTypeListField(serializers.Field):
    def __init__(self, child_serializers, *args, **kwargs):
        self.child_serializers = child_serializers
        kwargs.setdefault('many', True)
        super().__init__(*args, **kwargs)

    def to_representation(self, value):
        serializer = MultiTypeListSerializer(child_serializers=self.child_serializers, instance=value, context=self.context)
        return serializer.to_representation(value)

    def to_internal_value(self, data):
        serializer = MultiTypeListSerializer(child_serializers=self.child_serializers, data=data, context=self.context)
        serializer.is_valid(raise_exception=True)
        return serializer.validated_data

在BundleSerializer中使用该字段：

class BundleSerializer(serializers.ModelSerializer):
    identifier = MultiTypeListField(child_serializers=[IdentifierSerializerA, IdentifierSerializerB], required=False)

    class Meta:
        model = BundleModel
        fields = "__all__"

方案二：结合SerializerMethodField与重写CRUD方法（多态关联场景） #

如果identifier对应多个关联模型（多态外键），可以用SerializerMethodField处理序列化，重写create/update方法处理反序列化：

class BundleSerializer(serializers.ModelSerializer):
    identifier = serializers.SerializerMethodField()

    def get_identifier(self, obj):
        # 序列化：遍历关联对象，根据模型类型选择序列化器
        representations = []
        # 假设obj.identifier是包含多类型实例的查询集/列表，需根据实际关联方式调整
        for item in obj.identifier.all():
            if isinstance(item, IdentifierSerializerA.Meta.model):
                representations.append(IdentifierSerializerA(item).data)
            elif isinstance(item, IdentifierSerializerB.Meta.model):
                representations.append(IdentifierSerializerB(item).data)
        return representations

    def create(self, validated_data):
        identifier_data = validated_data.pop('identifier', [])
        bundle = super().create(validated_data)
        # 反序列化：根据数据特征匹配对应的模型创建实例
        for item_data in identifier_data:
            if 'specific_field_a' in item_data:  # 用A专属字段判断类型
                IdentifierModelA.objects.create(bundle=bundle, **item_data)
            elif 'specific_field_b' in item_data:  # 用B专属字段判断类型
                IdentifierModelB.objects.create(bundle=bundle, **item_data)
        return bundle

    class Meta:
        model = BundleModel
        fields = "__all__"

优化建议 #

如果需要更高效的类型判断，可在每个标识符数据中加入type标识字段，反序列化时直接根据type匹配序列化器，避免逐个尝试验证：

# 在MultiTypeListSerializer的to_internal_value中修改
def to_internal_value(self, data):
    internal_values = []
    # 建立类型与序列化器的映射
    serializer_map = {
        'type_a': IdentifierSerializerA,
        'type_b': IdentifierSerializerB
    }
    for item in data:
        item_type = item.get('type')
        if not item_type or item_type not in serializer_map:
            raise serializers.ValidationError(f"无效的标识符类型: {item_type}")
        serializer = serializer_map[item_type](data=item, context=self.context)
        serializer.is_valid(raise_exception=True)
        internal_values.append(serializer.validated_data)
    return internal_values

内容的提问来源于stack exchange，提问作者bacon-delight