Java树工具类，mysql树工具类

男娘i 2022-09-15 11:52 55阅读 0赞

依赖

<dependency>
                <groupId>cn.hutool</groupId>
                <artifactId>hutool-all</artifactId>
                <version>5.6.0</version>
            </dependency>
    <dependency>
                <groupId>com.baomidou</groupId>
                <artifactId>mybatis-plus-boot-starter</artifactId>
                <version>3.4.2</version>
            </dependency>

工具类

import cn.hutool.core.bean.BeanUtil;
    import cn.hutool.db.DbUtil;
    import cn.hutool.db.Entity;
    import cn.hutool.db.handler.EntityListHandler;
    import cn.hutool.db.sql.SqlExecutor;
    import com.baomidou.mybatisplus.core.toolkit.support.SFunction;
    import lombok.SneakyThrows;
    
    import javax.sql.DataSource;
    import java.io.Serializable;
    import java.lang.invoke.SerializedLambda;
    import java.lang.reflect.Method;
    import java.sql.Connection;
    import java.sql.SQLException;
    import java.util.ArrayList;
    import java.util.List;
    import java.util.function.Function;
    import java.util.stream.Collectors;
    
    /**
     * 函数式-树形工具类:将数据库中根据parentId的无限级数据转树形结构输出...
     *
     * @author sunziwen
     * @since 2021-4-16 10:36:06
     */
    
    public class TreeUtil {
        /**
         * 树形输出-自动寻找根节点
         *
         * @param list          基础数据集
         * @param getIdFn       获取主键的函数
         * @param getParentIdFn 获取父节点的函数
         * @param getChildrenFn 获取子集的函数
         * @param <T>           t
         * @param <R>           r
         * @return t
         */
        @SneakyThrows
        public static <T, R> List<T> treeStructure(List<T> list, Function<T, R> getIdFn, Function<T, R> getParentIdFn, SFunction<T, R> getChildrenFn) {
            /*所有元素的Id*/
            List<Object> ids = list.stream().map(getIdFn).collect(Collectors.toList());
            /*查出所有顶级节点*/
            List<T> topLevel = list.stream().filter(x -> {
                R apply = getParentIdFn.apply(x);
                return !ids.contains(apply);
            }).collect(Collectors.toList());
            return TreeUtil.recursion(topLevel, list, getIdFn, getParentIdFn, getChildrenFn);
        }
    
        /**
         * 树形输出-指定根节点
         *
         * @param list          基础数据集
         * @param t             根节点元素
         * @param getIdFn       获取主键的函数
         * @param getParentIdFn 获取父节点的函数
         * @param getChildrenFn 获取子集的函数
         * @param <T>           t
         * @param <R>           r
         * @return t
         */
        @SneakyThrows
        public static <T, R> List<T> treeStructure(List<T> list, T t, Function<T, R> getIdFn, Function<T, R> getParentIdFn, SFunction<T, R> getChildrenFn) {
            List<T> topLevel = new ArrayList<T>() {
       {
                add(t);
            }};
            return TreeUtil.recursion(topLevel, list, getIdFn, getParentIdFn, getChildrenFn);
        }
    
        @SneakyThrows
        private static <T, R> List<T> recursion(List<T> superLevel, List<T> list, Function<T, R> getIdFn, Function<T, R> getParentIdFn, SFunction<T, R> getChildrenFn) {
            //获取setChildren的Method
            Method writeReplaceMethod = getChildrenFn.getClass().getDeclaredMethod("writeReplace");
            boolean accessible = writeReplaceMethod.isAccessible();
            writeReplaceMethod.setAccessible(true);
            SerializedLambda serializedLambda = (SerializedLambda) writeReplaceMethod.invoke(getChildrenFn);
            writeReplaceMethod.setAccessible(accessible);
            String setMethodName = serializedLambda.getImplMethodName().replaceFirst("g", "s");
            Method setMethod = Class.forName(serializedLambda.getImplClass().replace("/", ".")).getDeclaredMethod(setMethodName, List.class);
    
            for (T t : superLevel) {
                List<T> children = list.stream().filter(x -> {
                    R apply = getParentIdFn.apply(x);
                    R apply1 = getIdFn.apply(t);
                    return apply.equals(apply1);
                }).collect(Collectors.toList());
                if (children.size() <= 0) {
                    continue;
                }
    
                List<T> recursion = recursion(children, list, getIdFn, getParentIdFn, getChildrenFn);
                setMethod.invoke(t, recursion);
            }
            return superLevel;
        }
    
        /**
         * Mysql查询指定ID下的不限级子元素集（适用于数据库中树太大，无法一次性查出的情况）
         *
         * @param dataSource   数据源
         * @param tableName    表名
         * @param idName       主键字段
         * @param parentIdName 关联字段
         * @param id           查询ID
         * @return
         */
        public static <T> List<T> cascade(DataSource dataSource, String tableName, String idName, String parentIdName, Serializable id, Class<T> clazz) {
            String sql = "SELECT * FROM ( SELECT * FROM " + tableName + ") A,( SELECT @pv := ? ) B  WHERE find_in_set( " + parentIdName + ", @pv ) AND length(@pv := concat( @pv, ',', " + idName + " ))";
            Connection conn = null;
            try {
                conn = dataSource.getConnection();
                /* 执行查询语句，返回实体列表，一个Entity对象表示一行的数据，Entity对象是一个继承自HashMap的对象，存储的key为字段名，value为字段值 */
                List<Entity> entityList = SqlExecutor.query(conn, sql, new EntityListHandler(), id);
                List<T> resultList = new ArrayList<T>();
                entityList.forEach(entity -> {
                    try {
                        T t = BeanUtil.fillBeanWithMap(entity, clazz.newInstance(), true, true);
                        resultList.add(t);
                    } catch (InstantiationException | IllegalAccessException e) {
                        System.out.println("Convert error!");
                    }
                });
                return resultList;
            } catch (SQLException e) {
                System.out.println("SQL error!");
            } finally {
                DbUtil.close(conn);
            }
            return null;
        }
    /**
         * Mysql查询指定ID下的不限级子元素集
         *
         * @param dataSource   数据源
         * @param tableName    表名
         * @param idName       主键字段
         * @param parentIdName 关联字段
         * @param id           查询ID
         * @return
         */
        public static <T> List<T> cascade(DataSource dataSource, String tableName, String idName, String parentIdName, Serializable id,String where, Class<T> clazz) {
            String sql = "SELECT * FROM ( SELECT * FROM " + tableName + ") A,( SELECT @pv := ? ) B  WHERE find_in_set( " + parentIdName + ", @pv ) AND length(@pv := concat( @pv, ',', " + idName + " ))"+(where==null?"":" and "+where);
            Connection conn = null;
            try {
                conn = dataSource.getConnection();
                /* 执行查询语句，返回实体列表，一个Entity对象表示一行的数据，Entity对象是一个继承自HashMap的对象，存储的key为字段名，value为字段值 */
                List<Entity> entityList = SqlExecutor.query(conn, sql, new EntityListHandler(), id);
                List<T> resultList = new ArrayList<T>();
                entityList.forEach(entity -> {
                    try {
                        T t = BeanUtil.fillBeanWithMap(entity, clazz.newInstance(), true, true);
                        resultList.add(t);
                    } catch (InstantiationException | IllegalAccessException e) {
                        System.out.println("Convert error!");
                    }
                });
                return resultList;
            } catch (SQLException e) {
                System.out.println("SQL error!");
            } finally {
                DbUtil.close(conn);
            }
            return null;
        }
    
    }

使用

@RestController
    @RequestMapping
    public class TestController {
        @Resource
        private DataSource dataSource;
    
        @PostMapping("test")
        public ServiceResult<?> test(@RequestParam  Integer id) {
         
            //级联查询,根据跟ID查询出不限级下属所有ID
            List<Organization> cascade = TreeUtil.cascade(dataSource, "organization", "id", "parent_id", id, Organization.class);
            if (cascade == null) {
                return failure(null, "不存在的目录ID:" + id);
            }
            return success(cascade);
        }
    }