Java Platform Module System

The Java Platform Module System ^[1] specifies a distribution format for collections of Java code and associated resources. It also specifies a repository for storing these collections, or modules , and identifies how they can be discovered, loaded and checked for integrity. It includes features such as namespaces with the aim of fixing some of the shortcomings in the existing JAR format, especially the JAR Hell, which can lead to issues such as classpath and class loading problems.

The Java Module System was initially being developed under the Java Community Process as JSR 277 and was scheduled to be released with Java 7.

JSR 277 later was put on hold and Project Jigsaw ^[2] was created to modularize the JDK. This JSR was superseded by JSR 376 (Java Platform Module System).

Project Jigsaw was originally intended for Java 7 (2011) but was deferred to Java 8 (2014) as part of Plan B, ^[3] and again deferred to a Java 9 release in 2017. ^[4] Java 9 including the Java Module System was released on September 21, 2017. ^[5]

Architecture

The Java Module System implemented in Java 9 includes the following JEPs and JSR (Java Specification Request): ^[2]

• JEP 200: The Modular JDK: Define a modular structure for the JDK
• JEP 201: Modular Source Code: Reorganize the JDK source code into modules, enhance the build system to compile modules, and enforce module boundaries at build time
• JEP 220: Modular Run-Time Images: Restructure the JDK and JRE run-time images to accommodate modules and to improve performance, security, and maintainability
• JEP 261: Module System: Implement the Java Platform Module System
• JEP 282: The Java Linker: Create a tool that can assemble and optimize a set of modules and their dependencies into a custom run-time image ^[6]
• JSR 376: Java Platform Module System ^[7]

Additionally, several other JDK 9 features have been added to ease transition to the module system:

• JEP 238: Multi-Release JAR Files: Extend the JAR file format to allow multiple, Java-release-specific versions of class files to coexist in a single archive. ^[8]
• JEP 253: Prepare JavaFX UI Controls & CSS APIs for Modularization: Define public APIs for the JavaFX functionalities that is presently only available via internal APIs and would become inaccessible due to modularization. ^[9]
• JEP 260: Encapsulate Most Internal APIs: Make most of the JDK's internal APIs inaccessible by default but leave a few critical, widely-used internal APIs accessible, until supported replacements exist for all or most of their functionality. ^[10]
• JEP 275: Modular Java Application Packaging: The Java packager will evolve for JDK 9, making it aware of modules, allowing for example to package a module and all the modules it depends on. ^[11]

Properties of modules

Modules are used to group packages and tightly control what packages belong to the public API. Contrary to Jar files, modules explicitly declare which modules they depend on, and what packages they export. ^[12] Explicit dependency declarations improve the integrity of the code, by making it easier to reason about large applications and the dependencies between software components.

The module declaration is placed in a file named module-info.java at the root of the module’s source-file hierarchy. The JDK will verify dependencies and interactions between modules both at compile-time and runtime.

For example, the following module declaration declares that the module com.foo.bar depends on another com.foo.baz module, and exports the following packages: com.foo.bar.alpha and com.foo.bar.beta:

modulecom.foo.bar{requirescom.foo.baz;exportscom.foo.bar.alpha;exportscom.foo.bar.beta;}

The public members of com.foo.bar.alpha and com.foo.bar.beta packages will be accessible by dependent modules. Private members are inaccessible even through a means such as reflection. Note that in Java versions 9 through 16, whether such 'illegal access' is de facto permitted depends on a command line setting. ^[13]

The JDK itself has been modularized in Java 9. ^[14] For example, the majority of the Java standard library is exported by the module java.base.

As of Java 25, modules can themselves be imported, automatically importing all exported packages. ^[15] This is done using import module. For example, importmodulejava.sql; is equivalent to

importjava.sql.*;importjavax.sql.*;// Remaining indirect exports from java.logging, java.transaction.xa, and java.xml

Similarly, importmodulejava.base;, similarly, imports all 54 packages belonging to java.base.

importmodulejava.base;/** * importing module java.base allows us to avoid manually importing most classes * the following classes (outside of java.lang) are used: * java.text.MessageFormat * java.util.Date * java.util.List * java.util.concurrent.ThreadLocalRandom */publicclassExample{publicstaticvoidmain(String[]args){List<String>colours=List.of("Red","Orange","Yellow","Green","Blue","Indigo","Violet");IO.println(MessageFormat.format("My favourite colour is {0} and today is {1,date,long}",colours.get(ThreadLocalRandom.current().nextInt(colours.size())),newDate()));}}

Modules use the following keywords:

• exports: used in a module declaration to specify which packages are available to other modules
• module: declares a module
• open: indicates that all classes in a package are accessible via reflection by other modules
• opens: used to open a specific package for reflection to other modules
• provides: used to declare that a module provides an implementation of a service interface
• requires: used in a module declaration to specify that the module depends on another module
• to: used with the opens directive to specify which module is allowed to reflectively access the package
• transitive: used with the requires directive to indicate that a module not only requires another module but also makes that module's dependencies available to modules that depend on it
• uses: used in a module to declare that the module is using a service (i.e. it will consume a service provided by other modules)
• with: used with the provides directive to specify which implementation of a service is provided by the module

Standard modules

Core modules

The modules under namespace java.* belong to the Java Platform, Standard Edition, and modules under namespace jdk.* belong to the Java Development Kit. ^[16]

Name	Description
java.base	Defines the core APIs that form the foundation of the Java SE Platform. Implicitly required by all modules and does not need to be declared with requires inside a module declaration.
java.compiler	Defines APIs related to the language model, Java annotation processing, and the Java compiler.
java.datatransfer	Defines the APIs that facilitate data transfer between applications or within an application.
java.desktop	Defines the Abstract Window Toolkit (AWT) and Swing libraries for user interfaces, along with APIs for accessibility, audio, imaging, printing, and JavaBeans.
java.instrument	Defines services that allow for the instrumentation of programs running on the Java Virtual Machine (JVM).
java.logging	Defines the API for logging events in Java applications (Java Logging API).
java.management	Defines the APIs for the Java Management Extensions (JMX) framework.
java.management.rmi	Defines the Remote Method Invocation (RMI) connector for the Java Management Extensions (JMX) Remote API.
java.naming	Defines the API for Java Naming and Directory Interface (JNDI) services.
java.net.http	Defines the API for HTTP client and WebSocket functionality.
java.prefs	Defines the API for managing and storing user preferences.
java.rmi	Defines the Remote Method Invocation (RMI) API for object communication across Java virtual machines.
java.scripting	Defines the API for integrating scripting engines into Java applications (Scripting API).
java.se	Defines the standard API for the Java SE Platform.
java.security.jgss	Defines the Java binding for the IETF Generic Security Services API (GSS-API) for security contexts.
java.security.sasl	Defines Java's support for the Simple Authentication and Security Layer (SASL) protocol.
java.smartcardio	Defines the API for interacting with smart card devices (Java Smart Card I/O API).
java.sql	Defines the Java Database Connectivity (JDBC) API for database interaction.
java.sql.rowset	Defines the JDBC RowSet API for managing and interacting with tabular data in Java.
java.transaction.xa	Defines an API for managing distributed transactions within JDBC.
java.xml	Defines the Java API for XML Processing (JAXP), including tools for parsing and transforming XML data.
java.xml.crypto	Defines the API for cryptographic operations with XML data.
jdk.accessibility	Defines utility classes for implementing Assistive Technologies in the JDK.
jdk.attach	Defines the attach API for connecting to and interacting with a running JVM instance (attach API).
jdk.charsets	Provides additional character sets (charsets), including double-byte and IBM-specific charsets, not included in java.base.
jdk.compiler	Defines the internal implementation of the Java compiler and the command-line tool javac .
jdk.crypto.cryptoki	Defines the implementation of the SunPKCS11 security provider for cryptographic operations.
jdk.dynalink	Defines the API for dynamically linking high-level operations on objects.
jdk.editpad	Implements the edit pad service used by jdk.jshell for evaluating code.
jdk.hotspot.agent	Provides the implementation for the HotSpot Serviceability Agent.
jdk.httpserver	Defines the JDK-specific HTTP server API and the jwebserver tool for running a simple HTTP server.
jdk.incubator.vector	Defines the API for expressing computations that can be compiled into SIMD instructions at runtime, such as AVX or NEON instructions.
jdk.jartool	Provides tools for manipulating Java Archive (JAR) files, such as the jar and jarsigner commands.
jdk.javadoc	Defines the system documentation tool implementation and its command-line version, javadoc .
jdk.jcmd	Defines tools for diagnosing and troubleshooting JVM processes, including jcmd, jps, and jstat.
jdk.jconsole	Defines the JMX-based graphical tool, jconsole , for monitoring and managing Java applications.
jdk.jdeps	Defines tools for analysing dependencies in Java programs and libraries, such as jdeps, javap, jdeprscan, and jnativescan.
jdk.jdi	Defines the Java Debug Interface (JDI) for debugging Java applications.
jdk.jdwp.agent	Provides the implementation of the Java Debug Wire Protocol (JDWP) agent for remote debugging.
jdk.jfr	Defines the API for JDK Flight Recorder (JFR) for collecting performance and diagnostic data.
jdk.jlink	Defines the jlink tool for creating custom runtime images, and jmod and jimage tools for managing JMOD and JDK container files.
jdk.jpackage	Defines the Java packager tool (jpackage) for creating platform-specific application packages.
jdk.jshell	Provides the jshell tool for interactively evaluating Java code snippets.
jdk.jsobject	Defines the API for integrating JavaScript objects in Java applications.
jdk.jstatd	Defines the jstatd tool for remotely monitoring JVM statistics.
jdk.localedata	Provides locale-specific data for non-US locales.
jdk.management	Defines JDK-specific management interfaces for JVM monitoring and control.
jdk.management.agent	Defines the JMX-based management agent for the JVM.
jdk.management.jfr	Defines the management interface for JDK Flight Recorder (JFR).
jdk.naming.dns	Implements the DNS Java Naming provider for resolving domain names.
jdk.naming.rmi	Implements the RMI Java Naming provider for remote method invocation.
jdk.net	Defines the JDK-specific API for network programming.
jdk.nio.mapmode	Defines specific file mapping modes available in the JDK.
jdk.sctp	Provides the API for Stream Control Transmission Protocol (SCTP) in the JDK.
jdk.security.auth	Implements authentication modules and security-related interfaces within the javax.security.auth package (interfaces in javax.security.auth.*).
jdk.security.jgss	Defines extensions to the GSS-API and the implementation of the SASL GSSAPI mechanism in the JDK.
jdk.xml.dom	Defines the JDK's subset of the World Wide Web Consortium (W3C) Document Object Model (DOM) API not covered by Java SE. Exports packages outside of the java namespace (from org.w3c.dom).
jdk.zipfs	Provides the implementation for the ZIP file system provider, enabling access to ZIP files as file systems.

Jakarta EE, formerly part of the Java standard library, is not modularised, however build systems can generate automatic modules for it.

JavaFX modules

JavaFX was previously bundled with the core JDK, until Java 11 when it was split into OpenJFX. JavaFX is split into the following modules. ^[17]

Name	Description
javafx.base	Defines core APIs for the JavaFX UI toolkit (such as APIs for bindings, properties, collections, and events).
javafx.controls	Defines the APIs for UI controls, charts, skins in the JavaFX UI toolkit.
javafx.fxml	Defines the FXML APIs in the JavaFX UI toolkit.
javafx.graphics	Defines scenegraph, animation, geometry, and other related APIs for the JavaFX UI toolkit.
javafx.media	Defines media playback and audio content APIs for the JavaFX UI toolkit.
javafx.swing	Defines JavaFX/Swing interop support APIs for the JavaFX UI toolkit.
javafx.web	Defines WebView APIs for the JavaFX UI toolkit.
jdk.jsobject	Defines APIs for JavaScript objects.
jfx.incubator.input	Incubates mechanism for customising JavaFX controls.
jfx.incubator.richtext	Incubates RichTextArea control for JavaFX.

Links with OSGi

The Java Module System does not intend to support all the functionalities that the OSGi platform currently supports (for example the Life-Cycle model and the Services Registry). However the Java Module System will support functions which are not supported by OSGi, such as modularity at compile-time, and built-in support for native libraries. ^[18] A couple of articles exploring how the Java Module System and OSGi could interoperate were published in 2016. These can be found on InfoQ ^[19] and also the OSGi Alliance Blog. ^[20]

See also

• Java package
• Classpath
• Java class loader
• Modules (C++)

References

1. "Java Platform Module System (JSR 376)". Oracle Corporation . Retrieved 2018-07-02.
2. "Project Jigsaw". Oracle Corporation . Retrieved 2015-11-29.
3. Mark Reinhold (2009-09-20). "It's time for … Plan B". Oracle Corporation . Retrieved 2017-06-21.
4. "JDK 9". Oracle Corporation . Retrieved 2016-02-24.
5. "Java 9: Release date and new features". techworld.com. 2017-07-21. Retrieved 2017-11-18.
6. "jlink: The Java Linker (JSR 282)". Oracle Corporation . Retrieved 2016-03-12.
7. "Java Platform Module System (JSR 376)". Oracle Corporation . Retrieved 2015-11-29.
8. "JEP 238: Multi-Release JAR Files". Oracle Corporation . Retrieved 2017-07-31.
9. "JEP 253: Prepare JavaFX UI Controls & CSS APIs for Modularization". Oracle Corporation . Retrieved 2017-07-31.
10. "JEP 260: Encapsulate Most Internal APIs". Oracle Corporation . Retrieved 2017-07-31.
11. "JEP 275: Modular Java Application Packaging". Oracle Corporation . Retrieved 2017-07-31.
12. Mark Reinhold (2016-03-08). "The State of the Module System". Oracle Corporation . Retrieved 2017-02-18.
13. "JEP 396: Strongly Encapsulate JDK Internals by Default" . Retrieved 2021-02-06.
14. "JDK Module Summary". Oracle Corporation. 2016-06-24. Archived from the original on 2015-12-08. Retrieved 2017-02-18.
15. "JEP 494: Module Import Declarations (Second Preview)". openjdk.org.
16. "Java® Platform, Standard Edition & Java Development Kit Version 24 API Specification". docs.oracle.com.
17. "Overview (JavaFX)". openjfx.io.
18. Mark Reinhold (2012-08-24). "Project Jigsaw: Late for the train: The Q&A". Oracle Corporation . Retrieved 2015-11-29.
19. "Java 9, OSGi and the Future of Modularity". InfoQ. Retrieved 2016-09-26.
20. "Java Module Layers and OSGi Bundles". OSGi Alliance. Retrieved 2016-08-01.

External links

• JSR 277
• JSR 294
• JSR 376
• Project Jigsaw
• The State of the Module System
• Java Platform Module System: Issue Summary