如何在Django中实现具有双向对称特性的Balance模型？

针对你需要的双向对称Balance模型特性，这里提供两种实用方案，根据业务场景选择即可：

方案一：单条记录存储+自定义查询逻辑（推荐） #

这种方式避免冗余数据，通过逻辑处理实现对称查询，减少一致性维护成本。

1. 模型定义（带约束） #

通过clean和save方法确保同一对用户只存一条记录，自动调整方向和金额符号：

from django.db import models
from django.contrib.auth import get_user_model
from django.core.exceptions import ValidationError
from decimal import Decimal

User = get_user_model()

class Balance(models.Model):
    payer = models.ForeignKey(User, on_delete=models.CASCADE, related_name='outgoing_balances')
    payee = models.ForeignKey(User, on_delete=models.CASCADE, related_name='incoming_balances')
    amount = models.DecimalField(max_digits=10, decimal_places=2)

    def clean(self):
        super().clean()
        if self.payer == self.payee:
            raise ValidationError("付款方和收款方不能是同一用户")
        # 强制payer ID小于payee ID，统一存储方向
        if self.payer.id > self.payee.id:
            self.payer, self.payee = self.payee, self.payer
            self.amount = -self.amount

    def save(self, *args, **kwargs):
        self.full_clean()  # 确保约束生效
        super().save(*args, **kwargs)

    class Meta:
        unique_together = ('payer', 'payee')  # 避免重复记录

2. 自定义管理器实现对称查询 #

添加管理器方法，自动处理正向/反向查询的金额转换：

class BalanceManager(models.Manager):
    def get_balance(self, payer, payee):
        if payer.id == payee.id:
            return Decimal('0.00')
        try:
            if payer.id < payee.id:
                return self.get(payer=payer, payee=payee).amount
            else:
                return -self.get(payer=payee, payee=payer).amount
        except Balance.DoesNotExist:
            return Decimal('0.00')

class Balance(models.Model):
    # ... 保留之前的字段定义 ...
    objects = BalanceManager()

使用示例：

# 获取USER1欠USER2的金额
balance_forward = Balance.objects.get_balance(USER_1, USER_2)
# 获取USER2欠USER1的金额，自动取反
balance_backward = Balance.objects.get_balance(USER_2, USER_1)
# 自动满足 balance_forward == -balance_backward

方案二：双向记录同步（适用于必须存储两条记录的场景） #

如果业务要求必须存储双向记录，用Django信号保证数据一致性：

1. 基础模型定义 #

from django.db import models
from django.contrib.auth import get_user_model

User = get_user_model()

class Balance(models.Model):
    payer = models.ForeignKey(User, on_delete=models.CASCADE, related_name='outgoing_balances')
    payee = models.ForeignKey(User, on_delete=models.CASCADE, related_name='incoming_balances')
    amount = models.DecimalField(max_digits=10, decimal_places=2)

    class Meta:
        unique_together = ('payer', 'payee')

2. 信号同步逻辑 #

创建signals.py文件，实现记录的同步创建、更新和删除：

from django.db.models.signals import post_save, post_delete
from django.dispatch import receiver
from .models import Balance

@receiver(post_save, sender=Balance)
def sync_reverse_balance(sender, instance, created, **kwargs):
    # 跳过初始化数据导入时的信号触发
    if kwargs.get('raw', False):
        return
    # 创建或更新反向记录
    reverse_balance, is_created = Balance.objects.get_or_create(
        payer=instance.payee,
        payee=instance.payer,
        defaults={'amount': -instance.amount}
    )
    # 已存在则更新金额
    if not is_created and reverse_balance.amount != -instance.amount:
        reverse_balance.amount = -instance.amount
        reverse_balance.save(update_fields=['amount'])

@receiver(post_delete, sender=Balance)
def delete_reverse_balance(sender, instance, **kwargs):
    # 删除对应的反向记录
    Balance.objects.filter(payer=instance.payee, payee=instance.payer).delete()

然后在apps.py中注册信号：

from django.apps import AppConfig

class YourAppConfig(AppConfig):
    default_auto_field = 'django.db.models.BigAutoField'
    name = 'your_app_name'

    def ready(self):
        import your_app_name.signals

使用示例：

# 创建正向记录，自动生成反向记录
Balance.objects.create(payer=USER_1, payee=USER_2, amount=100.00)
balance_backward = Balance.objects.get(payer=USER_2, payee=USER_1)
# balance_backward.amount 自动为 -100.00

# 修改正向记录，反向记录同步更新
balance_forward = Balance.objects.get(payer=USER_1, payee=USER_2)
balance_forward.amount = 50.00
balance_forward.save()
# balance_backward.amount 自动变为 -50.00

方案对比 #

• 方案一更高效，无冗余数据，适合绝大多数场景。
• 方案二适合特殊业务需求，但增加了数据库写入开销和维护复杂度。

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