Django ORM 多对多关系实现：自定义中间表与 ManyToManyField 详解
本文深入解析 Django ORM 中处理多对多关系的两种核心方案：通过自定义模型构建中间表，以及使用内置的 ManyToManyField。详细对比了两者在灵活性、数据列限制及操作方式上的差异，并介绍了结合两者的“杂交”模式，即在 ManyToManyField 中指定 through 参数以保留自定义中间表的额外字段功能，帮助开发者根据实际需求选择最优的数据模型设计。
Django 多对多关系概述
在 Django 数据库设计中，处理实体间的多对多关系是常见需求。
第一种方案是手动创建自定义的第三张表（中间表）。这种方式的优势在于极高的灵活性，开发者可以完全控制表结构，添加任意所需的额外字段或约束。
第二种方案是利用 Django 内置的 ManyToManyField 字段。框架会自动生成关联第三张表，但其限制在于该表仅包含外键指向的两个主表 ID，无法直接添加其他自定义字段。
自定义第三张表方案
接下来，我们将通过具体代码示例，分别演示如何手动实现自定义中间表，以及如何利用 ManyToManyField 简化开发流程。
# models.py
class Boy(models.Model):
name = models.CharField(max_length=32)
class Girl(models.Model):
name = models.CharField(max_length=32)
class Love(models.Model):
b = models.ForeignKey('Boy')
g = models.ForeignKey('Girl')
# 创建联合唯一索引
# class Meta:
# unique_together = [
# ('b','g')，
# ]
# views.py
def test(request):
# objs = [
# models.Boy(name='summer'),
# models.Boy(name='spring'),
# models.Boy(name='autumn'),
# ]
# models.Boy.objects.bulk_create(objs,5)
# objs = [
# models.Girl(name='小于'),
# models.Girl(name='小秋'),
# models.Girl(name='小夏'),
# ]
# models.Girl.objects.bulk_create(objs,5)
# 查询和girl小于有关系的boy
# 1 通过girl表进行反向查找
obj = models.Girl.objects.filter(name='小于').first().love_set.all()
# obj = models.Girl.objects.filter(name='小于').first().love_set.select_related('b').all()
for i in obj:
print(i.b.name)
print(' '.center(60,'='))
# 2 通过Love表进行查找
obj = models.Love.objects.filter(g__name='小于').all()
for i in obj:
print(i.b.name)
# 这样进行查询性能不好，需要重新发sql请求在进行查询另外一张表中的数据
boy_list = models.Love.objects.filter(g__name='小于').values('b__name')
for i in boy_list:
print(i['b__name'])
# 这样 进行了 优化 不会重复发送sql请求，查询到的结果内是字典
boy_obj = models.Love.objects.filter(g__name='小于').select_related('b').all()
for i in boy_obj:
print(i.b.name)
# select_related('ut') 相当 于 inner join 先连成一张表再进行查询
return HttpResponse('insert ok ....')
在使用 ManyToManyField 时，Django 会自动处理关联表的创建与维护。开发者可以通过字段对象直接进行添加、移除、设置或清空关联对象的操作，无需手动编写 SQL 或处理外键关联。
ManyToManyField 自动关联方案
# models.py
from django.db import models
class Boy(models.Model):
name = models.CharField(max_length=32)
# m = models.ManyToManyField('Girl')
class Girl(models.Model):
name = models.CharField(max_length=32)
m = models.ManyToManyField('Boy')
# views.py
def test(request):
# objs = [
# models.Boy(name='summer'),
# models.Boy(name='spring'),
# models.Boy(name='autumn'),
# ]
# models.Boy.objects.bulk_create(objs,5)
# objs = [
# models.Girl(name='小于'),
# models.Girl(name='小秋'),
# models.Girl(name='小夏'),
# ]
# models.Girl.objects.bulk_create(objs,5)
# ManyToManyField
obj = models.Girl.objects.filter(name='小秋').first()
# 增
# obj.m.add(3)
# obj.m.add(3,4)
# obj.m.add(*[1,2])
# 删
# obj.m.remove(3)
# obj.m.remove(3,4)
# obj.m.remove(*[1,2])
# 改
# obj.m.set([1,2,])
# boy_obj = obj.m.all()
# for row in boy_obj:
# print(row.id,row.name)
# 清除
# obj.m.clear()
# 反向查 在没有 ManyToManyField 字段的表中查
obj = models.Boy.objects.filter(name='summer').first()
girl_obj = obj.girl_set.all()
# 增删改查
obj.girl_set.set([1,2,3])
for row in girl_list:
print(row.id,row.name)
return HttpResponse('ok')
除了上述两种独立方案，Django 还支持将两者结合使用的“杂交”模式。即在使用 ManyToManyField 的同时，通过指定 through 参数指向自定义的中间表模型。这种模式既保留了 ManyToManyField 带来的便利，又允许通过自定义中间表添加额外的属性字段。
混合模式：自定义中间表与 ManyToManyField 结合
# modles.py
class Boy(models.Model):
name = models.CharField(max_length=32)
class Girl(models.Model):
name = models.CharField(max_length=32)
m = models.ManyToManyField('Boy',through='Love',through_fields=('b','g')) # 只让其生成3张表，如果不加后面产生生成4张表
class Love(models.Model):
b = models.ForeignKey('Boy')
g = models.ForeignKey('Girl')
# views.py
def test(request):
obj = models.Girl.objects.filter(name='小于').first()
# obj.m.add(1) # 不行
# obj.m.remove(1) # 不行
# obj.m.set([1,2]) # 不行
# obj.m.clear() # 可以
# obj.m.all() # 可以
# 杂交的方法对获取查询方便点，还添加了清空功能
boy_obj = obj.m.all()
for i in boy_obj:
print(i.name)以上内容总结了 Django ORM 中多对多查询的几种主要实现方式。开发者可根据业务对灵活性和开发效率的不同侧重，选择合适的方案。建议在实际项目中根据具体场景进行权衡，并参考官方文档获取更深入的指导。
免责声明：本文内容仅供参考，不代表本站观点。转载或引用请注明出处。
