首页 > 编程语言> 文章详细

java集合快速构建成树形json

2021-03-17 21:03:36 阅读：108 来源： 互联网

标签：return String List public json 树形 import java 节点

文章目录

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;
    }   
}

标签：return,String,List,public,json,树形,import,java,节点
来源： https://blog.csdn.net/weixin_55891090/article/details/114852269

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9