java 读取数据库结构_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 {

private T entity;

private boolean hasChildren = false;

private List> 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){

if(children == null)

children = new ArrayList>();

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, 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> getChildren(){

if(children!=null && !children.isEmpty())

return children;

return null;

}

/**

* 得到指定位置的节点信息

* @param number 指定位置，如果指定位置不存在将抛出异常

* @return 返回指定位置对应的内容

*/

public TreeNode 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> selectAbsolutePathOfNodesAsTree() throws Exception {

//非空校验

//获得当前条件对应的结果

List nodes = reportRepository.findAll(); //获取该表所有数据，替换成自己的查询方法

//遍历结果获得每个结果对应的TreeNode信息，这里保存的TreeNode只是根级的TreeNode

List> roots = new ArrayList<>();

List> parentNodes = new ArrayList<>();

for(Report treeNode : nodes){

//根据node创建TreeNode

TreeNode node = compositeTheTreePath(new TreeNode(treeNode),parentNodes);

if(!roots.contains(node))

roots.add(node);

}

//返回TreeNode信息

return roots;

}

/**

* 完成TreeNode的构建，该构建会逐步向上追溯到最上层节点

**/

private TreeNode compositeTheTreePath(TreeNode treeNode, List> savedNodes) throws Exception {

//非空校验

//判断是否存在子节点

int count = reportRepository.hasChildren(treeNode.getEntity().getId(), treeNode.getEntity().getId().length());

if(count > 0)

//如果存在，标注TreeNode有子节点

treeNode.setHasChildren(true);

//判断是否存在父节点

TreeNode rootNode = null;

if (getParentNode(treeNode.getEntity()) != null) {

// 检查root节点是否已经存在，存在则添加当前节点到父节点之下

Report parentNode = getParentNode(treeNode.getEntity());

//创建父节点，检查是否已存在父节点

TreeNode parentTreeNode = new TreeNode(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;

}