Django ORM深度优化技巧

2026-04-13

字数统计: 1.4k字 | 阅读时长≈ 6分

Django ORM深度优化：从查询到性能的全面调优指南

Django ORM是开发者的得力助手，但不当使用可能导致性能灾难。掌握这些优化技巧，让你的应用飞起来！

引言：为什么需要优化Django ORM？

Django的ORM（对象关系映射）以其优雅的API和强大的功能而闻名。然而，随着应用规模的扩大，简单的查询可能演变为性能瓶颈。我曾经在一个项目中，一个看似无害的.all()调用竟然导致了N+1查询问题，使页面加载时间从200ms飙升到5秒！

今天，我将分享一些经过实战检验的Django ORM优化技巧，帮助你构建高性能的Django应用。

一、查询优化：避免常见的性能陷阱

1.1 解决N+1查询问题

这是最常见的ORM性能问题。看这个例子：

# 糟糕的写法 - 产生N+1查询
books = Book.objects.all()
for book in books:
    print(book.author.name)  # 每次循环都查询数据库

优化方案：使用select_related和prefetch_related

# 使用select_related（用于ForeignKey和OneToOneField）
books = Book.objects.select_related('author').all()

# 使用prefetch_related（用于ManyToManyField和反向ForeignKey）
books = Book.objects.prefetch_related('categories').all()

# 复杂情况：链式预取
books = Book.objects.select_related('author').prefetch_related(
    'categories',
    'reviews__user'  # 深度预取
).all()

经验分享：select_related使用SQL的JOIN，而prefetch_related执行额外的查询。对于深度关系，prefetch_related通常更高效。

1.2 只获取需要的字段

# 避免获取所有字段
books = Book.objects.all()  # 获取所有字段

# 只获取需要的字段
books = Book.objects.only('title', 'author_id').all()
books = Book.objects.defer('description', 'metadata').all()  # 排除某些字段

# 使用values()或values_list()获取字典或元组
titles = Book.objects.values_list('title', flat=True)
book_data = Book.objects.values('title', 'author__name')

注意：使用only()和defer()时要小心，后续访问未加载的字段会触发额外的查询。

二、数据库层面的优化

2.1 利用数据库索引

class Book(models.Model):
    title = models.CharField(max_length=200, db_index=True)
    author = models.ForeignKey(Author, on_delete=models.CASCADE)
    published_date = models.DateField()
    
    class Meta:
        indexes = [
            models.Index(fields=['published_date', 'author']),
            models.Index(fields=['title'], name='title_idx'),
        ]
        
    # 函数索引（Django 3.2+）
    # indexes = [
    #     models.Index(Lower('title').desc(), name='lower_title_idx'),
    # ]

建议：使用Django的db_index参数或Index类创建复合索引。定期使用python manage.py check检查索引使用情况。

2.2 批量操作

# 避免循环插入
books = []
for i in range(1000):
    books.append(Book(title=f'Book {i}'))
Book.objects.bulk_create(books)  # 一次插入

# 批量更新
Book.objects.filter(published_date__year=2020).update(status='archived')

# 批量删除
Book.objects.filter(status='draft').delete()

性能对比：bulk_create比循环save()快10-100倍！

三、高级查询技巧

3.1 使用子查询和窗口函数

from django.db.models import Subquery, OuterRef, Window, F
from django.db.models.functions import RowNumber

# 子查询
latest_reviews = Review.objects.filter(
    book_id=OuterRef('pk')
).order_by('-created_at')
books = Book.objects.annotate(
    latest_review_text=Subquery(latest_reviews.values('text')[:1])
)

# 窗口函数（Django 2.0+）
books = Book.objects.annotate(
    row_number=Window(
        expression=RowNumber(),
        partition_by=[F('author_id')],
        order_by=F('published_date').desc()
    )
)

3.2 条件聚合

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

# 条件计数
stats = Author.objects.annotate(
    published_count=Count('book', filter=Q(book__status='published')),
    draft_count=Count('book', filter=Q(book__status='draft')),
    total_books=Count('book')
)

# Case/When表达式
books = Book.objects.annotate(
    priority=Case(
        When(rating__gte=4.5, then=1),
        When(rating__gte=4.0, then=2),
        default=3,
        output_field=IntegerField()
    )
).order_by('priority', '-rating')

四、缓存策略

4.1 查询结果缓存

from django.core.cache import cache

def get_popular_books():
    cache_key = 'popular_books'
    books = cache.get(cache_key)
    
    if not books:
        books = Book.objects.filter(
            rating__gte=4.5
        ).select_related('author').prefetch_related('categories')[:10]
        cache.set(cache_key, books, 3600)  # 缓存1小时
    
    return books

4.2 使用`cache_page`装饰器

from django.views.decorators.cache import cache_page

@cache_page(60 * 15)  # 缓存15分钟
def book_list(request):
    # 视图逻辑

五、监控和调试

安装django-debug-toolbar，它可以：

显示所有SQL查询
分析查询时间
检查重复查询
查看缓存使用情况

5.2 自定义查询监控

# settings.py
LOGGING = {
    'version': 1,
    'handlers': {
        'console': {
            'level': 'DEBUG',
            'class': 'logging.StreamHandler',
        },
    },
    'loggers': {
        'django.db.backends': {
            'level': 'DEBUG',
            'handlers': ['console'],
        },
    },
}

# 或者使用信号
from django.db import connection
from django.db.backends.signals import connection_created

def print_queries(sender, connection, **kwargs):
    if connection.vendor == 'postgresql':
        connection.connection.set_session(autocommit=True)

from django.core.signals import request_finished

def print_slow_queries(sender, **kwargs):
    for query in connection.queries:
        if float(query['time']) > 0.1:  # 超过100ms的查询
            print(f"Slow query: {query['sql']} took {query['time']}s")

六、实战经验分享

经验1：分页优化

# 使用keyset分页（游标分页）替代offset分页
def get_books_after_cursor(cursor_id, limit=20):
    return Book.objects.filter(
        id__gt=cursor_id
    ).select_related('author').order_by('id')[:limit]

经验2：避免在循环中保存对象

# 错误做法
for book in books:
    book.view_count += 1
    book.save()  # 每次保存都提交事务

# 正确做法
from django.db import transaction

with transaction.atomic():
    for book in books:
        book.view_count += 1
        book.save(update_fields=['view_count'])
    
# 或者使用F表达式
Book.objects.filter(id__in=[b.id for b in books]).update(
    view_count=F('view_count') + 1
)

经验3：使用数据库特定功能

# PostgreSQL的全文搜索
from django.contrib.postgres.search import SearchVector

Book.objects.annotate(
    search=SearchVector('title', 'description')
).filter(search='django')

# MySQL的JSON字段查询
Book.objects.filter(
    metadata__author__name='John'
)

结语：优化思维比技巧更重要

Django ORM优化不仅仅是应用技巧，更是一种思维方式：

测量优先：不要猜测性能问题，使用工具测量
渐进优化：先让功能工作，然后优化热点
理解代价：知道每个查询的数据库代价
保持简单：复杂的优化可能带来维护成本

记住，最好的优化有时是重新

本文作者： 来的太快的龙卷风
本文链接： https://ljf.30790842.xyz/2026/04/13/2026-04-13-Django-ORM深度优化技巧-e21e9491/
版权声明： 本博客所有文章除特别声明外，均采用 MIT 许可协议。转载请注明出处！