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;
}
}
网友评论