查询部门树（递归）

 /**
     * 查询部门树
     *
     * @return 部门树
     */
    @Override
    public ResponseMessageDTO<List<LabelValueDTO<String>>> queryDepartmentTree() {
        // 1.查询第一层部门
        List<DepartmentDTO> firstDepartmentList = queryDepartmentList(Constants.DEFAULT_LEVEL, null);
        if (CollectionUtils.isEmpty(firstDepartmentList)) {
            return ResponseMessageDTO.success(Collections.emptyList());
        }
        // 2. 查询子集
        return ResponseMessageDTO.success(queryChildren(firstDepartmentList, Constants.DEFAULT_LEVEL));
    }

queryDepartmentList

  /**
     * 查询部门列表
     *
     * @param level      层级
     * @param parentList 父级编码集合
     * @return 部门列表
     */
    private List<DepartmentDTO> queryDepartmentList(Integer level, List<String> parentList) {
        List<DepartmentDO> result = list(new LambdaQueryWrapper<DepartmentDO>()
                .eq(DepartmentDO::getLevel, level)
                .in(CollectionUtils.isNotEmpty(parentList), DepartmentDO::getParentCode, parentList)
                .eq(BaseInfoDO::getDeleted, DeleteEnum.NO_DELETE.getCode()));
        if (CollectionUtils.isEmpty(result)) {
            return Collections.emptyList();
        }
        return ConversionUtils.transformList(result, DepartmentDTO.class);
    }

queryChildren

    /**
     * 查询子集
     *
     * @param departmentList 父级集合
     * @param level          级别
     */
    private List<LabelValueDTO<String>> queryChildren(List<DepartmentDTO> departmentList, Integer level) {
        Integer nextLevel = level + 1;
        List<DepartmentDTO> childrenDepartmentList = queryDepartmentList(nextLevel, departmentList.stream().map(DepartmentDTO::getCode).collect(Collectors.toList()));
        Map<String, List<DepartmentDTO>> departmentMap = childrenDepartmentList.stream().collect(Collectors.groupingBy(DepartmentDTO::getParentCode));
        List<LabelValueDTO<String>> result = new ArrayList<>();
        departmentList.forEach(item -> {
            // 有子集就继续查询子集
            List<LabelValueDTO<String>> childrenResult = Collections.emptyList();
            //containsKey主要用于判断map中是否包含指定的键名
            if (departmentMap.containsKey(item.getCode())) {
                List<DepartmentDTO> childrenList = ConversionUtils.transformList(departmentMap.get(item.getCode()), DepartmentDTO.class);
                childrenResult = queryChildren(childrenList, nextLevel);
            }
            result.add(LabelValueDTO
                    .<String>builder()
                    .children(childrenResult)
                    .label(item.getName())
                    .value(String.valueOf(item.getId()))
                    .ext(item.getCode())
                    .build());
        });
        return result;
    }

transformList

    public static <T, V> List<T> transformList(List<V> sourceList, Class<T> targetClass) {
        List<T> targetList = new ArrayList();
        if (CollectionUtils.isEmpty(sourceList)) {
            return targetList;
        } else {
            try {
                Iterator var3 = sourceList.iterator();

                while(var3.hasNext()) {
                    V item = var3.next();
                    T target = targetClass.newInstance();
                    BeanUtils.copyProperties(item, target);
                    targetList.add(target);
                }
            } catch (Exception var6) {
                log.error("参数转换异常", var6);
            }

            return targetList;
        }
    }

isEmpty

    public static boolean isEmpty(Collection<?> coll) {
        return coll == null || coll.isEmpty();
    }

ConversionUtils.transformList

public class ConversionUtils {
    private static final Logger log = LoggerFactory.getLogger(ConversionUtils.class);

    public ConversionUtils() {
    }

    public static <T, V> List<T> transformList(List<V> sourceList, Class<T> targetClass) {
        List<T> targetList = new ArrayList();
        if (CollectionUtils.isEmpty(sourceList)) {
            return targetList;
        } else {
            try {
                Iterator var3 = sourceList.iterator();

                while(var3.hasNext()) {
                    V item = var3.next();
                    T target = targetClass.newInstance();
                    BeanUtils.copyProperties(item, target);
                    targetList.add(target);
                }
            } catch (Exception var6) {
                log.error("参数转换异常", var6);
            }

            return targetList;
        }
    }

    public static <T, V> T transform(V source, Class<T> targetClass) {
        Object target = null;

        try {
            target = targetClass.newInstance();
            BeanUtils.copyProperties(source, target);
        } catch (InstantiationException var4) {
            log.error("参数转换异常", var4);
        } catch (Exception var5) {
            log.error("未知异常", var5);
        }

        return target;
    }
}