我想知道是否有一种简单的方法来确定 Java 类递归扩展或实现的类型的完整列表？
例如：
class Foo extends Bar implements I1, I2 {...}
class Bar implements I3 {...}
interface I1 extends I4, I5 {...}
interface I2 {...}
interface I3 {...}
interface I4 {...}
interface I5 {...}
class ClassUtil {
public static Set<Class<?>> getAllExtendedOrImplementedTypesRecursively(Class<?> clazz){
???
}
}
import static org.junit.Assert.*;
public class ClassUtilTest {
@Test
public void shouldEqualClasses(){
Set<Class<?>> types = ClassUtil.getAllExtendedOrImplementedTypesRecursively(Foo.class);
Set<Class<?>> checklist = new HashSet<>();
checklist.add(Foo.class);
checklist.add(Bar.class);
checklist.add(I1.class);
checklist.add(I2.class);
checklist.add(I3.class);
checklist.add(I4.class);
checklist.add(I5.class);
assertTrue(checklist.containsAll(types));
assertTrue(types.containsAll(checklist));
}
}
想想 Arquillian ShrinkWrap 创建助手。
更新：由于Class对象没有实现Comparable>，我还需要找到一种在不实现Comparable接口的情况下创建Set（或类似的类）的方法（例如，仅依赖于类对象的哈希码）。
更新：更改了测试以使用哈希集。德普。
该方法的以下实现满足OP的要求，它遍历每个类和接口的继承层次结构：
public static Set<Class<?>> getAllExtendedOrImplementedTypesRecursively(Class<?> clazz) {
List<Class<?>> res = new ArrayList<>();
do {
res.add(clazz);
// First, add all the interfaces implemented by this class
Class<?>[] interfaces = clazz.getInterfaces();
if (interfaces.length > 0) {
res.addAll(Arrays.asList(interfaces));
for (Class<?> interfaze : interfaces) {
res.addAll(getAllExtendedOrImplementedTypesRecursively(interfaze));
}
}
// Add the super class
Class<?> superClass = clazz.getSuperclass();
// Interfaces does not have java,lang.Object as superclass, they have null, so break the cycle and return
if (superClass == null) {
break;
}
// Now inspect the superclass
clazz = superClass;
} while (!"java.lang.Object".equals(clazz.getCanonicalName()));
return new HashSet<Class<?>>(res);
}
我用
JFrame.classSet<Class<?>> classes = getAllExtendedOrImplementedTypesRecursively(JFrame.class);
for (Class<?> clazz : classes) {
System.out.println(clazz.getName());
}
输出：
java.awt.Container
java.awt.Frame
javax.swing.JFrame
javax.swing.TransferHandler$HasGetTransferHandler
java.awt.Window
javax.accessibility.Accessible
javax.swing.RootPaneContainer
java.awt.Component
javax.swing.WindowConstants
java.io.Serializable
java.awt.MenuContainer
java.awt.image.ImageObserver
更新： 对于OP的测试用例，它打印：
test.I5
test.Bar
test.I2
test.I1
test.Foo
test.I3
test.I4
Apache Common Lang 中有一个 ClassUtils，它具有您想要的 2 个方法。 .getAllSuperClasses() 和 .getAllInterfaces()。
你想要的钥匙就在
Class#getSuperclass()public static Set<Class<?>> stuff(Class<?> target) {
Set<Class<?>> classesInterfaces = new HashSet<>();
classesInterfaces.add(target);
classesInterfaces.addAll(Arrays.asList(target.getInterfaces());
Class<?> superClass = target.getSuperclass();
if(superClass != null)
classesInterfaces.addAll(stuff(superClass));
}
在Java8中
import java.util.Arrays;
import java.util.Optional;
import java.util.Set;
import java.util.function.Predicate;
import java.util.stream.Collectors;
import java.util.stream.Stream;
public class ClassUtil {
public static Set<Class<?>> getAllExtendedOrImplementedTypesRecursively(final Class<?> clazz) {
return walk(clazz)
.filter(Predicate.isEqual(java.lang.Object.class).negate())
.collect(Collectors.toSet());
}
public static Stream<Class<?>> walk(final Class<?> c) {
return Stream.concat(Stream.of(c),
Stream.concat(
Optional.ofNullable(c.getSuperclass()).map(Stream::of).orElseGet(Stream::empty),
Arrays.stream(c.getInterfaces())
).flatMap(ClassUtil::walk));
}
}
测试代码：
import java.util.Set;
class Test {
public static void main(String[] args) {
final Set<Class<?>> set = ClassUtil.getAllExtendedOrImplementedTypesRecursively(Foo.class);
set.stream().map(Class::getName).forEach(System.out::println);
}
class Foo extends Bar implements I1, I2 {}
class Bar implements I3 {}
interface I1 extends I4, I5 {}
interface I2 {}
interface I3 {}
interface I4 {}
interface I5 {}
}
输出：
测试$Foo 测试$栏 测试$I2 测试$I5 测试$I1 测试$I3 测试$I4
从问题如何在 Java 中找到给定类的所有子类？，这个答案可能会有所帮助：
使用类PojoClassImpl.java，您可以通过调用方法
getSuperClass()如果我没有回答你的问题，你想找到特定类的所有超类（类和接口）。如果是这样你可以检查以下解决方案
找到超类
Class C = getClass();
while (C != null) {
System.out.println(C.getSimpleName());
C = C.getSuperclass();
}
找到接口
C = getClass();
for(Class adf: C.getInterfaces()){
System.out.println(adf.getSimpleName());
}
这很简单，如果你的类是 Foo 那么你的代码将是这样的，
public void getClassDetails() {
Class klass = Foo.class;
Class<?> superKlass = klass.getSuperClass();
Class[] interfaces = klass.getInterfaces();
}
我曾经在某些ShrinkWrap分支上使用
asm据我所知，不久前官方立场是不将此类功能包含在
ShrinkWrapJBoss Tools对 @otamega 解决方案的一些建议减少：
这个不会过滤对象（这会导致不一致），并使用一些重构和静态导入来使代码更具可读性。
package com.stackoverflow.question22031207;
import static java.util.Arrays.stream;
import static java.util.stream.Collectors.toSet;
import static java.util.stream.Stream.concat;
import static java.util.stream.Stream.of;
import static java.util.stream.Stream.ofNullable;
import java.util.Set;
import java.util.stream.Stream;
public class ClassUtil {
public static Set<Class<?>> getAllExtendedOrImplementedTypesRecursively(final Class<?> clazz) {
return walk(clazz).collect(toSet());
}
public static Stream<Class<?>> walk(final Class<?> clazz) {
final Class<?> superclass = clazz.getSuperclass();
final Class<?>[] interfaces = clazz.getInterfaces();
return concat(of(clazz), concat(ofNullable(superclass), stream(interfaces)).flatMap(ClassUtil::walk));
}
}
AnnotationUtils.findAnnotation()在提供的类上找到一个annotationType的注释， 遍历它的接口、注释和超类，如果 注释并不直接出现在给定类本身上。这 方法显式处理类级别的注释，但这些注释不是 声明为继承以及元注释和注释 接口。
算法运行如下：
- 搜索给定类的注释，如果找到则返回。
- 递归搜索给定类声明的所有注释。
- 递归搜索给定类声明的所有接口。
- 递归搜索给定类的超类层次结构。
查找方法上的注释有一个重载，
AnnotatedElements