Django：两个模型之间的两种关系

我正在努力创建两个具有两种关系的模型

我的目标是，一个人可以拥有多个对象，并且始终拥有一个最喜欢的对象（他们拥有）

因此，准确地说，约束可以总结如下：

@api_view(['POST'])
@permission_classes((AllowAny,))
def api_user_registration_view(request):
    if request.method == 'POST':
        dummy_object = Object.objects.get(name='dummy')
        person_serializer = PersonRegistrationSerializer(favorite_object=dummy_object, data=request.data)
        data = {

        }
        if person_serializer.is_valid():
            person = person_serializer.save()
            object_serializer = ObjectRegistrationSerializer(owner=person)
            if object_serializer.is_valid():
                object_serializer.save()
            else:
                data = serializer.errors
        else:
            data = serializer.errors
        return Response(data)

• 1:n关系人-对象（一个人[独占]拥有多个对象）
• n:1关系人-对象（收藏夹对象，每个人都有一个收藏夹对象）
• person.（favorite object）.owner=person（一个人必须拥有自己喜爱的对象，这使得喜爱对象的n:1关系更像是“从对象的角度看可选的1:1”）

班级人员（models.Model）：
favorite_object=models.ForeignKey（'object'））
类对象（models.Model）：
所有者=型号。外键（个人）

首先，我得到一个错误，指出我应该添加一个

相关的\u名称

，以帮助解决反向引用，我想知道在这里最好做什么，因为从对象的角度来看，最喜欢的关系是可选的

我要把主人改成

owner=models.ForeignKey（个人，相关的_name=“+”）

首先要避免反向引用？ 但是，如何查询所有者的所有对象？ 我甚至可以强制Django模型必须拥有最喜欢的对象这一约束吗

---

其次，我首先要如何创建对象？他们相互依赖

我无法创建没有收藏对象的用户，也无法创建不知道其所有者的对象。注意，在我的例子中，这是一个必要的约束

我想做一些像这样的事情，但它似乎不起作用

使用transaction.atomic（）的

：
我的人
我的对象=对象（所有者=我的人）
my_person.favorite_object=我的对象
我的人。保存（）
我的_对象。保存（）

例如，我可以允许

Object.owner

为空，但这将放松我的一般约束，即每个对象都需要有一个所有者

编辑：

看来

favorite_object=models.ForeignKey（'object'，related_name=“+”）

不排除反向关系可能是一个好主意，因为从对象引用回所有者似乎是不必要的。 首先，我可以通过owner属性检查所有者（我的限制是偏爱对象的人也是他们的所有者）。

---

其次，这种反向关系并不总是存在。

也许你可以在数据库中有一个“虚拟”对象，这样Person（）对象就有了一个最喜欢的对象，并且不会失败，然后在创建Person的同一视图中，使用该Person创建一个对象（即persons最喜欢的对象）并更新Person（），使其具有刚创建的对象，而不是虚拟对象

我想它会像这样：

@api_view(['POST'])
@permission_classes((AllowAny,))
def api_user_registration_view(request):
    if request.method == 'POST':
        dummy_object = Object.objects.get(name='dummy')
        person_serializer = PersonRegistrationSerializer(favorite_object=dummy_object, data=request.data)
        data = {

        }
        if person_serializer.is_valid():
            person = person_serializer.save()
            object_serializer = ObjectRegistrationSerializer(owner=person)
            if object_serializer.is_valid():
                object_serializer.save()
            else:
                data = serializer.errors
        else:
            data = serializer.errors
        return Response(data)

在serializers.py中，您只需为每个模型声明注册序列化程序

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

class ObjectRegistrationSerializer(serializers.ModelSerializer):
    class Meta:
        model = Object
        fields = '__all__'

---

我希望这有助于或至少为您指明正确的方向。

也许您可以在数据库中有一个“虚拟”对象，这样Person（）对象就有一个最喜欢的对象，并且不会失败，然后在创建Person的同一视图中，使用该Person创建一个对象（即persons最喜欢的对象）并更新Person（），使其具有刚创建的对象，而不是虚拟对象

我想它会像这样：

@api_view(['POST'])
@permission_classes((AllowAny,))
def api_user_registration_view(request):
    if request.method == 'POST':
        dummy_object = Object.objects.get(name='dummy')
        person_serializer = PersonRegistrationSerializer(favorite_object=dummy_object, data=request.data)
        data = {

        }
        if person_serializer.is_valid():
            person = person_serializer.save()
            object_serializer = ObjectRegistrationSerializer(owner=person)
            if object_serializer.is_valid():
                object_serializer.save()
            else:
                data = serializer.errors
        else:
            data = serializer.errors
        return Response(data)

在serializers.py中，您只需为每个模型声明注册序列化程序

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

class ObjectRegistrationSerializer(serializers.ModelSerializer):
    class Meta:
        model = Object
        fields = '__all__'

---

我希望这有助于或至少为您指明正确的方向。

谢谢您的回答，因此您更喜欢虚拟对象而不是设置

null=True

？还要记住，如果没有所有者，虚拟对象也不可能存在，这意味着您还必须拥有虚拟所有者。首先需要创建一个虚拟对象。你明白了，这是一个循环依赖性谢谢你的回答，所以你更喜欢虚拟对象而不是设置

null=True

？还要记住，如果没有所有者，虚拟对象也不可能存在，这意味着您还必须拥有虚拟所有者。首先需要创建一个虚拟对象。你明白了，这是一个循环依赖