将数据转换成树型层级的Json格式的String

有时候我们项目里面需要将树型关系的数据转换成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字符串。