Hol dir alle Klassen aus einem Paket

Question

Sagen wir, ich habe ein Java-Paket commands, das Klassen enthält, die alle von ICommand erben, kann ich alle diese Klassen irgendwie bekommen? Ich sperre für etwas zwischen den Zeilen:

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

Ist so etwas möglich?

Answer 1

Hier ist ein einfaches Beispiel unter der Annahme gefunden werden, dass Klassen nicht JAR-verpackt:

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

Starten Sie mit öffentlichen Classloader.getResources (String-Name). Fragen Sie den Klassenlader nach einer Klasse, die jedem Namen in dem Paket entspricht, an dem Sie interessiert sind. Wiederholen Sie dies für alle relevanten Klassenlader.

Answer 3

Ja, aber es ist nicht die einfachste Sache zu tun. Es gibt viele Probleme damit. Nicht alle Klassen sind leicht zu finden. Einige Klassen könnten in einem: Glas, als Klassendatei über das Netzwerk usw.

Werfen Sie einen Blick at this thread.

Um sicherzustellen, dass sie der ICommand Typ dann müßten Sie Reflexion verwenden, um das zu überprüfen Klasse erben.

Answer 4

Hier ist eine Hilfsmethode, die Spring verwendet.

Details zum Muster können 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

Dies ist ein sehr nützliches Werkzeug, das wir brauchen würde, und JDK sollte etwas Unterstützung bieten.

Aber es ist wahrscheinlich besser während des Builds getan. Sie wissen, wo sich alle Ihre Klassendateien befinden, und Sie können sie statisch untersuchen und ein Diagramm erstellen. Zur Laufzeit können Sie dieses Diagramm abfragen, um alle Subtypen zu erhalten. Das erfordert mehr Arbeit, aber ich glaube, es gehört wirklich zum Build-Prozess.

Answer 6

Im Folgenden eine Implementierung der JSR-199 API dh Klassen von javax.tools.* mit:

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

Johannes Link's ClasspathSuite Verwendung, konnte ich es, wie dies tun:

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

Die ClasspathClassesFinder für Klasse sieht Dateien und Gläser im Systemklassenpfad.

In Ihrem speziellen Fall könnten Sie acceptClass wie folgt ändern:

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

Eine Sache zu beachten: Seien Sie vorsichtig, was Sie in acceptClassName zurückkehren, wie das nächste, was ClasspathClassesFinder tut, ist die Klasse zu laden und rufen acceptClass . Wenn acceptClassName immer true zurückgibt, wird am Ende jede Klasse im Klassenpfad geladen, was zu einem OutOfMemoryError führen kann.

Answer 8

könnten Sie OpenPojo verwenden und dies tun:

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

Dann können Sie die Liste durchgehen und führen Sie alle Funktionen, die Sie sich wünschen.