组织结构树： java递归实现 或 mysql迭代实现

最新推荐文章于 2024-06-13 11:20:13 发布
最新推荐文章于 2024-06-13 11:20:13 发布
阅读量2.2k 收藏 4
点赞数
分类专栏： 学习笔记 文章标签： java mysql
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Mr_daChen/article/details/108712672
版权

组织结构树： java递归实现 或 mysql迭代实现

前言

最近开发中遇到了查询组织机构树（五级）问题，记录并分享一下（仅供借鉴）。

实现方法===》1，mysql迭代实现

实体类

public Class SysOrg {
private String sysOrgId;            //主键
private String tenantId;        //租户ID
private String tenantName;        //租户名称
private String orgId；           //组织机构编码
private String orgName；         //组织机构名称
private String orgPId；         //父级组织机构编码
private String orgTopId；        //顶级组织机构编码
private String orgLevel；        //组织机构级别
private String orgStatus；        //组织机构状态（0：无效，1;有效）
private List<SysOrg> childNodeList;    //子树
}

具体库中测试数据
在这里插入图片描述

mapper文件

    <resultMap id="orgTree" type="com.cmos.ngscsman.beans.sys.SysOrgTree">
        <result column="tenant_id" jdbcType="VARCHAR" property="tenantId" />
        <result column="tenant_name" jdbcType="VARCHAR" property="tenantName" />
        <result column="org_id" jdbcType="VARCHAR" property="orgId" />
        <result column="org_pid" jdbcType="VARCHAR" property="orgPid" />
        <result column="org_name" jdbcType="VARCHAR" property="orgName" />
        <result column="org_level" jdbcType="CHAR" property="orgLevel" />
        <result column="org_sort" jdbcType="CHAR" property="orgSort" />
        <result column="org_status" jdbcType="CHAR" property="status" />
        <result column="remarks" jdbcType="VARCHAR" property="remarks" />
        <collection property="childNodeList" ofType="com.cmos.ngscsman.beans.sys.SysOrgTree" column="org_id" select="getOrgChild"/>
    </resultMap

<select id="getOrgChild" resultMap="orgTree">
      select
        org_id,
        org_name,
        org_level,
        tenant_id,
        tenant_name,
        org_status,
        org_sort,
        org_pid,
        remarks
      from
        sys_org
      where org_pid = #{org_id} and org_status = '1';
    </select>

查询当前节点及以下的树结构，当前节点以上的树结构，可for循环查出

<select id="getOrgTree" resultMap="orgTree">
      select
        org_id,
        org_name,
        org_level,
        tenant_id,
        tenant_name,
        org_status,
        org_sort,
        org_pid,
        remarks
      from
        sys_org
      where org_status = '1'
      <choose>
        <when test="orgId == '-1'">
          and org_pid = #{orgId}

        </when>
        <otherwise>
          and org_id = #{orgId}

        </otherwise>
      </choose>
    </select>

补全父级节点至一级-----(仅供参考)

String orgPid = orgTreeList.get(0).getOrgPid();
for(int i =1 ; i < level;i++){
    SysOrgTree sysOrg = sysOrgDao.getOrgParent(orgPid);
    List<SysOrgTree> childNodeList = new ArrayList<>();
    childNodeList.addAll(orgTreeList);
    sysOrg.setChildNodeList(childNodeList);
    orgPid = sysOrg.getOrgPid();
    orgTreeList.clear();
    orgTreeList.add(sysOrg);
    }

实现方法===》2，java递归

实体类

public Class SysOrg {
private String sysOrgId;            //主键
private String tenantId;        //租户ID
private String tenantName;        //租户名称
private String orgId；           //组织机构编码
private String orgName；         //组织机构名称
private String orgPId；         //父级组织机构编码
private String orgTopId；        //顶级组织机构编码
private String orgLevel；        //组织机构级别
private String orgStatus；        //组织机构状态（0：无效，1;有效）

}

基本思路：
根据当前登录人员挂靠的组织机构编码，向下递归查询所有的子节点和向上递归查询父级节点，进行封装转换（超级管理员挂靠的组织机构编码：-1，可查询所有的组织机构树）

核心业务代码：

public List<Map<String, Object>> getOrgTreeList(String orgId) throws GeneralException {
        LOGGER.info("getOrgTreeList入参："+orgId);
        //返回的tree
        List<Map<String, Object>> listTree = new ArrayList<>();
        List<SysOrg> listOrg = new ArrayList<>();
        //判断是否是超级管理员
        if("-1".equals(orgId)){
            //超级管理员查询多个树
            Map map = new HashMap();
            map.put("orgPid",orgId);
            map.put("status","1");
            listOrg = sysOrgDao.selectOrgListByPid(map);
        }else{
            SysOrg curOrg = sysOrgDao.selectById(orgId,"1");
            listOrg.add(curOrg);
        }
        for (SysOrg curOrg : listOrg) {
            if (null == curOrg) {
              break;
            }
            //获取顶级组织机构id
            String orgTopId = "-1";
            //获取有效的组织机构列表
            List<SysOrg> sysOrgList = sysOrgDao.selectAllSysOrg("1");
            //拼装当前节点及其子节点
            List<Map<String, Object>> resList = new ArrayList<>();
            Map<String, Object> map = new HashMap();
            //实体转map
            assembleOrgMap(map, curOrg);
            //判断是否租户
            if(“0”.equals(curOrg.getOrgLevel())){
                orgId = curOrg.getOrgId();
            }
            //递归查询子级组织机构
            map.put("childNodeList", buildChildOrgTree(sysOrgList, orgId));
            resList.add(map);
            //获取父级组织机构
            List<Map<String, Object>> list =  buildParentOrgTree(sysOrgList, curOrg, orgTopId, resList);
            listTree.addAll(list);
        }
        return listTree;
    }

根据当前节点向下获取所有子节点

public static List<Map<String, Object>> buildChildOrgTree(List<SysOrg> sysOrgList, String pid) 
{ 
   List<Map<String, Object>> resList = null; 
   for (SysOrg sysOrg : sysOrgList)
    {  
       if (pid.equals(sysOrg.getOrgPid()))
          { if (null == resList)     
              resList = new ArrayList<>(); 
          } 
     Map<String, Object> map = new HashMap<>();
     assembleOrgMap(map, sysOrg);
      map.put("childNodeList", buildChildOrgTree(sysOrgList, sysOrg.getOrgId()));             
     resList.add(map); 
     }
     return resList;
      }

根据当前节点向上递归获取所有父节点

/**
     * 根据当前节点向上递归获取所有父节点
     * @param sysOrgList 组织结构表
     * @param curOrg     当前组织
     * @param topOrgId   顶级组织id
     * @param resList    返回结果
     * @return
     */
      public static List<Map<String, Object>> buildParentOrgTree(List<SysOrg> sysOrgList, SysOrg curOrg, String topOrgId, List<Map<String, Object>> resList) {
        if (topOrgId.equals(curOrg.getOrgPid())) {
            return resList;
        }
        String curOrgPid = curOrg.getOrgPid();
        for (SysOrg sysOrg : sysOrgList) {
            if (curOrgPid.equals(sysOrg.getOrgId())) {
                List<Map<String, Object>> newList = new ArrayList<>();
                Map<String, Object> map = new HashMap<>();
                assembleOrgMap(map, sysOrg);
                map.put("childNodeList", resList);
                newList.add(map);
                curOrg = sysOrg;
                resList = newList;
                break;
            }
        }
        return buildParentOrgTree(sysOrgList, curOrg, topOrgId, resList);
    }

装配SysOrg实体类到map

/* 装配SysOrg到map
 * @param map
 * @param sysOrg
 */
public static void assembleOrgMap(Map map, SysOrg sysOrg) {
    map.put("orgName", sysOrg.getOrgName());
    map.put("tenantId", sysOrg.getTenantId());
    map.put("tenantName", sysOrg.getTenantName());
    map.put("orgId", sysOrg.getOrgId());
    map.put("orgLevel", sysOrg.getOrgLevel());
    map.put("orgSort", sysOrg.getOrgSort());
}

相关SQL

根据父级组织机构编码查询组织机构

<select id="selectOrgListByPid" resultMap="BaseResultMap" parameterType="java.util.Map"> 
  SELECT
   <include refid="template" />
  FROM sys_org WHERE org_pid= #{orgPid} 
   <if test="tenantId != null &amp; tenantId != '' " >
  AND tenant_id = #{tenantId,jdbcType=VARCHAR}
   </if>
  <if test="status != null &amp; status != '' " > 
  AND org_status = #{status,jdbcType=VARCHAR}
   </if>
  ORDER by org_id DESC 
  </select>

查询所有的组织机构

  <select id="selectAllSysOrg" resultMap="BaseResultMap"> 
  select <include refid="template" />
          from sys_org where org_status = #{valid, jdbcType=CHAR} ORDER by org_sort ASC 
  </select>

根据组织机构编码查询组织机构信息

<select id="selectById" parameterType="java.lang.String" resultMap="BaseResultMap">
  select <include refid="template" /> 
          from sys_org 
  where org_id = #{orgId, jdbcType=VARCHAR} and org_status = #{valid, jdbcType=CHAR} 
  </select>

执行结果如下：

[{
		    "orgName": "测试导入",
            "tenantName": "测试导入",
            "tenantId": "777",
            "orgLevel": "0",
            "orgId": "777",  
            "childNodeList": [{
			       "orgName": "河南",
                   "tenantName": "测试导入",
                  "tenantId": "777",
                  "orgLevel": "1",
                  "orgId": "777001",
                  "childNodeList": [
                          "orgName": "郑州",
                          "tenantName": "测试导入",
                         "tenantId": "777",
                         "orgLevel": "2"，
                         "orgId": "777001001",
                         "childNodeList": []
                  ]
                 ]
               }
           ]
Mr_daChen
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
java代码递归部门结构树
Alain999的博客
03-20 479
组织所有部门树，以及条件查询部门树： /** * 组织部门树 * @return */ @Override public List<SxyBranchVO> findAllBranchTree(String branchname) { SxyBranchVO sxyBranchVOParam = new SxyBra...
java实现多层嵌套循环参数转换
06-20
例如，如果有一个表示组织结构的类，其中包含子组织的列表，我们可以使用递归或嵌套循环来遍历整个结构： ```java public void traverseOrganization(Organization org) { // 处理当前组织 processOrganization...
Java 递归查询组织机构树
zhuzicc的博客
11-15 3429
需求：现有一个A集合（机构id集合），需要利用A集合查询出集合中所有机构的子级机构，层级（不知道一共有多少级），最终返回所有的子级机构（就是返回一个childOrganList，不包括A集合） 文章目录代码实现聊聊递归递归示例1.计算1~n的和2.递归打印多级目录 代码实现 /** * 根据父级id集合查询所有子孙级id集合 * @param organIdList 父级机构id集合 * @param childOrg 子级机构id集合 * @return.
系统管理之组织机构树形化结构优化篇
zhouzhiwengang的专栏
11-30 742
本文基于：系统管理之组织机构树形化结构一文，采用Java8 filter 和group by 实现树形结构分组。 Controller层代码片段： Map<String, List<UcasAuthOrganizationInfo >> sub = list.stream().filter(node -> node.getPsid() != "0").collect(Collectors.groupingBy(node -> node.getPsid()));.
Java——递归
最新发布
Stewie Lee的博客
06-13 1926
回溯算法是一种系统化地搜索问题解空间的方法，主要用于解决组合优化问题。它通过递归地构建候选解，并在发现候选解不满足问题条件时回溯，从而尝试其他可能的选择。回溯算法的核心思想是不断尝试和撤销选择，直到找到所有可能的解决方案或者确认无解。
java递归mysql生成树_java递归生成树结构的数据
weixin_39977886的博客
01-20 63
@Data@EqualsAndHashCode(callSuper =true)@ApiModel(value = "AccountCaptionVo", description = "会计科目")public class AccountCaptionVo extends BaseModel {@ApiModelProperty(value ="会计科目名称",name = "captionNam...
递归
weixin_30650039的博客
12-10 92
递归是一种常见的解决问题的方法，即把问题逐渐简单化。递归的基本思想就是“自己调用自己”，一个使用递归技术的方法将会直接或者间接的调用自己。 利用递归可以用简单的程序来解决一些复杂的问题。比如：斐波那契数列的计算、汉诺塔、快排等问题。 递归结构包括两个部分： 1.定义递归头。解答：什么时候不调用自身方法。如果没有头，将陷入死循环，也就是递归的结束条件。 ...
java递归生成组织结构图
clc_2020的博客
08-26 856
引用：https://blog.csdn.net/u014204541/article/details/96484771 在大佬的基础上改了改，适合我这个项目使用， /** * 核心思想： * 判断传入的父名是否等于自身的父名，如果是，就说明自己是子节点，再递归自己这个节点， * 判断是否还有子节点； */ public List<Map<String, Object>> getChild(String pName, List<ContactInf
java:递归的结构--基础篇
aot72341的博客
01-06 168
递归结构： 递归的基本思想就是“自己调用自己” 【示例1-1】 public static void main(String[] args) { a(); } static void a(){ System.out.println("a"); a(); } 如上示例，将会报错java.lang.StackO...
漂亮无限级分类源代码（三层实现）.zip
06-19
- **遍历分类**：实现深度优先搜索（DFS）或广度优先搜索（BFS）算法，以展示完整的分类树。 5. **性能优化**： - **缓存策略**：为了提高性能，可能需要实现缓存机制，如Redis或Memcached，减少数据库的频繁访问...
利用kNN算法实现图书推荐系统.zip
03-10
URL收集： 爬虫从一个或多个初始URL开始，递归或迭代地发现新的URL，构建一个URL队列。这些URL可以通过链接分析、站点地图、搜索引擎等方式获取。 请求网页： 爬虫使用HTTP或其他协议向目标URL发起请求，获取网页的...
在java中 遍历mysql中的树形结构
06-18
在java中 遍历mysql中的树形结构
java树形结构递归查询
09-04
/** * 根据等级查询类目树 * * @param level * @return */ @Override public List queryCategoryTree(Integer level) { //查询当前级别下类目 List list = categoryDAO.list(level); //组装好的类目树，返回前端 List categoryTree = new ArrayList(); //所有类目 List allDTOList = new ArrayList(); if (CollectionUtils.isEmpty(list)) { return categoryTree; } for (CategoryDO categoryDO : list) { allDTOList.add(new CategoryTreeDTO().convertDOToDTO(categoryDO)); } //当前等级类目 categoryTree = allDTOList.stream().filter(dto -> level.equals(dto.getLevel())).collect(Collectors.toList()); for (CategoryTreeDTO categoryTreeDTO : categoryTree) { //组装类目为树结构 assembleTree(categoryTreeDTO, allDTOList,Constants.CATEGORY_MAX_LEVEL - level); } return categoryTree; } /** * 组装树 * * @param categoryTreeDTO * @param allList * @param remainRecursionCount 剩余递归次数 * @return */ public CategoryTreeDTO assembleTree(CategoryTreeDTO categoryTreeDTO, List allList, int remainRecursionCount) { remainRecursionCount--; //最大递归次数不超过Constants.CATEGORY_MAX_LEVEL-level次，防止坏数据死循环 if(remainRecursionCount < 0){ return categoryTreeDTO; } String categoryCode = categoryTreeDTO.getCategoryCode(); Integer level = categoryTreeDTO.getLevel(); //到达最后等级树返回 if (Constants.CATEGORY_MAX_LEVEL == level) { return categoryTreeDTO; } //子类目 List child = allList.stream().filter(a -> categoryCode.equals(a.getParentCode())).collect(Collectors.toList()); if (null == child) { return categoryTreeDTO; } categoryTreeDTO.setChildren(child); //组装子类目 for (CategoryTreeDTO dto : child) { assembleTree(dto, allList,remainRecursionCount); } return categoryTreeDTO; }
组织树递归获取
10-27
组织树机构数据递归后台开发方便前端调用。组织树机构数据递归后台开发方便前端调用。
mysql 递归
11-24
用mysql实现oracle递归,通过with as 来实现
后台管理系统模板++树形
07-12
后台管理系统模板++树形模型，有利于你在次基础上进行开发项目。结构清晰明了。
递归查询数据库,返回List到前台
12-26
本文将深入探讨如何利用递归技术实现对数据库中的树形结构数据进行查询，并将查询结果以列表形式返回到前端。 #### 一、递归查询的基本概念 递归查询是指在一个函数或方法内部调用自身来解决问题的过程。这种方法...
java面试题及答案-非常全面（包括基础、网络、数据结构、算法及IT大厂面经）
11-16
- **应用场景**：实现泛型编程、构建框架等。 ### 动态代理 - **概念**：通过代理类来间接访问目标对象。 - **类型**：包括JDK动态代理（实现接口）和CGLIB动态代理（子类继承）。 ### 设计模式 - **单例模式**...
使用java8新特性递归实现快速组装一个JSON格式的组织架构树对象
ZDY0904的博客
03-23 648
递归实现组织机构树JSON格式对象的快速组装
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值