En tiempo de ejecución, se encuentran todas las clases en una aplicación Java que se extienden una clase base

Question

que quiero hacer algo como esto:

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

lo tanto, quiero mirar a todas las clases en el universo de mi solicitud, y cuando encuentro uno que desciende de Animal, quiero crear un nuevo objeto de ese tipo y agregarlo a la lista. Esto me permite agregar funcionalidad sin tener que actualizar una lista de cosas. Puedo evitar lo siguiente:

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

Con el enfoque anterior, simplemente puede crear una nueva clase de animal que se extiende y va a ser recogido de forma automática.

ACTUALIZACIÓN: 10/16/2008 9 a.m. hora estándar del Pacífico:

Esta cuestión ha generado una gran cantidad de grandes respuestas - gracias. A partir de las respuestas y mi investigación, descubrí que lo que realmente quiero hacer simplemente no es posible en Java. Existen enfoques, como el mecanismo ServiceLoader de ddimitrov, que pueden funcionar, pero son muy pesados ​​para lo que yo quiero, y creo que simplemente transfiero el problema del código de Java a un archivo de configuración externo.

Otra forma de expresar lo que quiero: una función estática en mi clase Animal encuentra e instaura todas las clases que heredan de Animal, sin ninguna configuración/codificación adicional. Si tengo que configurar, también podría instanciarlos en la clase Animal de todos modos. Entiendo que debido a que un programa Java es solo una federación suelta de archivos .class, esa es la forma en que es.

Curiosamente, parece que es fairly trivial en C#.

Answer 1

utilizo org.reflections:

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

Answer 2

Java carga dinámicamente las clases, por lo que su universo de clases sería solo aquellas que ya se han cargado (y aún no se han descargado). Quizás pueda hacer algo con un cargador de clases personalizado que pueda verificar los supertipos de cada clase cargada. No creo que haya una API para consultar el conjunto de clases cargadas.

Answer 3

Desafortunadamente, esto no es del todo posible ya que ClassLoader no le dirá qué clases están disponibles. Puede, sin embargo, conseguir bastante cerca de hacer algo como esto:

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

Editar: johnstok es correcto (en los comentarios) que esto sólo funciona para las aplicaciones Java autónomas, y no funcionarán bajo un servidor de aplicaciones .

Answer 4

Este es un problema difícil y tendrá que averiguar esta información mediante el análisis estático, no está disponible fácilmente en tiempo de ejecución. Básicamente, obtenga el classpath de su aplicación y escanee las clases disponibles y lea la información del bytecode de una clase de la que hereda. Tenga en cuenta que una clase Dog puede no heredar directamente de Animal pero puede heredar de Pet, que a su vez hereda de Animal, por lo que deberá realizar un seguimiento de esa jerarquía.

Answer 5

Gracias a todos los que respondieron esta pregunta.

Parece que es un hueso duro de roer. Terminé rindiéndome y creando una matriz estática y getter en mi clase base.

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

Parece que Java simplemente no está configurado para la auto-descubrimiento de la manera en que C# es. Supongo que el problema es que ya que una aplicación Java es solo una colección de.archivos de clase en un directorio/archivo jar en alguna parte, el tiempo de ejecución no sabe acerca de una clase hasta que se haga referencia a ella. En ese momento el cargador lo carga, lo que intento hacer es descubrirlo antes de hacer referencia a él, lo que no es posible sin tener que salir al sistema de archivos y mirar.

Siempre me gusta el código que puede descubrirse a sí mismo en lugar de tener que contarlo, pero esto también funciona.

¡Gracias nuevamente!

Answer 6

Una forma es hacer que las clases utilizan un inicializadores estáticos ... No creo que éstos son heredadas (no va a funcionar si son):

public class Dog extends Animal{ 

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

Se requiere que se agregue este código para todas las clases involucradas. Pero evita tener un gran bucle feo en alguna parte, probando cada clase buscando niños de Animal.

Answer 7

Piense en esto desde un punto de vista orientado al aspecto; lo que realmente quieres hacer es conocer todas las clases en tiempo de ejecución que HAN extendido la clase Animal. (Creo que es una descripción un poco más precisa de su problema que su título, de lo contrario, no creo que tenga una pregunta en tiempo de ejecución)

Entonces, lo que creo que quiere es crear un constructor de su clase base (Animal) que agrega a su matriz estática (prefiero ArrayLists, yo mismo, pero a cada uno de ellos) el tipo de clase actual que se está instanciando.

Así, aproximadamente;

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

Por supuesto, se necesita un constructor estático en el animal para inicializar instantiatedDerivedClass ... Creo que esto va a hacer lo que es probable que desee. Tenga en cuenta que esto depende de la ruta de ejecución; si tiene una clase de Perro que deriva de Animal que nunca se invoca, no la tendrá en su lista de Animal Class.

Answer 8

La forma Java de hacer lo que quiera es usar el mecanismo ServiceLoader.

También muchas personas obtienen su propio rollo al tener un archivo en una ubicación classpath conocida (es decir /META-INF/services/myplugin.properties) y luego usar ClassLoader.getResources() para enumerar todos los archivos con este nombre de todos los jar. Esto permite que cada jar exporte sus propios proveedores y usted puede instanciarlos por reflejo usando Class.forName()

Answer 9

Resolví este problema de manera muy elegante usando anotaciones de nivel de paquete y luego haciendo esa anotación tengo como argumento una lista de clases.

Find Java classes implementing an interface

implementaciones sólo hay que crear un package-info.java y poner la anotación con la magia en la lista de clases que quieran apoyar.

Answer 10

Usted podría utilizar ResolverUtil (raw source) de la Stripes Framework
si necesita algo sencillo y rápido sin refactorización el código existente.

Aquí hay un ejemplo simple de no haber cargado cualquiera de las clases:

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

Esto también funciona en un servidor de aplicaciones, así, ya que es donde se diseñó para trabajar;)

El código hace básicamente lo siguiente:

• iterar sobre todos los recursos en el paquete (s) se especifica
• mantener sólo º recursos electrónicos que terminan en .class
• carga las clases utilizando ClassLoader#loadClass(String fullyQualifiedName)
• Comprueba si Animal.class.isAssignableFrom(loadedClass);

Answer 11

Usando OpenPojo puede hacer lo siguiente:

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