🎯 简介

DefaultNodeParser 是 Hutool 树结构模块中的默认节点解析器，实现了 NodeParser 接口。它用于将 TreeNode 类型的节点转换为 MapTree 类型，是树结构构建过程中的默认转换器。

📋 核心特性

• ✅ 实现了 NodeParser 接口
• ✅ 专门用于 TreeNode 到 MapTree 的转换
• ✅ 自动处理扩展字段，将 extra 映射到 MapTree
• ✅ 转换逻辑完整，包含所有必要属性
• ✅ 代码简洁，易于理解和使用
• ✅ 是树结构构建的默认选择

🛠️ 类结构

typedef DefaultNodeParser<T>
  ├── 实现自 NodeParser<TreeNode<T>, T>
  └── 方法
      └── parse(treeNode, tree): void // 将TreeNode转换为MapTree

🚀 快速开始

基本使用

// 创建TreeNode实例
TreeNode<Long> treeNode1 = new TreeNode<>(1L, 0L, "节点1", 1);
TreeNode<Long> treeNode2 = new TreeNode<>(2L, 1L, "节点2", 2);
TreeNode<Long> treeNode3 = new TreeNode<>(3L, 1L, "节点3", 3);

// 添加扩展字段
treeNode1.setExtra(Map.of("key1", "value1", "key2", "value2"));

// 创建DefaultNodeParser实例
DefaultNodeParser<Long> parser = new DefaultNodeParser<>();

// 创建TreeBuilder并添加节点
TreeBuilder<Long> builder = TreeBuilder.of(0L);
builder.append(List.of(treeNode1, treeNode2, treeNode3), parser);

// 构建树
MapTree<Long> tree = builder.build();

// 输出结果
Console.log("构建的树: {}", tree);

结合TreeUtil使用

// 创建TreeNode列表
List<TreeNode<String>> treeNodeList = new ArrayList<>();
treeNodeList.add(new TreeNode<>("1", "0", "根节点", 0));
treeNodeList.add(new TreeNode<>("2", "1", "子节点1", 1));
treeNodeList.add(new TreeNode<>("3", "1", "子节点2", 2));

// 使用DefaultNodeParser构建树
List<MapTree<String>> tree = TreeUtil.build(treeNodeList, "0", new DefaultNodeParser<>());

// 输出结果
Console.log("使用DefaultNodeParser构建的树: {}", tree);

📖 详细方法

parse(treeNode, tree)

• 功能：将 TreeNode 转换为 MapTree

• 参数：

  • treeNode - 源 TreeNode 节点
  • tree - 目标 MapTree 节点

• 转换逻辑：

  1. 设置ID
  2. 设置父节点ID
  3. 设置权重
  4. 设置名称
  5. 如果存在扩展字段 extra，将其所有属性添加到 MapTree

• 示例：

  DefaultNodeParser<Long> parser = new DefaultNodeParser<>();
  parser.parse(treeNode, mapTree);
  

🎨 使用场景

1. TreeNode转MapTree

// 创建TreeNode
TreeNode<Long> treeNode = new TreeNode<>(1L, 0L, "测试节点", 5);

// 添加扩展字段
Map<String, Object> extra = new HashMap<>();
extra.put("type", "test");
extra.put("status", "active");
treeNode.setExtra(extra);

// 创建MapTree
MapTree<Long> mapTree = new MapTree<>();

// 使用DefaultNodeParser转换
DefaultNodeParser<Long> parser = new DefaultNodeParser<>();
parser.parse(treeNode, mapTree);

// 输出结果
Console.log("转换后的MapTree: {}", mapTree);

2. 批量转换

// 创建TreeNode列表
List<TreeNode<Long>> treeNodeList = new ArrayList<>();

// 添加带扩展字段的TreeNode
for (long i = 1; i <= 5; i++) {
    TreeNode<Long> node = new TreeNode<>(i, i == 1 ? 0L : i - 1, "节点" + i, (int) i);
    // 为奇数节点添加扩展字段
    if (i % 2 != 0) {
        Map<String, Object> extra = new HashMap<>();
        extra.put("isOdd", true);
        extra.put("value", i * 10);
        node.setExtra(extra);
    }
    treeNodeList.add(node);
}

// 使用TreeBuilder和DefaultNodeParser构建树
TreeBuilder<Long> builder = TreeBuilder.of(0L);
builder.append(treeNodeList, new DefaultNodeParser<>());
MapTree<Long> tree = builder.build();

// 输出结果
Console.log("批量转换后的树: {}", tree);

3. 与自定义配置结合

// 创建自定义配置
TreeNodeConfig config = new TreeNodeConfig();
config.setNameKey("title")
    .setChildrenKey("items")
    .setWeightKey("order");

// 创建TreeNode
TreeNode<Long> treeNode = new TreeNode<>(1L, 0L, "自定义节点", 3);
treeNode.setExtra(Map.of("icon", "📦", "url", "/custom"));

// 创建MapTree
MapTree<Long> mapTree = new MapTree<>(config);

// 使用DefaultNodeParser转换
DefaultNodeParser<Long> parser = new DefaultNodeParser<>();
parser.parse(treeNode, mapTree);

// 输出结果
Console.log("自定义配置转换后的MapTree: {}", mapTree);

💡 注意事项

1. 适用范围：

   • 只适用于 TreeNode 到 MapTree 的转换
   • 对于其他类型的源数据，需要自定义 NodeParser 实现

2. 扩展字段处理：

   • 会将 TreeNode 的 extra 字段中的所有属性添加到 MapTree
   • 如果 extra 为 null 或空，不会执行任何操作
   • 使用 forEach 遍历添加，保证所有扩展字段都能被处理

3. 属性映射：

   • 固定映射 TreeNode 的基本属性到 MapTree
   • 映射关系：
     • id → id
     • parentId → parentId
     • weight → weight
     • name → name
     • extra → 所有键值对

4. 性能考虑：

   • 转换逻辑简单，性能较好
   • 对于大量节点的场景，建议使用 TreeBuilder 批量处理

5. 线程安全：

   • 该类本身是线程安全的
   • 但在多线程环境下使用时，需要确保传入的参数是线程安全的

🚀 性能优化

• 对于大量节点的场景，建议使用 TreeBuilder 批量添加节点，减少重复创建解析器的开销
• 避免在 TreeNode 的 extra 中存储大量数据，影响转换性能
• 对于固定的转换规则，可以考虑缓存转换结果

🔍 最佳实践

1. 默认选择：

   • 当源数据是 TreeNode 类型时，优先使用 DefaultNodeParser
   • 它提供了完整的转换逻辑，无需自定义实现

2. 扩展使用：

   • 如果需要在转换过程中添加额外的逻辑，可以继承 DefaultNodeParser 并扩展 parse 方法
   • 例如：添加自定义属性、修改转换规则等

3. 结合TreeBuilder：

   • 建议与 TreeBuilder 结合使用，实现批量转换和树构建
   • 这种方式代码更简洁，性能更好

4. 测试转换结果：

   • 转换完成后，建议验证转换结果是否符合预期
   • 特别是扩展字段的处理，确保所有属性都能正确映射

📝 总结

DefaultNodeParser 是 Hutool 树结构模块中的默认节点解析器，专门用于将 TreeNode 转换为 MapTree。它提供了完整的转换逻辑，包括基本属性和扩展字段的处理，是树结构构建过程中的常用工具。

通过使用 DefaultNodeParser，可以快速实现 TreeNode 到 MapTree 的转换，减少自定义转换逻辑的编写。它的设计简洁、性能良好，适合各种规模的树结构构建场景。

在实际开发中，当需要将 TreeNode 转换为 MapTree 时，建议优先使用 DefaultNodeParser。如果需要特殊的转换逻辑，可以考虑继承它或实现自定义的 NodeParser 接口。