在运行时，查找 Java 应用程序中扩展基类的所有类

Question

我想做这样的事情：

List<Animal> animals = new ArrayList<Animal>();

for( Class c: list_of_all_classes_available_to_my_app() )
   if (c is Animal)
      animals.add( new c() );

因此，我想查看应用程序 Universe 中的所有类，当我找到一个来自 Animal 的类时，我想创建一个该类型的新对象并将其添加到列表中。 这使我无需更新事物列表即可添加功能。 我可以避免以下情况：

List<Animal> animals = new ArrayList<Animal>();
animals.add( new Dog() );
animals.add( new Cat() );
animals.add( new Donkey() );
...

使用上述方法，我可以简单地创建一个扩展 Animal 的新类，它会自动被选中。

更新：2008 年 10 月 16 日上午 9:00 太平洋标准时间：

这个问题引起了很多很好的回应——谢谢。 从回复和我的研究中，我发现我真正想做的事情在 Java 下是不可能的。 有一些方法，例如 ddimitrov 的 ServiceLoader 机制可以工作——但它们对于我想要的东西来说非常繁重，我相信我只是将问题从 Java 代码转移到外部配置文件。 2019 年 5月 10 日更新（11 年后！）根据@IvanNik 的回答org.reflections看起来不错，现在有几个库可以帮助解决这个问题。 此外ClassGraph从@Luke和记黄埔的答案看起来很有趣。 答案中还有更多的可能性。

另一种说明我想要的方式：我的 Animal 类中的静态函数查找并实例化从 Animal 继承的所有类——无需任何进一步的配置/编码。 如果我必须配置，我不妨在 Animal 类中实例化它们。 我明白这是因为 Java 程序只是 .class 文件的松散联合，这就是它的方式。

有趣的是，这在 C# 中似乎相当简单。

Answer 1

我使用org.reflections ：

Reflections reflections = new Reflections("com.mycompany");    
Set<Class<? extends MyInterface>> classes = reflections.getSubTypesOf(MyInterface.class);

另一个例子：

public static void main(String[] args) throws IllegalAccessException, InstantiationException {
    Reflections reflections = new Reflections("java.util");
    Set<Class<? extends List>> classes = reflections.getSubTypesOf(java.util.List.class);
    for (Class<? extends List> aClass : classes) {
        System.out.println(aClass.getName());
        if(aClass == ArrayList.class) {
            List list = aClass.newInstance();
            list.add("test");
            System.out.println(list.getClass().getName() + ": " + list.size());
        }
    }
}

Answer 2

做您想做的事情的 Java 方法是使用ServiceLoader机制。

许多人也通过在众所周知的类路径位置（即 /META-INF/services/myplugin.properties）中放置一个文件然后使用ClassLoader.getResources()枚举所有 jar 中具有此名称的所有文件来推出自己的文件。 这允许每个 jar 导出自己的提供者，您可以使用 Class.forName() 通过反射来实例化它们

Answer 3

从面向方面的角度考虑这个问题； 你真正想要做的是在运行时知道所有扩展了 Animal 类的类。 （我认为这比标题更准确地描述了您的问题；否则，我认为您没有运行时问题。）

所以我认为你想要的是创建你的基类（动物）的构造函数，它添加到你的静态数组（我更喜欢 ArrayLists，我自己，但每个人自己）正在实例化的当前类的类型。

所以，大致;

public abstract class Animal
    {
    private static ArrayList<Class> instantiatedDerivedTypes;
    public Animal() {
        Class derivedClass = this.getClass();
        if (!instantiatedDerivedClass.contains(derivedClass)) {
            instantiatedDerivedClass.Add(derivedClass);
        }
    }

当然，你需要在 Animal 上有一个静态构造函数来初始化instantiatedDerivedClass......我认为这会做你可能想要的。 请注意，这是依赖于执行路径的； 如果您的 Dog 类从永远不会被调用的 Animal 派生，则您的 Animal 类列表中将不会有它。

Answer 4

不幸的是，这并非完全可能，因为 ClassLoader 不会告诉您哪些类可用。 但是，您可以非常接近地执行以下操作：

for (String classpathEntry : System.getProperty("java.class.path").split(System.getProperty("path.separator"))) {
    if (classpathEntry.endsWith(".jar")) {
        File jar = new File(classpathEntry);

        JarInputStream is = new JarInputStream(new FileInputStream(jar));

        JarEntry entry;
        while( (entry = is.getNextJarEntry()) != null) {
            if(entry.getName().endsWith(".class")) {
                // Class.forName(entry.getName()) and check
                //   for implementation of the interface
            }
        }
    }
}

编辑： johnstok 是正确的（在评论中），这仅适用于独立的 Java 应用程序，不能在应用程序服务器下工作。

Answer 5

列出给定类的所有子类的最健壮的机制目前是ClassGraph ，因为它处理最广泛的类路径规范机制，包括新的 JPMS 模块系统。 （我是作者。）

List<Class<Animal>> animals;
try (ScanResult scanResult = new ClassGraph().whitelistPackages("com.zoo.animals")
        .enableClassInfo().scan()) {
    animals = scanResult
        .getSubclasses(Animal.class.getName())
        .loadClasses(Animal.class);
}

Answer 6

您可以使用Stripes Framework 中的ResolverUtil （ 原始源）
如果您需要简单快速的东西而无需重构任何现有代码。

这是一个没有加载任何类的简单示例：

package test;

import java.util.Set;
import net.sourceforge.stripes.util.ResolverUtil;

public class BaseClassTest {
    public static void main(String[] args) throws Exception {
        ResolverUtil<Animal> resolver = new ResolverUtil<Animal>();
        resolver.findImplementations(Animal.class, "test");
        Set<Class<? extends Animal>> classes = resolver.getClasses();

        for (Class<? extends Animal> clazz : classes) {
            System.out.println(clazz);
        }
    }
}

class Animal {}
class Dog extends Animal {}
class Cat extends Animal {}
class Donkey extends Animal {}

这也适用于应用程序服务器，因为它是设计用来工作的;)

该代码主要执行以下操作：

• 迭代您指定的包中的所有资源
• 只保留以 .class 结尾的资源
• 使用ClassLoader#loadClass(String fullyQualifiedName)加载这些类
• 检查是否Animal.class.isAssignableFrom(loadedClass);

Answer 7

Java 动态加载类，因此您的类世界将只是那些已经加载（尚未卸载）的类。 也许您可以使用自定义类加载器来检查每个加载类的超类型。 我不认为有一个 API 来查询加载的类集。

Answer 8

用这个

public static Set<Class> getExtendedClasses(Class superClass)
{
    try
    {
        ResolverUtil resolver = new ResolverUtil();
        resolver.findImplementations(superClass, superClass.getPackage().getName());
        return resolver.getClasses();  
    }
    catch(Exception e)
    {Log.d("Log:", " Err: getExtendedClasses() ");}

    return null;
}

getExtendedClasses(Animals.class);

编辑：

• (ResolverUtil) 的库：条纹

Answer 9

感谢所有回答这个问题的人。

看来这确实是一个难以破解的难题。 我最终放弃并在我的基类中创建了一个静态数组和 getter。

public abstract class Animal{
    private static Animal[] animals= null;
    public static Animal[] getAnimals(){
        if (animals==null){
            animals = new Animal[]{
                new Dog(),
                new Cat(),
                new Lion()
            };
        }
        return animals;
    }
}

似乎 Java 并没有像 C# 那样设置为可自我发现。 我想问题在于，由于 Java 应用程序只是某个目录/jar 文件中的 .class 文件的集合，因此运行时在引用类之前不知道该类。 那时加载程序加载它——我想做的是在我引用它之前发现它，如果不去文件系统并查看，这是不可能的。

我总是喜欢可以发现自己的代码，而不是我必须告诉它关于它自己，但可惜这也有效。

再次感谢！

Answer 10

使用OpenPojo，您可以执行以下操作：

String package = "com.mycompany";
List<Animal> animals = new ArrayList<Animal>();

for(PojoClass pojoClass : PojoClassFactory.enumerateClassesByExtendingType(package, Animal.class, null) {
  animals.add((Animal) InstanceFactory.getInstance(pojoClass));
}

Answer 11

这是一个棘手的问题，您需要使用静态分析找出这些信息，它在运行时不容易获得。 基本上获取您的应用程序的类路径并扫描可用类并读取它从哪个类继承的类的字节码信息。 请注意，Dog 类可能不会直接从 Animal 继承，而是可能从 Pet 继承，而 Pet 又从 Animal 继承，因此您需要跟踪该层次结构。

Answer 12

一种方法是让类使用静态初始值设定项......我不认为这些是继承的（如果它们是的话就行不通）：

public class Dog extends Animal{

static
{
   Animal a = new Dog();
   //add a to the List
}

它要求您将此代码添加到所有涉及的类中。 但它避免了在某处出现一个丑陋的大循环，测试每个类以寻找 Animal 的孩子。

Answer 13

我使用包级注释非常优雅地解决了这个问题，然后使该注释具有类列表作为参数。

查找实现接口的 Java 类

实现只需要创建一个 package-info.java 并将魔法注释放入他们想要支持的类列表中。

Answer 14

由于不推荐直接使用newInstance() ，因此您可以使用Reflections 以这种方式进行操作。

Reflections r = new Reflections("com.example.location.of.sub.classes")
Set<Class<? extends Animal>> classes = r.getSubTypesOf(Animal.class);

classes.forEach(c -> {
    Animal a = c.getDeclaredConstructor().newInstance();
    //a is your instance of Animal.
});