1 场景

1.1 面对问题

java中，经常会需要构建树形结构的json，如构建一个省市区的树形结构。

此处情况，有如下几个情况需要解决：

• 需要根据不同的前端组件，来定义不同格式的json（如easyui、ext里面的tree结构均不同）。如切换组件，原代码不适用
• 树形结构，需手动组装，如不同的树形结构太多，则会花较多的时间来组装不同业务的树形结构。
• 手动实现，代码较复杂，容易出问题
• 如让java中的实体类实现定义的树形结构的接口，代码侵入性太强

1.2 实现目标

这里实现一个代码工具，各位朋友可以参考下，实现如下功能：

• 实现树形结构的快速构建
• 定义不同树类型的实现，可切换树形结构简单
• 系统实体类无需实现自定义接口，代码无侵入性
• 使用类适配器，可随意自行扩展

2 代码结构图

代码结构图.png

3 实现效果

依赖model：

package com.sa.example.tree.bean;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

/**
 * 区域信息
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
public class Area {

    private String areaCode;
    
    private String areaName;
    
    private Integer order;
    
    private String parentCode;
    
}

3.1 调用

package com.sa.example.tree.test;

import com.sa.example.tree.*;
import com.sa.example.tree.ext.EasyuiNode;
import com.sa.example.tree.bean.Area;
import org.apache.commons.lang3.StringUtils;
import org.junit.Test;

import java.util.ArrayList;
import java.util.List;

public class TreeParseTest {
    
    @Test
    public void testParse(){
    
        // 节点转换器（将任意对象转换为树节点）
        NodeConvert departmentConverter = new NodeConvert<Area>() {
            @Override
            public Node convert(Area area) {
                // 根据实体的属性，补充到对应的NodeInstance对象上（转换为EasyUi）
                NodeInstance instance = new EasyuiNode();
                instance.setParentCode(area.getParentCode());
                instance.setCode(area.getAreaCode());
                instance.setName(area.getAreaName());
                instance.setOrder(area.getOrder());
                // 根据实际业务，配置其他属性......
                /*instance.setCss("icon-value");
                instance.setChecked(true);
                instance.setState("opened");
                instance.putExtMap("aa", "aaVaule");*/
            
                return instance;
            }
        };
    
        // 默认根节点选择器（确定根节点）
        RootSelector defaultSelector = new RootSelector() {
            @Override
            public boolean select(Node node) {
                if (node != null && StringUtils.isEmpty(node.getParentCode())) {
                    return true;
                }
                return false;
            }
        };
    
        List<Area> areaList = new ArrayList<>();
        areaList.add(new Area("130000000000", "河北", 2, ""));
        areaList.add(new Area("130100000000", "石家庄", 1, "130000000000"));
        areaList.add(new Area("130400000000", "邯郸", 2, "130000000000"));
        areaList.add(new Area("370000000000", "山东", 1, ""));
        areaList.add(new Area("370100000000", "济南", 1, "370000000000"));
        areaList.add(new Area("370200000000", "青岛", 2, "370000000000"));
        areaList.add(new Area("370202000000", "市南", 2, "370200000000"));
        areaList.add(new Area("370203000000", "市北", 3, "370200000000"));
        
        TreeBuilder<Area> treeBuilder = new TreeBuilder<>(departmentConverter, defaultSelector);
        Tree tree = treeBuilder.build(areaList);
        System.out.println(tree.toJson());
    }
}

3.2 结果

[{
    "children": [{
        "id": "370100000000",
        "text": "济南"
    }, {
        "children": [{
            "id": "370202000000",
            "text": "市南"
        }, {
            "id": "370203000000",
            "text": "市北"
        }],
        "id": "370200000000",
        "text": "青岛"
    }],
    "id": "370000000000",
    "text": "山东"
}, {
    "children": [{
        "id": "130100000000",
        "text": "石家庄"
    }, {
        "id": "130400000000",
        "text": "邯郸"
    }],
    "id": "130000000000",
    "text": "河北"
}]

4 实现代码

maven依赖：

<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-lang3</artifactId>
    <version>3.11</version>
</dependency>
<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-collections4</artifactId>
    <version>4.4</version>
</dependency>
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.73</version>
</dependency>

4.1 JSON转换器

/**
 * JSON转换器
 */
public interface JsonParser {
    
    /**
     * 生成JSON对象
     * @return JSON对象
     */
    JSONObject toJson();
    
}

4.2 节点

package com.sa.example.tree;

import java.util.List;
import java.util.Map;

/**
 * 节点
 */
public interface Node extends JsonParser, Comparable<Node> {
    
    /**
     * 获取节点代码
     *
     * @return
     */
    String getCode();
    
    /**
     * 获取节点名称
     *
     * @return
     */
    String getName();
    
    /**
     * 获取节点排序
     *
     * @return
     */
    Integer getOrder();
    
    /**
     * 获取节点样式
     *
     * @return
     */
    String getCss();
    
    /**
     * 获取节点状态
     *
     * @return
     */
    String getState();
    
    /**
     * 获取节点复选状态
     *
     * @return
     */
    Boolean getChecked();
    
    /**
     * 扩展属性
     *
     * @return
     */
    Map<String, Object> getExtMap();
    
    /**
     * 获取父节点代码
     *
     * @return
     */
    String getParentCode();
    
    /**
     * 获取子节点集合
     *
     * @return
     */
    List<Node> getChildList();
    
    @Override
    default int compareTo(Node o) {
        return this.getOrder().compareTo(o.getOrder());
    }
    
    /**
     * 添加子节点
     *
     * @param node 子节点
     */
    void addChildNode(Node node);
    
    /**
     * 设置额外属性
     * @param key
     * @param value
     */
    void putExtMap(String key, Object value);
}

4.3 节点实例

package com.sa.example.tree;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * Node实例
 */
public abstract class NodeInstance implements Node {
    
    /**
     * 节点代码
     */
    private String code;
    
    /**
     * 节点名称
     */
    private String name;
    
    /**
     * 节点排序
     */
    private Integer order;
    
    /**
     * 节点样式
     */
    private String css;
    
    /**
     * 节点状态
     */
    private String state;
    
    /**
     * 节点复选状态
     */
    private Boolean checked;
    
    /**
     * 扩展属性
     */
    private Map<String, Object> extMap;
    /**
     * 父节点代码
     */
    private String parentCode;
    
    /**
     * 子节点集合
     */
    private List<Node> childList;
    
    @Override
    public void addChildNode(Node node) {
        if (childList == null) {
            childList = new ArrayList<>();
        }
        childList.add(node);
    }
    
    @Override
    public List<Node> getChildList() {
        return childList;
    }
    
    @Override
    public void putExtMap(String key, Object value) {
        if (extMap == null) {
            extMap = new HashMap<>();
        }
        extMap.put(key, value);
    }
    
    @Override
    public String getCode() {
        return code;
    }
    
    public void setCode(String code) {
        this.code = code;
    }
    
    @Override
    public String getName() {
        return name;
    }
    
    public void setName(String name) {
        this.name = name;
    }
    
    @Override
    public Integer getOrder() {
        return order;
    }
    
    public void setOrder(Integer order) {
        this.order = order;
    }
    
    @Override
    public String getCss() {
        return css;
    }
    
    public void setCss(String css) {
        this.css = css;
    }
    
    @Override
    public String getState() {
        return state;
    }
    
    public void setState(String state) {
        this.state = state;
    }
    
    @Override
    public Boolean getChecked() {
        return checked;
    }
    
    public void setChecked(Boolean checked) {
        this.checked = checked;
    }
    
    @Override
    public String getParentCode() {
        return parentCode;
    }
    
    public void setParentCode(String parentCode) {
        this.parentCode = parentCode;
    }
    
    @Override
    public Map<String, Object> getExtMap() {
        return extMap;
    }
}

4.4 根节点选择器

package com.sa.example.tree;

/**
 * 根节点选择器
 */
public interface RootSelector {
    
    /**
     * 选择节点为根节点
     * @param node 被选择节点
     * @return true：选择为根节点；false：不选择为根节点
     */
    boolean select(Node node);

}

4.5 节点转换器

/**
 * 节点转换器
 */
public interface NodeConvert<T> {
    
    /**
     * 实体转换为节点
     * @param t
     * @return
     */
    Node convert(T t);
    
}

4.6 树

package com.sa.example.tree;

import com.alibaba.fastjson.JSONArray;
import org.apache.commons.collections4.CollectionUtils;

import java.util.List;

/**
 * 树
 */
public class Tree {
    
    /**
     * 根节点
     */
    private List<Node> nodeList;
    
    public Tree() {
    }
    
    public void setNodeList(List<Node> nodeList) {
        this.nodeList = nodeList;
    }
    
    public String toJson() {
        JSONArray jsonArray = new JSONArray();
    
        if (CollectionUtils.isNotEmpty(nodeList)) {
            for (Node node : nodeList) {
                jsonArray.add(node.toJson());
            }
        }
        return jsonArray.toJSONString();

    }
}

4.7 树构建器

package com.sa.example.tree;

import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.lang3.StringUtils;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;

/**
 * 树构建器
 *
 * @param <T>
 */
public class TreeBuilder<T> {
    
    /**
     * 节点转换器
     */
    private NodeConvert<T> nodeConvert;
    
    /**
     * 根节点选择器
     */
    private RootSelector rootSelector;
    
    public TreeBuilder(NodeConvert nodeConvert, RootSelector rootSelector) {
        this.nodeConvert = nodeConvert;
        this.rootSelector = rootSelector;
    }
    
    /**
     * 初始化节点列表
     *
     * @return
     */
    protected List<Node> initNodeList(List<T> list) {
        List<Node> nodeList = new ArrayList<>();
        if (CollectionUtils.isNotEmpty(list)) {
            for (T model : list) {
                nodeList.add(nodeConvert.convert(model));
            }
        }
        return nodeList;
    }
    
    /**
     * 构建节点结构
     *
     * @param nodeList
     * @return
     */
    protected List<Node> buildNodeStructure(List<Node> nodeList) {
        List<Node> rootList = new ArrayList<>();
        if (CollectionUtils.isNotEmpty(nodeList)) {
            // 1、构建root节点
            Iterator<Node> iterator = nodeList.iterator();
            while (iterator.hasNext()) {
                Node node = iterator.next();
                if (rootSelector.select(node)) {
                    rootList.add(node);
                    iterator.remove();
                }
            }
            // 2、循环查找子节点
            for (Node rootNode : rootList) {
                this.buildChildNode(rootNode, nodeList);
            }
        }
        
        return rootList;
    }
    
    /**
     * 构建子节点（反复调用）
     *
     * @param parentNode     父节点
     * @param originNodeList 自己节点列表
     */
    protected void buildChildNode(Node parentNode, List<Node> originNodeList) {
        if (CollectionUtils.isNotEmpty(originNodeList)) {
            Iterator<Node> iterator = originNodeList.iterator();
            while (iterator.hasNext()) {
                Node node = iterator.next();
                if (StringUtils.equals(parentNode.getCode(), node.getParentCode())) {
                    parentNode.addChildNode(node);
                    iterator.remove();
                    // 迭代调用
                    this.buildChildNode(node, originNodeList);
                }
            }
        }
    }
    
    /**
     * 节点集合排序
     *
     * @param nodeList
     * @return
     */
    protected void sortNodeList(List<Node> nodeList) {
        if (CollectionUtils.isNotEmpty(nodeList)) {
            Collections.sort(nodeList);
            for (Node node : nodeList) {
                if (CollectionUtils.isNotEmpty(node.getChildList())) {
                    this.sortNodeList(node.getChildList());
                }
            }
        }
    }
    
    /**
     * 构建树
     *
     * @param list
     * @return
     */
    public Tree build(List<T> list) {
        List<Node> nodeList = this.initNodeList(list);
        List<Node> buildNodeList = this.buildNodeStructure(nodeList);
        this.sortNodeList(buildNodeList);
        
        Tree tree = new Tree();
        tree.setNodeList(buildNodeList);
        return tree;
    }
    
}

4.8 Easyui节点实例

实例继承自“节点实例NodeInstance”，此类实例可根据实际要求自行定义和扩展。

package com.sa.example.tree.ext;

import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.sa.example.tree.Node;
import com.sa.example.tree.NodeInstance;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.collections4.MapUtils;
import org.apache.commons.lang3.StringUtils;

import java.util.List;
import java.util.Map;

/**
 * Easyui节点实例
 */
public class EasyuiNode extends NodeInstance {
    @Override
    public JSONObject toJson() {
        JSONObject jsonObject = new JSONObject();
        // ==========【（1）组装必有属性】==========
        jsonObject.put("id", this.getCode());
        jsonObject.put("text", this.getName());
        
        // ==========【（2）组装可选属性】==========
        String css = this.getCss();
        if (StringUtils.isNotEmpty(css)) {
            jsonObject.put("iconCls", css);
        }
        String state = this.getState();
        if (StringUtils.isNotEmpty(state)) {
            jsonObject.put("state", state);
        }
        Boolean checked = this.getChecked();
        if (checked != null) {
            jsonObject.put("checked", checked);
        }
        
        Map<String, Object> extMap = this.getExtMap();
        if (MapUtils.isNotEmpty(extMap)) {
            JSONObject attributesObject = new JSONObject();
            for (Map.Entry<String, Object> entry : extMap.entrySet()) {
                attributesObject.put(entry.getKey(), entry.getValue());
            }
            jsonObject.put("attributes", attributesObject);
        }
        
        // ==========【（3）组装子节点】==========
        List<Node> childList = this.getChildList();
        if (CollectionUtils.isNotEmpty(childList)) {
            JSONArray jsonArray = new JSONArray();
            for (Node child : childList) {
                jsonArray.add(child.toJson());
            }
            jsonObject.put("children", jsonArray);
        }
        return jsonObject;
    }   
}