Können Sie mit Hilfe von Reflection alle Klassen in einem Paket finden?

Question

Ist es möglich, alle Klassen oder Schnittstellen in einem bestimmten Paket zu finden? (Ein schneller Blick auf z.B. Package scheint das nicht der Fall zu sein.)

Answer 1

Aufgrund der dynamischen Natur von Klassenladern ist dies nicht möglich. Klassenlader sind nicht verpflichtet, der VM mitzuteilen, welche Klassen sie bereitstellen können. Stattdessen werden ihnen lediglich Anforderungen für Klassen übergeben, und sie müssen eine Klasse zurückgeben oder eine Ausnahme auslösen.

Wenn Sie jedoch Ihre eigenen Klassenlader schreiben oder die Klassenpfade und die Jars untersuchen, ist es möglich, diese Informationen zu finden. Dies geschieht jedoch über Dateisystemoperationen und nicht über Reflexion. Vielleicht gibt es sogar Bibliotheken, die Ihnen dabei helfen können.

Wenn es Klassen gibt, die aus der Ferne erzeugt oder geliefert werden, können Sie diese Klassen nicht erkennen.

Die normale Methode ist stattdessen, die Klassen, auf die Sie Zugriff benötigen, irgendwo in einer Datei zu registrieren oder sie in einer anderen Klasse zu referenzieren. Oder verwenden Sie einfach Konventionen, wenn es um die Namensgebung geht.

Nachtrag: Die Bibliothek der Reflexionen ermöglicht es Ihnen, im aktuellen Klassenpfad nach Klassen zu suchen. Es kann verwendet werden, um alle Klassen in einem Paket zu erhalten:

 Reflections reflections = new Reflections("my.project.prefix");

 Set<Class<? extends Object>> allClasses = 
     reflections.getSubTypesOf(Object.class);

Answer 2

Vielleicht sollten Sie sich die Open-Source-Software Bibliothek der Reflexionen . Mit ihm können Sie leicht erreichen, was Sie wollen.

Richten Sie zunächst den Reflexionsindex ein (er ist ein wenig unübersichtlich, da die Suche nach allen Klassen standardmäßig deaktiviert ist):

List<ClassLoader> classLoadersList = new LinkedList<ClassLoader>();
classLoadersList.add(ClasspathHelper.contextClassLoader());
classLoadersList.add(ClasspathHelper.staticClassLoader());

Reflections reflections = new Reflections(new ConfigurationBuilder()
    .setScanners(new SubTypesScanner(false /* don't exclude Object.class */), new ResourcesScanner())
    .setUrls(ClasspathHelper.forClassLoader(classLoadersList.toArray(new ClassLoader[0])))
    .filterInputsBy(new FilterBuilder().include(FilterBuilder.prefix("org.your.package"))));

Dann können Sie nach allen Objekten in einem bestimmten Paket suchen:

Set<Class<?>> classes = reflections.getSubTypesOf(Object.class);

Answer 3

Sie könnten verwenden diese Methode 1 die den ClassLoader .

/**
 * Scans all classes accessible from the context class loader which belong to the given package and subpackages.
 *
 * @param packageName The base package
 * @return The classes
 * @throws ClassNotFoundException
 * @throws IOException
 */
private static Class[] getClasses(String packageName)
        throws ClassNotFoundException, IOException {
    ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
    assert classLoader != null;
    String path = packageName.replace('.', '/');
    Enumeration<URL> resources = classLoader.getResources(path);
    List<File> dirs = new ArrayList<File>();
    while (resources.hasMoreElements()) {
        URL resource = resources.nextElement();
        dirs.add(new File(resource.getFile()));
    }
    ArrayList<Class> classes = new ArrayList<Class>();
    for (File directory : dirs) {
        classes.addAll(findClasses(directory, packageName));
    }
    return classes.toArray(new Class[classes.size()]);
}

/**
 * Recursive method used to find all classes in a given directory and subdirs.
 *
 * @param directory   The base directory
 * @param packageName The package name for classes found inside the base directory
 * @return The classes
 * @throws ClassNotFoundException
 */
private static List<Class> findClasses(File directory, String packageName) throws ClassNotFoundException {
    List<Class> classes = new ArrayList<Class>();
    if (!directory.exists()) {
        return classes;
    }
    File[] files = directory.listFiles();
    for (File file : files) {
        if (file.isDirectory()) {
            assert !file.getName().contains(".");
            classes.addAll(findClasses(file, packageName + "." + file.getName()));
        } else if (file.getName().endsWith(".class")) {
            classes.add(Class.forName(packageName + '.' + file.getName().substring(0, file.getName().length() - 6)));
        }
    }
    return classes;
}

__________
_{¹Diese Methode wurde ursprünglich übernommen von <a href="http://snippets.dzone.com/posts/show/4831" rel="noreferrer">http://snippets.dzone.com/posts/show/4831 </a>das war <a href="https://web.archive.org/web/20090227113602/http://snippets.dzone.com:80/posts/show/4831" rel="noreferrer">archiviert </a>durch das Internet Archive, wie jetzt verlinkt. Das Snippet ist auch verfügbar unter <a href="https://dzone.com/articles/get-all-classes-within-package" rel="noreferrer">https://dzone.com/articles/get-all-classes-within-package </a>.}

Answer 4

Google Guava 14 enthält eine neue Klasse ClassPath mit drei Methoden, um nach Klassen der obersten Ebene zu suchen:

• getTopLevelClasses()
• getTopLevelClasses(String packageName)
• getTopLevelClassesRecursive(String packageName)

Siehe die ClassPath javadocs für weitere Informationen.

Answer 5

Frühling

Dieses Beispiel ist für Spring 4, aber Sie können den Klassenpfad-Scanner auch in früheren Versionen finden.

// create scanner and disable default filters (that is the 'false' argument)
final ClassPathScanningCandidateComponentProvider provider = new ClassPathScanningCandidateComponentProvider(false);
// add include filters which matches all the classes (or use your own)
provider.addIncludeFilter(new RegexPatternTypeFilter(Pattern.compile(".*")));

// get matching classes defined in the package
final Set<BeanDefinition> classes = provider.findCandidateComponents("my.package.name");

// this is how you can load the class type from BeanDefinition instance
for (BeanDefinition bean: classes) {
    Class<?> clazz = Class.forName(bean.getBeanClassName());
    // ... do your magic with the class ...
}

Google Guava

Note : In Version 14 ist die API noch als @Beta also Vorsicht im Produktionscode.

final ClassLoader loader = Thread.currentThread().getContextClassLoader();

for (final ClassPath.ClassInfo info : ClassPath.from(loader).getTopLevelClasses()) {
  if (info.getName().startsWith("my.package.")) {
    final Class<?> clazz = info.load();
    // do something with your clazz
  }
}