Во время выполнения найдите все классы в приложении 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, и он будет автоматически выбран.

ОБНОВЛЕНИЕ: 16.10.2008 9:00 по тихоокеанскому стандартному времени:

Этот вопрос вызвал много хороших ответов - спасибо. Из ответов и моих исследований я обнаружил, что то, что я действительно хочу сделать, просто невозможно в Java. Есть подходы, такие как механизм ServiceLoader ddimitrov, который может работать - но они очень тяжелы для того, что я хочу, и я считаю, что я просто перенесу проблему из кода 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- файлов. Это позволяет каждому банку экспортировать своих собственных провайдеров, и вы можете создавать их экземпляры путем отражения с помощью Class.forName ()

Подумайте об этом с аспектно-ориентированной точки зрения; на самом деле вы хотите знать все классы во время выполнения, которые расширили класс Animal. (Я думаю, что это немного более точное описание вашей проблемы, чем ваше название; в противном случае, я не думаю, что у вас есть вопрос времени выполнения.)

Поэтому я думаю, что вы хотите создать конструктор вашего базового класса (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.

К сожалению, это не совсем возможно, так как 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, и не будет работать под сервером приложений.

Вы можете использовать ResolverUtil ( необработанный источник ) из Stripes Framework
если вам нужно что-то простое и быстрое без рефакторинга какого-либо существующего кода.

Вот простой пример, не загружающий ни один из классов:

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): полосы

Спасибо всем, кто ответил на этот вопрос.

Кажется, это действительно крепкий орешек. В итоге я сдался и создал статический массив и геттер в своем базовом классе.

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, который в свою очередь наследует от Animal, поэтому вам нужно будет отслеживать эту иерархию.

Один из способов - заставить классы использовать статические инициализаторы ... Я не думаю, что они наследуются (это не сработает):

public class Dog extends Animal{

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

Требуется добавить этот код ко всем участвующим классам. Но это позволяет избежать больших уродливых циклов, где каждый класс ищет детей Animal.

Я решил эту проблему довольно элегантно, используя аннотации уровня пакета, а затем сделал эту аннотацию в качестве аргумента списком классов.

Найти классы Java, реализующие интерфейс

Реализации просто должны создать package-info.java и поместить волшебную аннотацию со списком классов, которые они хотят поддерживать.