有时候我们项目里面需要将树型关系的数据转换成Json格式的String字符串
假设数据库中的数据如下
需要转换后输出的字符串的结果如下（对应的层级的关系）
[
{name:'爷爷',id:'1',content:'老人辈',parentId:'0',expanded: true,children:[
{name:'爸爸',id:'2',content:'长辈',parentId:'1',expanded: true,children:[
{name:'儿子',id:'4',content:'晚辈',parentId:'2',leaf:true},{name:'女儿',id:'5',content:'晚辈',parentId:'2',leaf:true}
]},{name:'叔叔',id:'3',content:'长辈',parentId:'1',leaf:true}
]
}
]
相应的代码资料网上可以找到
1、树节点类
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map; /**
* 树节点类（用于模拟树型结构关系中的节点）
*/
public class TreeNode {
public static final String TREENODE_ATTRIBUTE_NAME_NAME = "name"; // 字段属性name
public static final String TREENODE_ATTRIBUTE_NAME_ID = "id"; // 字段属性id
private Map<String,Object> attributes = new HashMap<String, Object>(); // 字段属性的Map private TreeNode parent = null; //当前节点的父节点
private List<TreeNode> child = new ArrayList<TreeNode>(); //当前节点的子节点
private boolean isCheck = false; //当前节点是否被勾选标志 /*
无参构造函数
*/
public TreeNode(){
super();
} /**
* 获取/设置 节点的属性name
* @return
*/
public String getName() {
return (String) attributes.get(TREENODE_ATTRIBUTE_NAME_NAME);
}
public void setName(String name) {
attributes.put(TREENODE_ATTRIBUTE_NAME_NAME,name);
} /**
* 获取/设置 节点的属性id
* @return
*/
public String getId() {
return (String) attributes.get(TREENODE_ATTRIBUTE_NAME_ID);
}
public void setId(String id) {
attributes.put(TREENODE_ATTRIBUTE_NAME_ID,id);
} /**
* 获取/设置 节点需要在树形结构中显示的信息
* @return
*/
public Map<String, Object> getAttributes() {
return attributes;
}
public void setAttributes(Map<String, Object> attributes) {
this.attributes = attributes;
} /**
* 获取/设置 节点是否被勾选信息
* @return
*/
public boolean isCheck() {
return isCheck;
}
public void setCheck(boolean check) {
isCheck = check;
} /**
* 获取/设置 节点父节点信息
* @return
*/
public TreeNode getParent() {
return parent;
}
public void setParent(TreeNode parent) {
this.parent = parent;
} /**
* 是否存在/获取/设置/添加 节点子节点信息
* @return
*/
public boolean hasChildren(){
return child.size()>0;
}
public List<TreeNode> getChild() {
return child;
}
public void setChild(List<TreeNode> child) {
this.child = child;
}
public void addChild(TreeNode treeNode){
treeNode.setParent(this);
child.add(treeNode);
}
}
2、树型节点的属性Map类
import java.util.HashMap;
import java.util.Map; /**
* 树型节点的属性Map（用于操作节点的各个属性，如name,id）
*/
public class TreeAttributesMap {
private Map<String,Object> attributes = new HashMap<>(); //存放属性的Map /**
* 有参构造函数
* @param id
* @param name
*/
public TreeAttributesMap(Object id,Object name){
attributes.put(TreeNode.TREENODE_ATTRIBUTE_NAME_ID,id);
attributes.put(TreeNode.TREENODE_ATTRIBUTE_NAME_NAME,name);
} /**
* 获取属性的Map
* @return
*/
public Map<String, Object> getAttributes() {
return attributes;
} /**
* 往属性的Map中添加属性
* @param name
* @param value
*/
public void putAttributes(String name,Object value){
attributes.put(name,value);
}
}
3、定义一些树型结构相关的接口（方便以后拓展）
/**
* 定义一般普通的树节点的接口
*/
public interface ISimpleTreeNode { /**
* 每个树节点都具备自身的一些属性
* @return
*/
public TreeAttributesMap getTreeAttributesMap();
}
/**
* 定义层级树节点的接口
*/
public interface ILevelTreeNode extends ISimpleTreeNode{ public int getParentId();
public int getId();
}
public interface ITreeParser<T> {
/**
* 解析数据
* @param data
* @return
*/
List<T> parser(Object data);
}
4、树类
/**
* 树类 （根据自身需求对数据进行解析和转换）
*/
public class Tree {
private ITreeParser<TreeNode> treeParser;
private int treeType; //转换标志（可以拓展）
private Object data; //数据源 /**
* 有参构造函数
* @param data
* @param treeType
*/
public Tree(Object data,int treeType){
this.data = data;
this.treeType = treeType;
} /**
* 数据转换 data ---> json格式
* @return json格式的String
*/
public String toJsonTree(){
String json = "";
if (treeType == 1){
treeParser = new LevelTreeParser();
json = toLevelTree();
}else if (treeType == 2){
//XXX树型结构
}else if (treeType == 3){
//XXX树型结构
}else{
//other树型结构
}
return json;
} private String toLevelTree(){
String jsonString = "";
List<TreeNode> nodes = treeParser.parser(data);
StringBuffer sb = new StringBuffer();
sb.append("[");
parserLevelNodeToJson(sb,nodes);
sb.append("]");
jsonString = sb.toString();
return jsonString;
} private void parserLevelNodeToJson(StringBuffer sb,List<TreeNode> nodes){
Iterator<TreeNode> it = nodes.iterator();
while(it.hasNext()){
TreeNode node = it.next();
boolean isLeaf = node.hasChildren();
sb.append("{");
Map<String,Object> attributes = node.getAttributes();
for(String key:attributes.keySet()){
Object obj = attributes.get(key);
if (obj != null)
sb.append(key + ":'" + obj.toString() + "',");
}
if (isLeaf){
sb.append("expanded: true,children: [");
parserLevelNodeToJson(sb,node.getChild());
if (it.hasNext()){
sb.append("]},");
}else{
sb.append("]}");
}
}else{
if (it.hasNext()){
sb.append("leaf:true},");
}else{
sb.append("leaf:true}");
}
}
}
}
}
5、层级树状结构解析实现类
import java.util.HashMap;
import java.util.List;
import java.util.Map; public class LevelTreeParser implements ITreeParser<TreeNode>{ private Map<Object,TreeNode> treeNodeMap = new HashMap<Object, TreeNode>();
TreeNode root = new TreeNode(); public List<TreeNode> parser(Object data){
//将数据data强转为List<ILevelTreeNode>格式
List<ILevelTreeNode> list = (List<ILevelTreeNode>) data;
//List<TreeNode> nodes = new ArrayList<TreeNode>(); //list不为空且大小不为0
if (list != null && list.size()>0){ //加强for循环list
for (ILevelTreeNode levelTreeNode:list){
TreeNode item = new TreeNode();
//获取每个树节点的属性
item.setAttributes(levelTreeNode.getTreeAttributesMap().getAttributes());
//封装每个树节点
treeNodeMap.put(levelTreeNode.getId(),item);
}
//再次遍历所有的树节点
for (ILevelTreeNode levelTreeNode:list){
TreeNode parent = treeNodeMap.get(levelTreeNode.getParentId());
TreeNode treeNode = treeNodeMap.get(levelTreeNode.getId());
if (parent == null){
root.addChild(treeNode);
}else{
parent.addChild(treeNode);
}
}
}
return root.getChild();
}
}
6、解析格式选择类
/**
* 解析格式选择类 （用于接受数据源并选择解析格式）
*/
public class BaseParser {
public static String parserListToLevelTree(List list){
Tree tree = new Tree(list,1);
return tree.toJsonTree();
}
}
7、数据库的Model类treeLevel
要实现接口ILevelTreeNode并实现getTreeAttributesMap的方法，把数据库字段对应的类中的属性都封装起来
public class treeLevel implements ILevelTreeNode {
private int id;
private int parentId;
private String name;
private String content;
@Override
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
@Override
public int getParentId() {
return parentId;
}
public void setParentId(int parentId) {
this.parentId = parentId;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getContent() {
return content;
}
public void setContent(String content) {
this.content = content;
}
@Override
public TreeAttributesMap getTreeAttributesMap() {
TreeAttributesMap treeMap = new TreeAttributesMap(this.id,this.name);
treeMap.putAttributes("content",this.content);
treeMap.putAttributes("parentId",this.parentId);
return treeMap;
}
}
8、Dao层（查询数据库表中所有的记录）
@Mapper
public interface MyDao { @Select("SELECT * FROM treelevel")
4 List<treeLevel> getTreeLevelList();
5 }
9、Server层就省略了，最后只要在Controller层提供Server层调用Dao层访问数据库，将返回的结果List传入静态方法BaseParser.parserListToLevelTree()中即可。
最后，总结一下
a.先为自己的树型节点定义好接口，比如每个节点有获取自己的id、父节点id、属性集合等方法。
b.根据数据库字段创建好对应的类的Model，这里Model类需要实现之前定义好节点的接口，便于后面代码的接入。
c.创建好Parser转换类，将传入List形式的数据转换成自己想要的节点链表形式的数据（对每个节点封装好父节点、子节点们和自身属性集合等）。
d.创建好Tree数据选择解析类，将转换好的节点数据集合解析成自己想要的Json格式的String字符串。