如何优化Django序列化器生成文件夹与实体树形结构的性能？

当前实现的核心问题是递归N+1查询：每序列化一个文件夹就会触发两次新的数据库查询（子文件夹、关联实体），数据量越大，查询次数呈指数级增长，耗时剧增。以下是针对性优化方案：

1. 一次性预加载所有数据，内存中构建树形结构 #

放弃递归查询数据库的方式，先把所有文件夹和实体一次性查询出来，在内存中组装树形结构，彻底消除N+1问题。

实现步骤： #

• 视图层一次性查询所有文件夹，通过prefetch_related预加载关联实体
• 用字典映射父ID到对应的子文件夹和实体，快速构建层级关系
• 修改序列化器，直接从内存映射中获取子节点，不再触发数据库查询

示例代码：

# 视图层查询数据
from django.db.models import Prefetch

def get_folder_tree(request):
    # 一次性查询所有文件夹及关联实体，提前排序
    all_folders = Folder.objects.prefetch_related(
        Prefetch('entities', queryset=Entity.objects.order_by('name'))
    ).order_by('name')

    # 构建父ID到子文件夹的映射，同时存储关联实体
    folder_map = {}
    root_folders = []
    for folder in all_folders:
        folder_map[folder.id] = {
            'folder': folder,
            'child_folders': [],
            'entities': list(folder.entities.all())
        }
        if not folder.parent:
            root_folders.append(folder)
        else:
            parent_id = folder.parent.id
            if parent_id in folder_map:
                folder_map[parent_id]['child_folders'].append(folder)

    # 序列化根文件夹，传递映射表到序列化器上下文
    serializer = OptimizedListFolderSerializer(
        root_folders, 
        many=True, 
        context={'folder_map': folder_map}
    )
    return Response(serializer.data)

# 修改后的序列化器
class OptimizedListFolderSerializer(serializers.ModelSerializer):
    children = serializers.SerializerMethodField()

    class Meta:
        model = Folder
        fields = ['id', 'name', 'children']

    def get_children(self, instance):
        folder_map = self.context.get('folder_map', {})
        current_data = folder_map.get(instance.id, {})
        child_folders = current_data.get('child_folders', [])
        entities = current_data.get('entities', [])

        all_children = []
        # 序列化子文件夹（复用上下文映射表）
        if child_folders:
            all_children.extend(OptimizedListFolderSerializer(
                child_folders, 
                many=True, 
                context={'folder_map': folder_map}
            ).data)
        # 序列化实体
        if entities:
            all_children.extend(ListEntitySerializer(entities, many=True).data)
        return all_children if all_children else None

2. 添加数据库索引，加速查询 #

给关联字段添加数据库索引，减少查询时的数据库扫描时间：

class Folder(models.Model):
    name = models.CharField(max_length=255, null=False, blank=False)
    parent = models.ForeignKey(
        'self', 
        on_delete=models.SET_NULL, 
        null=True, 
        blank=True, 
        related_name="child",
        db_index=True  # 添加索引
    )

class Entity(models.Model):
    name = models.CharField(max_length=255, null=False, blank=False)
    folder = models.ForeignKey(
        'Folder', 
        on_delete=models.SET_NULL, 
        null=True, 
        blank=True, 
        related_name="entities",
        db_index=True  # 添加索引
    )

3. 缓存序列化结果 #

对于不经常变动的目录结构，用Django缓存框架缓存序列化后的树形数据，避免重复计算：

from django.core.cache import cache

def get_folder_tree(request):
    cache_key = 'folder_tree_cache'
    cached_data = cache.get(cache_key)
    if cached_data:
        return Response(cached_data)
    
    # 执行数据查询和序列化逻辑（同上）
    serializer_data = serializer.data
    
    # 缓存结果，设置过期时间（比如1小时）
    cache.set(cache_key, serializer_data, 3600)
    return Response(serializer_data)

4. 分页或懒加载（可选） #

如果目录层级极深、数据量极大，可以考虑前端懒加载：只返回当前层级的文件夹和实体，用户点击展开时再请求子节点数据，减少单次请求的数据处理量。

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