SpringBoot树形查询优化：从3秒到30毫秒的O(n)算法实践

一个真实的性能灾难

某项目的首页分类树加载功能，在业务快速增长阶段遭遇了严峻的性能瓶颈，具体表现为：

• 用户体验：页面加载分类树耗时长达3到5秒，用户投诉不断。
• 系统压力：访问高峰期，数据库连接池被迅速耗尽，甚至导致系统崩溃。
• 开发困扰：之前的每次优化都只能暂时缓解，未能根除问题，技术债务越积越重。

问题根源在于采用了传统的递归查询方式，引发了经典的N+1查询问题。对于一个拥有15000个分类节点的场景，这意味着需要执行15000次独立的数据库查询。

经过文中的优化方案改造后，响应时间从3秒以上骤降至约30毫秒，性能提升超过100倍。如果你的系统也面临类似的树形结构查询性能瓶颈，这篇来自生产环境的实战总结将为你提供一套行之有效的解决方案。

传统方案为什么这么慢？

N+1查询灾难

// 这段看似简洁的代码，实则是一个性能杀手
public List<Category> getCategoryTree() {
    List<Category> roots = categoryMapper.getRootCategories(); // 1次查询
    for (Category root : roots) {
        loadChildren(root); // 每个根节点都会触发一轮递归查询
    }
    return roots;
}

private void loadChildren(Category parent) {
    List<Category> children = categoryMapper.getByParentId(parent.getId()); // N次查询
    parent.setChildren(children);
    for (Category child : children) {
        loadChildren(child); // 递归继续深入
    }
}

性能问题分析：

• 对于10000个节点，就意味着10000次数据库查询。
• 假设单次查询耗时2ms，总耗时将高达20秒。
• 大量并发查询会迅速耗尽数据库连接池。
• 内存中会创建海量临时对象，给垃圾回收（GC）带来巨大压力。

性能测试数据对比

节点数量	传统递归方案	优化后方案	性能提升
1,000	800ms	15ms	53倍
5,000	2.8s	25ms	112倍
10,000	5.2s	30ms	173倍
50,000	超时	45ms	1000倍+

核心解决方案：一次查询 + O(n)算法

解决思路

核心理念：将“N+1次数据库查询 + 递归构建”的模式，彻底转变为“1次查询 + 内存高效构建”。

1. 一次性批量查询：SELECT * FROM category WHERE status = 1，一次获取全量数据。
2. HashMap建立内存索引：以节点ID为Key，实现O(1)时间复杂度的父子关系查找。
3. 单次遍历构建树：遍历所有节点，通过HashMap快速找到父节点并挂载，整体时间复杂度为O(n)。
4. 缓存优化：将构建好的完整树结构进行缓存，避免重复计算。

数据库设计

采用增强版邻接表模型，在基础的parent_id字段上增加level层级字段：

CREATE TABLE category (
    id BIGINT PRIMARY KEY,
    name VARCHAR(100) NOT NULL,
    parent_id BIGINT,
    level INT NOT NULL DEFAULT 0,
    sort_order INT DEFAULT 0,
    status TINYINT DEFAULT 1,
    create_time DATETIME,
    update_time DATETIME,

    INDEX idx_parent_id (parent_id),
    INDEX idx_level (level),
    INDEX idx_status (status)
);

设计要点：

• level字段便于按层级进行批量查询和优化排序逻辑。
• 可考虑建立复合索引 (parent_id, sort_order) 以支持带排序的子树查询。
• status字段实现软删除，方便状态过滤。

算法复杂度分析：O(n²) → O(n) 的关键突破

传统递归算法的复杂度分析

// 传统方案：时间复杂度 O(n²)，空间复杂度 O(n)
public List<Category> getChildren(Long parentId) {
    List<Category> children = categoryMapper.getByParentId(parentId);  // 1次查询
    for (Category child : children) {                                 // 对每个子节点
        child.setChildren(getChildren(child.getId()));                // 递归查询子节点
    }
    return children;
}

复杂度分析：

• 时间复杂度：O(n²)
  • 最坏情况下，每个节点的查询都需要扫描全表来寻找其子节点。
  • 总复杂度近似为 n × n = O(n²)。
• 空间复杂度：O(n) - 递归调用栈的深度等于树的最大深度。
• 数据库查询次数：O(n) - 每个节点一次查询，总计n次。

性能问题根源在于大量的离散查询：

// 以10000个节点为例的执行过程
Root Node (id=1)
├── Child1 (id=2) -> SELECT * FROM category WHERE parent_id = 2  // 第1次查询
│   ├── Child1.1 (id=5) -> SELECT * FROM category WHERE parent_id = 5  // 第2次查询
│   └── Child1.2 (id=6) -> SELECT * FROM category WHERE parent_id = 6  // 第3次查询
├── Child2 (id=3) -> SELECT * FROM category WHERE parent_id = 3  // 第4次查询
│   └── Child2.1 (id=7) -> SELECT * FROM category WHERE parent_id = 7  // 第5次查询
└── Child3 (id=4) -> SELECT * FROM category WHERE parent_id = 4  // 第6次查询
    └── ...继续递归，总共10000次查询

优化后算法的复杂度分析

// 优化方案：时间复杂度 O(n)，空间复杂度 O(n)
public <T extends TreeNode<T>> List<T> buildTree(List<T> nodes, Object rootValue) {
    // 步骤1：建立HashMap索引 - O(n)
    Map<Object, T> nodeMap = nodes.stream()
        .collect(Collectors.toMap(TreeNode::getId, node -> node));

    List<T> rootNodes = new ArrayList<>();

    // 步骤2：单次遍历建立父子关系 - O(n)
    for (T node : nodes) {                   // 遍历n个节点
        Object parentId = node.getParentId();
        if (Objects.equals(parentId, rootValue)) {
            rootNodes.add(node);
        } else {
            T parent = nodeMap.get(parentId); // HashMap查找：O(1)
            if (parent != null) {
                parent.addChild(node);        // 建立父子关系：O(1)
            }
        }
    }
    return rootNodes;
}

复杂度分析：

• 时间复杂度：O(n)
  • 建立HashMap：O(n)。
  • 遍历建立关系：n次循环，每次循环内是O(1)的查找和添加操作，合计O(n)。
• 空间复杂度：O(n) - HashMap存储了n个节点的引用。
• 数据库查询次数：O(1) - 仅需一次全量查询。

性能提升的关键在于将计算转移到内存，并利用高效的数据结构：

// 优化后的执行过程 - 以10000个节点为例
Step 1: SELECT * FROM category WHERE status = 1  // 仅1次查询获取所有数据

Step 2: 内存中构建HashMap索引 - O(n)
{
  1 -> Node{id=1, name="根节点", parentId=null},
  2 -> Node{id=2, name="子节点1", parentId=1},
  3 -> Node{id=3, name="子节点2", parentId=1},
  ...
  10000 -> Node{id=10000, name="叶子节点", parentId=9999}
}

Step 3: 单次遍历建立关系 - O(n)
for (Node node : allNodes) {  // 10000次循环
    Node parent = nodeMap.get(node.parentId);  // O(1)查找
    parent.addChild(node);  // O(1)添加
}

算法复杂度对比表

算法维度	传统递归方案	优化后方案	性能提升
时间复杂度	O(n²)	O(n)	线性级提升
空间复杂度	O(h) 递归栈深度	O(n) HashMap	空间换时间
数据库查询	O(n) 次查询	O(1) 次查询	n倍减少
网络IO	n次往返	1次往返	n倍减少
缓存友好性	差（随机访问）	好（顺序访问）	显著提升

O(n)高性能树构建算法

核心算法实现

@Component
public class TreeBuilder {

    /**
     * 高性能树构建算法 - O(n)时间复杂度
     * @param nodes 所有节点列表
     * @param rootValue 根节点的parent_id值（通常为null或0）
     * @return 构建好的树结构
     */
    public <T extends TreeNode<T>> List<T> buildTree(List<T> nodes, Object rootValue) {
        if (CollectionUtils.isEmpty(nodes)) {
            return new ArrayList<>();
        }

        // 1. 建立ID->Node的快速索引，时间复杂度O(n)
        Map<Object, T> nodeMap = nodes.stream()
            .collect(Collectors.toMap(TreeNode::getId, node -> node));

        List<T> rootNodes = new ArrayList<>();

        // 2. 单次遍历建立父子关系，时间复杂度O(n)
        for (T node : nodes) {
            Object parentId = node.getParentId();

            if (Objects.equals(parentId, rootValue)) {
                // 根节点
                rootNodes.add(node);
            } else {
                // 子节点，建立父子关系
                T parent = nodeMap.get(parentId);
                if (parent != null) {
                    parent.addChild(node);
                }
            }
        }

        // 3. 递归排序（可选），时间复杂度O(n log n)
        sortTreeRecursively(rootNodes);

        return rootNodes;
    }

    private <T extends TreeNode<T>> void sortTreeRecursively(List<T> nodes) {
        if (CollectionUtils.isEmpty(nodes)) {
            return;
        }

        // 按sort_order排序
        nodes.sort(Comparator.comparing(TreeNode::getSortOrder,
            Comparator.nullsLast(Comparator.naturalOrder())));

        // 递归排序子节点
        for (T node : nodes) {
            if (node.hasChildren()) {
                sortTreeRecursively(node.getChildren());
            }
        }
    }
}

树节点基类设计

public interface TreeNode<T> {
    Object getId();
    Object getParentId();
    Integer getSortOrder();
    List<T> getChildren();
    void setChildren(List<T> children);

    default void addChild(T child) {
        if (getChildren() == null) {
            setChildren(new ArrayList<>());
        }
        getChildren().add(child);
    }

    default boolean hasChildren() {
        return getChildren() != null && !getChildren().isEmpty();
    }
}

完整业务实现

实体类设计

@Data
@TableName("category")
public class Category implements TreeNode<Category> {
    @TableId(type = IdType.AUTO)
    private Long id;

    private String name;
    private Long parentId;
    private Integer level;
    private Integer sortOrder;
    private Integer status;

    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
    private LocalDateTime createTime;

    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
    private LocalDateTime updateTime;

    // 非数据库字段，用于构建树形结构
    @TableField(exist = false)
    private List<Category> children;

    @Override
    public void addChild(Category child) {
        if (children == null) {
            children = new ArrayList<>();
        }
        children.add(child);
    }
}

数据访问层

@Mapper
public interface CategoryMapper extends BaseMapper<Category> {

    /**
     * 获取所有有效分类（用于一次性构建整棵树）
     */
    @Select("SELECT id, name, parent_id, level, sort_order, status, " +
            "create_time, update_time FROM category WHERE status = 1 " +
            "ORDER BY level, parent_id, sort_order")
    List<Category> selectAllForTree();

    /**
     * 根据父ID查询子分类（传统方案或懒加载时使用）
     */
    @Select("SELECT * FROM category WHERE parent_id = #{parentId} AND status = 1 " +
            "ORDER BY sort_order")
    List<Category> selectByParentId(@Param("parentId") Long parentId);
}

服务层实现

@Service
@Transactional(rollbackFor = Exception.class)
public class CategoryServiceImpl implements CategoryService {

    @Autowired
    private CategoryMapper categoryMapper;

    @Autowired
    private TreeBuilder treeBuilder;

    /**
     * 获取分类树（带缓存）
     */
    @Cacheable(value = "category:tree", key = "'all'")
    public List<Category> getCategoryTree() {
        // 1. 一次性查询所有数据
        List<Category> allCategories = categoryMapper.selectAllForTree();

        // 2. 使用高性能O(n)算法构建树
        return treeBuilder.buildTree(allCategories, null);
    }

    /**
     * 创建分类
     */
    @CacheEvict(value = "category:tree", allEntries = true)
    public Category createCategory(Category category) {
        // 设置层级
        if (category.getParentId() != null) {
            Category parent = categoryMapper.selectById(category.getParentId());
            category.setLevel(parent.getLevel() + 1);
        } else {
            category.setLevel(0);
        }

        category.setStatus(1);
        category.setCreateTime(LocalDateTime.now());
        category.setUpdateTime(LocalDateTime.now());

        categoryMapper.insert(category);
        return category;
    }

    /**
     * 更新分类
     */
    @CacheEvict(value = "category:tree", allEntries = true)
    public Category updateCategory(Category category) {
        category.setUpdateTime(LocalDateTime.now());
        categoryMapper.updateById(category);
        return category;
    }

    /**
     * 删除分类（软删除）
     */
    @CacheEvict(value = "category:tree", allEntries = true)
    public void deleteCategory(Long id) {
        Category category = new Category();
        category.setId(id);
        category.setStatus(0);
        category.setUpdateTime(LocalDateTime.now());
        categoryMapper.updateById(category);
    }
}

控制器层

@RestController
@RequestMapping("/api/categories")
public class CategoryController {

    @Autowired
    private CategoryService categoryService;

    /**
     * 获取分类树
     */
    @GetMapping("/tree")
    public Result<List<Category>> getCategoryTree() {
        List<Category> tree = categoryService.getCategoryTree();
        return Result.success(tree);
    }

    /**
     * 创建分类
     */
    @PostMapping
    public Result<Category> createCategory(@RequestBody @Valid Category category) {
        Category created = categoryService.createCategory(category);
        return Result.success(created);
    }

    /**
     * 更新分类
     */
    @PutMapping("/{id}")
    public Result<Category> updateCategory(@PathVariable Long id,
                                           @RequestBody @Valid Category category) {
        category.setId(id);
        Category updated = categoryService.updateCategory(category);
        return Result.success(updated);
    }

    /**
     * 删除分类
     */
    @DeleteMapping("/{id}")
    public Result<Void> deleteCategory(@PathVariable Long id) {
        categoryService.deleteCategory(id);
        return Result.success();
    }
}

缓存优化策略

多级缓存配置

方案一：自定义复合缓存管理器（推荐）

@Configuration
@EnableCaching
public class MultiLevelCacheConfig {

    /**
     * 多级缓存管理器：L1(Caffeine本地缓存) + L2(Redis分布式缓存)
     */
    @Bean
    @Primary
    public CacheManager multiLevelCacheManager(RedisConnectionFactory connectionFactory) {
        return new MultiLevelCacheManager(
            createCaffeineCacheManager(),
            createRedisCacheManager(connectionFactory)
        );
    }

    private CaffeineCacheManager createCaffeineCacheManager() {
        CaffeineCacheManager cacheManager = new CaffeineCacheManager();
        cacheManager.setCaffeine(Caffeine.newBuilder()
                .initialCapacity(100)
                .maximumSize(1000)
                .expireAfterWrite(10, TimeUnit.MINUTES) // L1缓存10分钟过期
                .recordStats());
        return cacheManager;
    }

    private RedisCacheManager createRedisCacheManager(RedisConnectionFactory connectionFactory) {
        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
                .entryTtl(Duration.ofHours(2)) // L2缓存2小时过期
                .serializeKeysWith(RedisSerializationContext.SerializationPair
                        .fromSerializer(new StringRedisSerializer()))
                .serializeValuesWith(RedisSerializationContext.SerializationPair
                        .fromSerializer(new GenericJackson2JsonRedisSerializer()))
                .disableCachingNullValues();

        return RedisCacheManager.builder(connectionFactory)
                .cacheDefaults(config)
                .build();
    }
}

/**
 * 自定义多级缓存管理器
 */
public class MultiLevelCacheManager implements CacheManager {

    private final CacheManager l1CacheManager; // 本地缓存
    private final CacheManager l2CacheManager; // 分布式缓存

    public MultiLevelCacheManager(CacheManager l1CacheManager, CacheManager l2CacheManager) {
        this.l1CacheManager = l1CacheManager;
        this.l2CacheManager = l2CacheManager;
    }

    @Override
    public Cache getCache(String name) {
        Cache l1Cache = l1CacheManager.getCache(name);
        Cache l2Cache = l2CacheManager.getCache(name);
        return new MultiLevelCache(name, l1Cache, l2Cache);
    }

    @Override
    public Collection<String> getCacheNames() {
        Set<String> names = new HashSet<>();
        names.addAll(l1CacheManager.getCacheNames());
        names.addAll(l2CacheManager.getCacheNames());
        return names;
    }
}

/**
 * 多级缓存实现
 */
public class MultiLevelCache implements Cache {

    private final String name;
    private final Cache l1Cache; // 本地缓存
    private final Cache l2Cache; // 分布式缓存

    public MultiLevelCache(String name, Cache l1Cache, Cache l2Cache) {
        this.name = name;
        this.l1Cache = l1Cache;
        this.l2Cache = l2Cache;
    }

    @Override
    public String getName() {
        return name;
    }

    @Override
    public Object getNativeCache() {
        return this;
    }

    @Override
    public ValueWrapper get(Object key) {
        // 1. 先查L1缓存
        ValueWrapper l1Value = l1Cache.get(key);
        if (l1Value != null) {
            return l1Value;
        }

        // 2. L1未命中，查L2缓存
        ValueWrapper l2Value = l2Cache.get(key);
        if (l2Value != null) {
            // 3. L2命中，回写到L1
            l1Cache.put(key, l2Value.get());
            return l2Value;
        }

        return null;
    }

    @Override
    public <T> T get(Object key, Class<T> type) {
        ValueWrapper wrapper = get(key);
        return wrapper != null ? (T) wrapper.get() : null;
    }

    @Override
    public <T> T get(Object key, Callable<T> valueLoader) {
        ValueWrapper wrapper = get(key);
        if (wrapper != null) {
            return (T) wrapper.get();
        }

        try {
            T value = valueLoader.call();
            put(key, value);
            return value;
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    @Override
    public void put(Object key, Object value) {
        // 同时写入L1和L2
        l1Cache.put(key, value);
        l2Cache.put(key, value);
    }

    @Override
    public void evict(Object key) {
        // 同时清除L1和L2
        l1Cache.evict(key);
        l2Cache.evict(key);
    }

    @Override
    public void clear() {
        l1Cache.clear();
        l2Cache.clear();
    }
}

方案二：手动实现多级缓存（适合精细控制）

@Service
public class CategoryServiceImpl implements CategoryService {

    @Autowired
    private CategoryMapper categoryMapper;

    @Autowired
    private TreeBuilder treeBuilder;

    @Autowired
    private StringRedisTemplate redisTemplate;

    private final Cache<String, List<Category>> localCache = Caffeine.newBuilder()
            .maximumSize(100)
            .expireAfterWrite(10, TimeUnit.MINUTES)
            .build();

    private static final String CACHE_KEY = "category:tree:all";

    /**
     * 手动实现多级缓存
     */
    public List<Category> getCategoryTree() {
        // 1. 查询L1缓存（本地）
        List<Category> result = localCache.getIfPresent(CACHE_KEY);
        if (result != null) {
            log.debug("命中L1缓存");
            return result;
        }

        // 2. 查询L2缓存（Redis）
        String json = redisTemplate.opsForValue().get(CACHE_KEY);
        if (StringUtils.hasText(json)) {
            try {
                result = JSON.parseArray(json, Category.class);
                // 回写到L1缓存
                localCache.put(CACHE_KEY, result);
                log.debug("命中L2缓存，回写L1");
                return result;
            } catch (Exception e) {
                log.warn("Redis缓存反序列化失败", e);
            }
        }

        // 3. 缓存未命中，查询数据库
        List<Category> allCategories = categoryMapper.selectAllForTree();
        result = treeBuilder.buildTree(allCategories, null);

        // 4. 同时写入L1和L2缓存
        localCache.put(CACHE_KEY, result);
        try {
            redisTemplate.opsForValue().set(CACHE_KEY, JSON.toJSONString(result),
                    Duration.ofHours(2));
        } catch (Exception e) {
            log.warn("写入Redis缓存失败", e);
        }

        log.debug("查询数据库，构建缓存");
        return result;
    }

    /**
     * 清除多级缓存
     */
    @Override
    public void evictCache() {
        localCache.invalidate(CACHE_KEY);
        redisTemplate.delete(CACHE_KEY);
        log.info("清除多级缓存完成");
    }
}

缓存预热策略

@Component
public class CacheWarmUp {

    @Autowired
    private CategoryService categoryService;

    /**
     * 应用启动时预热缓存
     */
    @EventListener(ApplicationReadyEvent.class)
    public void warmUpCache() {
        log.info("开始预热分类树缓存...");
        try {
            categoryService.getCategoryTree();
            log.info("分类树缓存预热完成");
        } catch (Exception e) {
            log.error("分类树缓存预热失败", e);
        }
    }

    /**
     * 定时刷新缓存
     */
    @Scheduled(fixedRate = 300000) // 5分钟
    public void refreshCache() {
        try {
            categoryService.getCategoryTree();
            log.debug("定时刷新分类树缓存完成");
        } catch (Exception e) {
            log.error("定时刷新分类树缓存失败", e);
        }
    }
}

性能监控

@Component
public class TreePerformanceMonitor {

    private static final String TREE_BUILD_TIMER = "tree.build.time";
    private static final String TREE_SIZE_GAUGE = "tree.size";

    @Autowired
    private MeterRegistry meterRegistry;

    /**
     * 监控树构建性能
     */
    public <T> List<T> monitorTreeBuild(Supplier<List<T>> treeBuilder) {
        return Timer.Sample.start(meterRegistry)
                .stop(Timer.builder(TREE_BUILD_TIMER)
                        .description("Tree building time")
                        .register(meterRegistry))
                .recordCallable(treeBuilder::get);
    }

    /**
     * 记录树规模
     */
    public void recordTreeSize(int size) {
        Gauge.builder(TREE_SIZE_GAUGE)
                .description("Tree node count")
                .register(meterRegistry, size, s -> s);
    }
}

常见问题与解决方案

Q1: 数据更新时如何保证缓存一致性？

解决方案：采用Write-Invalidate（写操作使缓存失效）模式，这是最常用且简单有效的方式。

@CacheEvict(value = "category:tree", allEntries = true)
@Transactional
public void updateCategory(Category category) {
    // 1. 先更新数据库
    categoryMapper.updateById(category);
    // 2. @CacheEvict注解使对应缓存自动失效
    // 3. 下次查询时，缓存未命中，会重新从数据库查询并构建新的缓存
}

// 对于极端高并发场景，可以考虑“延时双删”来降低缓存不一致的时间窗口
@Async
public void delayedCacheEvict() {
    try {
        Thread.sleep(500); // 延时500ms，等待可能的主从延迟或旧缓存更新
        cacheManager.getCache("category:tree").clear();
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
    }
}

Q2: 树的层级过深导致递归栈溢出怎么办？

解决方案：在必须使用递归的地方（如排序），用基于队列或栈的迭代算法替代递归。

public void sortTreeIteratively(List<TreeNode> roots) {
    Queue<TreeNode> queue = new LinkedList<>(roots);

    while (!queue.isEmpty()) {
        TreeNode node = queue.poll();

        if (node.hasChildren()) {
            // 排序当前节点的直接子节点
            node.getChildren().sort(Comparator.comparing(TreeNode::getSortOrder));
            // 将子节点加入队列，继续处理下一层
            queue.addAll(node.getChildren());
        }
    }
}

Q3: 数据量极大，一次性加载到内存导致内存不足怎么办？

解决方案：结合分页加载和懒加载（按需加载）策略。

// 方案A：限制加载深度
public List<Category> getCategoryTreeLazy(int maxDepth) {
    // 只加载指定深度以内的数据
    List<Category> categories = categoryMapper.selectByMaxLevel(maxDepth);
    return treeBuilder.buildTree(categories, null);
}

// 方案B：初始只加载顶层，点击时再异步加载子节点
public List<Category> loadChildren(Long parentId) {
    return categoryMapper.selectByParentId(parentId);
}

总结：从3秒到30毫秒的核心要点

三个关键突破

1. 算法突破：O(n²) → O(n)

   • 利用HashMap建立内存索引，将树构建的复杂度降为线性。
   • 避免深度递归和嵌套循环，减少函数调用开销。
   • 顺序的内存访问模式，对CPU缓存更友好。

2. 数据库突破：N+1查询 → 1次查询

   • 改变查询思维，变多次离散查询为一次批量查询。
   • 通过合理的数据库索引设计（如parent_id, level），保障全量查询的效率。
   • 充分利用数据库自身的批量数据处理能力。

3. 缓存突破：无缓存 → 高命中率多级缓存

   • 构建本地缓存(L1)+分布式缓存(L2)的多级缓存架构，兼顾速度和一致性。
   • 设计智能的缓存失效和更新策略。
   • 引入缓存预热机制，避免系统启动或缓存崩溃后的雪崩问题。

立即行动指南

如果你的系统树形查询响应时间超过500ms，可以按照以下步骤进行改造：

1. 复制TreeBuilder代码 → 直接替换项目中现有的递归构建逻辑。
2. 检查并添加数据库索引 → 确保parent_id、level、status等字段有合适索引。
3. 集成缓存 → 在Service层方法上添加@Cacheable和@CacheEvict注解。
4. 进行性能压测 → 使用JMeter等工具对比优化前后的QPS和响应时间。

预期收益：

• 接口响应时间降低90%以上。
• 系统并发处理能力提升一个数量级。
• 数据库负载压力减少80%以上。
• 最终用户体验获得显著改善。

最后的思考

性能优化并非一次性的魔法，而是一个需要持续观察、度量和改进的循环过程。本文提供的这套基于Spring Boot的解决方案，虽然已在多个生产环境得到验证，但切记每个业务场景都有其独特性。

记住一个原则：优秀的架构往往不是一开始就设计完美的，而是随着业务发展不断演进出来的。对于树形结构，从简单的邻接表开始，根据数据量、访问模式的变化，逐步引入一次查询、内存构建、多级缓存等优化，才是最务实和可持续的技术演进路径。

希望这篇文章能为你解决实际的性能问题带来启发。如果你想与更多开发者交流此类架构优化经验，欢迎在云栈社区的技术论坛中参与讨论。