前言

现在大部分都是后端封装树形结构，第一次做的时候想从网上找通用，发现大部分都是要用类的get/set方法，不一样就要改，毕竟懒，改就改改，后来发现部门要，地区要，分类要，于是想着就把之前的用注解和反射做成通用的，当时改的下面这种的

改完之后在我的电脑上测试发现处理456条数据要3000毫秒左右(测试结果不同的电脑不一样)

终于在今天凌晨4点的时候灵光一闪，把所有的数据遍历不到两遍就可以，

思路

代码

注解类：

import java.lang.annotation.ElementType;

import java.lang.annotation.Retention;

import java.lang.annotation.RetentionPolicy;

import java.lang.annotation.Target;

/**

* @author ***

* @version 1.0

* @date 2020/7/28 16:12

* 树形封装注解

* value：id 主键id

* pid 父级别id

* list 子列表

* level：等级，由高到底，逗号分割

*/

@Retention(RetentionPolicy.RUNTIME)

@Target(value = {ElementType.FIELD})

public @interface TreeType {

//注解成员，default表示默认值

public String value() default "";

public String level() default "";

}

tree工具类

package com.mooc1993.common.utils;

import com.mooc1993.common.annotate.TreeType;

import org.springframework.util.StringUtils;

import java.beans.IntrospectionException;

import java.beans.PropertyDescriptor;

import java.lang.reflect.InvocationTargetException;

import java.lang.reflect.Method;

import java.util.*;

import java.lang.reflect.Field;

/**

* @author ***

* @version 1.0

* @date 2020/7/28 15:47

*/

public class TreeObjectUtils {

//主键id字段名

private String id;

//父级id字段名

private String parentId;

//子级集合字段名

private String child;

//等级集合,从高到底。如：1，2，3

private List level;

//等级字段名

private String levelName;

//key父id

//value索引

private Map map = null;

/**

* 获取树形结构

* @param list

* @param

* @param

* @return

*/

public List get1(List list) {

if (null == list) {

return list;

}

int size = list.size();

if (size == 0) {

return list;

}

getType(list.get(0));

map = new HashMap<>(list.size());

int levelSize = level.size();

Map> levelMap = new HashMap<>(levelSize);

for (int i = 0; i < size; i++) {

T t = list.get(i);

Object key = getName(id, t, null);

Object mapLevel = getName(levelName, t, null);

List levelLists = levelMap.get(mapLevel);

Integer index = null;

if (null == levelLists) {

List levelList = new ArrayList<>();

index = 0;

levelList.add(t);

levelMap.put(mapLevel, levelList);

} else {

index = levelLists.size();

levelLists.add(t);

levelMap.put(mapLevel, levelLists);

}

map.put(key, index);

}

for (int i = levelSize - 1; i > 0; i--) {

List levelLists = levelMap.get(level.get(i));

int size1 = levelLists.size();

for (int j = 0; j < size1; j++) {

T unit = levelLists.get(j);

//获取父级id

Object key = getName(parentId, unit, null);

//获取索引id

Integer integer = map.get(key);

//获取上一级对象

List tList = levelMap.get(level.get(i - 1));

T t = tList.get(integer);

List childList = (List) getName(child, t, null);

if (null == childList) {

childList = new ArrayList<>();

}

childList.add(unit);

getName(child, t, childList);

}

}

return levelMap.get(level.get(0));

}

/**

* 通过反射获取注解对应的字段名

*

* @param t

*/

public void getType(T t) {

// 反射获得 class

Class> clazz = t.getClass();

// 如果类 上有注解 @TreeType ，取出注解 value的值

TreeType declaredAnnotation = clazz.getDeclaredAnnotation(TreeType.class);

if (declaredAnnotation != null) {

System.out.println("类的注解@TreeType的value值是：" + declaredAnnotation.value());

}

//获得所有该类方法，不包括从其他地方继承过来的

Field[] declaredFields = clazz.getDeclaredFields();

for (Field declaredField : declaredFields) {

TreeType fieldAnnotation = declaredField.getDeclaredAnnotation(TreeType.class);

if (fieldAnnotation != null) {

String value = fieldAnnotation.value();

String level = fieldAnnotation.level();

String name = declaredField.getName();

//首字母转大写，拼接get,set方法。反射调用不拼接，不使用

//name=toUpperCaseFirstOne(name);

if ("id".equals(value)) {

Home | This.ID = name;

} else if ("pid".equals(value)) {

this.parentId = name;

} else if ("list".equals(value)) {

this.child = name;

} else if (!StringUtils.isEmpty(level)) {

this.level = Arrays.asList(level.split(","));

this.levelName = name;

}

}

}

}

/**

* 通过反射调用方法获取参数

*

* @param name 方法名

* @param obj 类

* @param arg 参数

* @return

*/

private Object getName(String name, Object obj, Object arg) {

PropertyDescriptor pd = null;

try {

pd = new PropertyDescriptor(name, obj.getClass());

} catch (IntrospectionException e) {

e.printStackTrace();

}

//获取set方法

Method getMethod = pd.getReadMethod();

//获取get方法

Method getMethod1 = pd.getWriteMethod();

Object rtn = null;

try {

if (arg == null) {

rtn = getMethod.invoke(obj);

} else {

getMethod1.invoke(obj, arg);

}

} catch (IllegalAccessException e) {

e.printStackTrace();

} catch (InvocationTargetException e) {

e.printStackTrace();

}

return rtn;

}

}

例子：

@Data

public class FcSkillsType implements Serializable {

@TreeType("id")

private Integer typeId;

private String typeName;

@TreeType(level = "1,2,3,4,5")

private String typeLevel;

@TreeType("pid")

private Integer typeFatherId;

private String skillYpeIcon;

private Boolean isDelete;

@TreeType("list")

private List typeList;

}

测试

用这种思路加反射和注解测试处理456条数据大概要30毫秒左右，如果不使用注解和反射，直接类.属性大概率1毫秒。

不足

工具还有好多不足和需要优化的地方，

比如等级要提前写入，不能根据数据自动扩展，这里我稍微处理了一下，假如预计会分3个等级(1,2,3)，你可以在注解上多写几个,比如1，2，3，4，5，他不会影响代码的运行

还有对反射获取到的参数没有校验

注意反射获得所有该类方法，不包括从其他地方继承过来的

等等…