你的这个思路非常棒，用ContentType来做通用模型关系的抽象，确实是Django里实现跨任意模型灵活关系的标准方向。不过你遇到的问题很典型——GenericForeignKey要求当前模型必须直接持有对应的ContentType字段和实例ID字段，而你想从关联的RelationshipType里动态获取这两个ContentType，这确实不能直接用GeneratedField（原因后面说）。我给你几个可行的解决方案，帮你把这个模型跑起来：

方案一：显式保存ContentType字段，通过模型逻辑自动填充 #

这是最直接也最可靠的方案——我们在Relationship模型里显式添加model_a和model_b的ContentType外键字段，然后通过重写save方法或者信号，从关联的RelationshipType里自动填充这两个字段。这样GenericForeignKey就能正常工作了。

1. 先完善RelationshipType模型 #

首先给它加个唯一约束，避免重复的关系类型：

from django.contrib.contenttypes.models import ContentType
from django.db import models

class RelationshipType(models.Model):
    model_a = models.ForeignKey(
        ContentType, 
        on_delete=models.PROTECT, 
        related_name="relationship_types_as_a"
    )
    model_b = models.ForeignKey(
        ContentType, 
        on_delete=models.PROTECT, 
        related_name="relationship_types_as_b"
    )
    name = models.CharField(max_length=127)

    class Meta:
        # 确保同一模型对下的关系名唯一
        unique_together = ('model_a', 'model_b', 'name')

    def __str__(self):
        return f"{self.model_a.model_class().__name__} -> {self.model_b.model_class().__name__}: {self.name}"

2. 调整Relationship模型 #

添加model_a和model_b字段，并用save方法自动填充：

from django.contrib.contenttypes.fields import GenericForeignKey
from django.core.exceptions import ValidationError
from django.db import models

class Relationship(models.Model):
    type = models.ForeignKey(
        RelationshipType, 
        on_delete=models.PROTECT, 
        related_name="relationships"
    )
    
    # 显式保存ContentType，设置editable=False避免手动修改
    model_a = models.ForeignKey(
        ContentType, 
        on_delete=models.PROTECT, 
        editable=False, 
        related_name="relationships_as_a"
    )
    instance_a_id = models.PositiveBigIntegerField()
    instance_a = GenericForeignKey("model_a", "instance_a_id")

    model_b = models.ForeignKey(
        ContentType, 
        on_delete=models.PROTECT, 
        editable=False, 
        related_name="relationships_as_b"
    )
    instance_b_id = models.PositiveBigIntegerField()
    instance_b = GenericForeignKey("model_b", "instance_b_id")

    def save(self, *args, **kwargs):
        # 从关联的RelationshipType自动填充ContentType
        if self.type:
            self.model_a = self.type.model_a
            self.model_b = self.type.model_b
        super().save(*args, **kwargs)

    def clean(self):
        super().clean()
        # 验证实例ID是否属于对应的模型（可选但推荐，避免无效数据）
        if self.type:
            # 验证instance_a的有效性
            if self.instance_a_id:
                model_a_class = self.type.model_a.model_class()
                if not model_a_class.objects.filter(pk=self.instance_a_id).exists():
                    raise ValidationError(
                        f"ID为{self.instance_a_id}的实例不存在于模型{self.type.model_a.name}中"
                    )
            # 验证instance_b的有效性
            if self.instance_b_id:
                model_b_class = self.type.model_b.model_class()
                if not model_b_class.objects.filter(pk=self.instance_b_id).exists():
                    raise ValidationError(
                        f"ID为{self.instance_b_id}的实例不存在于模型{self.type.model_b.name}中"
                    )

    class Meta:
        # 避免同一实例对重复添加同一类型的关系
        unique_together = ('type', 'instance_a_id', 'instance_b_id')

    def __str__(self):
        return f"{self.instance_a} {self.type.name} {self.instance_b}"

为什么不能用GeneratedField？ #

Django的GeneratedField是数据库层面的计算字段，它只能基于当前模型的其他字段生成值，无法跨表引用RelationshipType的字段（比如type.model_a）。不同数据库对生成字段的支持也有限，比如PostgreSQL的GENERATED COLUMN就不允许跨表查询，所以用save方法或者信号是更通用的方案。

方案二：用信号替代重写save方法 #

如果你不想重写模型的save方法，也可以用Django的信号来自动填充ContentType字段：

from django.db.models.signals import pre_save
from django.dispatch import receiver

@receiver(pre_save, sender=Relationship)
def populate_relationship_content_types(sender, instance, **kwargs):
    if instance.type:
        instance.model_a = instance.type.model_a
        instance.model_b = instance.type.model_b

把这段代码放在你的models.py或者signals.py里（记得在apps.py里注册信号），效果和重写save方法一样。

额外提示：性能与场景权衡 #

这种通用关系模型非常适合需要极度灵活的场景（比如CMS、知识图谱类应用），但要注意：

1. 性能问题：GenericForeignKey的查询效率不如普通的ForeignKey，因为它需要先查ContentType再查目标实例，数据量大的时候要注意加索引或者优化查询。
2. 管理后台优化：如果要在Django Admin里方便地管理这些关系，可以自定义表单，根据选中的RelationshipType动态过滤可选的instance_a和instance_b，提升用户体验。
3. 简化场景的替代方案：如果你的关系只在固定几个模型之间存在（比如只有Person和Book），那用普通的多对多中间表会更高效：

   class PersonBookRelationship(models.Model):
       person = models.ForeignKey(Person, on_delete=models.CASCADE)
       book = models.ForeignKey(Book, on_delete=models.CASCADE)
       type = models.CharField(
           max_length=127,
           choices=[('author', '作者'), ('editor', '编辑'), ('subject', '主题')]
       )
   

这样调整后，你就能完美实现需求了——既可以创建任意模型之间的关系类型，又能给具体实例绑定这些关系，比如“张三 是 自传《我的一生》的作者和主题”这种复合关系也能轻松支持。