Question

我无法在文档或互联网上找到此信息最新的django-rest-framework，django 1.6.5

如何创建一个可以处理嵌套序列化器的ModelSerializer，其中嵌套模型是使用多重继承实现的？

e.g。

######## MODELS
class OtherModel(models.Model):
    stuff = models.CharField(max_length=255)

class MyBaseModel(models.Model):
    whaddup = models.CharField(max_length=255)
    other_model = models.ForeignKey(OtherModel)

class ModelA(MyBaseModel):
    attr_a = models.CharField(max_length=255)

class ModelB(MyBaseModel):
    attr_b = models.CharField(max_length=255)


####### SERIALIZERS
class MyBaseModelSerializer(serializers.ModelSerializer):
    class Meta:
        model=MyBaseModel

class OtherModelSerializer(serializer.ModelSerializer):
    mybasemodel_set = MyBaseModelSerializer(many=True)

    class Meta:
        model = OtherModel

这显然不起作用，但说明了我在这里要做的事情在OtherModelSerializer中，我希望mybasemodel_set根据我们的内容序列化ModelA或ModelB的特定表示。

如果重要，我也使用django.model_utils和inheritencemanager，这样我就可以检索一个查询集，其中每个实例已经是相应子类的实例。

由于

Answer 1

我以稍微不同的方式解决了这个问题。

使用：

DRF 3.5.x
django-model-utils 2.5.x

我的models.py看起来像这样：

class Person(models.Model):
    first_name = models.CharField(max_length=40, blank=False, null=False)
    middle_name = models.CharField(max_length=80, blank=True, null=True)
    last_name = models.CharField(max_length=80, blank=False, null=False)
    family = models.ForeignKey(Family, blank=True, null=True)


class Clergy(Person):
    category = models.IntegerField(choices=CATEGORY, blank=True, null=True)
    external = models.NullBooleanField(default=False, null=True)
    clergy_status = models.ForeignKey(ClergyStatus, related_name="%(class)s_status", blank=True, null=True)


class Religious(Person):
    religious_order = models.ForeignKey(ReligiousOrder, blank=True, null=True)
    major_superior = models.ForeignKey(Person, blank=True, null=True, related_name="%(class)s_superior")


class ReligiousOrder(models.Model):
    name = models.CharField(max_length=255, blank=False, null=False)
    initials = models.CharField(max_length=20, blank=False, null=False)


class ClergyStatus(models.Model):
    display_name = models.CharField(max_length=255, blank=True, null=True)
    description = models.CharField(max_length=255, blank=True, null=True)

基本上 - 基本模型是＆＃34; Person＆＃34;模特 - 一个人既可以是神职人员，也可以是宗教，或者两者都不是，只是一个人和人。虽然继承Person的模型也有特殊的关系。

在我的views.py中，我使用mixin来＆＃34;注入＆＃34;将子类放入查询集中，如下所示：

class PersonSubClassFieldsMixin(object):

    def get_queryset(self):
        return Person.objects.select_subclasses()

class RetrievePersonAPIView(PersonSubClassFieldsMixin, generics.RetrieveDestroyAPIView):
    serializer_class = PersonListSerializer
    ...

然后真实＆＃34; unDRY＆＃34;部分进入serializers.py，我宣布＆＃34; base＆＃34; PersonListSerializer，但覆盖to_representation方法，根据实例类型返回特殊的serailzer，如下所示：

class PersonListSerializer(serializers.ModelSerializer):

    def to_representation(self, instance):
        if isinstance(instance, Clergy):
            return ClergySerializer(instance=instance).data
        elif isinstance(instance, Religious):
            return ReligiousSerializer(instance=instance).data
        else:
            return LaySerializer(instance=instance).data

    class Meta:
        model = Person
        fields = '__all__'


class ReligiousSerializer(serializers.ModelSerializer):
    class Meta:
        model = Religious
        fields = '__all__'
        depth = 2


class LaySerializer(serializers.ModelSerializer):
    class Meta:
        model = Person
        fields = '__all__'


class ClergySerializer(serializers.ModelSerializer):
    class Meta:
        model = Clergy
        fields = '__all__'
        depth = 2

＆＃34;开关＆＃34;发生在主序列化程序的to_representation方法中（PersonListSerializer）。它查看实例类型，然后＆＃34;注入＆＃34;所需的序列化器。由于Clergy，Religious都是从Person继承回Person成员的Clergy，所以返回所有Person字段和所有Clergy字段。同样适用于Religious。如果Person既不是Clergy也不是Religious，则只返回基本模型字段。

不确定这是否是正确的方法 - 但它似乎非常灵活，适合我的用例。请注意，我通过不同的视图/序列化程序保存/更新/创建Person - 所以我不必担心这种类型的设置。

Answer 2

我能够通过创建自定义相关字段来实现此目的

class MyBaseModelField(serializers.RelatedField):
    def to_native(self, value):
        if isinstance(value, ModelA):
            a_s = ModelASerializer(instance=value)
            return a_s.data
        if isinstance(value, ModelB):
            b_s = ModelBSerializer(instance=value)
            return b_s.data

        raise NotImplementedError


class OtherModelSerializer(serializer.ModelSerializer):
    mybasemodel_set = MyBaseModelField(many=True)

    class Meta:
        model = OtherModel
        fields = # make sure we manually include the reverse relation (mybasemodel_set, )

我确实担心为每个对象立即启动Serializer是反向关系查询集很昂贵，所以我想知道是否有更好的方法来执行此操作。

我尝试的另一种方法是动态更改__init__内MyBaseModelSerializer上的模型字段，但我遇到了此处描述的问题：
django rest framework nested modelserializer

Answer 3

我试图使用涉及不同模型子类的不同序列化程序子类的解决方案：

class MyBaseModelSerializer(serializers.ModelSerializer):

    @staticmethod
    def _get_alt_class(cls, args, kwargs):
        if (cls != MyBaseModel):
            # we're instantiating a subclass already, use that class
            return cls

        # < logic to choose an alternative class to use >
        # in my case, I'm inspecting kwargs["data"] to make a decision
        # alt_cls = SomeSubClass

        return alt_cls

    def __new__(cls, *args, **kwargs):
        alt_cls = MyBaseModel.get_alt_class(cls, args, kwargs)
        return super(MyBaseModel, alt_cls).__new__(alt_cls, *args, **kwargs)

    class Meta:
        model=MyBaseModel

class ModelASerializer(MyBaseModelSerializer):
    class Meta:
        model=ModelA

class ModelBSerializer(MyBaseModelSerializer):
    class Meta:
        model=ModelB

也就是说，当你尝试实例化一个MyBaseModelSerializer类型的对象时，你实际上最终得到了一个子类的对象，它正确地序列化（对我来说，最重要的是反序列化）。

我刚刚开始使用此功能，因此可能存在我尚未遇到的问题。

Answer 4

使用Django 3.1，我发现可以覆盖get_serializer而不是get_serializer_class，在这种情况下，您可以访问实例以及self.action等。

默认情况下，get_serializer会调用get_serializer_class，但是这种行为可以根据您的需要进行调整。

这比上面提出的解决方案更干净，更容易，所以我将其添加到线程中。

示例：

class MySubclassViewSet(viewsets.ModelViewSet):
    # add your normal fields and methods ...

    def get_serializer(self, *args, **kwargs):
        if self.action in ('list', 'destroy'):
            return MyListSerializer(args[0], **kwargs)
        if self.action in ('retrieve', ):
            instance = args[0]
            if instance.name.contains("really?"):  # or check if instance of a certain Model...
                return MyReallyCoolSerializer(instance)
            else return MyNotCoolSerializer(instance)
        # ... 
        return MyListSerializer(*args, **kwargs)  # default

django-rest-framework，多表模型继承，ModelSerializers和嵌套序列化程序

4 个答案: