TheJava Platform Module System^[1] specifies a distribution format for collections ofJava code and associated resources. It also specifies a repository for storing these collections, ormodules, 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 existingJAR format, especially theJAR Hell, which can lead to issues such as classpath and class loading problems.

The Java Module System was initially being developed under theJava 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 forJava 7 (2011) but was deferred toJava 8 (2014) as part of Plan B,^[3] and again deferred to aJava 9 release in 2017.^[4] Java 9 including the Java Module System was released on September 21, 2017.^[5]

The Java Module System implemented in Java 9 includes the followingJEPs andJSR (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: PrepareJavaFX 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: TheJava 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]

Modules are a new way of grouping code. Contrary toJar 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 namedmodule-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 modulecom.foo.bar depends on anothercom.foo.baz module, and exports the following packages:com.foo.bar.alpha andcom.foo.bar.beta:

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

The public members ofcom.foo.bar.alpha andcom.foo.bar.beta packages will be accessible by dependent modules. Private members are inaccessible even through a means such asreflection. Note that inJava versions 9 through 16, whether such 'illegal access' isde facto permitted depends on a command line setting.^[13]

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

Modules can themselves be imported, automatically importing all exported packages.^[15] This is done usingimport 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 tojava.base.

Modules use the followingkeywords:

• 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 theopens directive to specify which module is allowed to reflectively access the package
• transitive: used with therequires 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 theprovides directive to specify which implementation of a service is provided by the module

The modules under namespacejava.* belong to theJava Platform, Standard Edition, and modules under namespacejdk.* belong to theJava Development Kit.^[16]

The Java Module System does not intend to support all the functionalities that theOSGi 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.^[17] A couple of articles exploring how the Java Module System and OSGi could interoperate were published in 2016. These can be found on InfoQ^[18] and also the OSGi Alliance Blog.^[19]

• Java package
• Classpath
• Java class loader
• Precompiled header#Modules, C++ modules

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

• Java specification requests

• Articles with short description
• Short description matches Wikidata