ClassScanner.java

import java.lang.module.Configuration;
import java.lang.module.ModuleReader;
import java.lang.module.ModuleReference;
import java.lang.module.ResolvedModule;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;

/**
 * A utility class for scanning and loading classes from Java modules.
 */
public class ClassScanner {

 // Private constructor to prevent instantiation from outside
 private ClassScanner() {}

 // Static instance of ClassScanner (singleton instance, created eagerly)
 private static final ClassScanner INSTANCE = new ClassScanner();

 /**
 * Provides access to the singleton instance of ClassScanner.
 * @return the singleton instance of ClassScanner
 */
 public static ClassScanner getInstance() {
 return INSTANCE;
 }

 /**
 * Static method to get the list of all classes found in the modules.
 * Uses the singleton instance to perform the scan.
 * 
 * @return List of classes found across Java modules
 */
 public static List<Class<?>> totalClasses() {
 return INSTANCE.performClassScan(); // Calls the private method that performs the scanning
 }

 /**
 * Performs the actual class scanning by iterating through modules in the boot layer.
 * Only classes within "java." and "jdk." packages are scanned, and only exported packages are included.
 * 
 * @return List of Class&lt;?&gt; objects representing the scanned classes
 */
 private List<Class<?>> performClassScan() {
 List<Class<?>> classes = new ArrayList<>(); // List to store discovered classes
 ModuleLayer bootLayer = ModuleLayer.boot(); // Gets the boot layer, which contains core Java modules
 Configuration bootConfig = bootLayer.configuration();

 // Iterate over modules in the boot layer that start with "java." or "jdk."
 bootLayer.modules().stream()
 .filter(module -> module.getName().startsWith("java.") || module.getName().startsWith("jdk."))
 .forEach(module -> {
 // Resolve each module in the configuration, if available
 Optional<ResolvedModule> resolved = bootConfig.findModule(module.getName());
 resolved.ifPresent(rm -> {
 ModuleReference ref = rm.reference();
 // Use ModuleReader to list entries in the module
 try (ModuleReader reader = ref.open()) {
 reader.list().forEach(s -> {
 // Check if entry is a .class file but not a special info file
 if (s.endsWith(".class") && !(s.equals("package-info.class") || s.equals("module-info.class") || s.equals("META-INF.class"))) {
 String packageName = s.substring(0, s.lastIndexOf('/')).replace('/', '.');
 String className = s.replace('/', '.').substring(0, s.length() - ".class".length());
 // Check if the package is exported from the module
 if (module.isExported(packageName)) {
 try {
 // Load the class by its name
 Class<?> clazz = Class.forName(className);
 if (!classes.contains(clazz)) classes.add(clazz); // Add if not already in the list
 System.out.println("Loaded: " + clazz.getName());
 } catch (ClassNotFoundException | SecurityException e) {
 System.out.println("Type not found: " + e.getMessage());
 }
 }
 }
 });
 } catch (IOException e) {
 System.out.println("Could not open Module: " + e.getMessage());
 }
 });
 });
 return classes; // Return the list of loaded classes
 }
}