Obteniendo todas las clases de un paquete

Question

Digamos que tengo un paquete java commands que contiene clases que todos heredan de ICommand ¿puedo obtener todas esas clases de alguna manera? Estoy buscando algo entre las líneas de:

Package p = Package.getPackage("commands"); 
Class<ICommand>[] c = p.getAllPackagedClasses(); //not real 

¿Es posible algo así?

Answer 1

Aquí hay un ejemplo básico, en el supuesto de que las clases no son JAR-envasados:

// Prepare. 
String packageName = "com.example.commands"; 
List<Class<ICommand>> commands = new ArrayList<Class<ICommand>>(); 
URL root = Thread.currentThread().getContextClassLoader().getResource(packageName.replace(".", "/")); 

// Filter .class files. 
File[] files = new File(root.getFile()).listFiles(new FilenameFilter() { 
    public boolean accept(File dir, String name) { 
     return name.endsWith(".class"); 
    } 
}); 

// Find classes implementing ICommand. 
for (File file : files) { 
    String className = file.getName().replaceAll(".class$", ""); 
    Class<?> cls = Class.forName(packageName + "." + className); 
    if (ICommand.class.isAssignableFrom(cls)) { 
     commands.add((Class<ICommand>) cls); 
    } 
} 

Answer 2

Comience con public Classloader.getResources (String name). Pídale al cargador de clases una clase correspondiente a cada nombre en el paquete que le interese. Repita para todos los clasificadores de relevancia.

Answer 3

Sí, pero no es lo más fácil de hacer. Hay muchos problemas con esto. No todas las clases son fáciles de encontrar. Algunas clases podrían estar en una: Tarro, como un archivo de clase, etc. través de la red

Tome una mirada at this thread.

Para asegurarse de que eran del tipo ICommand entonces usted tendría que utilizar la reflexión para comprobar la clase heredera

Answer 4

Aquí hay un método de utilidad, utilizando Spring.

Los detalles sobre el patrón se pueden encontrar here

public static List<Class> listMatchingClasses(String matchPattern) throws IOException { 
    List<Class> classes = new LinkedList<Class>(); 
    PathMatchingResourcePatternResolver scanner = new PathMatchingResourcePatternResolver(); 
    Resource[] resources = scanner.getResources(matchPattern); 

    for (Resource resource : resources) { 
     Class<?> clazz = getClassFromResource(resource); 
     classes.add(clazz); 
    } 

    return classes; 
} 



public static Class getClassFromResource(Resource resource) { 
    try { 
     String resourceUri = resource.getURI().toString(); 
     resourceUri = resourceUri.replace(esourceUri.indexOf(".class"), "").replace("/", "."); 
     // try printing the resourceUri before calling forName, to see if it is OK. 
     return Class.forName(resourceUri); 
    } catch (Exception ex) { 
     ex.printStackTrace(); 
    } 
    return null; 
} 

Answer 5

Esta sería una herramienta muy útil que necesitamos, y JDK debería proporcionar algo de apoyo.

Pero probablemente sea mejor hacerlo durante la compilación. Usted sabe dónde están todos sus archivos de clase y puede inspeccionarlos estáticamente y crear un gráfico. En tiempo de ejecución puede consultar este gráfico para obtener todos los subtipos. Esto requiere más trabajo, pero creo que realmente pertenece al proceso de compilación.

Answer 6

A continuación, una implementación usando los JSR-199 clases API es decir, desde javax.tools.*:

List<Class> commands = new ArrayList<Class>(); 

JavaCompiler compiler = ToolProvider.getSystemJavaCompiler(); 
StandardJavaFileManager fileManager = compiler.getStandardFileManager(
     null, null, null); 

Location location = StandardLocation.CLASS_PATH; 
String packageName = "commands"; 
Set<JavaFileObject.Kind> kinds = new HashSet<JavaFileObject.Kind>(); 
kinds.add(JavaFileObject.Kind.CLASS); 
boolean recurse = false; 

Iterable<JavaFileObject> list = fileManager.list(location, packageName, 
     kinds, recurse); 

for (JavaFileObject javaFileObject : list) { 
    commands.add(javaFileObject.getClass()); 
} 

Answer 7

Usando Johannes Link's ClasspathSuite, yo era capaz de hacerlo de esta manera:

import org.junit.extensions.cpsuite.ClassTester; 
import org.junit.extensions.cpsuite.ClasspathClassesFinder; 

public static List<Class<?>> getClasses(final Package pkg, final boolean includeChildPackages) { 
    return new ClasspathClassesFinder(new ClassTester() { 
     @Override public boolean searchInJars() { return true; } 
     @Override public boolean acceptInnerClass() { return false; } 
     @Override public boolean acceptClassName(String name) { 
      return name.startsWith(pkg.getName()) && (includeChildPackages || name.indexOf(".", pkg.getName().length()) != -1); 
     } 
     @Override public boolean acceptClass(Class<?> c) { return true; } 
    }, System.getProperty("java.class.path")).find(); 
} 

El ClasspathClassesFinder busca de clases archivos y jar en classpath del sistema.

En su caso específico, usted podría modificar acceptClass así:

@Override public boolean acceptClass(Class<?> c) { 
    return ICommand.class.isAssignableFrom(c); 
} 

Una cosa a tener en cuenta: cuidado con lo que regresa en acceptClassName, como el siguiente que ClasspathClassesFinder hace es cargar la clase y llamar a acceptClass . Si acceptClassName siempre devuelve verdadero, terminará cargando cada clase en la ruta de clase y eso puede causar un OutOfMemoryError.

Answer 8

Usted podría utilizar OpenPojo y hacer esto:

final List<PojoClass> pojoClasses = PojoClassFactory.getPojoClassesRecursively("my.package.path", null); 

entonces usted puede ir sobre la lista y realizar cualquier funcionalidad que usted desea.