Сканирование classpath/modulepath во время выполнения в Java 9

Я не могу найти какую-либо информацию о том, возможно ли сканирование всех доступных классов (для интерфейсов, аннотаций и т.д.) Во время выполнения, как это делают Spring, Reflections и многие другие фреймворки и библиотеки в настоящее время, несмотря на изменения Jigsaw, связанные с способ загрузки классов.

EDIT: Этот вопрос касается сканирования реальных физических путей к файлам в поисках классов. Другой вопрос касается динамической загрузки классов и ресурсов. Это связано, но очень не дубликат.

ОБНОВЛЕНИЕ: проект Jetty сделал предложение JEP для стандартизированного API для этого. Если у вас есть способ помочь сделать это реальностью, сделайте это. В противном случае, подождите и надейтесь.

ОБНОВЛЕНИЕ 2: Найдено этого соответствующего звучащего сообщения. Цитирую фрагмент кода для потомков:

Если вы действительно просто хотите узнать содержание модулей в загрузочный слой (модули, которые разрешаются при запуске), то вы будете делать как то так:

  ModuleLayer.boot().configuration().modules().stream()
         .map(ResolvedModule::reference)
         .forEach(mref -> {
             System.out.println(mref.descriptor().name());
             try (ModuleReader reader = mref.open()) {
                 reader.list().forEach(System.out::println);
            } catch (IOException ioe) {
                 throw new UncheckedIOException(ioe);
             }
         });

Ответ 1

Следующий код выполняет сканирование пути модуля в Java 9+ (Jigsaw). Он находит все классы в стеке вызовов, затем для каждой ссылки на класс вызывает classRef.getModule().getLayer().getConfiguration().modules(), которая возвращает a List<ResolvedModule>, а не просто List<Module>. (ResolvedModule предоставляет вам доступ к ресурсам модуля, а Module - нет.) Учитывая ссылку ResolvedModule для каждого модуля, вы можете вызвать метод .reference(), чтобы получить ModuleReference для модуля. ModuleReference#open() дает вам ModuleReader, который позволяет вам перечислять ресурсы в модуле, используя ModuleReader#list(), или открывать ресурс, используя Optional<InputStream> ModuleReader#open(resourcePath) или Optional<ByteBuffer> ModuleReader#read(resourcePath). Затем вы закрываете ModuleReader, когда закончите с модулем. Это не задокументировано нигде, что я видел. Было очень сложно все это понять. Но вот код, в надежде, что кто-то еще выиграет от этого.

Обратите внимание, что даже в JDK 9+ вы все равно можете использовать традиционные элементы classpath вместе с элементами пути к модулю, поэтому для полного сканирования пути к модулю + пути к классам вам, вероятно, следует использовать правильное решение для сканирования пути к классам, такое как ClassGraph, который поддерживает модуль сканирования с использованием приведенного ниже механизма (отказ от ответственности, я автор). Вы можете найти основанную на отражении версию следующего кода здесь.

Также обратите внимание, что в нескольких версиях JDK после JDK 9 была ошибка в StackWalker, которую необходимо обойти, см. подробности в приведенном выше коде, основанном на отражениях.

package main;

import java.lang.StackWalker;
import java.lang.StackWalker.Option;
import java.lang.StackWalker.StackFrame;
import java.lang.module.ModuleReader;
import java.lang.module.ModuleReference;
import java.lang.module.ResolvedModule;
import java.net.URI;
import java.security.AccessController;
import java.security.PrivilegedAction;
import java.util.AbstractMap.SimpleEntry;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Deque;
import java.util.HashSet;
import java.util.List;
import java.util.Map.Entry;
import java.util.Optional;
import java.util.Set;
import java.util.stream.Stream;

public class Java9Scanner {

    /** Recursively find the topological sort order of ancestral layers. */
    private static void findLayerOrder(ModuleLayer layer,
            Set<ModuleLayer> visited, Deque<ModuleLayer> layersOut) {
        if (visited.add(layer)) {
            List<ModuleLayer> parents = layer.parents();
            for (int i = 0; i < parents.size(); i++) {
                findLayerOrder(parents.get(i), visited, layersOut);
            }
            layersOut.push(layer);
        }
    }

    /** Get ModuleReferences from a Class reference. */
    private static List<Entry<ModuleReference, ModuleLayer>> findModuleRefs(
            Class<?>[] callStack) {
        Deque<ModuleLayer> layerOrder = new ArrayDeque<>();
        Set<ModuleLayer> visited = new HashSet<>();
        for (int i = 0; i < callStack.length; i++) {
            ModuleLayer layer = callStack[i].getModule().getLayer();
            findLayerOrder(layer, visited, layerOrder);
        }
        Set<ModuleReference> addedModules = new HashSet<>();
        List<Entry<ModuleReference, ModuleLayer>> moduleRefs = new ArrayList<>();
        for (ModuleLayer layer : layerOrder) {
            Set<ResolvedModule> modulesInLayerSet = layer.configuration()
                    .modules();
            final List<Entry<ModuleReference, ModuleLayer>> modulesInLayer =
                    new ArrayList<>();
            for (ResolvedModule module : modulesInLayerSet) {
                modulesInLayer
                        .add(new SimpleEntry<>(module.reference(), layer));
            }
            // Sort modules in layer by name for consistency
            Collections.sort(modulesInLayer,
                    (e1, e2) -> e1.getKey().descriptor().name()
                            .compareTo(e2.getKey().descriptor().name()));
            // To be safe, dedup ModuleReferences, in case a module occurs in multiple
            // layers and reuses its ModuleReference (no idea if this can happen)
            for (Entry<ModuleReference, ModuleLayer> m : modulesInLayer) {
                if (addedModules.add(m.getKey())) {
                    moduleRefs.add(m);
                }
            }
        }
        return moduleRefs;
    }

    /** Get the classes in the call stack. */
    private static Class<?>[] getCallStack() {
        // Try StackWalker (JDK 9+)
        PrivilegedAction<Class<?>[]> stackWalkerAction =
                (PrivilegedAction<Class<?>[]>) () ->
                    StackWalker.getInstance(
                            Option.RETAIN_CLASS_REFERENCE)
                    .walk(s -> s.map(
                            StackFrame::getDeclaringClass)
                            .toArray(Class[]::new));
        try {
            // Try with doPrivileged()
            return AccessController
                    .doPrivileged(stackWalkerAction);
        } catch (Exception e) {
        }
        try {
            // Try without doPrivileged()
            return stackWalkerAction.run();
        } catch (Exception e) {
        }

        // Try SecurityManager
        PrivilegedAction<Class<?>[]> callerResolverAction = 
                (PrivilegedAction<Class<?>[]>) () ->
                    new SecurityManager() {
                        @Override
                        public Class<?>[] getClassContext() {
                            return super.getClassContext();
                        }
                    }.getClassContext();
        try {
            // Try with doPrivileged()
            return AccessController
                    .doPrivileged(callerResolverAction);
        } catch (Exception e) {
        }
        try {
            // Try without doPrivileged()
            return callerResolverAction.run();
        } catch (Exception e) {
        }

        // As a fallback, use getStackTrace() to try to get the call stack
        try {
            throw new Exception();
        } catch (final Exception e) {
            final List<Class<?>> classes = new ArrayList<>();
            for (final StackTraceElement elt : e.getStackTrace()) {
                try {
                    classes.add(Class.forName(elt.getClassName()));
                } catch (final Throwable e2) {
                    // Ignore
                }
            }
            if (classes.size() > 0) {
                return classes.toArray(new Class<?>[0]);
            } else {
                // Last-ditch effort -- include just this class
                return new Class<?>[] { Java9Scanner.class };
            }
        }
    }

    /**
     * Return true if the given module name is a system module.
     * There can be system modules in layers above the boot layer.
     */
    private static boolean isSystemModule(
            final ModuleReference moduleReference) {
        String name = moduleReference.descriptor().name();
        if (name == null) {
            return false;
        }
        return name.startsWith("java.") || name.startsWith("jdk.")
            || name.startsWith("javafx.") || name.startsWith("oracle.");
    }

    public static void main(String[] args) throws Exception {
        // Get ModuleReferences for modules of all classes in call stack,
        List<Entry<ModuleReference, ModuleLayer>> systemModuleRefs = new ArrayList<>();
        List<Entry<ModuleReference, ModuleLayer>> nonSystemModuleRefs = new ArrayList<>();

        Class<?>[] callStack = getCallStack();
        List<Entry<ModuleReference, ModuleLayer>> moduleRefs = findModuleRefs(
                callStack);
        // Split module refs into system and non-system modules based on module name
        for (Entry<ModuleReference, ModuleLayer> m : moduleRefs) {
            (isSystemModule(m.getKey()) ? systemModuleRefs
                    : nonSystemModuleRefs).add(m);
        }

        // List system modules
        System.out.println("\nSYSTEM MODULES:\n");
        for (Entry<ModuleReference, ModuleLayer> e : systemModuleRefs) {
            ModuleReference ref = e.getKey();
            System.out.println("  " + ref.descriptor().name());
        }

        // Show info for non-system modules
        System.out.println("\nNON-SYSTEM MODULES:");
        for (Entry<ModuleReference, ModuleLayer> e : nonSystemModuleRefs) {
            ModuleReference ref = e.getKey();
            ModuleLayer layer = e.getValue();
            System.out.println("\n  " + ref.descriptor().name());
            System.out.println(
                    "    Version: " + ref.descriptor().toNameAndVersion());
            System.out.println(
                    "    Packages: " + ref.descriptor().packages());
            System.out.println("    ClassLoader: "
                    + layer.findLoader(ref.descriptor().name()));
            Optional<URI> location = ref.location();
            if (location.isPresent()) {
                System.out.println("    Location: " + location.get());
            }
            try (ModuleReader moduleReader = ref.open()) {
                Stream<String> stream = moduleReader.list();
                stream.forEach(s -> System.out.println("      File: " + s));
            }
        }
    }
}

Ответ 2

Настоящая проблема заключается в том, чтобы найти пути ко всем баночкам и папкам в пути к классам. Когда вы их получите, вы можете сканировать.

Я сделал следующее:

получить текущий дескриптор модуля для текущего класса
получить все requires модули
для каждого такого модуля открытый ресурс MANIFEST.MF
удалите путь MANIFEST.MF из URL ресурса
то, что остается, это путь к модулю, то есть к нему jar или папке.

Я делаю то же самое для текущего модуля, чтобы получить путь к классу для текущего кода.

Таким образом, я собираю classpath текущего работающего модуля и всех его необходимых модулей (в 1 шаге). Это работало для меня - и мой сканер Java8 все еще мог выполнять эту работу. Этот подход не требует дополнительного флага VM и т.д.

Я мог бы расширить этот подход, чтобы получить все необходимые модули легко (не только на первом уровне), но пока мне это не нужно.

Код.