您现在的位置：程式碼之家 >> 編程語言 > >> Java 程式設計 >> Java 程式設計入門

Java 遞歸菜單樹轉換 POJO 完整實現：從數據庫扁平數據到層級樹結構

編輯：Java 程式設計入門

前言：權限系統的核心數據結構

「菜單樹」是 RBAC 權限系統、CMS 內容管理、組織架構、商品分類的通用數據模型。數據庫通常存儲扁平記錄（含 id、parentId、sortOrder），前端組件（如 zTree、Ant Design Tree、Element UI Tree）需要巢狀樹結構。本文提供高效、線程安全、支援多根節點、可擴展的遞歸構建方案。

1. 數據模型定義


// 數據庫實體（扁平）
public class SysModel {
    private String sysModuleId;    // 主鍵
    private String parentId;       // 父節點 ID，根節點為 null/""
    private String systemId;       // 子系統標識（多租戶/多模塊隔離）
    private String moduleName;     // 顯示名稱
    private String url;            // 前端路由
    private String icon;           // 圖標
    private Integer sortOrder;     // 同級排序
    private Integer status;        // 1啟用 0禁用
    // getter/setter 略
}

// 樹節點 POJO（前端輸出）
public class MenuTreeNode implements Serializable {
    private SysModel model;                    // 業務數據
    private List children = new ArrayList<>(); // 子節點
    private int level;                         // 層級深度（根=0）
    private boolean leaf;                      // 是否葉子節點
    private boolean expanded;                  // 默認展開
    private boolean selected;                  // 是否選中
    // getter/setter/構造函數 略
}

2. 核心構建算法：O(n) 時間複雜度

避免雙重循環 O(n²) 或遞歸查詢數據庫。採用 Map 索引 + 單次遍歷：


import java.util.*;
import java.util.stream.Collectors;

public class MenuTreeBuilder {

    /** 構建菜單樹（多根節點，返回森林 List） */
    public static List buildTree(List flatModels) {
        if (flatModels == null || flatModels.isEmpty()) {
            return Collections.emptyList();
        }

        // 1. 過濾啟用節點，按排序字段預排序（保證同級順序）
        List enabled = flatModels.stream()
                .filter(m -> m.getStatus() == 1)
                .sorted(Comparator.comparing(SysModel::getSortOrder, Comparator.nullsLast(Comparator.naturalOrder())))
                .collect(Collectors.toList());

        // 2. 建立 ID -> Node 映射（O(n)）
        Map nodeMap = new LinkedHashMap<>(enabled.size() * 2);
        for (SysModel model : enabled) {
            MenuTreeNode node = new MenuTreeNode();
            node.setModel(model);
            node.setLevel(-1); // 待計算
            nodeMap.put(model.getSysModuleId(), node);
        }

        // 3. 掛接父子關係（O(n)）
        List roots = new ArrayList<>();
        for (SysModel model : enabled) {
            MenuTreeNode node = nodeMap.get(model.getSysModuleId());
            String parentId = model.getParentId();

            if (parentId == null || parentId.isEmpty() || !nodeMap.containsKey(parentId)) {
                // 根節點：parentId 為空、或父節點不存在（孤兒節點視為根）
                node.setLevel(0);
                roots.add(node);
            } else {
                MenuTreeNode parent = nodeMap.get(parentId);
                parent.getChildren().add(node);
                // 層級將在下一步統一計算
            }
        }

        // 4. 遞歸計算層級、葉子標記、默認展開邏輯
        for (MenuTreeNode root : roots) {
            initNodeProperties(root, 0);
        }

        return roots;
    }

    private static void initNodeProperties(MenuTreeNode node, int level) {
        node.setLevel(level);
        node.setLeaf(node.getChildren().isEmpty());
        // 默認展開前 2 級，或配置化
        node.setExpanded(level < 2);
        
        for (MenuTreeNode child : node.getChildren()) {
            initNodeProperties(child, level + 1);
        }
    }

    /** 按 systemId 分組構建多棵樹（適配多子系統） */
    public static Map> buildTreeBySystem(List models) {
        return models.stream()
                .collect(Collectors.groupingBy(SysModel::getSystemId))
                .entrySet().stream()
                .collect(Collectors.toMap(
                    Map.Entry::getKey,
                    e -> buildTree(e.getValue())
                ));
    }
}

3. 原文代碼分析與改進點

原文 ModelList.createTree2() 存在以下問題：

問題	原文表現	改進方案
時間複雜度	遞歸中遍歷 childs 列表 O(n²)	Map 索引 O(n)
多根節點處理	創建虛擬根節點包裝	直接返回 List<MenuTreeNode> 森林
層級計算	遞歸傳參 flag	構建後統一 DFS 計算
排序支持	無	預排序 + LinkedHashMap 保持順序
線程安全	實例方法共享狀態	靜態純函數，無狀態
孤兒節點	父節點不在 childs 中會丟失	視為根節點保留
循環引用檢測	無	可選：構建時檢測拋出異常

4. 進階功能擴展

權限過濾：根據用戶權限動態剪枝


public static List filterByPermissions(List tree, Set permittedIds) {
    return tree.stream()
            .map(node -> filterNode(node, permittedIds))
            .filter(Objects::nonNull)
            .collect(Collectors.toList());
}

private static MenuTreeNode filterNode(MenuTreeNode node, Set permittedIds) {
    String id = node.getModel().getSysModuleId();
    boolean hasPermission = permittedIds.contains(id);
    
    List filteredChildren = node.getChildren().stream()
            .map(child -> filterNode(child, permittedIds))
            .filter(Objects::nonNull)
            .collect(Collectors.toList());
    
    if (!hasPermission && filteredChildren.isEmpty()) {
        return null; // 無權限且無子節點 → 剪枝
    }
    
    node.setChildren(filteredChildren);
    node.setLeaf(filteredChildren.isEmpty());
    return node;
}

路徑查找：根據節點 ID 獲取從根到該節點的路徑


public static List findPath(List tree, String targetId) {
    List path = new ArrayList<>();
    if (findPathRecursive(tree, targetId, path)) {
        return path;
    }
    return Collections.emptyList();
}

private static boolean findPathRecursive(List nodes, String targetId, List path) {
    for (MenuTreeNode node : nodes) {
        path.add(node);
        if (node.getModel().getSysModuleId().equals(targetId)) {
            return true;
        }
        if (findPathRecursive(node.getChildren(), targetId, path)) {
            return true;
        }
        path.remove(path.size() - 1); // 回溯
    }
    return false;
}

樹扁平化：樹 → 列表（用於 Excel 導出、數據庫批量更新）


public static List flattenTree(List tree) {
    List result = new ArrayList<>();
    flattenRecursive(tree, result);
    return result;
}

private static void flattenRecursive(List nodes, List result) {
    for (MenuTreeNode node : nodes) {
        SysModel model = node.getModel();
        model.setLevel(node.getLevel()); // 回寫層級
        result.add(model);
        if (!node.getChildren().isEmpty()) {
            flattenRecursive(node.getChildren(), result);
        }
    }
}

5. 前端適配：JSON 序列化規範

主流前端組件期望字段：


// Ant Design / Element UI
{
  "key": "module_101",           // 唯一標識
  "title": "用戶管理",           // 顯示文本
  "children": [...],             // 子節點
  "icon": "user",                // 圖標
  "disabled": false,             // 禁用
  "selectable": true,            // 可選
  "expanded": true,              // 默認展開
  "isLeaf": false                // 葉子節點
}

// zTree
{
  "id": "module_101",
  "pId": "module_100",
  "name": "用戶管理",
  "open": true,
  "icon": "user"
}

建議在 MenuTreeNode 添加 toAntNode()、toZTreeNode() 轉換方法，或使用 Jackson @JsonProperty 重命名字段。

6. 單元測試


@Test
void testBuildTree() {
    List models = Arrays.asList(
        m("1", null, "系統管理", 1),
        m("2", "1", "用戶管理", 1),
        m("3", "1", "角色管理", 2),
        m("4", "2", "用戶列表", 1),
        m("5", "2", "新增用戶", 2),
        m("6", null, "系統監控", 2) // 第二個根節點
    );

    List tree = MenuTreeBuilder.buildTree(models);
    
    assertEquals(2, tree.size()); // 兩棵樹
    assertEquals("系統管理", tree.get(0).getModel().getModuleName());
    assertEquals(2, tree.get(0).getChildren().size());
    assertEquals("用戶列表", tree.get(0).getChildren().get(0).getChildren().get(0).getModel().getModuleName());
    assertEquals(0, tree.get(0).getLevel());
    assertEquals(1, tree.get(0).getChildren().get(0).getLevel());
    assertEquals(2, tree.get(0).getChildren().get(0).getChildren().get(0).getLevel());
    assertTrue(tree.get(0).isExpanded()); // 0 < 2
    assertFalse(tree.get(0).getChildren().get(0).getChildren().get(0).isExpanded()); // 2 !< 2
}

private SysModel m(String id, String parentId, String name, int sort) {
    SysModel m = new SysModel();
    m.setSysModuleId(id);
    m.setParentId(parentId);
    m.setModuleName(name);
    m.setSortOrder(sort);
    m.setStatus(1);
    return m;
}