実行時に、基本クラスを拡張する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() );

そのため、アプリケーションのユニバース内のすべてのクラスを確認し、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コードから外部構成ファイルに移すだけだと思います。 19年5月10日更新（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クラスを拡張したすべてのクラスを知っていることです。（私はそれがタイトルよりも少し正確な問題の説明だと思います。それ以外の場合は、実行時の質問はないと思います。）

だから私があなたが望むのは、インスタンス化されている現在のクラスのタイプを静的配列に追加する基本クラス（動物）のコンストラクターを作成することです（私はArrayLists、自分自身が好きですが、それぞれ独自のものです）。

だいたい、

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

もちろん、instantiatedDerivedClassを初期化するには、Animalの静的コンストラクターが必要になります...これはおそらくあなたが望むことを行うと思います。これは実行パスに依存することに注意してください。決して呼び出されないAnimalから派生する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（rawソース）を使用できます。

以下は、クラスをロードしていない簡単な例です。

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);

特定のクラスのすべてのサブクラスをリストするための最も堅牢なメカニズムは、新しいJPMSモジュールシステムを含むクラスパス指定メカニズムの可能な限り幅広い配列を処理するため、現在はClassGraphです。（私は著者です。）

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）のライブラリ：ストライプ

この質問に答えたすべての人に感謝します。

これは確かにクラックするのが難しいナットのようです。結局、私のベースクラスに静的配列とゲッターをあきらめて作成してしまいました。

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アプリが.classファイルのコレクションであり、どこかディレクトリ/ jarファイルにあるため、ランタイムはクラスが参照されるまでクラスを認識しないということです。その時、ローダーはそれをロードします-私がしようとしていることは、それを参照する前にそれを発見することです。

私は自分自身について語る代わりに、自分自身を発見できるコードがいつも好きですが、悲しいかな、これもうまくいきます。

再度、感謝します！

使用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から継承されます。したがって、その階層を追跡する必要があります。

1つの方法は、クラスに静的初期化子を使用させることです...これらは継承されているとは思われません（継承されている場合は機能しません）。

public class Dog extends Animal{

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

関係するすべてのクラスにこのコードを追加する必要があります。しかし、どこかに大きな醜いループができるのを避け、すべてのクラスをテストして、Animalの子を検索します。

パッケージレベルのアノテーションを使用してこの問題をかなりエレガントに解決し、そのアノテーションに引数としてクラスのリストを含めました。

インターフェースを実装するJavaクラスを見つける

実装は、package-info.javaを作成し、サポートしたいクラスのリストとともに魔法の注釈を入れるだけです。