• java 处理树形结构数据

    前言

    问题的背景大概是这样的，有下面这样一个excel表，原始数据结构如下：

    需求点：

    • 导入excel的机构层级数据到mysql的机构表（这里假设为 depart）;
    • 导入的机构数据以层级进行保存和区分；
    • 界面展示时需要以完整的树形层级进行展示；

    处理过程

    按照上面已知的信息，设计一个简单的机构表

    1. CREATE TABLE `depart` (
    2.   `depart_id` varchar(64) DEFAULT NULL,
    3.   `pid` varchar(64) DEFAULT NULL,
    4.   `name` varchar(255) DEFAULT NULL,
    5.   `path` varchar(255) DEFAULT NULL
    6. ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
    7.

    接下来分析下具体的实现；

    1、导入的时候以层级保存数据 

    有做过树形结构处理业务的小伙伴们对树形结构的处理并不陌生，主要就是在机构表中合理运用 id 和 pid 构建数据层级关系，期间可能涉及到递归的操作（不建议在数据库层面递归）；

    但我们说具体问题具体分析，比如按照上面的exce表的数据结构，以 “/产品研发中心/业务一部” 这个机构为例做简单说明

    • 以 “/” 区分，这条数据涉及到2个部门，“产品研发中心” 为一级部门，而 “业务一部” 为其子部门，即二级部门；
    • 按照第一步的分析，需要将这条数据拆开来做处理，通过部门名称以及其所在层级（业务中可能还存在其他字段），即在查库过程中作为查询条件；
    • 需要考虑excel中的数据存在性，比如 “产品研发中心” 这条数据在数据库中可能存在，也可能不存在，“业务一部” 也可能存在或不存在；
    • 在第三步的基础上，需要按照程序的逻辑设置一定的规则，大概如下：1、顶级部门不存在，可以认为这条数据在数据库中不存在，处理的时候直接按照正常的规则；2、顶级部门存在，直接处理最后一级数据；
    • 不考虑中间部门层级，像 “/A/B/C” 中的B是否存在问题；

    2、返回树形层级结构数据

    相比导入来说，返回树形层级结构相对来说，已经有相对成熟的处理方式，大致思路如下：

    • 查询所有数据（如果考虑动态加载另说）；
    • 构建返回数据的树形结构（可根据 id 和 pid 的关系）；

    树形结构的返回对象结构大致如下

    1. public class DepartDTO {
    2.  
    3.     private String departId;
    4.  
    5.     private String pid;
    6.  
    7.     private String name;
    8.  
    9.     private String path;
    10.  
    11.     private String pname;
    12.  
    13.     private List children;
    14.  
    15. }

    返回树形层级数据

    先来做第二个需求，由于解决思路已经给出，只需要按照思路进行即可，下面贴出主要的逻辑代码

    1.     public static String random() {
    2.         return UUID.randomUUID().toString().replaceAll("-", "");
    3.     }
    4.  
    5.  
    6.     public static List getDepartTree(List allDepart) {
    7.         //查询到的所有的部门数据
    8.         //List allDepart = getAllDepart();
    9.         //最高级别用户集合
    10.         List roots = new ArrayList<>();
    11.         List res = new ArrayList<>();
    12.         for (DepartDTO departDto : allDepart) {
    13.             //-1表示最高级别的用户
    14.             if (departDto.getPid().equals("0")) {
    15.                 roots.add(departDto);
    16.             }
    17.         }
    18.         //从最高级别用户开始遍历，递归找到该用户的下级用户，将带有下级的最高级用户放入返回结果中
    19.         for (DepartDTO userDto : roots) {
    20.             userDto = buildUserTree(allDepart, userDto);
    21.             res.add(userDto);
    22.         }
    23.         return res;
    24.     }
    25.  
    26.     public static DepartDTO buildUserTree(List allDeparts, DepartDTO departDTO) {
    27.         List children = new ArrayList<>();
    28.         //遍历查到的所有用户
    29.         for (DepartDTO departDTO1 : allDeparts) {
    30.             //-1代表根节点，无需重复比较
    31.             if (departDTO1.getPid().equals("0") || departDTO1.getPname().equals("") || departDTO1.getPname() == null)
    32.                 continue;
    33.             //当前用户的上级编号和传入的用户编号相等，表示该用户是传入用户的下级用户
    34.             if (departDTO1.getPname().equals(departDTO.getName())) {
    35.                 //递归调用，再去寻找该用户的下级用户
    36.                 departDTO1 = buildUserTree(allDeparts, departDTO1);
    37.                 //当前用户是该用户的一个下级用户，放入children集合内
    38.                 children.add(departDTO1);
    39.             }
    40.         }
    41.         //给该用户的children属性赋值，并返回该用户
    42.         departDTO.setChildren(children);
    43.         return departDTO;
    44.     }

    这里先直接模拟一部分的数据，通过这部分的数据做处理

    1. static List departLists = new ArrayList<>();
    2.  
    3.     static {
    4.  
    5.         departLists.add("/产品研发中心/业务中台部");
    6.         departLists.add("/产品研发中心/技术中台部");
    7.         departLists.add("/产品研发中心/技术中台部/产品A组");
    8.         departLists.add("/总裁办");
    9.         departLists.add("/总裁办/品牌管理部");
    10.     }
    11.  
    12.  
    13.     public static void main(String[] args) {
    14.         List allDepart = getAllDepart();
    15.         List departTree = getDepartTree(allDepart);
    16.         System.out.println(departTree);
    17.     }

    上面程序用到的两个工具类

    1. public class PathUtils {
    2.  
    3.     public static List getPaths(String path) {
    4.         List parentPaths = getParentPaths(path);
    5.         parentPaths.add(path);
    6.         return parentPaths;
    7.     }
    8.  
    9.     public static String getParentPath(String path) {
    10.         return StringUtils.substringBeforeLast(StringUtils.removeEnd(path, "/"), "/");
    11.     }
    12.  
    13.     public static List getParentPaths(String path) {
    14.         List paths = new ArrayList<>();
    15.         while (true) {
    16.             path = getParentPath(path);
    17.             if (StringUtils.isBlank(path)) {
    18.                 break;
    19.             }
    20.             paths.add(path);
    21.         }
    22.  
    23.         paths.sort(String::compareTo);
    24.         return paths;
    25.     }
    26.  
    27.     /**
    28.      * 拼接部门名称完整路径，如 湖北省，襄阳市，谷城县，最终组装成 : 湖北省/襄阳市/谷城县
    29.      *
    30.      * @param paths
    31.      * @return
    32.      */
    33.     public static String merge(List paths) {
    34.         return merge(paths, null);
    35.     }
    36.  
    37.     public static String merge(List paths, Function function) {
    38.         if (CollectionUtils.isEmpty(paths)) {
    39.             return null;
    40.         }
    41.  
    42.         Stream stream = paths.stream();
    43.         if (Objects.nonNull(function)) {
    44.             stream = stream.map(function);
    45.         }
    46.  
    47.         return stream.filter(Objects::nonNull).collect(joining("/", "/", ""));
    48.     }
    49.  
    50.     public static String getNextPath(String path) {
    51.         path = StringUtils.removeEnd(path, "/");
    52.         String parentPath = StringUtils.substringBeforeLast(path, "/");
    53.         int val = NumberUtils.toInt(StringUtils.substringAfterLast(path, "/")) + 1;
    54.         return parentPath + "/" + StringUtils.leftPad(String.valueOf(val), 4, "0");
    55.     }
    56.  
    57.     public static String getNextPath(String parentPath, List childPaths) {
    58.         if (CollectionUtils.isEmpty(childPaths)) {
    59.             return parentPath + "/001";
    60.         }
    61.         if (childPaths.size() + 1 >= 1000) {
    62.             throw new RuntimeException("同级机构最多支持9999个");
    63.         }
    64.         //获取同级最大值路径
    65.         Collections.sort(childPaths, Comparator.reverseOrder());
    66.         String maxPath = childPaths.get(0);
    67.         if (StringUtils.isNotBlank(maxPath)) {
    68.             return PathUtils.getNextPath(maxPath);
    69.         }
    70.         return parentPath + "/001";
    71.     }
    72.  
    73.     public static void main(String[] args) {
    74.         /*System.out.println(getParentPaths("/001/002/003/004/"));
    75.         List childPaths = new ArrayList<>();
    76.         childPaths.add("/001");
    77.         childPaths.add("/007");
    78.         childPaths.add("/1000");
    79.         childPaths.add("/001");
    80.         childPaths.add("/901");
    81.         childPaths.add("/766");
    82.         List result = new ArrayList<>();
    83.         childPaths.forEach(item ->{
    84.             result.add(Integer.valueOf(item.substring(1)));;
    85.         });
    86.         Integer max = Collections.max(result);
    87.         System.out.println(max);*/
    88.         String pathNames = "/产品研发中心/业务中台部";
    89.         String substring = pathNames.substring(pathNames.lastIndexOf("/") + 1);
    90.         System.out.println(substring);
    91.  
    92.         //String paths = "/001/002/003/004/";
    93.         String paths = "/001/001";
    94.         List parentPaths = getParentPaths(paths);
    95.  
    96.         System.out.println(parentPaths);
    97.  
    98.     }
    99.  
    100.     public static String getMaxPath(List pathList) {
    101.         List result = new ArrayList<>();
    102.         pathList.forEach(item -> {
    103.             result.add(Integer.valueOf(item.substring(1)));
    104.             ;
    105.         });
    106.         Integer max = Collections.max(result);
    107.         return String.valueOf("/" + max);
    108.     }
    109.  
    110. }

    最后写个接口模拟下

    1.      //localhost:8087/getAllDepart
    2.     @GetMapping("/getAllDepart")
    3.     public Object getAllDepart() {
    4.        
    5.         return departService.importDepart();
    6.     }

    运行上面的main程序，观察控制台输出结果

    用格式化工具处理下再看，这即为我们期待的结果，实际业务中，只需要在 getAllDepart 这个方法中，将获取数据从数据库查询即可；

    1. [
    2.     {
    3.         "departId":"e1c6d8ba4a504b7da85472ca713be107",
    4.         "pid":"0",
    5.         "name":"产品研发中心",
    6.         "path":null,
    7.         "pname":"",
    8.         "children":[
    9.             {
    10.                 "departId":"8e39b272531449ca96c0668ae60d2c2f",
    11.                 "pid":"e1c6d8ba4a504b7da85472ca713be107",
    12.                 "name":"业务中台部",
    13.                 "path":null,
    14.                 "pname":"产品研发中心",
    15.                 "children":[
    16.  
    17.                 ]
    18.             },
    19.             {
    20.                 "departId":"ecfe24e1769248df885287c7e153f9e6",
    21.                 "pid":"e1c6d8ba4a504b7da85472ca713be107",
    22.                 "name":"技术中台部",
    23.                 "path":null,
    24.                 "pname":"产品研发中心",
    25.                 "children":[
    26.                     {
    27.                         "departId":"0218c648abdf4867ad5ea1e99098d526",
    28.                         "pid":"ecfe24e1769248df885287c7e153f9e6",
    29.                         "name":"产品A组",
    30.                         "path":null,
    31.                         "pname":"技术中台部",
    32.                         "children":[
    33.  
    34.                         ]
    35.                     }
    36.                 ]
    37.             }
    38.         ]
    39.     },
    40.     {
    41.         "departId":"843bfa6b371e4d7d8d44894d939ca0a5",
    42.         "pid":"0",
    43.         "name":"总裁办",
    44.         "path":null,
    45.         "pname":"",
    46.         "children":[
    47.             {
    48.                 "departId":"12dc458b6996484394e2026d5b0f547e",
    49.                 "pid":"843bfa6b371e4d7d8d44894d939ca0a5",
    50.                 "name":"品牌管理部",
    51.                 "path":null,
    52.                 "pname":"总裁办",
    53.                 "children":[
    54.  
    55.                 ]
    56.             }
    57.         ]
    58.     }
    59. ]

    数据导入

    其实，只要按照上文的处理思路做即可，但是这里提一个在逻辑编写过程中遇到的一个比较难处理的问题，即机构的 path 上；

    这里必须要说一下这个 path 的事情，path 在真实的业务场景中，是一个非常重要，并且在众多的使用场景中高频使用的字段，因为对一个机构来说，通过业务的区分，这个path一定是唯一的存在； 

    仍然使用文章开头的那些数据，最终将 “/产品研发中心/业务一部” 这样的数据入库时，需要将数据组装成一个个对象插入到数据库，同时，插入数据之前，层级也需要组装好，那么对于 “/产品研发中心/业务一部” 这样一条数据，可以想象到，将会产生两个 depart 对象，这里我们考虑下面两个简单的场景；

    1. 如果顶级部门不存在，全量导入，比如 “/产品研发中心/业务一部” 这样一条数据，当 “/产品研发中心” 不存在时，完整导入；
    2. “/产品研发中心/业务一部” ，当  “产品研发中心” 存在时，只需导入 “业务一部” ；

    下面来看核心代码

    1. @Service
    2. public class DepartTest {
    3.  
    4.     @Autowired
    5.     private DepartDao departDao;
    6.  
    7.     @Autowired
    8.     private TransactionUtils transactionUtils;
    9.  
    10.     @Autowired
    11.     private DataSourceTransactionManager dataSourceTransactionManager;
    12.  
    13.     static List departLists = new ArrayList<>();
    14.  
    15.     private static final String tenantId = "e10adc3949ba59abbe56e057f20f88dd";
    16.  
    17.     static {
    18.         departLists.add("/top1");
    19.         departLists.add("/top1/ch1");
    20.         departLists.add("/top1/ch1/ch2");
    21.  
    22.     }
    23.  
    24.     public static List getFullNames(String departName) {
    25.         List result = new ArrayList<>();
    26.         String[] splitNames = departName.split("/");
    27.         for (int i = 0; i < splitNames.length; i++) {
    28.             if (!StringUtils.isEmpty(splitNames[i])) {
    29.                 result.add(splitNames[i]);
    30.             }
    31.         }
    32.         return result;
    33.     }
    34.  
    35.  
    36.     public List getAllDepart() {
    37.  
    38.         List departDTOS = new ArrayList<>();
    39.         //保存 部门名称和部门ID的映射关系
    40.         Map nameDepartIdMap = new HashMap<>();
    41.         List dbExistDepart = new ArrayList<>();
    42.         List newDeparts = new ArrayList<>();
    43.  
    44.         for (String single : departLists) {
    45.             //全部的部门名称
    46.             List fullNames = getFullNames(single);
    47.             //直接父级
    48.             String parentPath = PathUtils.getParentPath(single);
    49.             //处理顶级的部门数据【只有自己本身，比如 "/总裁办"】
    50.             if (StringUtils.isEmpty(parentPath)) {
    51.                 //1、说明当前只有一级，即顶级数据
    52.                 //2、如果是顶级数据，则需要判断数据库是否存在，如果已经存在，不用管，如果不存在，生成新的相关数据
    53.                 Depart depart = departDao.getTopDepartByName(fullNames.get(0));
    54.                 if (depart != null) {
    55.                     nameDepartIdMap.put(fullNames.get(0), depart.getDepartId());
    56.                     //确认数据库已经存在过的，后面只需要新建部门与用户的关系即可
    57.                     dbExistDepart.add(depart);
    58.                     continue;
    59.                 }
    60.                 //如果数据不存在，新生成
    61.                 String departId = random();
    62.                 Depart newDepart = new Depart();
    63.                 newDepart.setDepartId(departId);
    64.                 newDepart.setName(fullNames.get(0));
    65.                 newDepart.setPid("0");
    66.                 newDepart.setPath(DepartUtils.getNextPath(tenantId, "0"));
    67.                 TransactionStatus transaction = transactionUtils.getTransaction();
    68.                 try {
    69.                     departDao.insert(newDepart);
    70.                     //设置手动提交事务
    71.                     dataSourceTransactionManager.commit(transaction);
    72.                 } catch (Exception e) {
    73.                     dataSourceTransactionManager.rollback(transaction);
    74.                 }
    75.                 newDeparts.add(newDepart);
    76.                 nameDepartIdMap.put(fullNames.get(0), departId);
    77.                 continue;
    78.             }
    79.  
    80.             //如果是非顶级的，则需要拆开  /产品研发中心/技术中台部/产品A组
    81.             for (int i = 0; i < fullNames.size(); i++) {
    82.                 String currentDepart = fullNames.get(i);
    83.                 //遍历的时候从顶级开始
    84.                 if (nameDepartIdMap.containsKey(currentDepart))
    85.                     continue;
    86.  
    87.                 if (i == 0) {
    88.                     TransactionStatus transaction = transactionUtils.getTransaction();
    89.                     //仍然是顶级，需要先查数据库
    90.                     Depart topDepart = departDao.getTopDepartByName(currentDepart);
    91.                     if (topDepart != null) {
    92.                         nameDepartIdMap.put(fullNames.get(0), topDepart.getDepartId());
    93.                         dbExistDepart.add(topDepart);
    94.                     } else {
    95.                         //如果数据不存在，新生成
    96.                         String departId = random();
    97.                         Depart _depart = new Depart();
    98.                         _depart.setDepartId(departId);
    99.                         _depart.setName(fullNames.get(0));
    100.                         _depart.setTenantId(tenantId);
    101.                         _depart.setPid("0");
    102.                         _depart.setPath(DepartUtils.getNextPath(tenantId, "0"));
    103.                         try {
    104.                             departDao.insert(_depart);
    105.                             //设置手动提交事务
    106.                             dataSourceTransactionManager.commit(transaction);
    107.                         } catch (Exception e) {
    108.                             dataSourceTransactionManager.rollback(transaction);
    109.                         }
    110.                         if (fullNames.size() == 1) {
    111.                             newDeparts.add(_depart);
    112.                         }
    113.                     }
    114.                     continue;
    115.                 }
    116.                 //处理其他层级数据
    117.                 String parentName = parentPath.substring(parentPath.lastIndexOf("/") + 1);
    118.                 //开启一个新的事务
    119.                 TransactionStatus transaction = transactionUtils.getTransaction();
    120.                 //判断自身是否已经存在了
    121.                 Depart dbCurrentDepart = departDao.getDepartByNameAndPid(currentDepart, nameDepartIdMap.get(parentName));
    122.                 if (dbCurrentDepart != null) {
    123.                     //如果已经存在了，直接跳过
    124.                     dbExistDepart.add(dbCurrentDepart);
    125.                     nameDepartIdMap.put(currentDepart, dbCurrentDepart.getDepartId());
    126.                     dataSourceTransactionManager.commit(transaction);
    127.                     continue;
    128.                 }
    129.  
    130.                 Depart _depart = new Depart();
    131.                 _depart.setTenantId(tenantId);
    132.                 String departId = random();
    133.                 _depart.setDepartId(departId);
    134.                 _depart.setName(currentDepart);
    135.                 String pid = nameDepartIdMap.get(parentName);
    136.  
    137.                 //判断上级部门在数据库是否真的存在
    138.                 Depart directParent = departDao.getDepartById(nameDepartIdMap.get(parentName));
    139.  
    140.                 boolean isCurrentDepartDbExist = false;
    141.                 if (directParent != null) {
    142.                     _depart.setPid(pid);
    143.                     String nextPath = DepartUtils.getNextPath(tenantId, pid);
    144.                     _depart.setPath(nextPath);
    145.                     departDao.insert(_depart);
    146.                     dataSourceTransactionManager.commit(transaction);
    147.                     //父级存在时
    148.                     nameDepartIdMap.put(currentDepart, departId);
    149.                 }
    150.  
    151.                 //如果是最后的那一个，才是本次实际要关联的部门数据
    152.                 if (i == fullNames.size() - 1) {
    153.                     if (isCurrentDepartDbExist) {
    154.                         dbExistDepart.add(_depart);
    155.                         nameDepartIdMap.put(currentDepart, departId);
    156.                         continue;
    157.                     }
    158.                     newDeparts.add(_depart);
    159.                     nameDepartIdMap.put(currentDepart, departId);
    160.                 }
    161.             }
    162.         }
    163.         return departDTOS;
    164.     }
    165.  
    166.  
    167.     public static String random() {
    168.         return UUID.randomUUID().toString().replaceAll("-", "");
    169.     }
    170. }

    在代码编写过程中，有一个比较难处理的问题，就是在读取外部数据，组装depart 的path的时候，为什么这么讲呢？

    要知道，根据上面描述的两种实现情况，path 可能需要动态组装而成，很多同学可能会说，可以先把depart对象全部组装完成，最后再通过层级关系构建出 path 的完整路径；

    事实上，一开始我也是这么想的，但是最终发现这样走不通，原因就在于 顶级部门 “/产品研发中心”在数据库中可能存在，也可能不存在，而 path的生成一定是需要结合数据库的某些业务字段动态查询而构造出来的；

    所以如果先组装完成数据再构建path，这样带来的问题复杂性将会大大增加；

    那么比较可行的而且可以实现的方式就是，在组装数据的过程中，动态查库进行组装数据；

    但是小编在编码的时候发现，如果使用springboot工程自身的事务管理器的话，无论是哪种事务隔离级别，都将无法满足这样一个需求，即 “前一步将父级部门数据插入，子部门能够查到父级的数据”这样一个问题；

    所以为了达到这个目的，这里采用了 jdbc 手动管理事务的方式进行；

    那么通过上面的方式，就可以实现层级数据的导入效果了，具体逻辑可以参考注释说明进行理解；

  • 相关阅读:
    【一周安全资讯1007】多项信息安全国家标准10月1日起实施；GitLab发布紧急安全补丁修复高危漏洞
    Allegro格式PCB转换成Pads操作指导
    【Linux】之Centos7卸载KVM虚拟化服务
    openGaussDatakit让运维如丝般顺滑！
    u盘格式化后数据能恢复吗?
    ROS服务Service通信机制在无人车中的具体应用
    你的开发套件已到货「GitHub 热点速览」
    Android 11.0 禁止弹出系统simlock的锁卡弹窗功能实现
    替换文章中的关键词
    练[GYCTF2020]EasyThinking
  • 原文地址：https://blog.csdn.net/congge_study/article/details/126082771