W czasie wykonywania Znajdź wszystkie klasy w aplikacji Java, które rozszerzają klasę bazową

Sposobem Javy, aby zrobić to, co chcesz, jest użycie mechanizmu ServiceLoader .

Również wiele osób robi swoje, mając plik w znanej lokalizacji classpath (np. / META-INF/services / myplugin.właściwości), a następnie używając ClassLoader.getResources () aby wyliczyć wszystkie pliki o tej nazwie ze wszystkich słoików. Pozwala to każdemu jar eksportować własnych dostawców i można utworzyć ich instancję przez odbicie za pomocą klasy.forName ()

Pomyśl o tym z punktu widzenia aspektu; to, co chcesz zrobić, naprawdę, to znać wszystkie klasy w czasie wykonywania, które rozszerzyły klasę zwierząt. (Myślę, że jest to nieco dokładniejszy opis Twojego problemu niż tytuł; w przeciwnym razie, nie sądzę, że masz pytanie runtime.)

Więc myślę, że chcesz stworzyć konstruktor swojej klasy bazowej (Animal), który dodaje do tablicy statycznej (wolę ArrayLists, sam, ale do każdej z nich) Typ bieżąca Klasa, która jest tworzona.

Więc z grubsza;

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

Oczywiście, będziesz potrzebował statycznego konstruktora na Animalu, aby zainicjować instantiatedDerivedClass... Myślę, że to zrobi to, czego prawdopodobnie chcesz. Zauważ, że jest to zależne od ścieżki wykonania; jeśli masz klasę psa, która wywodzi się od zwierzęcia, które nigdy nie zostanie wywołane, nie będziesz mieć jej na liście klas zwierząt.

Niestety nie jest to całkowicie możliwe, ponieważ ClassLoader nie powie Ci, jakie klasy są dostępne. Można jednak podejść dość blisko robiąc coś takiego:

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
            }
        }
    }
}

Edit: johnstok ma rację (w komentarzach), że to działa tylko dla samodzielnych aplikacji Java i nie będzie działać pod serwerem aplikacji.

Możesz użyć ResolverUtil (raw source ) z frameworka
jeśli potrzebujesz czegoś prostego i szybkiego bez refaktoryzacji istniejącego kodu.

Oto prosty przykład bez załadowania żadnej z klas:

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 {}

Kod zasadniczo wykonuje następujące czynności:

• iteracja wszystkich zasobów w pakiecie) określasz
• Zachowaj tylko zasoby kończące się.Klasa
• załaduj te klasy używając ClassLoader#loadClass(String fullyQualifiedName)
• sprawdza, czy Animal.class.isAssignableFrom(loadedClass);

Java dynamicznie ładuje klasy, więc twój wszechświat klas będzie tylko tymi, które zostały już załadowane (i nie zostały jeszcze rozładowane). Być może możesz zrobić coś z niestandardowym ładowaniem klas, które może sprawdzić supertypy każdej załadowanej klasy. Myślę, że nie ma API do odpytywania zestawu załadowanych klas.

Dziękuję wszystkim, którzy odpowiedzieli na to pytanie.

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

Wydaje się, że Java po prostu nie jest skonfigurowana do samodzielnego odkrywania, tak jak C#. Przypuszczam, że problem polega na tym, że ponieważ aplikacja Java jest tylko zbiorem .pliki klas znajdujące się gdzieś w katalogu / pliku jar, środowisko wykonawcze nie wie o klasie, dopóki nie zostanie do niej odwołane. W tym czasie ładowarka Ładuje próbuję go odkryć, zanim się do niego odwołam, co nie jest możliwe bez wyjścia do systemu plików i szukania.

Zawsze lubię kod, który może się odkryć, zamiast mówić o sobie, ale niestety to też działa.

Jeszcze raz dziękuję!

Używając OpenPojo możesz wykonać następujące czynności:

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

Użyj tego

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

Edit:

• biblioteka dla (ResolverUtil):

Spróbuj ClassGraph . (Zastrzeżenie, jestem autorem). Dla podanego przykładu, Kod ClassGraph będzie:

List<Animal> animals =
    new ClassGraph()
        .whitelistPackages("com.zoo.animals")
        .enableAllInfo()
        .scan()
        .getSubclasses(Animal.class.getName())
        .loadClasses(Animal.class);

ClassGraph może zrobić o wiele więcej niż to -- Sprawdź API .

Jest to trudny problem i musisz dowiedzieć się tych informacji za pomocą analizy statycznej, jej nie jest łatwo dostępne w czasie wykonywania. Zasadniczo Pobierz classpath swojej aplikacji i przeskanuj dostępne klasy i odczytaj informacje o kodzie bajtowym klasy, od której dziedziczy. Zauważ, że pies klasowy może nie dziedziczyć bezpośrednio od zwierzęcia, ale może dziedziczyć od zwierzęcia, które jest dziedziczeniem turn od zwierzęcia,więc będziesz musiał śledzić tę hierarchię.

Jednym ze sposobów jest zmuszenie klas do użycia statycznych inicjalizatorów... Nie sądzę, że są dziedziczone (nie zadziała, jeśli są):

public class Dog extends Animal{

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

Wymaga dodania tego kodu do wszystkich klas. Ale unika gdzieś Wielkiej brzydkiej pętli, testując każdą klasę w poszukiwaniu dzieci zwierząt.

Rozwiązałem ten problem dość elegancko używając adnotacji na poziomie pakietu, a następnie sprawiając, że adnotacja ma jako argument listę klas.

Znajdź klasy Java implementujące interfejs

Implementacje muszą tylko utworzyć pakiet-info.java i umieść magiczną adnotację z listą klas, które chcą obsługiwać.