java 数据库读取多叉树结构列表

数据库id格式如下

001

001001

001002

001001001

001001001001

002

package com.scistor.designer.report.model;  
  
import lombok.Data;  
  
import java.util.ArrayList;  
import java.util.List;  
  
/** 
 * 描述：报表列表实体 
 * author qiaobin   2016/8/30 16:23. 
 */  
@Data  
public class TreeNode<T> {  
  
    private T entity;  
    private boolean hasChildren = false;  
    private List<TreeNode<T>> children ;  
  
  
    /** 
     * 初始TreeNode 
     * @param entity 被注入的更新内容 
     */  
    public TreeNode(T entity){  
        this.entity = entity;  
    }  
  
    /** 
     * 返回TreeNode包含的实例 
     * @return 
     */  
    public T getEntity(){  
        return entity;  
    }  
  
    /** 
     * 添加子节点,被添加的子节点将放置在最后 
     * @param t 
     */  
    public void addChildren(TreeNode<T> t){  
        if(children == null)  
            children = new ArrayList<TreeNode<T>>();  
        if (!children.contains(t)) {  
            hasChildren = children.add(t); //如果没有子节点并添加子节点成功，则标注为true  
        } else {  
            children.remove(t);  
            children.add(t);  
        }  
    }  
  
    /** 
     * 添加子节点,被添加的子节点将放置在指定位置，如果指定位置不存在则被放置在最后 
     * @param t 
     * @param index 指定位置 
     */  
    public void addChildrenAt(TreeNode<T> t, int index){  
        if(children == null)  
            addChildren(t);  
        else if(!children.contains(t)) {  
            if(index<0||index>children.size())  
                children.add(t);  
            else  
                children.add(index, t);  
            hasChildren = !hasChildren ? true : false; //如果没有子节点并添加子节点成功，则标注为true  
        }  
    }  
  
    /** 
     * 查看是否存在子列点 
     * @return 
     */  
    public boolean hasChildren(){  
        return hasChildren;  
    }  
  
    /** 
     * 设置存在子节点 
     */  
    public void setHasChildren(boolean has){  
        this.hasChildren = has;  
    }  
  
    /** 
     * 返回子列表 
     * @return 
     */  
    public List<TreeNode<T>> getChildren(){  
        if(children!=null && !children.isEmpty())  
            return children;  
        return null;  
    }  
  
    /** 
     * 得到指定位置的节点信息 
     * @param number 指定位置，如果指定位置不存在将抛出异常 
     * @return 返回指定位置对应的内容 
     */  
    public TreeNode<T> getChildAt(int number){  
        if(children != null && !children.isEmpty()) {  
            return children.get(number);  
        }  
        return null;  
    }  
  
    @Override  
    public boolean equals(Object obj) {  
        if(obj == null && entity == null)   //both null  
            return true;  
        if(obj != null && entity != null && obj instanceof TreeNode){ // both not null  
            TreeNode t = (TreeNode) obj;  
            return entity.equals(t.getEntity());  
        }  
        return false;   //one of them is null or obj is not a instance of TreeNode  
    }  
  
}  

数据读取类

/* 
   *  查询所有节点 
   * */  
   private List<TreeNode<Report>> selectAbsolutePathOfNodesAsTree() throws Exception {  
       //非空校验  
       //获得当前条件对应的结果  
       List<Report> nodes = reportRepository.findAll(); //获取该表所有数据，替换成自己的查询方法  
       //遍历结果获得每个结果对应的TreeNode信息，这里保存的TreeNode只是根级的TreeNode  
       List<TreeNode<Report>> roots = new ArrayList<>();  
       List<TreeNode<Report>> parentNodes = new ArrayList<>();  
       for(Report treeNode : nodes){  
           //根据node创建TreeNode  
           TreeNode<Report> node = compositeTheTreePath(new TreeNode<Report>(treeNode),parentNodes);  
           if(!roots.contains(node))  
               roots.add(node);  
       }  
       //返回TreeNode信息  
       return roots;  
   }  
  
   /** 
    *  完成TreeNode的构建，该构建会逐步向上追溯到最上层节点 
    **/  
   private TreeNode<Report> compositeTheTreePath(TreeNode<Report> treeNode, List<TreeNode<Report>> savedNodes) throws Exception {  
       //非空校验  
       //判断是否存在子节点  
       int count = reportRepository.hasChildren(treeNode.getEntity().getId(), treeNode.getEntity().getId().length());  
       if(count > 0)  
           //如果存在，标注TreeNode有子节点  
           treeNode.setHasChildren(true);  
       //判断是否存在父节点  
       TreeNode<Report> rootNode = null;  
       if (getParentNode(treeNode.getEntity()) != null) {  
           // 检查root节点是否已经存在，存在则添加当前节点到父节点之下  
           Report parentNode = getParentNode(treeNode.getEntity());  
           //创建父节点，检查是否已存在父节点  
           TreeNode<Report> parentTreeNode = new TreeNode<Report>(parentNode);  
           //如果存在则获得父节点  
           if (savedNodes.contains(parentTreeNode)) {  
               parentTreeNode = savedNodes.get(savedNodes.indexOf(parentTreeNode));  
           } else {  
               savedNodes.add(parentTreeNode);  
           }  
           //并将当前节点添加到父节点之下、写入已保存节点  
           parentTreeNode.addChildren(treeNode);  
           // 递归获得父节点  
           rootNode = compositeTheTreePath(parentTreeNode, savedNodes);  
       } else {  
           //如果没有，表明已是最高节点，返回该节点  
           if (!savedNodes.contains(treeNode))  
               savedNodes.add(treeNode);  
           rootNode = treeNode;  
       }  
       return rootNode;  
   }  
  
   /** 
    *  查询父节点 
    **/  
   private Report getParentNode(Report report) {  
       String nodeId = report.getId();  
       String parentId = nodeId.substring(0, nodeId.length() - 3);  
       Report parent = null;  
       try {  
           parent = reportRepository.parentNode(parentId);  //此处换成自己的查询方法，思想是001001的parentId = 001  
       } catch (Exception e) {  
           return null;  
       }  
       return parent;  
   }