將數據轉換成樹型層級的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 { 3     @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字符串。