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

我想做这样的事情：

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的新类，它将自动被拾取。

更新：10/16/2008 9:00 AM太平洋标准时间：

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

声明我想要的另一种方式：Animal类中的静态函数查找并实例化了从Animal继承的所有类-无需任何进一步的配置/编码。如果必须进行配置，无论如何，我还是可以在Animal类中实例化它们。我了解这是因为Java程序只是.class文件的松散联合，而事实就是如此。

有趣的是，这似乎在C＃中是微不足道的。

我使用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());
        }
    }
}

执行所需操作的Java方法是使用ServiceLoader机制。

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

从面向方面的角度考虑这一点；实际上，您想做的是知道运行时已扩展Animal类的所有类。（我认为这是对您的问题的描述，比标题更准确；否则，我认为您没有运行时问题。）

因此，我认为您想要的是创建基类（Animal）的构造函数，该构造函数将要实例化的当前Class的类型添加到您的静态数组中（我个人更喜欢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 Class列表中找到它。

不幸的是，这并非完全可能，因为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应用程序，在应用程序服务器下不起作用。

如果您需要简单快捷的方法而无需重构任何现有代码，则可以使用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);

列出给定类的所有子类的最健壮的机制是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);
}

Java动态地加载类，因此您的类的范围将仅是那些已经加载（但尚未卸载）的类。也许您可以使用自定义类加载器执行某些操作，该加载器可以检查每个已加载类的超类型。我认为没有API可以查询一组已加载的类。

用这个

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）：条纹

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

看来这确实是一个难以克服的难题。我最终放弃了在基类中创建一个静态数组和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文件的集合，因此运行库直到被引用才知道类。那时，加载程序加载了它-我想做的是在我引用它之前先发现它，这是不访问文件系统并查找的情况。

我一直喜欢可以发现自己的代码，而不必告诉我有关自身的信息，但是but，这也行得通。

再次感谢！

使用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));
}

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

一种方法是使类使用静态初始化器...我不认为它们是继承的（如果它们是不起作用的）：

public class Dog extends Animal{

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

它要求您将此代码添加到所有涉及的类中。但这避免了在某个地方出现一个大的丑陋循环，测试每个班级搜索Animal的孩子。

我使用Package Level Annotations很好地解决了这个问题，然后使该注释具有一个类列表作为参数。

查找实现接口的Java类

实现只需创建一个package-info.java并将魔术批注放入要支持的类的列表中即可。