发布于 由admin

Python高级技术之：`Django`的`ORM`性能调优：`select_related()`、`prefetch_related()`和`annotate()`的实践。

各位观众老爷们，大家好！我是你们的老朋友，今天咱们来聊聊 Django 的 ORM 性能调优，保证让你的网站速度起飞！

咱们今天的主题是 select_related()、prefetch_related() 和 annotate()，这三个家伙是 Django ORM 性能优化的三板斧，用好了能让你的数据库压力骤降，用户体验蹭蹭上涨。

一、为什么要优化 ORM 性能？

在深入技术细节之前，咱们先来聊聊为什么要优化 ORM 性能。毕竟，如果网站访问量小，数据量也少，那随便怎么写代码都问题不大。但是，当你的网站火了，用户量大了，数据库就成了瓶颈。

想象一下，你的网站上有一个页面要展示文章列表，每篇文章都要显示作者的名字。如果没有优化，Django ORM 可能会这样操作：

  1. 查询所有文章。
  2. 循环遍历文章列表，对每一篇文章都发起一次数据库查询来获取作者信息。

这种方式被称为 "N+1 查询问题"，其中 N 是文章数量。如果你的文章列表有 100 篇文章，那就要发起 101 次数据库查询！这效率，简直没眼看。

所以，优化 ORM 性能，就是为了避免这种不必要的数据库查询，减少数据库压力，提高网站响应速度。

二、select_related()：一步到位，减少查询

select_related() 是专门用来优化外键（ForeignKey）和一对一关系（OneToOneField）的。它的作用是，在查询主表的同时，把关联表的数据也一起查出来，放到缓存里。这样，以后再访问关联表的数据，就不用再发起数据库查询了。

1. 示例场景

假设我们有两个模型：Author（作者）和 Article（文章），一个作者可以写多篇文章。

from django.db import models

class Author(models.Model):
    name = models.CharField(max_length=100)
    email = models.EmailField()

    def __str__(self):
        return self.name

class Article(models.Model):
    title = models.CharField(max_length=200)
    content = models.TextField()
    author = models.ForeignKey(Author, on_delete=models.CASCADE)  # 关键：外键关联

    def __str__(self):
        return self.title

2. 未优化的情况

如果我们直接查询文章列表，然后循环遍历，获取作者信息，就会出现 N+1 查询问题。

articles = Article.objects.all()

for article in articles:
    print(f"Article: {article.title}, Author: {article.author.name}")  # 每次访问 article.author 都会发起一次查询

3. 使用 select_related() 优化

articles = Article.objects.select_related('author').all()  # 预先获取 author 信息

for article in articles:
    print(f"Article: {article.title}, Author: {article.author.name}")  # 直接从缓存中获取 author 信息，无需额外查询

在上面的代码中，select_related('author') 告诉 Django 在查询 Article 的时候，顺便把 author 的信息也查出来。这样，在循环遍历的时候，访问 article.author.name 就不会再发起数据库查询了，而是直接从缓存中读取。

4. 链式 select_related()

如果你的模型之间有多层关联关系，可以使用链式 select_related()。例如，如果 Author 模型还有一个 Profile 模型，表示作者的个人资料，你可以这样写：

articles = Article.objects.select_related('author__profile').all()
# 查询 Article 的同时，获取 author 和 author 的 profile 信息

5. 注意事项

  • select_related() 只能用于外键和一对一关系。
  • 如果关联关系是多对多（ManyToManyField）或反向外键，select_related() 就无能为力了。这时候就需要用到 prefetch_related() 了。

三、prefetch_related()：解决多对多和反向外键的利器

prefetch_related() 用于优化多对多关系（ManyToManyField）和反向外键。它的原理是，先查询主表的数据，然后分别查询关联表的数据，最后把它们组装起来。

1. 示例场景

假设我们有两个模型：Article（文章）和 Tag（标签），一篇文章可以有多个标签。

from django.db import models

class Article(models.Model):
    title = models.CharField(max_length=200)
    content = models.TextField()

    def __str__(self):
        return self.title

class Tag(models.Model):
    name = models.CharField(max_length=50)
    articles = models.ManyToManyField(Article)  # 关键：多对多关系

    def __str__(self):
        return self.name

2. 未优化的情况

articles = Article.objects.all()

for article in articles:
    tags = article.tag_set.all()  # 每次访问 article.tag_set.all() 都会发起一次查询
    print(f"Article: {article.title}, Tags: {[tag.name for tag in tags]}")

3. 使用 prefetch_related() 优化

articles = Article.objects.prefetch_related('tag_set').all()  # 预先获取 tag_set 信息

for article in articles:
    tags = article.tag_set.all()  # 直接从缓存中获取 tag_set 信息，无需额外查询
    print(f"Article: {article.title}, Tags: {[tag.name for tag in tags]}")

在上面的代码中，prefetch_related('tag_set') 告诉 Django 在查询 Article 的时候，顺便把所有与 Article 相关的 Tag 也查出来。

4. 使用 Prefetch 对象进行更精细的控制

prefetch_related() 还可以接受 Prefetch 对象作为参数，让你对预取的数据进行更精细的控制。例如，你可以指定预取数据的查询条件。

from django.db.models import Prefetch

articles = Article.objects.prefetch_related(
    Prefetch('tag_set', queryset=Tag.objects.filter(name__startswith='Django'))
).all()

for article in articles:
    tags = article.tag_set.all()  # 只获取标签名以 "Django" 开头的标签
    print(f"Article: {article.title}, Tags: {[tag.name for tag in tags]}")

在这个例子中，我们使用 Prefetch 对象指定了只预取标签名以 "Django" 开头的标签。

5. prefetch_related() 结合 select_related()

prefetch_related() 和 select_related() 可以一起使用，以优化更复杂的关联关系。例如：

articles = Article.objects.select_related('author').prefetch_related('tag_set').all()
# 查询 Article 的同时，获取 author 和 tag_set 信息

四、annotate()：聚合统计，化繁为简

annotate() 用于在查询结果中添加额外的字段，这些字段通常是聚合函数的结果。它的作用是，把复杂的聚合统计操作放到数据库中进行，减少数据传输量和 Python 代码的复杂度。

1. 示例场景

假设我们需要查询所有作者，并统计每位作者的文章数量。

from django.db.models import Count

authors = Author.objects.annotate(article_count=Count('article'))  # 统计每个作者的文章数量

for author in authors:
    print(f"Author: {author.name}, Article Count: {author.article_count}")

在上面的代码中，annotate(article_count=Count('article')) 告诉 Django 在查询 Author 的时候，顺便统计每位作者的文章数量，并将结果存储在 article_count 字段中。

2. 结合 filter() 使用

annotate() 可以和 filter() 结合使用，对聚合结果进行过滤。例如，我们可以查询文章数量超过 5 篇的作者。

from django.db.models import Count

authors = Author.objects.annotate(article_count=Count('article')).filter(article_count__gt=5)
# 统计每个作者的文章数量，并过滤出文章数量超过 5 篇的作者

for author in authors:
    print(f"Author: {author.name}, Article Count: {author.article_count}")

3. 多个 annotate() 叠加

annotate() 可以多次使用，添加多个聚合字段。例如，我们可以统计每位作者的文章数量和评论数量。

from django.db.models import Count, Sum

class Comment(models.Model):
    article = models.ForeignKey(Article, on_delete=models.CASCADE)
    content = models.TextField()

    def __str__(self):
        return self.content[:50]

authors = Author.objects.annotate(
    article_count=Count('article'),
    comment_count=Sum('article__comment__id')  # 统计作者所有文章的评论数量
)

for author in authors:
    print(f"Author: {author.name}, Article Count: {author.article_count}, Comment Count: {author.comment_count}")

4. 使用 Case 和 When 进行条件聚合

Case 和 When 可以让你根据条件进行聚合统计。例如，我们可以统计每位作者的已发布文章数量和草稿文章数量。

from django.db.models import Count, Case, When, IntegerField

class Article(models.Model):
    STATUS_CHOICES = (
        ('draft', 'Draft'),
        ('published', 'Published'),
    )
    title = models.CharField(max_length=200)
    content = models.TextField()
    author = models.ForeignKey(Author, on_delete=models.CASCADE)
    status = models.CharField(max_length=10, choices=STATUS_CHOICES, default='draft')  # 添加文章状态字段

    def __str__(self):
        return self.title

authors = Author.objects.annotate(
    published_count=Count(Case(When(article__status='published', then=1), output_field=IntegerField())),
    draft_count=Count(Case(When(article__status='draft', then=1), output_field=IntegerField()))
)

for author in authors:
    print(f"Author: {author.name}, Published Count: {author.published_count}, Draft Count: {author.draft_count}")

五、实战案例：优化博客首页

现在，让我们用一个实战案例来巩固一下所学知识。假设我们有一个博客网站，首页需要展示文章列表，每篇文章都要显示作者的名字和标签列表。

1. 未优化的情况

articles = Article.objects.all()

for article in articles:
    author = article.author
    tags = article.tag_set.all()
    print(f"Article: {article.title}, Author: {author.name}, Tags: {[tag.name for tag in tags]}")

这段代码会导致 N+1 查询问题，效率非常低下。

2. 优化后的代码

articles = Article.objects.select_related('author').prefetch_related('tag_set').all()

for article in articles:
    author = article.author  # 直接从缓存中获取
    tags = article.tag_set.all()  # 直接从缓存中获取
    print(f"Article: {article.title}, Author: {author.name}, Tags: {[tag.name for tag in tags]}")

通过使用 select_related() 和 prefetch_related()，我们避免了 N+1 查询问题，大大提高了页面加载速度。

六、总结：三板斧的用法和适用场景

为了方便大家记忆，我把这三板斧的用法和适用场景总结成一个表格：

技术 适用场景
select_related() 优化外键和一对一关系，在查询主表的时候，把关联表的数据也一起查出来。

发表回复

您的邮箱地址不会被公开。 必填项已用 * 标注