Attributes

Following are some of the most important attributes defined by the Module class:

• ModuleLayer layer: Represents the layer that contains this module. The layer can also be null.

• String name: Represents the name of this module.

• ClassLoader loader: Represents the ClassLoader of this module.

• ModuleDescriptor descriptor: Represents the ModuleDescriptor of this module.

• Map<String, Set<Module>> exportedPackages: Represents the packages that are exported by this module.

• Map<String, Set<Module>> openPackages: Represents the packages that are open to other modules.

• Set<Module> reads: Represents the modules that this module reads.

• static final Module ALL_UNNAMED_MODULE: Represents a special module that defines the entire set of unnamed modules. An unnamed module has no ClassLoader object , no ModuleLayer object and no ModuleDescriptor object defined.

Constructors

The Module class has three types of constructors, as stated in the JDK 9 API specification:

• Module(ClassLoader loader): This constructor creates the unnamed module for the given ClassLoader. The ClassLoader object can also be null. An unnamed module contains no ModuleDescriptor and no ModuleLayer.

• Module(ClassLoader loader, ModuleDescriptor descriptor): This constructor creates a named module that’s not inside a ModuleLayer.

• Module(ModuleLayer layer, ClassLoader loader, ModuleDescriptor descriptor, URI uri): This constructor creates a named module inside a ModuleLayer, which means that the module is represented inside the virtual machine.

Methods

The most important methods defined by the Module class are, according to the JDK 9 API specification, the following:

• boolean isNamed(): Returns true if the module is a named module and false otherwise.

• String getName(): Returns the name of the module if the module is a named module. If the module is in an unnamed module, it returns null.

• ClassLoader getClassLoader(): Returns the ClassLoader for this module.

• ModuleDescriptor getDescriptor(): Returns the ModuleDescriptor for this module if the module is a named module. If the module is an unnamed module, it returns null.

• ModuleLayer getLayer(): Returns the ModuleLayer that contains this module. If this module is not in a module layer, it returns null. If the module is in an unnamed module, null is returned.

• boolean canRead(Module other): Returns true if this module reads the module given as parameter and false otherwise. If our module is an unnamed module, then true will be always returned, since an unnamed module reads all the modules.

• Module addReads(Module other): Updates this module to read the given module.

• boolean isExported(String packageName): Returns true if this module exports the given package. If our module is in an unnamed module, then true is by default returned. If the package is opened, then this method returns true because an opened package is also exported at runtime.

• boolean isExported(String packageName, Module other): Returns true if this module exports the given package to at least the given module.

• boolean isOpen(String packageName): Returns true if this module has opened the given package. If the module is in an unnamed module, then true is always returned.

• boolean isOpen(String packageName, Module other): Returns true if this module has opened the given package to at least the given module specified as the second parameter.

• Module addExports(String packageName, Module other): Updates this module to export the given package to the given module.

• Module addOpens(String packageName, Module other): Updates this module to open the given package to the given module.

• Module addUses(Class<?> service ): Updates this module to add a service dependence on the given service type.

• boolean canUse(Class<?> service): Returns true if this module has a service dependence on the given service type. If our module is an automatic module or is in an unnamed module, the method returns true by default.

• Set<String> getPackages(): Returns a set of package names for all the packages in this module.

• InputStream getResourceAsStream(String name): Returns an InputStream object for reading a resource in this module. The resource is identified by the given name.

ModuleDescriptor Attributes

The most important attributes defined by the ModuleDescriptor class are the following, and they’re described more fully in the next subsection:

• String name

• Version version

• Set<Modifier> modifiers

• boolean open

• boolean automatic

• Set<Requires> requires

• Set<Exports> exports

• Set<Opens> opens

• Set<String> uses

• Set<Provides> provides

• Set<String> packages

• String mainClass

• static enum Modifier {OPEN, AUTOMATIC, SYNTHETIC, MANDATED}

Next up: the most important methods of the ModuleDescriptor class.

ModuleDescriptor Methods

The JDK 9 API specification defines a couple of methods for the ModuleDescriptor class. The most important methods of the ModuleDescriptor class are as follows:

• String name(): Returns the name of the module.

• Set<Modifier> modifiers(): Returns a set of the Modifier enum, which represents the module modifiers. A Modifier enum contains the following values: OPEN, AUTOMATIC, SYNTHETHIC, and MANDATE. Modifier.OPEN denotes an open module. Modifier.AUTOMATIC represents an automatic module. Modifier.SYNTHETIC specifies that the module wasn’t declared, either explicitly nor implicitly. Modifier.MANDATED states that the module was implicitly declared.

• boolean isOpen(): Returns true if the module is open and false otherwise.

• boolean isAutomatic(): Returns true if this is an automatic module and false otherwise.

• Set<Requires> requires(): Returns a set of Requires objects that denote the dependencies of the module.

• Set<Exports> exports(): Returns a set of Exports objects that stand for the exported packages of the module.

• Set<Opens> opens(): Returns a set of Opens objects that represent the open packages.

• Set<String> uses(): Returns a set of Strings that represent the service dependencies of the module.

• Set<Provides> provides(): Returns a set of Provides objects that expresses the services provided by the module.

• Optional<Version> version(): Returns the version of the module.

• String toNameAndVersion(): Returns the module name and the version formatted as <module_name>@<version>.

• Optional<String> mainClass(): Returns the main class of the module.

• Set<String> packages(): Returns a set of Strings that expresses the packages from the module.

The following sections focus on the nested classes of the ModuleDescriptor class.

The ModuleDescriptor.Requires Class

The ModuleDescriptor.Requires class, whose instance expresses a requires clause in a module descriptor, contains some attributes and methods, described next.

It contains an enum called Modifier with the following values:

• TRANSITIVE: As stated in the official JDK 9 documentation, “this dependence causes any module which depends on current module to have an implicitly declared dependence on the module named by the requires.”

• STATIC: This dependence is mandatory at compile-time but is optional at runtime.

• SYNTHETIC: This dependence wasn’t declared in the module declaration.

• MANDATED: This dependence was declared in the module declaration.

The methods defined by the ModuleDescriptor.Requires class are as follows:

• Set<Modifier> modifiers(): Returns a set of Modifier objects

• String name(): Returns the name of the module

• Optional<Version> compiledVersion(): Returns a Version object representing the version of the module

• Optional<String> rawCompiledVersion(): Returns a String representing the unparseable version of the module

The ModuleDescriptor.Exports Class

The ModuleDescriptor.Exports class can be instantiated to express an exports clause inside the module declaration. The class contains an enum called Modifier with the following values: SYNTHETIC and MANDATED.

Here are the methods defined by this class:

• Set<Modifier> modifiers(): Returns a set of Modifier objects

• boolean isQualified(): Returns true if the export is qualified or false otherwise

• String source(): Returns a String representing the name of the package

• Set<String> targets(): Returns a set representing the names of the modules to which the package is exported. If the export is unqualified, it returns an empty set.

The ModuleDescriptor.Opens Class

The ModuleDescriptor.Opens class can be instantiated to express an opens clause inside the module declaration. The class contains an enum called Modifier with the following values: Modifier.SYNTHETIC and Modifier.MANDATED. In this case, MANDATED means that the opens statement was declared in the module declaration, and SYNTHETIC means that the opens statement was not declared in the module declaration.

According to the JDK 9 API specification, the methods defined by this class are as follows:

• Set<Modifier> modifiers(): Returns a set of Modifier objects.

• boolean isQualified(): Returns true if it is a qualified opens operation and false otherwise. A qualified opens operation is characterized by the fact that the modules to which the package is opened are specified in the module declaration. An unqualified opens operation doesn’t specify any modules in the module declaration, which means that the package is opened to all the modules.

• String source(): Returns the name of the package as String.

• Set<String> targets(): Returns a set of String that represents the names of the modules to which the package is open, but for an unqualified opens it returns an empty set.

The ModuleDescriptor.Provides Class

The ModuleDescriptor.Provides class is, in a manner of speaking, the correspondent of the provides statement from the module-info.java file. To recap, the provides statement’s role is to define a service type. The syntax of the provides statement is like this: provides <interface_name> with <class_name>, where <class_name> represents the implementation class for the service type defined by the interface with the name <interface_name>.

The ModuleDescriptor.Provides class defines the following variables: String service and List<String> providers. This means we can create one instance of the ModuleDescriptor.Provides class to define a single service and one or more providers.

There are two methods defined by the ModuleDescriptor.Provides class:

• String service(): This method returns the fully qualified class name of the service type.

• List<String> providers(): This method returns a list of Strings representing the fully qualified class names of the providers or provider factories.

Further, we can define three provides statements inside our module descriptor:

module com.apress.myModule {
        provides ServiceType1 with package1.Class1;
        provides ServiceType1 with package1.Class2;
        provides ServiceType1 with package2.Class3;
}

Because we have only a single instance of the service type, we have only one instance of the class ModuleDescriptor.Provides. We can get all the names of the providers classes by calling the method providers() and the name of the service type by calling the method service().

The ModuleDescriptor.Version Class

The nested class ModuleDescriptor.Version represents the version of a module. The version of a module is used only for documentation, because the JPMS does not support versioning. The most used methods provided by the ModuleDescriptor.Version class are as follows:

• Version parse(String): Parses the given String as a version String

• int compareTo(Version version): Compares this module version to the given module version

Getting the Module of a Class

As we already learned in this chapter, a module at runtime is expressed by the Module class defined in package java.lang of the module java.base. The Module class can represent either a named or unnamed module. In order to return a Module object for our class called ModuleCore, we call the method getModule() of the class Class:

Class<ModuleCore> myClass = ModuleCore.class;
Module module = myClass.getModule();

This method returns a module that the class ModuleCore is a member of. If the class is in the unnamed module, the method getUnnamedModule() from ClassLoader.java is called.

Accessing Resources of a Module

Listing 9-2 shows how we can access resources of the module using the getResourceAsStream() method , which returns an InputStream object.

Listing 9-2. Accessing Resources of a Module Using Method getResourceAsStream()

this.class.getModule().getResourceAsStream("file.properties");

We can also access resources of a module using the getResource() method, which returns a URL object, as in Listing 9-3.

Listing 9-3. Accessing Resources of a Module Using Method getResource()

this.getClass().getResource("file.properties")
ClassLoader.getPlatformClassLoader().getResource("file.properties")

Searching for all Modules in the Module Path

Using the new module API, we can even find all the modules in the module path . Listing 9-4 shows how to search for all the modules in the module path in the system environment variable jdk.module.path, get their module descriptors, and print their module names.

Listing 9-4. Searching for All the Modules in the Module Path

ModuleFinder.of(Paths.get(System.getProperty("jdk.module.path"))).
        .findAll()
        .stream()
        .forEach(ref -> {
                System.out.println(moduleReference.descriptor().name());
});

Getting Module Information

Using the methods and classes described throughout this chapter, we can get complete information about a module. Listing 9-5 shows an example where we make use of the new classes and interfaces in order to get all the available information from the module java.base.

Listing 9-5. Print Extensive Information from Module java.base

import java.lang.module.ModuleDescriptor;
import java.lang.module.ModuleFinder;
import java.lang.module.ModuleReference;
import java.util.NoSuchElementException;
import java.util.Optional;
import java.util.Set;

public class BaseModule {

    public static void main(String[] args) {

        String moduleName;
        Optional<String> mainClass;
        Set<ModuleDescriptor.Exports> exports;
        boolean isAutomatic;
        boolean isOpen;
        Set<String> allPackagesNames;
        Set<ModuleDescriptor.Provides> provides;
        Set<ModuleDescriptor.Requires> dependencies;
        String moduleNameVersion;
        Set<String> serviceDependencies;
        ModuleDescriptor.Version version;

        ModuleFinder finder = ModuleFinder.ofSystem();
        Optional<ModuleReference> moduleReference = finder.find("java.base");

        if(moduleReference.isPresent()) {
            ModuleDescriptor moduleDescriptor = moduleReference.get().descriptor();

            // get the name of the module
            moduleName = moduleDescriptor.name();

            // get the module's main class
            mainClass = moduleDescriptor.mainClass();
            exports = moduleDescriptor.exports();
            isAutomatic = moduleDescriptor.isAutomatic();
            isOpen = moduleDescriptor.isOpen();
            allPackagesNames = moduleDescriptor.packages();
            provides = moduleDescriptor.provides();
            dependencies = moduleDescriptor.requires();
            moduleNameVersion = moduleDescriptor.toNameAndVersion();
            serviceDependencies = moduleDescriptor.uses();

            try {                                                                              
                Optional<ModuleDescriptor.Version> versionOptional = moduleDescriptor.version();
                version = versionOptional.get();
            }
            catch (NoSuchElementException exception) {
                version = null;
            }

            System.out.println("Module name is: " + moduleName);
            System.out.println();

            System.out.println("Main class is: ");
            if(mainClass.isPresent())  {
                System.out.println(mainClass);
            }
            else {
                System.out.println("Not exists");
            }
            System.out.println();

            System.out.println("The module exports the packages with the following name: ");
            for(ModuleDescriptor.Exports moduleExport : exports) {
                System.out.print(moduleExport.source());
                System.out.print(", ");
            }

            System.out.println();
            System.out.println();
            System.out.println("Is an automatic module: " + isAutomatic);

            System.out.println();
            System.out.println("Is an open module: " + isOpen);

            System.out.println();
            System.out.println("All packages names: ");
            for(String packageName : allPackagesNames) {
                System.out.print(packageName);
                System.out.print(", ");
            }

            System.out.println();
            System.out.println();
            System.out.println("The services provided by the module: ");
            for(ModuleDescriptor.Provides provide : provides) {
                System.out.print("Service " + provide.service());
                for(String p : provide.providers()) {
                    System.out.print(" with providers: " + p);
                    System.out.print(", ");
                }
            }
                                                                                  
            System.out.println();
            System.out.println("The name of the dependencies of the module: ");
            for(ModuleDescriptor.Requires dependency : dependencies) {
                System.out.print(dependency.name());
                System.out.print(", ");
            }

            System.out.println();
            System.out.println("Module name and version: " + moduleNameVersion);

            System.out.println();
            System.out.println("The service dependencies of the module: ");
            for(String serviceDependency : serviceDependencies) {
                System.out.print(serviceDependency);
                System.out.print(", ");
            }

            System.out.println();
            System.out.println("The version of the module: " + version);
        }
    }
}

We use the interface ModuleFinder to locate all the system modules. On the resulting object, we call the find() method and pass the string "java.base" representing the module’s name. This will return a ModuleReference to the java.base module. We verify whether the ModuleReference was found using the isPresent() method. Further, we call the descriptor() method on the ModuleReference object in order to get the module descriptor. The ModuleDescriptor object contains comprehensive information about a module, such as its name, its main class, its packages, its dependencies, its service dependencies, its provided services, its version name, and so on. We retrieve this information and print it. Listing 9-6 shows only the most important parts of the output.

Listing 9-6. Output After Running the Preceding Code that Prints the Information Regarding Module java.base

Module name is: java.base

Main class is:
Not exists

The module exports the packages with the following name:
jdk.internal.module, javax.net.ssl, java.time.format, java.nio.charset.spi, sun.security.ssl, sun.security.pkcs, sun.security.internal.interfaces, jdk.internal.util.jar, java.security.interfaces, sun.util.logging, jdk.internal.perf, java.util.function, sun.net.util, jdk.internal.misc, javax.security.auth.login, sun.security.x509, sun.security.rsa, jdk.internal.util.xml, jdk.internal, java.util.jar, java.util.regex, sun.security.action, jdk.internal.jmod, java.util.stream,
.........................................................
                                                                                  

Is an automatic module: false

Is an open module: false

All packages names:
jdk.internal.org.objectweb.asm.signature, sun.text.bidi, sun.text.normalizer, sun.security.action, sun.util.logging, sun.security.internal.interfaces, jdk.internal.jimage.decompressor, jdk.internal.util.jar, java.net.spi, sun.reflect.generics.factory, sun.util.resources.cldr, sun.security.tools, com.sun.java.util.jar.pack, java.text.spi, java.nio, jdk.internal.ref, sun.security.tools.keytool, java.security.spec, sun.security.util, java.nio.channels.spi, sun.net.www.protocol.ftp, java.util, sun.util.cldr, sun.reflect.generics.reflectiveObjects, java.util.spi, java.lang.ref,
..............................

The services provided by the module:
Service java.nio.file.spi.FileSystemProvider with providers: jdk.internal.jrtfs.JrtFileSystemProvider,
The name of the dependencies of the module:

Module name and version: java.base@9

The service dependencies of the module:
java.util.spi.LocaleNameProvider, jdk.internal.logger.DefaultLoggerFinder, java.lang.System$LoggerFinder, sun.util.resources.LocaleData$SupplementaryResourceBundleProvider, java.text.spi.NumberFormatProvider, java.time.chrono.Chronology, java.util.spi.CalendarNameProvider, java.text.spi.DateFormatSymbolsProvider, java.time.zone.ZoneRulesProvider, sun.text.spi.JavaTimeDateTimePatternProvider, java.text.spi.DecimalFormatSymbolsProvider
..........................

The version of the module: 9