一、列表参数

列表参数需要符合递归所需的关联关系，例如必须父子级关系(子数据的parentId需要为父级的id)，未进行关联的数据无法在树形结构中显示。

package com.vshi.util.entity;

import lombok.Data;

/**
 * @author zzz
 * @since 2022-03-04 15:54
 */
@Data
public class TestTree {

    /**
     * 节点ID
     */
    private String id;

    /**
     * 节点名称
     */
    private String name;

    /**
     * 父节点ID
     */
    private String parentId;

    /**
     * 顺序
     */
    private Integer sort;

    /**
     * 备注
     */
    private String remake;

}

二、响应数据适配（通用接口）

1. 接口方法构建

利用重写方法存储数据，通用适配接口

package com.vshi.util.tree.entity;

import java.util.List;

/**
 * @author zzz
 * @since 2022-03-04 15:07
 */
public interface TreeNode {

    /**
     * 节点ID
     *
     * @return String
     */
    String getId();

    /**
     * 节点名称
     *
     * @return String
     */
    String getName();

    /**
     * 顺序
     *
     * @return Integer
     */
    Integer getSort();

    /**
     * 父节点ID
     *
     * @return String
     */
    String getParentId();

    /**
     * 赋值子节点列表
     *
     * @param childNodes children
     */
    void setChildNodes(List<? extends TreeNode> childNodes);

    /**
     * 子节点列表
     *
     * @return List
     */
    List<? extends TreeNode> getChildNodes();
}

2. 创建响应实体类

利用类的继承和接口实现来构建实体类，增加代码的可读性和复用性。

package com.vshi.util.entity;

import java.util.List;

/**
 * @author zzz
 * @since 2022-03-04 16:48
 */
public class TestTreeVo extends TestTree implements TreeNode {

    private List<TestTreeVo> childNodes;

    @Override
    public void setChildNodes(List<? extends TreeNode> childNodes) {
        this.childNodes = (List<TestTreeVo>) childNodes;
    }

    @Override
    public List<? extends TreeNode> getChildNodes() {
        return this.childNodes;
    }
}

三、树形结构构建

package com.vshi.util;

import com.vshi.util.entity.TreeNode;
import org.springframework.beans.BeanUtils;
import org.springframework.util.CollectionUtils;

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

/**
 * @author zzz
 * @since 2022-03-02 14:55
 */
public class TreeNodeUtil {

    /**
     * 根结点ID
     */
    public static final String ROOT_ID = "0";

    public static <T> List<TreeNode> buildTreeNode(List<? extends TreeNode> list, Class<T> clazz) {
        if (CollectionUtils.isEmpty(list)) {
            return Collections.emptyList();
        }
        List<TreeNode> dtoList = new ArrayList<>();
        // 子类适配
        list.forEach(x -> {
            T entity = BeanUtils.instantiateClass(clazz);
            TreeNode treeDto = (TreeNode) adapt(x, entity);
            dtoList.add(treeDto);
        });
        // 构造树形
        return buildTree(dtoList, clazz);
    }

    private static <T> List<TreeNode> buildTree(List<TreeNode> dtoList, Class<T> clazz) {
        Map<String, List<TreeNode>> map = new HashMap<>(dtoList.size());
        dtoList.forEach(x -> {
            T entity = BeanUtils.instantiateClass(clazz);
            TreeNode nodeVO = (TreeNode) adapt(x, entity);
            BeanUtils.copyProperties(x, nodeVO);
            List<TreeNode> childNodes = map.getOrDefault(x.getParentId(), new ArrayList<>());
            childNodes.add(nodeVO);
            // 按sort排序
            List<TreeNode> collect = childNodes.stream().sorted(Comparator.comparing(TreeNode::getSort)).collect(Collectors.toList());
            map.put(x.getParentId(), collect);
        });
        // 顶层数据
        List<TreeNode> roots = map.get(ROOT_ID);
        // 处理子节点数据
        processNode(roots, map);
        return roots;
    }

    private static void processNode(List<TreeNode> roots, Map<String, List<TreeNode>> map) {
        if (CollectionUtils.isEmpty(roots)) {
            return;
        }
		// 递归+遍历插入每层数据
        roots.forEach(x -> {
            List<TreeNode> child = map.get(x.getId());
            if (!CollectionUtils.isEmpty(child)) {
                processNode(child, map);
                x.setChildNodes(child);
            }
        });
    }

    private static <T> Object adapt(TreeNode x, T entity) {
        BeanUtils.copyProperties(x, entity);
        return entity;
    }
}