Java Code Examples for java.lang.module.Configuration#modules()

/**
 * Checks a configuration and the module-to-loader mapping to ensure that
 * no two modules mapped to the same class loader have the same package.
 * It also checks that no two automatic modules have the same package.
 *
 * @throws LayerInstantiationException
 */
private static void checkForDuplicatePkgs(Configuration cf,
                                          Function<String, ClassLoader> clf)
{
    // HashMap allows null keys
    Map<ClassLoader, Set<String>> loaderToPackages = new HashMap<>();
    for (ResolvedModule resolvedModule : cf.modules()) {
        ModuleDescriptor descriptor = resolvedModule.reference().descriptor();
        ClassLoader loader = clf.apply(descriptor.name());

        Set<String> loaderPackages
            = loaderToPackages.computeIfAbsent(loader, k -> new HashSet<>());

        for (String pkg : descriptor.packages()) {
            boolean added = loaderPackages.add(pkg);
            if (!added) {
                throw fail("More than one module with package %s mapped" +
                           " to the same class loader", pkg);
            }
        }
    }
}
 

/**
 * Creates a pool of class loaders. Each module in the given configuration
 * is mapped to its own class loader in the pool. The class loader is
 * created with the given parent class loader as its parent.
 */
public LoaderPool(Configuration cf,
                  List<ModuleLayer> parentLayers,
                  ClassLoader parentLoader)
{
    Map<String, Loader> loaders = new HashMap<>();
    for (ResolvedModule resolvedModule : cf.modules()) {
        Loader loader = new Loader(resolvedModule, this, parentLoader);
        String mn = resolvedModule.name();
        loaders.put(mn, loader);
    }
    this.loaders = loaders;

    // complete the initialization
    loaders.values().forEach(l -> l.initRemotePackageMap(cf, parentLayers));
}
 

/**
 * Load/register the modules to the built-in class loaders.
 */
private static void loadModules(Configuration cf,
                                Function<String, ClassLoader> clf) {
    for (ResolvedModule resolvedModule : cf.modules()) {
        ModuleReference mref = resolvedModule.reference();
        String name = resolvedModule.name();
        ClassLoader loader = clf.apply(name);
        if (loader == null) {
            // skip java.base as it is already loaded
            if (!name.equals(JAVA_BASE)) {
                BootLoader.loadModule(mref);
            }
        } else if (loader instanceof BuiltinClassLoader) {
            ((BuiltinClassLoader) loader).loadModule(mref);
        }
    }
}
 

/**
 * Checks for split packages between modules defined to the built-in class
 * loaders.
 */
private static void checkSplitPackages(Configuration cf,
                                       Function<String, ClassLoader> clf) {
    Map<String, String> packageToModule = new HashMap<>();
    for (ResolvedModule resolvedModule : cf.modules()) {
        ModuleDescriptor descriptor = resolvedModule.reference().descriptor();
        String name = descriptor.name();
        ClassLoader loader = clf.apply(name);
        if (loader == null || loader instanceof BuiltinClassLoader) {
            for (String p : descriptor.packages()) {
                String other = packageToModule.putIfAbsent(p, name);
                if (other != null) {
                    String msg = "Package " + p + " in both module "
                                 + name + " and module " + other;
                    throw new LayerInstantiationException(msg);
                }
            }
        }
    }
}
 

/**
 * Checks incubating status of modules in the configuration
 */
private static void checkIncubatingStatus(Configuration cf) {
    String incubating = null;
    for (ResolvedModule resolvedModule : cf.modules()) {
        ModuleReference mref = resolvedModule.reference();

        // emit warning if the WARN_INCUBATING module resolution bit set
        if (ModuleResolution.hasIncubatingWarning(mref)) {
            String mn = mref.descriptor().name();
            if (incubating == null) {
                incubating = mn;
            } else {
                incubating += ", " + mn;
            }
        }
    }
    if (incubating != null)
        warn("Using incubator modules: " + incubating);
}
 

/**
 * Returns the function to map modules in the given configuration to the
 * built-in class loaders.
 */
static Function<String, ClassLoader> mappingFunction(Configuration cf) {
    Set<String> bootModules = bootModules();
    Set<String> platformModules = platformModules();

    ClassLoader platformClassLoader = ClassLoaders.platformClassLoader();
    ClassLoader appClassLoader = ClassLoaders.appClassLoader();

    Map<String, ClassLoader> map = new HashMap<>();
    for (ResolvedModule resolvedModule : cf.modules()) {
        String mn = resolvedModule.name();
        if (!bootModules.contains(mn)) {
            if (platformModules.contains(mn)) {
                map.put(mn, platformClassLoader);
            } else {
                map.put(mn, appClassLoader);
            }
        }
    }
    return new Mapper(map);
}
 

/**
 * Checks a configuration and the module-to-loader mapping to ensure that
 * no two modules mapped to the same class loader have the same package.
 * It also checks that no two automatic modules have the same package.
 *
 * @throws LayerInstantiationException
 */
private static void checkForDuplicatePkgs(Configuration cf,
                                          Function<String, ClassLoader> clf)
{
    // HashMap allows null keys
    Map<ClassLoader, Set<String>> loaderToPackages = new HashMap<>();
    for (ResolvedModule resolvedModule : cf.modules()) {
        ModuleDescriptor descriptor = resolvedModule.reference().descriptor();
        ClassLoader loader = clf.apply(descriptor.name());

        Set<String> loaderPackages
            = loaderToPackages.computeIfAbsent(loader, k -> new HashSet<>());

        for (String pkg : descriptor.packages()) {
            boolean added = loaderPackages.add(pkg);
            if (!added) {
                throw fail("More than one module with package %s mapped" +
                           " to the same class loader", pkg);
            }
        }
    }
}
 

/**
 * Creates a pool of class loaders. Each module in the given configuration
 * will be loaded its own class loader in the pool. The class loader is
 * created with the given parent class loader as its parent.
 */
public LoaderPool(Configuration cf,
                  List<ModuleLayer> parentLayers,
                  ClassLoader parentLoader)
{
    Map<String, Loader> loaders = new HashMap<>();
    for (ResolvedModule resolvedModule : cf.modules()) {
        Loader loader = new Loader(resolvedModule, this, parentLoader);
        String mn = resolvedModule.name();
        loaders.put(mn, loader);
    }
    this.loaders = loaders;

    // complete the initialization
    loaders.values().forEach(l -> l.initRemotePackageMap(cf, parentLayers));
}
 

/**
 * Load/register the modules to the built-in class loaders.
 */
private static void loadModules(Configuration cf,
                                Function<String, ClassLoader> clf) {
    for (ResolvedModule resolvedModule : cf.modules()) {
        ModuleReference mref = resolvedModule.reference();
        String name = resolvedModule.name();
        ClassLoader loader = clf.apply(name);
        if (loader == null) {
            // skip java.base as it is already loaded
            if (!name.equals(JAVA_BASE)) {
                BootLoader.loadModule(mref);
            }
        } else if (loader instanceof BuiltinClassLoader) {
            ((BuiltinClassLoader) loader).loadModule(mref);
        }
    }
}
 

/**
 * Checks for split packages between modules defined to the built-in class
 * loaders.
 */
private static void checkSplitPackages(Configuration cf,
                                       Function<String, ClassLoader> clf) {
    Map<String, String> packageToModule = new HashMap<>();
    for (ResolvedModule resolvedModule : cf.modules()) {
        ModuleDescriptor descriptor = resolvedModule.reference().descriptor();
        String name = descriptor.name();
        ClassLoader loader = clf.apply(name);
        if (loader == null || loader instanceof BuiltinClassLoader) {
            for (String p : descriptor.packages()) {
                String other = packageToModule.putIfAbsent(p, name);
                if (other != null) {
                    String msg = "Package " + p + " in both module "
                                 + name + " and module " + other;
                    throw new LayerInstantiationException(msg);
                }
            }
        }

    }
}
 

/**
 * Checks incubating status of modules in the configuration
 */
private static void checkIncubatingStatus(Configuration cf) {
    String incubating = null;
    for (ResolvedModule resolvedModule : cf.modules()) {
        ModuleReference mref = resolvedModule.reference();

        // emit warning if the WARN_INCUBATING module resolution bit set
        if (ModuleResolution.hasIncubatingWarning(mref)) {
            String mn = mref.descriptor().name();
            if (incubating == null) {
                incubating = mn;
            } else {
                incubating += ", " + mn;
            }
        }
    }
    if (incubating != null)
        warn("Using incubator modules: " + incubating);
}
 

/**
 * Returns the function to map modules in the given configuration to the
 * built-in class loaders.
 */
static Function<String, ClassLoader> mappingFunction(Configuration cf) {
    Set<String> bootModules = bootModules();
    Set<String> platformModules = platformModules();

    ClassLoader platformClassLoader = ClassLoaders.platformClassLoader();
    ClassLoader appClassLoader = ClassLoaders.appClassLoader();

    Map<String, ClassLoader> map = new HashMap<>();
    for (ResolvedModule resolvedModule : cf.modules()) {
        String mn = resolvedModule.name();
        if (!bootModules.contains(mn)) {
            if (platformModules.contains(mn)) {
                map.put(mn, platformClassLoader);
            } else {
                map.put(mn, appClassLoader);
            }
        }
    }
    return new Mapper(map);
}
 

/**
 * Creates a new module layer by defining the modules in the given {@code
 * Configuration} to the Java virtual machine. This method creates one
 * class loader and defines all modules to that class loader.
 *
 * <p> The class loader created by this method implements <em>direct
 * delegation</em> when loading classes from modules. If the {@link
 * ClassLoader#loadClass(String, boolean) loadClass} method is invoked to
 * load a class then it uses the package name of the class to map it to a
 * module. This may be a module in this layer and hence defined to the same
 * class loader. It may be a package in a module in a parent layer that is
 * exported to one or more of the modules in this layer. The class
 * loader delegates to the class loader of the module, throwing {@code
 * ClassNotFoundException} if not found by that class loader.
 * When {@code loadClass} is invoked to load classes that do not map to a
 * module then it delegates to the parent class loader. </p>
 *
 * <p> The class loader created by this method locates resources
 * ({@link ClassLoader#getResource(String) getResource}, {@link
 * ClassLoader#getResources(String) getResources}, and other resource
 * methods) in all modules in the layer before searching the parent class
 * loader. </p>
 *
 * <p> Attempting to create a layer with all modules defined to the same
 * class loader can fail for the following reasons:
 *
 * <ul>
 *
 *     <li><p> <em>Overlapping packages</em>: Two or more modules in the
 *     configuration have the same package. </p></li>
 *
 *     <li><p> <em>Split delegation</em>: The resulting class loader would
 *     need to delegate to more than one class loader in order to load
 *     classes in a specific package. </p></li>
 *
 * </ul>
 *
 * <p> In addition, a layer cannot be created if the configuration contains
 * a module named "{@code java.base}", or a module contains a package named
 * "{@code java}" or a package with a name starting with "{@code java.}". </p>
 *
 * <p> If there is a security manager then the class loader created by
 * this method will load classes and resources with privileges that are
 * restricted by the calling context of this method. </p>
 *
 * @param  cf
 *         The configuration for the layer
 * @param  parentLayers
 *         The list of parent layers in search order
 * @param  parentLoader
 *         The parent class loader for the class loader created by this
 *         method; may be {@code null} for the bootstrap class loader
 *
 * @return A controller that controls the newly created layer
 *
 * @throws IllegalArgumentException
 *         If the parent(s) of the given configuration do not match the
 *         configuration of the parent layers, including order
 * @throws LayerInstantiationException
 *         If all modules cannot be defined to the same class loader for any
 *         of the reasons listed above
 * @throws SecurityException
 *         If {@code RuntimePermission("createClassLoader")} or
 *         {@code RuntimePermission("getClassLoader")} is denied by
 *         the security manager
 *
 * @see #findLoader
 */
public static Controller defineModulesWithOneLoader(Configuration cf,
                                                    List<ModuleLayer> parentLayers,
                                                    ClassLoader parentLoader)
{
    List<ModuleLayer> parents = new ArrayList<>(parentLayers);
    checkConfiguration(cf, parents);

    checkCreateClassLoaderPermission();
    checkGetClassLoaderPermission();

    try {
        Loader loader = new Loader(cf.modules(), parentLoader);
        loader.initRemotePackageMap(cf, parents);
        ModuleLayer layer = new ModuleLayer(cf, parents, mn -> loader);
        return new Controller(layer);
    } catch (IllegalArgumentException | IllegalStateException e) {
        throw new LayerInstantiationException(e.getMessage());
    }
}
 

/**
 * Creates a new module layer by defining the modules in the given {@code
 * Configuration} to the Java virtual machine. This method creates one
 * class loader and defines all modules to that class loader.
 *
 * <p> The class loader created by this method implements <em>direct
 * delegation</em> when loading classes from modules. If the {@link
 * ClassLoader#loadClass(String, boolean) loadClass} method is invoked to
 * load a class then it uses the package name of the class to map it to a
 * module. This may be a module in this layer and hence defined to the same
 * class loader. It may be a package in a module in a parent layer that is
 * exported to one or more of the modules in this layer. The class
 * loader delegates to the class loader of the module, throwing {@code
 * ClassNotFoundException} if not found by that class loader.
 * When {@code loadClass} is invoked to load classes that do not map to a
 * module then it delegates to the parent class loader. </p>
 *
 * <p> The class loader created by this method locates resources
 * ({@link ClassLoader#getResource(String) getResource}, {@link
 * ClassLoader#getResources(String) getResources}, and other resource
 * methods) in all modules in the layer before searching the parent class
 * loader. </p>
 *
 * <p> Attempting to create a layer with all modules defined to the same
 * class loader can fail for the following reasons:
 *
 * <ul>
 *
 *     <li><p> <em>Overlapping packages</em>: Two or more modules in the
 *     configuration have the same package. </p></li>
 *
 *     <li><p> <em>Split delegation</em>: The resulting class loader would
 *     need to delegate to more than one class loader in order to load
 *     classes in a specific package. </p></li>
 *
 * </ul>
 *
 * <p> In addition, a layer cannot be created if the configuration contains
 * a module named "{@code java.base}", or a module contains a package named
 * "{@code java}" or a package with a name starting with "{@code java.}". </p>
 *
 * <p> If there is a security manager then the class loader created by
 * this method will load classes and resources with privileges that are
 * restricted by the calling context of this method. </p>
 *
 * @param  cf
 *         The configuration for the layer
 * @param  parentLayers
 *         The list of parent layers in search order
 * @param  parentLoader
 *         The parent class loader for the class loader created by this
 *         method; may be {@code null} for the bootstrap class loader
 *
 * @return A controller that controls the newly created layer
 *
 * @throws IllegalArgumentException
 *         If the parent configurations do not match the configuration of
 *         the parent layers, including order
 * @throws LayerInstantiationException
 *         If all modules cannot be defined to the same class loader for any
 *         of the reasons listed above
 * @throws SecurityException
 *         If {@code RuntimePermission("createClassLoader")} or
 *         {@code RuntimePermission("getClassLoader")} is denied by
 *         the security manager
 *
 * @see #findLoader
 */
public static Controller defineModulesWithOneLoader(Configuration cf,
                                                    List<ModuleLayer> parentLayers,
                                                    ClassLoader parentLoader)
{
    List<ModuleLayer> parents = new ArrayList<>(parentLayers);
    checkConfiguration(cf, parents);

    checkCreateClassLoaderPermission();
    checkGetClassLoaderPermission();

    try {
        Loader loader = new Loader(cf.modules(), parentLoader);
        loader.initRemotePackageMap(cf, parents);
        ModuleLayer layer =  new ModuleLayer(cf, parents, mn -> loader);
        return new Controller(layer);
    } catch (IllegalArgumentException | IllegalStateException e) {
        throw new LayerInstantiationException(e.getMessage());
    }
}