用hutools查询树结构_糊涂工具 对象树结构

1.需导入依赖

   	<!--hutool工具-->
     <dependency>
         <groupId>cn.hutool</groupId>
         <artifactId>hutool-all</artifactId>
         <version>5.3.8</version>
     </dependency>
     <dependency>
         <groupId>commons-collections</groupId>
         <artifactId>commons-collections</artifactId>
         <version>3.2</version>
         <scope>compile</scope>
     </dependency>
     <dependency>
         <groupId>commons-beanutils</groupId>
         <artifactId>commons-beanutils</artifactId>
         <version>1.9.4</version>
         <scope>compile</scope>
     </dependency>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

2.实体类

@AllArgsConstructor
@NoArgsConstructor
@Data
public class TreeDemo {
    private String id;
    private String columnName;
    private String parentId;
    private Double sortNum;

}
1
2
3
4
5
6
7
8
9
10

3. 代码实现

package com.xxxx.studyseckill.tree;


import cn.hutool.core.lang.tree.Tree;
import cn.hutool.core.lang.tree.TreeNode;
import cn.hutool.core.lang.tree.TreeNodeConfig;
import cn.hutool.core.lang.tree.TreeUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.toolkit.CollectionUtils;
import com.xxxx.studyseckill.mapper.TreeDemoMapper;

import org.apache.commons.beanutils.BeanComparator;
import org.apache.commons.collections.ComparatorUtils;
import org.apache.commons.collections.comparators.ComparableComparator;
import org.thymeleaf.util.StringUtils;

import javax.annotation.Resource;
import java.util.*;
import java.util.stream.Collectors;

public class TestTree {

    @Resource
    private TreeDemoMapper treeDemoMapper;

    public List<Tree<String>> getTree(String parentId){
        List<Tree<String>> resultTree = new ArrayList<>();
        if(StringUtils.isEmpty(parentId)){
            parentId = "root";
        }
        List<TreeDemo> demoTreeList = this.getDemoByParentId(parentId,new ArrayList<>());

        //转换成树结点
        List<TreeNode<String>> treeNodeList = demoTreeList.stream().map(treeDemo -> {
            Map<String,Object> map = new HashMap<>();
            map.put("columnName",treeDemo.getColumnName());
            map.put("id",treeDemo.getId());
            map.put("sortNum",treeDemo.getSortNum());
            TreeNode<String> treeNode = new TreeNode<String>().setId(treeDemo.getId()).setParentId(treeDemo.getParentId()).setExtra(map);
            return treeNode;
        }).collect(Collectors.toList());
        //转换树形列表中字段名称
        TreeNodeConfig config = new TreeNodeConfig().setChildrenKey("children").setIdKey("id").setParentIdKey("parentId");
        //转换树结点到树形列表
        String rootTreeNode = "root";
        if(CollectionUtils.isNotEmpty(demoTreeList)){
            rootTreeNode = demoTreeList.get(0).getParentId();
        }
        List<Tree<String>> treeList = TreeUtil.build(treeNodeList,rootTreeNode,config,(node,tree)->{
            tree.setId(node.getId()).setParentId(node.getParentId());
            tree.putExtra("columnName",node.getExtra().get("columnName"));
            tree.putExtra("id",node.getExtra().get("id"));
            tree.putExtra("sortNum",node.getExtra().get("sortNum"));
        });
        //排序
        treeListSort(treeList);

        return treeList;
    }

   

    /**
     * 获取当前结点和子节点的值
     * @param parentId
     * @return
     */
    private List<TreeDemo> getDemoByParentId(String parentId,List<TreeDemo> treeDemoList) {
        //获取当前结点信息
        TreeDemo currentTreeDemo = treeDemoMapper.selectOne(new LambdaQueryWrapper<TreeDemo>().eq(TreeDemo::getId, parentId).last("limit 1"));
        if(Objects.nonNull(currentTreeDemo)){
            treeDemoList.add(currentTreeDemo);
        }
        //获取子节点信息
        List<TreeDemo> demoTreeList = this.treeDemoMapper.getTreeDemoByParentId(parentId);
        treeDemoList.addAll(demoTreeList);
        if(CollectionUtils.isNotEmpty(demoTreeList)){
            for (TreeDemo treeDemo : demoTreeList) {
                String id = treeDemo.getId();
                getDemoByParentId(id,treeDemoList);
            }
        } else {
            return demoTreeList;
        }
        //去除重复值
        LinkedHashSet<TreeDemo> hashSet = new LinkedHashSet<>(demoTreeList);
        ArrayList<TreeDemo> listWithoutDuplicates = new ArrayList<>(hashSet);

        return listWithoutDuplicates;
    }

 	/**
     * 对树集合升序排列
     * @param treeList
     */
    private void treeListSort(List<Tree<String>> treeList) {
        Comparator<?> instance = ComparableComparator.getInstance();
        instance = ComparatorUtils.nullLowComparator(instance);
        treeList.sort(new BeanComparator<>("sortNum",instance));
        treeList.forEach(e -> {
            List<Tree<String>> childrenList = e.getChildren();
            if(CollectionUtils.isNotEmpty(childrenList)){
                treeListSort(childrenList);
            }
        });
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107