树数据树转换工具

简介

自用的把id,parent_id,name,sort表数据转换成前端用的树结构数据

TreeTransform类，抽象转换类，封装了树数据转的逻辑

/**
* 类描述:【 
* 	T:树对象实体类
* 	E:业务数据实体类
* 】
 * 
 * @author Simple-Zeng
 * @createTime 2019年7月24日下午9:35:32
 */
public abstract class TreeTransform<T extends TreeModel, E extends TreeModel>{
	
	public final static String ROOTID="0";

	/**
	 * 方法描述:【 获取业务数据实体类集合】
	 * 
	 * @author Simple-Zeng
	 * @createTime 2019年7月24日下午9:35:25
	 */
	public abstract List<T> getSourceDatas();

	/**
	 * 方法描述:【业务数据实体类转换成树对象实体类 】
	 * 
	 * @author Simple-Zeng
	 * @createTime 2019年7月24日下午9:36:13
	 */
	public abstract E sourceDataToTree(T t) ;
	

	/**
	 * 方法描述:【树转换 】
	 * 
	 * @author Simple-Zeng
	 * @createTime 2019年7月24日下午9:37:45
	 */
	public List<E> toTree(String keyword,String parentId) {
		// 获取原始数据
		List<T> ts = getSourceDatas();
		return  toTree(ts,parentId,keyword);
	}
	
	/**
	 * 方法描述:【树转换 】
	 * 
	 * @author Simple-Zeng
	 * @createTime 2019年7月24日下午9:37:45
	 */
	public List<E> toTree(List<T> sourceDatas,String parentId,String keyword) {
		// 声明结果集		
		List<E> result =new ArrayList<>();
		if(isNotNull(keyword)) {
			return toTreeByKeyword(sourceDatas, keyword, result);
		}else {
			Map<String, List<E>> parentMap = resolverParentMap(sourceDatas,result,parentId);
			//没找到根节点，返回空
			if(null==result||result.size()==0) {
				return new ArrayList<>();
			}
			toSetChildren(result,parentMap);
			//封装结果
			orderEmodel(result);
			return result;			
		}
		
	}

	private List<E> toTreeByKeyword(List<T> sourceDatas, String keyword, List<E> result) {
		for (T t : sourceDatas) {
			String nodeName = t.getNodeName();
			if(nodeName.indexOf(keyword)!=-1) {					
				E e = sourceDataToTree(t);
				result.add(e);
			}
		}
		return result;
	}

	private void toSetChildren(List<E> list, Map<String, List<E>> parentMap) {
		for (E e : list) {
			List<E> childs = parentMap.get(e.getNodeId());
			if(null!=childs&&childs.size()>0) {
				orderEmodel(childs);
				e.setChildrenNodes(childs);
				toSetChildren(childs,parentMap);
			}else {
				e.setChildrenNodes(new ArrayList<>());				
			}
		}
	}

	private Map<String,List<E>> resolverParentMap(List<T> sourceDatas,List<E> rootNode,String parentId) {
		Map<String,List<E>> pmap=new HashMap< >();
		List<String> ids = null;
		for (T t : sourceDatas) {
			E e = sourceDataToTree(t);
			//指明了父节点就只取这个父节点
			if(isNotNull(parentId)) {
				if(parentId.equals(t.getNodeId())) {					
					rootNode.add(e);
					continue;
				}
			}else {
				//放到这初始化
				if(null==ids) {
					ids = DrinListUtils.collectField(sourceDatas,T::getNodeId);
				}
				if(isRootNode(t, sourceDatas,ids)) {
					rootNode.add(e);
					continue;
				}
			}
			DrinListUtils.flushMap(t.getNodePId(), pmap, e);
		}
		return pmap;
	}
	
	/**
	 * 方法描述:【判断业务数据是不是最顶层父类 】
	 * 
	 * @author Simple-Zeng
	 * @createTime 2019年7月24日下午9:36:43
	 */
	protected  boolean isRootNode(T t,List<T> ts,List<String> ids) {
		String pId = t.getNodePId();
		boolean pidIsNull =isNull(pId);
		if(pidIsNull) {
			return true;
		}
		boolean pidEqualZero=ROOTID.equals(pId);
		if(pidEqualZero) {
			return true;
		}
		//父节点压根就没在集合里面，就是根节点
		return !ids.contains(pId);
	}

	/**
	 * 方法描述:【树数据排序 】
	 * 
	 * @author Simple-Zeng
	 * @createTime 2019年7月24日下午9:37:33
	 */
	protected  void orderEmodel(List<E> es) {
		es.sort((e1, e2) -> e1.getNodeSort().compareTo(e2.getNodeSort()));
	}
}

TreeModel类

public interface TreeModel {
	// 子类中必须存在这些名字的私有字段，如字段名不同，需要重写接口方法,如，有的父id叫private String
	// pId;,则实现类必须重写getNodePId()方法
	public final static String ID = "id";
	public final static String PID = "parentId";
	public final static String NAME = "name";
	public final static String LABEL = "label";
	public final static String SORT = "sort";
	public final static String CHILDREN = "children";

	@JsonIgnore
	@JSONField(serialize = false)
	default String getNodeId() {
		return DrinReflectUtils.getFieldProperties(this, ID);
	};

	@JsonIgnore
	@JSONField(serialize = false)
	default String getNodePId() {
		String parentId = DrinReflectUtils.getFieldProperties(this, PID);
		return isNull(parentId) ? "0" : parentId;
	};

	@JsonIgnore
	@JSONField(serialize = false)
	default String getNodeName() {
		String name = DrinReflectUtils.getFieldProperties(this, NAME);
		if (isNull(name)) {
			// 尝试用label获取
			name = DrinReflectUtils.getFieldProperties(this, LABEL);
		}
		return name;
	};

	@JsonIgnore
	@JSONField(serialize = false)
	default Integer getNodeSort() {
		String sortStr = DrinReflectUtils.getFieldProperties(this, SORT);
		return isNotNull(sortStr) ? Integer.parseInt(sortStr) : 999;
	};

	default void setChildrenNodes(List<?> childrens) {
		DrinReflectUtils.setFieldProperties(this, CHILDREN, childrens);
	}
}

TreeUtils类

public class TreeUtils  {
	
	public final static String TREE_ROOT_ID="0";

	/**
	 * @description 【返回默认树】
	 * @author Simple-Zeng
	 * @DATE 2019年11月15日上午11:03:03
	 */
	public static <M extends TreeModel> List<DefaultTree> toDefaultTree(List<M> ms) {
		return toDefaultTree(ms, null);
	}

	/**
	 * @description 【返回默认树】
	 * @author Simple-Zeng
	 * @DATE 2019年11月15日上午11:03:03
	 */
	public static <M extends TreeModel> List<DefaultTree> toDefaultTree(List<M> ms, String keyword) {
		return toTree(ms, m -> new DefaultTree(m), keyword, null);
	}

	/**
	 * @description 【返回默认树】
	 * @author Simple-Zeng
	 * @DATE 2019年11月15日上午11:03:03
	 */
	public static <M extends TreeModel> List<DefaultTree> toDefaultTree(List<M> ms, String keyword, String parentId) {
		return toTree(ms, m -> new DefaultTree(m), keyword, parentId);
	}

	/**
	 * @description 【返回实体转换转】
	 * @author Simple-Zeng
	 * @DATE 2019年11月15日上午11:03:16
	 */
	public static <M extends TreeModel, T extends TreeModel> List<T> toTree(List<M> ms, Function<M, T> function) {
		return toTree(ms, function, null);
	}

	/**
	 * @description 【返回实体转换转】
	 * @author Simple-Zeng
	 * @DATE 2019年11月15日上午11:03:16
	 */
	public static <M extends TreeModel, T extends TreeModel> List<T> toTree(List<M> ms, Function<M, T> function, String keyword) {
		return toTree(ms, function, keyword, null);
	}

	/**
	 * @description 【返回实体转换转】
	 * @author Simple-Zeng
	 * @DATE 2019年11月15日上午11:03:16
	 */
	public static <M extends TreeModel, T extends TreeModel> List<T> toTree(List<M> ms, Function<M, T> function, String keyword, String parentId) {
		TreeTransform<M, T> treeTransform = new TreeTransform<M, T>() {
			@Override
			public List<M> getSourceDatas() {
				return ms;
			}

			@Override
			public T sourceDataToTree(M m) {
				return function.apply(m);
			}
		};
		return treeTransform.toTree(keyword, parentId);
	}
}

使用示例：

```java

public class Tree implements Serializable, TreeModel {

	private static final long serialVersionUID = 1L;

	@EditDesc("树id")
	private String id;
	@EditDesc("上级树id")
	private String parentId;
	@EditDesc("树名称")
	private String name;
	@EditDesc("排序")
	private Long sort;
}
public class DefaultTree implements TreeModel,Serializable{

	/**   **/
	private static final long serialVersionUID = 1L;

	private String id;

	private String label;

	private String parentId;

	private String name;

	private Integer sort;

	private Integer level = 1;
}
//查出原始数据，实现TreeMode接口，调用工具类
public JsonResult findTrees(TreeQueryPo po) throws Exception {
		List<Tree> trees = dao.findByQuery(po.toTreeQuery());
		List<DefaultTree> defaultTree = TreeUtils.toDefaultTree(trees, po.getKeyword(), po.getParentId());
		removeAndSetLevel(defaultTree, po.getLevel());
		return OK(defaultTree);
	}

//只需要某些层的情况
private void removeAndSetLevel(List<DefaultTree> defaultTrees, Integer level) {
		for (DefaultTree defaultTree : defaultTrees) {
			List<DefaultTree> childrens = defaultTree.getChildren();
			if (null != childrens && childrens.size() > 0) {
				int thisLevel = defaultTree.getLevel() + 1;
				// 将不符合level的设置成空
				if (null != level && thisLevel > level.intValue()) {
					defaultTree.setChildren(newArrayList());
					continue;
				}
				// 将符合level的设置下level值
				for (DefaultTree children : childrens) {
					children.setLevel(thisLevel);
				}
				removeAndSetLevel(childrens, level);
			}
		}
	}
	//统计叶子节点个数情况
	private void resetTotal(List<ChaterGroupTreeVo> defaultTree) {
		for (ChaterGroupTreeVo vo : defaultTree) {
			Integer total = vo.getTotal();
			List<ChaterGroupTreeVo> childrens = vo.getChildren();
			if (null != childrens && childrens.size() > 0) {
				resetTotal(childrens);
				for (ChaterGroupTreeVo children : childrens) {
					total += children.getTotal();
				}
				vo.setTotal(total);
			}
		}
	}

返回数据示例：