
之前在项目需要实现一个功能——将xml文件映射成实体,然后对映射的实体进行逻辑处理,最后保存到数据库中;由于xml结构的数据是结构化的数据,所以需要保证保存的数据具有正确的主外键关联。如下所示,是一个需要保存到数据库的xml文件。当映射成对应的实体school和student的时候,我们需要知道“school-one”下面有哪些学生,“school-two”下面有哪些学生,这个时候想到了使用树形结构来保存实体,让实体之间依然存在关联关系。
<school-inf>
<msg>2017-10-1XX省学校信息总汇</msg>
<schools>
<school>
<name>school-one</name>
<students>
<student>Jack</student>
<student>Rose</student>
<student>Jon</student>
</students>
</school>
<school>
<name>school-two</name>
<students>
<student>Bob</student>
<student>Alisa</student>
</students>
</school>
</schools>
</school-inf>
树形工具
以下是树形工具类的实现,包含了树形节点类和树形结构类,由于代码中注释已经比较全面,所以不做过多的说明。
树形节点类BeanTreeNode.java
每一个节点对应一个实体,节点包含了实体信息,为了保证实体之间的关联关系,需要留有父节点信息,所有的子节点信息。由此推断出,节点的主要成员有
- 父节点信息
- 所有子节点信息
- 当前实体信息
为了方便操作,我还多增加了id和pid(parent id),以及节点类型(nodeType)。对id的相关操作我并没有添加,如果需要可以自行添加。
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
/**
* 实体树形结构点
* BeanTreeNode
* @author BrightLoong
* @version 1.0
*
*/
public class BeanTreeNode {
/**标识id*/
private String id;
/**父id标识,为了方便获取冗余出来*/
private String pid;
/**父节点*/
private BeanTreeNode parentNode;
/**节点类型*/
private String nodeType;
/**节点值*/
private Object bean;
/**子节点*/
private List<BeanTreeNode> childNodes;
/**
* @param parentNode
* @param nodeType
* @param bean
* @param childNodes
*/
public BeanTreeNode(BeanTreeNode parentNode, String nodeType, Object bean) {
this.parentNode = parentNode;
this.nodeType = nodeType;
this.bean = bean;
this.childNodes = new ArrayList<BeanTreeNode>();
this.id = UUID.randomUUID().toString().replaceAll("-", "");
if (parentNode != null) {
this.pid = parentNode.getId();
}
}
/**
* @return the nodeType
*/
public String getNodeType() {
return nodeType;
}
/**
* @param nodeType the nodeType to set
*/
public void setNodeType(String nodeType) {
this.nodeType = nodeType;
}
/**
* @return the parentNode
*/
public BeanTreeNode getParentNode() {
return parentNode;
}
/**
* @param parentNode the parentNode to set
*/
public void setParentNode(BeanTreeNode parentNode) {
this.parentNode = parentNode;
}
/**
* @return the bean
*/
public Object getBean() {
return bean;
}
/**
* @param bean the bean to set
*/
public void setBean(Object bean) {
this.bean = bean;
}
/**
* @return the childNodes
*/
public List<BeanTreeNode> getChildNodes() {
return childNodes;
}
/**
* @param childNodes the childNodes to set
*/
public void setChildNodes(List<BeanTreeNode> childNodes) {
this.childNodes = childNodes;
}
/**
* @return the id
*/
public String getId() {
return id;
}
/**
* @param id the id to set
*/
public void setId(String id) {
this.id = id;
}
/**
* @return the pid
*/
public String getPid() {
return pid;
}
/**
* @param pid the pid to set
*/
public void setPid(String pid) {
this.pid = pid;
}
/**
* 是否具有子节点
* @return true or false
*/
public boolean haveChild() {
return !CollectionUtils.isEmpty(childNodes);
}
}
树形结构类BeanTree.java
BeanTree.java里面包含了如下的一些常用操作:
- 返回根节点
- 返回最后添加节点
- 判断是否具有子节点
- 添加节点
- 移动节点到其他节点下
- 获取对应nodeType的所有节点或实体
- 根据实体获取节点
- 获取父节点
- 转化为map结构
代码如下
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.apache.commons.collections.CollectionUtils;
/**
* 实体树形结构
* BeanTree
* @author BrightLoong
* @version 1.0
*
*/
public class BeanTree {
/**根节点*/
private BeanTreeNode root;
/**
* 最新添加的节点
*/
private BeanTreeNode currentNode;
/**
* @return the currentNode
*/
public BeanTreeNode getCurrentNode() {
return currentNode;
}
/**
* @return the root
*/
public BeanTreeNode getRoot() {
return root;
}
/**
* 判断节点是否有子节点.
* @param node 要判断的节点
* @return true or false
*/
public boolean haveChild(BeanTreeNode node) {
return CollectionUtils.isEmpty(node.getChildNodes());
}
/**
* 在父节点上面添加节点,并返回天添加的节点.
* @param parentNode 父节点
* @param bean 要添加的bean
* @param nodeType 节点类型
* @return 返回包含bean的节点
*/
public BeanTreeNode addNode(BeanTreeNode parentNode, Object bean, String nodeType) {
BeanTreeNode node;
if (bean == null) {
return null;
}
//如果没有父节点说明为root根节点
if (parentNode == null) {
node = root = new BeanTreeNode(null, nodeType, bean);
} else {
//创建子节点,并添加到父节点上
node = new BeanTreeNode(parentNode, nodeType, bean);
parentNode.getChildNodes().add(node);
}
currentNode = node;
return node;
}
/**
* 将当期bean-sBean,以及sBean下的子Bean,挂到dBean下
* @param sBean 源Bean
* @param dBean 目的父Bean
*/
public void removeTo(Object sBean, Object dBean) {
BeanTreeNode sNode = getNodeByBean(sBean);
BeanTreeNode dNode = getNodeByBean(dBean);
removeTo(sNode, dNode);
}
/**
* 将当期node-sNode,以及sNode下的子Node,挂到dNode下
* @param sNode 源node
* @param dNode 目的父node
*/
public void removeTo(BeanTreeNode sNode, BeanTreeNode dNode) {
//从当前父节点移除sNode
sNode.getParentNode().getChildNodes().remove(sNode);
//将sNode移到dNode下
dNode.getChildNodes().add(sNode);
//修改sNode的父Id和父节点
sNode.setPid(dNode.getId());
sNode.setParentNode(dNode);
}
/**
* 获取父bean.
* @param bean 子bean
* @return 返回父bean
*/
public Object getParentBean(Object bean) {
return getNodeByBean(bean).getParentNode().getBean();
}
/**
* 根据传入的bean获取bean下面对应类型的子bean.
* @param bean 当前bean
* @param nodeType 节点类型
* @return 子bean的集合
*/
public List<Object> getBeanListByBeanAndNodeType(Object bean, String nodeType) {
BeanTreeNode node = getNodeByBean(bean);
return getBeanListByNodeType(node, nodeType);
}
/**
* 根据传入的bean获取包含bean的Node节点
* @param node 当前node
* @param bean 要查找的bean
* @return node节点
*/
public BeanTreeNode getNodeByBean(BeanTreeNode node, Object bean) {
BeanTreeNode resultNode = null;
if (node.getBean().equals(bean)) {
resultNode = node;
return resultNode;
} else {
for (BeanTreeNode tempNode : node.getChildNodes()) {
resultNode = getNodeByBean(tempNode, bean);
if (resultNode != null) {
break;
}
}
}
return resultNode;
}
/**
* 根据传入的bean获取root节点下包含bean的Node节点
* @param bean 要查找的bean
* @return node节点
*/
public BeanTreeNode getNodeByBean(Object bean) {
return getNodeByBean(root, bean);
}
/**
* 根据节点类型返回当前节点下对应节点类型的bean的list集合.
* 默认如果当前节点满足类型,那么当前节点不会存在相同类型的子节点
* @param node 当前节点
* @param nodeType 节点类型
* @return
*/
@SuppressWarnings("unchecked")
public <T> List<T> getBeanListByNodeType(BeanTreeNode node, String nodeType) {
List<T> beanList = new ArrayList<T>();
if (node.getNodeType().equals(nodeType)) {
beanList.add((T)node.getBean());
} else {
for (BeanTreeNode tempNode : node.getChildNodes()) {
beanList.addAll((Collection<? extends T>) getBeanListByNodeType(tempNode, nodeType));
}
}
return beanList;
}
/**
* 根据节点类型返回根节点下对应节点类型的bean的list集合.
* @param nodeType 节点类型
* @return
*/
public <T> List<T> getBeanListByNodeType(String nodeType) {
return getBeanListByNodeType(root, nodeType);
}
/**
* 从root节点开始获取对应nodeType的node.
* @param nodeType 节点类型
* @return nodeType类型的节点集合
*/
public List<BeanTreeNode> getNodeListByNodeType(String nodeType) {
return getNodeListByNodeType(root, nodeType);
}
/**
* 从node节点开始获取对应nodeType的node.
* @param node node节点
* @param nodeType 节点类型
* @return nodeType类型的节点集合
*/
public List<BeanTreeNode> getNodeListByNodeType(BeanTreeNode node, String nodeType) {
List<BeanTreeNode> nodeList = new ArrayList<BeanTreeNode>();
if(node==null){
return nodeList;
}
if (nodeType.equals(node.getNodeType())) {
nodeList.add(node);
} else {
for (BeanTreeNode tempNode : node.getChildNodes()) {
nodeList.addAll(getNodeListByNodeType(tempNode, nodeType));
}
}
return nodeList;
}
/**
* 将树形结构转化为map.
* @return
*/
public Map<String, List<Object>> toMap() {
return toMap(root);
}
/**
* 将对应节点及其子节点转化为map.
* @param node 树节点
* @return 转化后的map
*/
public Map<String, List<Object>> toMap(BeanTreeNode node) {
Map<String, List<Object>> map = new HashMap<String, List<Object>>();
toMap(node, map);
return map;
}
/**
* 根据传入的nodeType删除对应的节点以及其所有子节点.
* @param nodeType
*/
public void delNodeByNodeType(String nodeType) {
delNodeByNodeType(root, nodeType);
}
/**
* 删除node节点下,类型为nodeType的节点和所有子节点
* @param node
* @param nodeType
*/
public void delNodeByNodeType(BeanTreeNode node, String nodeType) {
List<BeanTreeNode> nodeList = getNodeListByNodeType(node, nodeType);
for (BeanTreeNode beanTreeNode : nodeList) {
beanTreeNode.getParentNode().getChildNodes().remove(beanTreeNode);
}
}
/**
* 从树结构里面删除bean和相关node.
* @param bean bean
*/
public void delNodeByBean(Object bean) {
BeanTreeNode node = getNodeByBean(bean);
BeanTreeNode parentNode = node.getParentNode();
List<BeanTreeNode> childNodes = parentNode.getChildNodes();
Iterator<BeanTreeNode> it = childNodes.iterator();
while (it.hasNext()) {
BeanTreeNode beanTreeNode = it.next();
if (node == beanTreeNode) {
it.remove();
}
}
}
/**
* 根据class返回对应的beanList.
* @param cls class
* @return beanList
*/
public <T> List<Object> getBeanListByClass(Class<T> cls) {
return getBeanListByClass(root, cls);
}
/**
* 根据class返回对应的beanList.
* @param node 节点
* @param cls class
* @return beanList
*/
public <T> List<Object> getBeanListByClass(BeanTreeNode node, Class<T> cls) {
List<Object> beanList = new ArrayList<Object>();
Object bean = node.getBean();
if (cls.isAssignableFrom(bean.getClass())) {
beanList.add(bean);
}
List<BeanTreeNode> childNodes = node.getChildNodes();
for (BeanTreeNode beanTreeNode : childNodes) {
beanList.addAll(getBeanListByClass(beanTreeNode, cls));
}
return beanList;
}
/**
* 将对应节点及其子节点转化为map.
* @param node 树节点
* @param map 用来保存结果的map
*/
private void toMap(BeanTreeNode node, Map<String, List<Object>> map) {
String key = node.getNodeType();
Object bean = node.getBean();
if (map.containsKey(key)) {
map.get(key).add(bean);
} else {
List<Object> list = new ArrayList<Object>();
list.add(bean);
map.put(key, list);
}
for (BeanTreeNode tempNode : node.getChildNodes()) {
toMap(tempNode, map);
}
}
}
测试树形工具
使用上面的xml进行测试,这里就不再做xml映射,假设存在上面xml所示的所有实体,“school-one”和“school-two”以及5个student,看看能否构造出想要的结构,测试类代码如下。
class SchoolInf {
private String msg;
public SchoolInf(String msg) {
this.msg = msg;
}
}
class Student {
private String name;
public Student(String name) {
this.name = name;
}
}
class School {
private String name;
public School(String name) {
this.name = name;
}
}
public class Test {
public static void main(String[] args) {
SchoolInf schoolInf = new SchoolInf("2017-10-1XX省学校信息总汇");
School school_one = new School("school-one");
School school_two = new School("school-two");
Student Jack = new Student("Jack");
Student Rose = new Student("Rose");
Student Jon = new Student("Jon");
Student Bob = new Student("Bob");
Student Alisa = new Student("Alisa");
BeanTree tree = new BeanTree();
BeanTreeNode root = tree.addNode(null, schoolInf, "root");
BeanTreeNode school_node1 = tree.addNode(root, school_one, "school");
BeanTreeNode school_node2 = tree.addNode(root, school_two, "school");
tree.addNode(school_node1, Jack, "root");
tree.addNode(school_node1, Rose, "root");
tree.addNode(school_node1, Jon, "root");
tree.addNode(school_node2, Bob, "root");
tree.addNode(school_node2, Alisa, "root");
System.out.println("end");
}
}
我们通过调试观察树结构变量“tree”的值如下:

可以看出来能够构造出正确的结构,BeanTree中其他的一些方法这里就不在一一测试了。
更新记录
- 2018/1/10,在BeanTree中添加更多的操作方法。