package com.walker.infrastructure.tree;
|
|
import com.walker.infrastructure.utils.StringUtils;
|
import org.slf4j.Logger;
|
import org.slf4j.LoggerFactory;
|
|
import java.util.ArrayList;
|
import java.util.Iterator;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.TreeMap;
|
|
/**
|
* 前端展示树结构，生成器对象，业务需要继承该抽象类实现自己的实体树结构。
|
* @param <T>
|
* @author 时克英
|
* @date 2022-12-08
|
*/
|
public abstract class AbstractTreeGenerator<T> {
|
|
protected final transient Logger logger = LoggerFactory.getLogger(this.getClass());
|
|
private boolean multiRoot = true;
|
|
/* 虚拟的根节点，可以显示用户指定的名称，可以不设置 */
|
private TreeNode dummyRoot = null;
|
|
private Map<Long, TreeNode> rootMap = new TreeMap<>();
|
private Map<Long, TreeNode> childMap = new TreeMap<>();
|
|
/**
|
* 默认构造函数，设置虚拟根节点名称，如果不需要则设置为<code>null</code>
|
* @param dummyRootName
|
*/
|
public AbstractTreeGenerator(String dummyRootName){
|
if(StringUtils.isNotEmpty(dummyRootName)){
|
dummyRoot = new TreeNode(0, dummyRootName, null, 0);
|
}
|
}
|
|
public void setMultiRoot(boolean multiRoot){
|
this.multiRoot = multiRoot;
|
}
|
|
public TreeNode getTreeRoot(){
|
if(multiRoot)
|
throw new IllegalStateException("存在多个根节点，请调用方法:getTreeRootList().");
|
if(dummyRoot != null){
|
return dummyRoot;
|
} else {
|
return rootMap.values().iterator().next();
|
}
|
}
|
|
public List<TreeNode> getTreeRootList(){
|
if(!multiRoot)
|
throw new IllegalStateException("存在多个根节点，请调用方法:getTreeRoot().");
|
List<TreeNode> list = new ArrayList<TreeNode>();
|
for(TreeNode node : rootMap.values()){
|
list.add(node);
|
}
|
return list;
|
}
|
|
/**
|
* 设置数据实体集合，通过此方法可以组织树结构。
|
* @param datas
|
*/
|
public void setEntityList(List<T> datas){
|
if(StringUtils.isEmptyList(datas)) return;
|
TreeNode node = null;
|
for(T obj : datas){
|
node = toTreeNode(obj);
|
// if(node.getParentId() == 0){
|
if(node.getParentId() == this.defaultParentId){
|
// 根节点
|
rootMap.put(node.getId(), node);
|
} else {
|
childMap.put(node.getId(), node);
|
}
|
}
|
if(rootMap.size() == 0)
|
throw new IllegalArgumentException("未找到根节点。");
|
|
// 组织成树结构
|
if(childMap != null && childMap.size() > 0){
|
mountTree(childMap);
|
}
|
|
// 如果存在虚拟根节点就把所有用户数据中的根节点加进去。
|
if(dummyRoot != null){
|
for(TreeNode n : rootMap.values()){
|
// n.setParentId(0);
|
n.setParentId(this.defaultParentId);
|
dummyRoot.addChild(n);
|
}
|
}
|
}
|
|
private void mountTree(Map<Long, TreeNode> childMap){
|
TreeNode _node = null;
|
for(Iterator<TreeNode> i = childMap.values().iterator(); i.hasNext();){
|
_node = i.next();
|
mountMiddleNode(_node, childMap);
|
}
|
}
|
|
private void mountMiddleNode(TreeNode currentNode, Map<Long, TreeNode> childMap){
|
// logger.debug("-------------> cache = " + cache);
|
// logger.debug("-------------> currentNode = " + currentNode);
|
TreeNode _parentNode = rootMap.get(currentNode.getParentId());
|
if(_parentNode == null){
|
// 没有找到上级根节点，说明是比较靠下的子节点
|
_parentNode = childMap.get(currentNode.getParentId());
|
if(_parentNode == null)
|
throw new NullPointerException("parent node not found, current: " + currentNode);
|
_parentNode.addChild(currentNode);
|
mountMiddleNode(_parentNode, childMap);
|
} else if(_parentNode.getParentId() == this.defaultParentId) {
|
// 父对象是根节点
|
_parentNode.addChild(currentNode);
|
// logger.debug("找到了挂在root下的子节点：" + _parentNode);
|
}
|
}
|
|
protected abstract TreeNode toTreeNode(T entity);
|
|
public long getDefaultParentId() {
|
return defaultParentId;
|
}
|
|
/**
|
* 设置默认父节点值，如：代码表中父节点为特定值的（代码表）才是根节点。
|
* @param defaultParentId
|
*/
|
public void setDefaultParentId(long defaultParentId) {
|
this.defaultParentId = defaultParentId;
|
}
|
|
private long defaultParentId = 0L;
|
}
|
