Class工具类-获取上级类或者接口集

packagexxx.xxx.utils.external.clazz;
importcn.hutool.core.collection.CollUtil;
importlombok.AllArgsConstructor;
importlombok.Getter;
importjava.lang.annotation.Annotation;
importjava.util.ArrayList;
importjava.util.Arrays;
importjava.util.Collections;
importjava.util.List;
importjava.util.stream.Collectors;
importjava.util.stream.Stream;
/*** @Description: class工具类*/publicclassClassUtil {
    ;
/*** 最多循环次数的极限值*/privatefinalstaticintLIMIT_FOR_COUNT=100;
/*** Object类型对象*/privatefinalstaticClass<Object>OBJECT_CLASS=Object.class;
/*** @Param clazz 指定的class对象* @description 获取指定类的父类及以上继承类class对象集合(包含当前类 ( 如果是类的话)的class对象)*/publicstaticList<Class<?>>getSuperClassList(Class<?>clazz) {
try {
if (clazz==null||clazz.isInterface()) {
returnCollections.emptyList();
            }
List<Class<?>>resultList=newArrayList<>();
resultList.add(clazz);
//上一个目标类的class对象Class<?>lastTargetClass=ClassUtil.getSuperClass(clazz);
if (lastTargetClass==null) {
returnresultList;
            }
resultList.add(lastTargetClass);
intcurrentCount=0;
while (currentCount<LIMIT_FOR_COUNT) {
++currentCount;
Class<?>targetClass=ClassUtil.getSuperClass(lastTargetClass);
//将此值赋值给lastTargetClasslastTargetClass=targetClass;
if (targetClass==null) {
break;
                }
resultList.add(targetClass);
            }
returnresultList;
        } catch (Exceptionignore) {
        }
returnCollections.emptyList();
    }
/*** @param clazz 指定的class对象* @description 获取指定类的接口及以上父类实现的接口集合(包含当前接口 ( 如果是接口的话)的class对象)*/publicstaticList<Class<?>>getSuperInterfaceList(Class<?>clazz) {
if (clazz==null) {
returnCollections.emptyList();
        }
List<Class<?>>resultList=newArrayList<>();
if (clazz.isInterface()) {
resultList.add(clazz);
        }
if (clazz.getInterfaces().length==0) {
returnresultList;
        }
CollUtil.addAll(resultList, clazz.getInterfaces());
Stream.of(clazz.getInterfaces()).forEach(item->CollUtil.addAll(resultList, getSuperInterfaceList(item)));
returnresultList.stream().distinct().collect(Collectors.toList());
    }
/*** @param clazz Exception类型的class对象(运行时及编译期)* @description 获取传入class对象的父类class对象* 如果传入为空或者传入的是Object(所有类的顶层父类)的class对象均返回为空*/publicstaticClass<?>getSuperClass(Class<?>clazz) {
if (clazz==null||clazz==OBJECT_CLASS||clazz.isInterface()) {
returnnull;
        }
returnclazz.getSuperclass();
    }
/*** @param clazz class对象* @description 判断传入的class对象是否是接口(interface)*/publicstaticbooleanisInterface(Class<?>clazz) {
if (null==clazz) {
returnfalse;
        }
returnclazz.isInterface();
    }
/*** @param compareClass    比较类对象* @param beComparedClass 被比较类对象* @description 比较比较类对象是否属于被比较类对象，或者是否是被比较类对象的子类，子实现类，子抽象类，子接口*/publicstaticbooleanequals(Class<?>compareClass, Class<?>beComparedClass) {
if (null==compareClass||null==beComparedClass) {
returnfalse;
        }
List<ClassTypeEnum>classTypeEnumList=ClassUtil.getClassType(beComparedClass);
if (classTypeEnumList.isEmpty()) {
returnfalse;
        }
//基本思路// 判断被比较的是类还是注解还是接口还是枚举//如果是注解//获取当前类上的注解及嵌套注解进行比较if (classTypeEnumList.contains(ClassTypeEnum.ANNOTATION)) {
returnClassUtil.equalsAnnotation(Arrays.asList(compareClass.getAnnotations()), beComparedClass);
        }
//如果是枚举//直接比较，枚举的统一父类都是Enumif (classTypeEnumList.contains(ClassTypeEnum.ENUM)) {
returncompareClass==beComparedClass;
        }
//如果是接口//获取当前类实现的接口及嵌套接口进行比较if (classTypeEnumList.contains(ClassTypeEnum.INTERFACE)) {
returnClassUtil.equalsInterface(Arrays.asList(compareClass.getInterfaces()), beComparedClass);
        }
//其它情况就判断是类//获取当前类对象的父以上类进行比较returnClassUtil.equalsClass(compareClass, beComparedClass);
    }
/*** @param annotationList  注解对象集合* @param beComparedClass 被比较的class对象* @description 比较注解对象集合中是否含被比较的class对象* 此处是【递归】调用实现*/publicstaticbooleanequalsAnnotation(List<Annotation>annotationList, Class<?>beComparedClass) {
if (null==annotationList||annotationList.isEmpty()) {
returnfalse;
        }
List<Annotation>subAnnotationList=newArrayList<>();
booleanflag=false;
for (Annotationannotation : annotationList) {
if (annotation.getClass() ==beComparedClass) {
flag=true;
break;
            } else {
subAnnotationList.add(annotation);
            }
        }
if (!flag) {
flag=ClassUtil.equalsAnnotation(subAnnotationList, beComparedClass);
        }
returnflag;
    }
/*** @param clazz           类class对象* @param beComparedClass 被比较的class对象* @description 比较注解对象集合中是否含被比较的class对象* 此处是【递归】调用实现*/publicstaticbooleanequalsClass(Class<?>clazz, Class<?>beComparedClass) {
returnnull!=clazz&& (clazz==beComparedClass||ClassUtil.equalsClass(clazz.getSuperclass(), beComparedClass));
    }
/*** @param interfaceList   接口class对象集合* @param beComparedClass 被比较的class对象* @description 比较注解对象集合中是否含被比较的class对象* 此处是【递归】调用实现*/publicstaticbooleanequalsInterface(List<Class<?>>interfaceList, Class<?>beComparedClass) {
if (null==interfaceList||interfaceList.isEmpty()) {
returnfalse;
        }
List<Class<?>>subInterfaceList=newArrayList<>();
booleanflag=false;
for (Class<?>clazz : interfaceList) {
if (clazz==beComparedClass) {
flag=true;
break;
            } else {
CollUtil.addAll(subInterfaceList, clazz.getInterfaces());
            }
        }
if (!flag) {
flag=ClassUtil.equalsInterface(subInterfaceList, beComparedClass);
        }
returnflag;
    }
/*** @param clazz 类对象* @description 判断传入的类对象类型*/publicstaticList<ClassTypeEnum>getClassType(Class<?>clazz) {
List<ClassTypeEnum>classTypeEnumList=newArrayList<>();
if (null==clazz) {
classTypeEnumList.add(ClassTypeEnum.NULL);
returnclassTypeEnumList;
        }
if (clazz.isInterface()) {
classTypeEnumList.add(ClassTypeEnum.INTERFACE);
        }
if (clazz.isEnum()) {
classTypeEnumList.add(ClassTypeEnum.ENUM);
        }
if (clazz.isAnnotation()) {
classTypeEnumList.add(ClassTypeEnum.ANNOTATION);
        }
if (clazz.isArray()) {
classTypeEnumList.add(ClassTypeEnum.ARRAY);
        }
if (clazz.isSynthetic()) {
classTypeEnumList.add(ClassTypeEnum.SYNTHETIC);
        }
if (clazz.isAnonymousClass()) {
classTypeEnumList.add(ClassTypeEnum.SYNTHETIC);
        }
returnclassTypeEnumList;
    }
@Getter@AllArgsConstructorpublicenumClassTypeEnum {
/*** 类*/CLASS,
/*** 接口*/INTERFACE,
/*** 枚举*/ENUM,
/*** 注解*/ANNOTATION,
/*** 其它类型*/OTHER,
/*** 空对象 无法识别*/NULL,
/*** 数组*/ARRAY,
/*** 合成类*/SYNTHETIC,
/*** 匿名类*/ANONYMOUS,
        ;
    }
}