package com.walker.cache.tree;
|
|
import com.walker.infrastructure.utils.StringUtils;
|
|
import java.util.ArrayList;
|
import java.util.Iterator;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.TreeMap;
|
|
/**
|
* 把业务数据集合转换成树节点对象的生成器实现。</p>
|
* 通常在业务中，从数据库查询出来记录，这些记录带有上下级关系，如：树分类等。<br>
|
* 把数据集合传递进来，就可以转换成树对象，子类必须实现抽象方法。
|
* @author shikeying
|
* @date 2014-9-2
|
*
|
* @param <T>
|
*/
|
public abstract class AbstractTreeGenerator<T> {
|
|
private boolean multiRoot = false;
|
|
/* 虚拟的根节点，可以显示用户指定的名称，可以不设置 */
|
private CacheTreeNode dummyRoot = null;
|
|
private Map<String, CacheTreeNode> rootMap = new TreeMap<String, CacheTreeNode>();
|
private Map<String, CacheTreeNode> childMap = new TreeMap<String, CacheTreeNode>();
|
|
/**
|
* 默认构造函数，设置虚拟根节点名称，如果不需要则设置为<code>null</code>
|
* @param dummyRootName
|
*/
|
public AbstractTreeGenerator(String dummyRootName){
|
if(StringUtils.isNotEmpty(dummyRootName)){
|
dummyRoot = new DefaultCacheTreeNode("root", dummyRootName, null, "0");
|
}
|
}
|
|
public CacheTreeNode getTreeRoot(){
|
if(multiRoot)
|
throw new IllegalStateException("存在多个根节点，请调用方法:getTreeRootList().");
|
if(dummyRoot != null){
|
return dummyRoot;
|
} else {
|
return rootMap.values().iterator().next();
|
}
|
}
|
|
public List<CacheTreeNode> getTreeRootList(){
|
if(!multiRoot)
|
throw new IllegalStateException("存在多个根节点，请调用方法:getTreeRoot().");
|
List<CacheTreeNode> list = new ArrayList<CacheTreeNode>();
|
for(CacheTreeNode node : rootMap.values()){
|
list.add(node);
|
}
|
return list;
|
}
|
|
public void setMultiRoot(boolean multiRoot){
|
this.multiRoot = multiRoot;
|
}
|
|
/**
|
* 设置数据实体集合，通过此方法可以组织树结构。
|
* @param datas
|
*/
|
public void setEntityList(List<T> datas){
|
if(StringUtils.isEmptyList(datas)) return;
|
CacheTreeNode node = null;
|
for(T obj : datas){
|
node = toCacheTreeNode(obj);
|
if(StringUtils.isNotEmpty(node.getParentId())
|
&& parentIsRoot(node.getParentId())){
|
// 根节点
|
rootMap.put(node.getKey(), node);
|
} else {
|
childMap.put(node.getKey(), node);
|
}
|
}
|
if(rootMap.size() == 0)
|
throw new IllegalArgumentException("未找到根节点。");
|
|
// 组织成树结构
|
if(childMap != null && childMap.size() > 0){
|
mountTree(childMap);
|
}
|
|
// 如果存在虚拟根节点就把所有用户数据中的根节点加进去。
|
if(dummyRoot != null){
|
for(CacheTreeNode n : rootMap.values()){
|
n.setParentId(CacheTree.ROOT_FLAG_NAME);
|
dummyRoot.addChild(n);
|
}
|
}
|
}
|
|
public void destroy(){
|
dummyRoot = null;
|
rootMap.clear();
|
childMap.clear();
|
}
|
|
protected abstract CacheTreeNode toCacheTreeNode(T entity);
|
|
private boolean parentIsRoot(String parentId){
|
if(parentId.equalsIgnoreCase(CacheTree.ROOT_FLAG_NAME) || parentId.equals(CacheTree.ROOT_FLAG_ZERO))
|
return true;
|
return false;
|
}
|
|
private void mountTree(Map<String, CacheTreeNode> childMap){
|
CacheTreeNode _node = null;
|
for(Iterator<CacheTreeNode> i = childMap.values().iterator(); i.hasNext();){
|
_node = i.next();
|
mountMiddleNode(_node, childMap);
|
}
|
}
|
|
private void mountMiddleNode(CacheTreeNode currentNode
|
, Map<String, CacheTreeNode> childMap){
|
// logger.debug("-------------> cache = " + cache);
|
// logger.debug("-------------> currentNode = " + currentNode);
|
CacheTreeNode _parentNode = (CacheTreeNode)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(parentIsRoot(_parentNode.getParentId())) {
|
// 父对象是根节点
|
_parentNode.addChild(currentNode);
|
// logger.debug("找到了挂在root下的子节点：" + _parentNode);
|
}
|
}
|
}
|
