package microservice.fpzj.utils;import microservice.fpzj.po.dict.FpzjXzdwArray;import org.aspectj.weaver.ast.Test;import java.lang.reflect.Field;import java.util.ArrayList;import java.util.List;/** * 作者 杨柳 * 创建时间 2017-07-05 16:54 */public class TreeUtils { //例子 public static void main(String[] args){ TestTree testTree = new TestTree(); testTree.setId("1001"); testTree.setName("潍坊市"); testTree.setPid("1000"); TestTree testTree1 = new TestTree(); testTree1.setId("1002"); testTree1.setName("青岛市"); testTree1.setPid("1000"); TestTree testTree2 = new TestTree(); testTree2.setId("1001001"); testTree2.setName("高新区"); testTree2.setPid("1001"); TestTree testTree3 = new TestTree(); testTree3.setId("1002001"); testTree3.setName("四方区"); testTree3.setPid("1002"); TestTree testTree4 = new TestTree(); testTree4.setId("1000"); testTree4.setName("山东省"); testTree4.setPid("0"); TestTree testTree5 = new TestTree(); testTree5.setId("1001001001"); testTree5.setName("清池街办"); testTree5.setPid("1001001"); List testTreeList = new ArrayList<>(); testTreeList.add(testTree); testTreeList.add(testTree1); testTreeList.add(testTree2); testTreeList.add(testTree3); testTreeList.add(testTree4); testTreeList.add(testTree5); TreeUtils.createTree(testTreeList,testTree4,"id","pid","testTrees"); System.out.println(testTree4); //通过上边的createTree方法，根节点，即testTree4就是最全的最后的树结构。 } /** * @param list 树数据 * @param root 根节点 * @param keyFieldName 关联属性 * @param parentKeyFieldName 关联父属性 * @param subFieldName 子节点数据 * @param 根节点 */ public static void createTree(List list, T root, String keyFieldName, String parentKeyFieldName, String subFieldName) { Field keyField = ReflectUtils.getField(keyFieldName, root); Field parentKeyField = ReflectUtils.getField(parentKeyFieldName, root); Field subField = ReflectUtils.getField(subFieldName, root); find(list, root, keyField, parentKeyField, subField); } /** * 根据父节点的关联值 查找 */ public static List getKeys(List list, T root, String keyFieldName, String parentKeyFieldName) { Field keyField = ReflectUtils.getField(keyFieldName, root); Field parentKeyField = ReflectUtils.getField(parentKeyFieldName, root); List keys = new ArrayList<>(); E value = ReflectUtils.getValueByGetMethod(keyField, root); keys.add(value); findKeys(list, keys, root, keyField, parentKeyField); return keys; } private static void find(List list, T parent, Field keyField, Field parentKeyField, Field subField) { List subs = getSubs(list, parent, keyField, parentKeyField); if (subs != null) { ReflectUtils.setValueByField(subField, parent, subs); for (T sub : subs) { //递归找子节点 find(list, sub, keyField, parentKeyField, subField); } } } private static List findKeys(List list, List keys, T parent, Field keyField, Field parentKeyField) { List subs = getSubs(list, parent, keyField, parentKeyField); List subKeys = getSubKeys(list, parent, keyField, parentKeyField); if (subs != null) { keys.addAll(subKeys); for (T sub : subs) { //递归找子节点 findKeys(list, keys, sub, keyField, parentKeyField); } } return keys; } private static List getSubs(List list, T parent, Field keyField, Field parentKeyField) { List subs = null; for (T t : list) { Object keyFieldValue = ReflectUtils.getValueByField(keyField, parent); Object parentFieldValue = ReflectUtils.getValueByField(parentKeyField, t); if (keyFieldValue.equals(parentFieldValue)) { if (subs == null) { subs = new ArrayList<>(); } subs.add(t); } } return subs; } private static List getSubKeys(List list, T parent, Field keyField, Field parentKeyField) { List subs = null; for (T t : list) { Object keyFieldValue = ReflectUtils.getValueByField(keyField, parent); //父节点key Object parentFieldValue = ReflectUtils.getValueByField(parentKeyField, t); //根结点关联的key if (keyFieldValue.equals(parentFieldValue)) { //关联字段相等 if (subs == null) { subs = new ArrayList<>(); } //取子节点key Object key = ReflectUtils.getValueByField(keyField, t); subs.add((E) key); } } return subs; } }class TestTree{ private String id; private String name; private String pid; private List testTrees; public List getTestTrees() { return testTrees; } public void setTestTrees(List testTrees) { this.testTrees = testTrees; } public String getId() { return id; } public void setId(String id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name; } public String getPid() { return pid; } public void setPid(String pid) { this.pid = pid; }} package microservice.fpzj.utils;import org.apache.commons.lang3.*;import java.lang.annotation.Annotation;import java.lang.reflect.Field;import java.lang.reflect.Method;import java.util.ArrayList;import java.util.Arrays;import java.util.List;/** * Created by 杨柳 on 2016/8/5 0005. * email:yangliu@buestc.com * tel:18523437817 */public class ReflectUtils { /** * 根据属性名获取属性 */ public static Field getField(String fieldName, Class clazz) { Class old = clazz; Field field = null; for (; clazz != Object.class; clazz = clazz.getSuperclass()) { try { field = clazz.getDeclaredField(fieldName); if (field != null) { break; } } catch (Exception e) { } } if (field == null) { throw new NullPointerException(old + "没有" + fieldName + "属性"); } return field; } /** * 获取目标类的属性 */ public static Field getField(String fieldName, String className) { try { return getField(fieldName, Class.forName(className)); } catch (Exception e) { throw new RuntimeException(e); } } /** * 获取目标对象的属性 */ public static Field getField(String fieldName, Object object) { return getField(fieldName, object.getClass()); } /** * 获取当前类的属性 包括父类 */ public static List getFields(Class clazz, Class stopClass) { try { List fieldList = new ArrayList<>(); while (clazz != null && clazz != stopClass) {//当父类为null的时候说明到达了最上层的父类(Object类). fieldList.addAll(Arrays.asList(clazz.getDeclaredFields())); clazz = clazz.getSuperclass(); //得到父类,然后赋给自己 } return fieldList; } catch (Exception e) { throw new RuntimeException(e.getMessage(), e); } } /** * 获取当前类的属性 包括父类 */ @Deprecated public static List getFields(Class clazz) { return getFields(clazz, Object.class); } private static List > getSuperClasses(Class clazz, Class stopClass) { List > classes = new ArrayList<>(); while (clazz != null && clazz != stopClass) {//当父类为null的时候说明到达了最上层的父类(Object类). classes.add(clazz); clazz = clazz.getSuperclass(); //得到父类,然后赋给自己 } return classes; } /** * 通过属性赋值 */ public static void setValueByField(String fieldName, Object object, Object value) { Field field = getField(fieldName, object.getClass()); setValueByField(field, object, value); } /** * 通过属性赋值 */ public static void setValueByField(Field field, Object object, Object value) { try { if (!field.isAccessible()) { field.setAccessible(true); field.set(object, value); field.setAccessible(false); } else { field.set(object, value); } } catch (Exception e) { throw new RuntimeException(e.getMessage(), e); } } /** * 获取属性的值 */ public static T getValueByField(String fieldName, Object object) { Field field = getField(fieldName, object.getClass()); return getValueByField(field, object); } /** * 获取属性的值 */ public static T getValueByField(Field field, Object object) { try { Object value; if (!field.isAccessible()) { field.setAccessible(true); value = field.get(object); field.setAccessible(false); } else { value = field.get(object); } return (T) value; } catch (Exception e) { throw new RuntimeException(e.getMessage(), e); } } /** * 通过set方法赋值 */ public static void setValueBySetMethod(String fieldName, Object object, Object value) { if (object == null) { throw new RuntimeException("实例对象不能为空"); } if (value == null) { return; } try { String setMethodName = "set" + fieldName.substring(0, 1).toUpperCase() + fieldName.substring(1); Method setMethod = getMethod(setMethodName, object.getClass(), value.getClass()); setMethod.invoke(object, value); } catch (Exception e) { throw new RuntimeException(e.getMessage(), e); } } /** * 通过set方法赋值 */ public static void setValueBySetMethod(Field field, Object object, Object value) { if (object == null) { throw new RuntimeException("实例对象不能为空"); } if (value == null) { return; } setValueBySetMethod(field.getName(), object, value); } /** * 通过get方法取值 */ public static T getValueByGetMethod(String fieldName, Object object) { try { if (StringUtils.isNotBlank(fieldName)) { String getMethodName = "get" + fieldName.substring(0, 1).toUpperCase() + fieldName.substring(1); Method getMethod = getMethod(getMethodName, object.getClass()); return (T) getMethod.invoke(object); } else { return null; } } catch (Exception e) { throw new RuntimeException(e.getMessage(), e); } } /** * 通过get方法取值 */ public static T getValueByGetMethod(Field field, Object object) { return getValueByGetMethod(field.getName(), object); } /** * 获取某个类的某个方法(当前类和父类) */ public static Method getMethod(String methodName, Class clazz) { Method method = null; for (; clazz != Object.class; clazz = clazz.getSuperclass()) { try { method = clazz.getDeclaredMethod(methodName); break; } catch (Exception e) { } } if (method == null) { throw new NullPointerException("没有" + methodName + "方法"); } return method; } /** * 获取get方法 * * @param fieldName 属性名 * @return */ public static String getMethodName(String fieldName) { String methodName = "get" + fieldName.substring(0, 1).toUpperCase() + fieldName.substring(1); return methodName; } /** * 获取某个类的某个方法(当前类和父类) 带一个参数 */ public static Method getMethod(String methodName, Class clazz, Class paramType) { Method method = null; for (; clazz != Object.class; clazz = clazz.getSuperclass()) { try { method = clazz.getDeclaredMethod(methodName, paramType); if (method != null) { return method; } } catch (Exception e) { } } if (method == null) { throw new NullPointerException(clazz + "没有" + methodName + "方法"); } return method; } /** * 获取某个类的某个方法(当前类和父类) */ public static Method getMethod(String methodName, Object obj) { return getMethod(methodName, obj.getClass()); } /** * 获取某个类的某个方法(当前类和父类) 一个参数 */ public static Method getMethod(String methodName, Object obj, Class paramType) { return getMethod(methodName, obj.getClass(), paramType); } /** * 获取某个类的某个方法(当前类和父类) */ public static Method getMethod(String methodName, String clazz) { try { return getMethod(methodName, Class.forName(clazz)); } catch (Exception e) { throw new RuntimeException(e.getMessage(), e); } } /** * 获取某个类的某个方法(当前类和父类) 一个参数 */ public static Method getMethod(String methodName, String clazz, Class paramType) { try { return getMethod(methodName, Class.forName(clazz), paramType); } catch (Exception e) { throw new RuntimeException(e.getMessage(), e); } } /** * 获取方法上的注解 */ public static Annotation getMethodAnnotation(Method method, Class targetAnnotationClass) { Annotation methodAnnotation = method.getAnnotation(targetAnnotationClass); return methodAnnotation; } /** * 获取属性上的注解 */ public static Annotation getFieldAnnotation(Field field, Class targetAnnotationClass) { Annotation methodAnnotation = field.getAnnotation(targetAnnotationClass); return methodAnnotation; } /** * 获取类上的注解 * * @param targetAnnotationClass 目标注解 * @param targetObjcetClass 目标类 * @return 目标注解实例 */ public static Annotation getClassAnnotation(Class targetAnnotationClass, Class targetObjcetClass) { Annotation methodAnnotation = targetObjcetClass.getAnnotation(targetAnnotationClass); return methodAnnotation; } /** * 获取类上的注解 * * @return 目标注解实例 */ public static Annotation getClassAnnotation(Class targetAnnotationClass, Object obj) { return getClassAnnotation(targetAnnotationClass, obj.getClass()); } /** * 获取类上的注解 * * @return 目标注解实例 */ public static Annotation getClassAnnotation(Class targetAnnotationClass, String clazz) { try { return getClassAnnotation(targetAnnotationClass, Class.forName(clazz)); } catch (Exception e) { throw new RuntimeException(e.getMessage(), e); } } /** * 获取注解某个属性的值 * * @param methodName 属性名 * @param annotation 目标注解 * @param 返回类型 * @throws Exception */ public static T getAnnotationValue(String methodName, Annotation annotation) { try { Method method = annotation.annotationType().getMethod(methodName); Object object = method.invoke(annotation); return (T) object; } catch (Exception e) { throw new RuntimeException(e.getMessage(), e); } } /** * 获取某个类的某个方法上的某个注解的属性 * * @param methodName 注解属性的名字 * @param targetAnnotationClass 目标注解 * @param targetObjecMethodName 目标类的方法 * @param targetObjectClass 目标类 * @param 返回值类型 */ public static T getMethodAnnotationValue(String methodName, Class targetAnnotationClass, String targetObjecMethodName, Class targetObjectClass) { Method method = getMethod(targetObjecMethodName, targetObjectClass); Annotation annotation = getMethodAnnotation(method, targetAnnotationClass); return getAnnotationValue(methodName, annotation); } /** * @param methodName 注解属性名 * @param targetAnnotationClass 目标注解 * @param targetObjecFieldName 目标属性名字 * @param targetObjectClass 目标类 * @param 返回值类型 */ public static T getFieldAnnotationValue(String methodName, Class targetAnnotationClass, String targetObjecFieldName, Class targetObjectClass) { Field field = getField(targetObjecFieldName, targetObjectClass); Annotation annotation = getFieldAnnotation(field, targetAnnotationClass); return getAnnotationValue(methodName, annotation); } /** * 判断 clazz是否是target的子类型或者相等 */ public static boolean isSubClassOrEquesClass(Class clazz, Class target) { if (clazz == target) { return true; } while (clazz != Object.class) { if (clazz == target) { return true; } clazz = clazz.getSuperclass(); } return false; }}