Django多用户类型实现：抽象模型与代理模型哪个更优？

一、改用抽象模型的实现代码 #

1. 抽象基类定义（models.py） #

先创建包含所有用户通用字段的抽象模型，三种用户类型将继承该基类：

from django.db import models
from django.contrib.auth.models import AbstractBaseUser, PermissionsMixin, BaseUserManager
from django.db import transaction
from django.apps import apps

class Role(models.TextChoices):
    ADMIN = "ADMIN", "管理员"
    COMPANY = "COMPANY", "企业用户"
    INDIVIDUAL = "INDIVIDUAL", "个人用户"

class AbstractUser(AbstractBaseUser, PermissionsMixin):
    # 所有用户共享的核心字段
    id = models.AutoField(primary_key=True)
    email = models.EmailField(max_length=150, unique=True, null=False, blank=False)
    is_staff = models.BooleanField(null=False, default=False)
    is_active = models.BooleanField(null=False, default=True)
    is_superuser = models.BooleanField(null=False, default=False)

    USERNAME_FIELD = "email"

    class Meta:
        abstract = True  # 标记为抽象模型，不会生成数据库表

    def __str__(self):
        return self.email

    def has_perm(self, perm, obj=None):
        return self.is_staff

    def has_module_perms(self, app_label):
        return self.is_superuser

2. 各用户类型模型定义 #

每个用户类型继承抽象基类，同时整合原Profile中的专属字段（也可保留一对一关系，这里直接整合更简洁）：

# 管理员用户模型
class Admin(AbstractUser):
    first_name = models.CharField(max_length=50, null=False, blank=False)
    middle_name = models.CharField(max_length=50, null=True, blank=True)
    last_name = models.CharField(max_length=50, null=False, blank=False)
    objects = AdminManager()

    def custom_method_for_admin_only(self):
        return "管理员专属操作"

# 企业用户模型
class Company(AbstractUser):
    name = models.CharField(max_length=50, null=False, blank=False)
    is_verified = models.BooleanField(default=False, null=False, blank=True)
    logo = models.ImageField(upload_to="images/", null=True, blank=True)
    objects = CompanyManager()

    def custom_method_for_company_only(self):
        return "企业专属操作"

# 个人用户模型
class Individual(AbstractUser):
    first_name = models.CharField(max_length=50, null=False, blank=False)
    middle_name = models.CharField(max_length=50, null=True, blank=True)
    last_name = models.CharField(max_length=50, null=False, blank=False)
    objects = IndividualManager()

3. 管理器调整（managers.py） #

由于每个用户类型是独立数据库模型，管理器无需再通过role字段过滤，直接创建对应实例即可：

class AccountManager(BaseUserManager):
    def create_superuser(
        self,
        email,
        password,
        first_name=None,
        middle_name=None,
        last_name=None,
        **other_fields
    ):
        with transaction.atomic():
            other_fields.setdefault("is_staff", True)
            other_fields.setdefault("is_superuser", True)
            other_fields.setdefault("is_active", True)
            
            if not email:
                raise ValueError("超级用户必须填写邮箱")
            if not first_name:
                raise ValueError("超级用户必须填写名字")
            if not last_name:
                raise ValueError("超级用户必须填写姓氏")
            if other_fields.get("is_staff") is not True:
                raise ValueError("超级用户必须设置is_staff=True")
            if other_fields.get("is_superuser") is not True:
                raise ValueError("超级用户必须设置is_superuser=True")
                
            email = self.normalize_email(email)
            superuser = self.model(
                email=email,
                first_name=first_name,
                middle_name=middle_name,
                last_name=last_name,
                **other_fields
            )
            superuser.set_password(password)
            superuser.save()
            return superuser

class AdminManager(AccountManager):
    def create(
        self, email, password, first_name, last_name, middle_name=None, **other_fields
    ):
        with transaction.atomic():
            admin = self.model(
                email=email,
                first_name=first_name,
                middle_name=middle_name,
                last_name=last_name,
                is_staff=True,
                **other_fields
            )
            admin.set_password(password)
            admin.save()
            return admin

class CompanyManager(AccountManager):
    def create(self, email, password, name, **other_fields):
        with transaction.atomic():
            company = self.model(
                email=email,
                name=name,
                **other_fields
            )
            company.set_password(password)
            company.save()
            return company

class IndividualManager(AccountManager):
    def create(
        self, email, password, first_name, last_name, middle_name=None, **other_fields
    ):
        with transaction.atomic():
            individual = self.model(
                email=email,
                first_name=first_name,
                middle_name=middle_name,
                last_name=last_name,
                **other_fields
            )
            individual.set_password(password)
            individual.save()
            return individual

二、代理模型 vs 抽象模型：优劣对比 #

代理模型的优劣势 #

优势

• 存储高效：所有用户类型共享同一张数据库表，无数据冗余，全量用户查询无需多表关联。
• 类型转换灵活：只需修改role字段值，即可将一个用户实例在不同类型间切换。
• 权限兼容好：基于同一个User基类，Django内置的认证、权限系统可直接复用，无需额外适配。

劣势

• 字段扩展受限：核心字段统一，专属字段只能通过一对一Profile表扩展，增加查询复杂度。
• 逻辑耦合度高：不同用户类型的业务逻辑（如创建、验证）需通过管理器或条件判断实现，代码冗余且维护成本高。
• 数据库约束弱：无法通过数据库层面强制约束不同类型的字段规则，只能靠代码校验。

抽象模型的优劣势 #

优势

• 字段定制自由：每个用户类型拥有独立数据表，可直接添加专属字段，无需依赖额外Profile表，查询更高效。
• 逻辑解耦清晰：各用户类型的模型、管理器完全独立，业务逻辑可单独维护，代码结构更清晰。
• 约束性强：可通过数据库字段约束（如null=False）强制保证各类型的必填字段，数据一致性更高。

劣势

• 数据冗余：通用字段（如email、is_active）会在各类型表中重复存储，占用更多数据库空间。
• 跨类型查询复杂：查询所有用户需多表联合查询或额外封装视图，比代理模型的单表查询繁琐。
• 权限适配成本高：各用户类型是独立模型，若要统一使用Django权限系统，需额外处理权限分配、认证逻辑的兼容问题。

内容的提问来源于stack exchange，提问作者Ashutosh Chapagain