2017  Kodetalk | Feedback | Privacy Policy | Terms | About

Java 9 Platform Modular System exposed

Moduler JDK 9:

JDK 9 divided into a set of modules that can be combined at compile time, build time, or run time into a variety of configurations. But JDK 9 not limited to configurations corresponding to the full Java SE Platform, the full JRE, and the full JDK; Configurations roughly equivalent in content to each of the Compact Profiles defined in Java SE 8; and Custom configurations which contain only a specified set of modules and the modules transitively required by those modules.

The definition of the modular structure must make a clear distinction between standard modules, whose specifications are governed by the Java Community Process, and modules that are specific to the JDK. It must also distinguish modules that will be proposed for inclusion in the Java SE Platform Specification, and thereby made mandatory in every Platform Implementation, from all other modules.

The modular structure of implemention uses theses following principles:

1) Standard modules, whose specifications are governed by the JCP, must have names starting with the string "java.".
2) All other modules are merely part of the JDK, and must have names starting with the string "jdk.".
3) If a module exports a package that contains a type that contains a public or protected member that, in turn, refers to a type from some other module, then the first module must grant implied readability to the second, via requires public. (This ensures that method-invocation chaining works in the obvious way.)
4) A standard module may contain both standard and non-standard API packages. If a standard module exports a standard API package then the export may be qualified; if a standard module exports a non-standard API package then the export must be qualified. In either case, if a standard module exports a package with qualification then the export must be to some subset of the modules in the JDK. If a standard module is a Java SE module, i.e., to be proposed for inclusion in the Java SE Platform Specification, then it must not export any non-SE API packages, at least not without qualification.
5) A standard module may depend upon one or more non-standard modules. It must not grant implied readability to any non-standard module. If it is a Java SE module then it must not grant implied readability to any non-SE module.
6) A non-standard module must not export any standard API packages. A non-standard module may grant implied readability to a standard module.
7) An important consequence of principles 4 and 5 is that code that depends only upon Java SE modules will depend only upon standard Java SE types, and thus be portable to all Implementations of the Java SE Platform.

The module graph

The modular structure of the JDK can be visualized as a graph: Each module is a node, and there is a directed edge from one module to another if the first depends upon the second. The full module graph has too many edges to be displayed easily; here is the transitive reduction of the graph, in which redundant edges are omitted (click to enlarge):

Here with a guided tour of the module graph:

1) Standard Java SE modules are colored orange; non-SE modules are colored blue.
2) If one module depends upon another, and it grants implied readability to that module, then the edge from the first module to the second is solid; otherwise, the edge is dashed.
3) At the very bottom is the java.base module, which contains essential classes such as java.lang.Object and java.lang.String. The base module depends upon no module, and every other module depends upon the base module. Edges to the base module are lighter than other edges.
4) At the top is the java.se.ee module, which gathers together all of the modules that comprise the Java SE Platform, including modules that overlap with the Java EE Platform Specification. This is an example of an aggregator module, which collects and re-exports the content of other modules but adds no content of its own. A run-time system configured to contain the java.se.ee module will contain all the API packages of the SE Platform. A module will be proposed for inclusion in the Java SE Platform Specification if, and only if, it is a standard module reachable from the java.se.ee module.
5) The java.se aggregator module gathers together those parts of the Java SE Platform that do not overlap with Java EE.
6) The java.compact1, java.compact2, and java.compact3 aggregator modules implement the Java SE Compact Profiles. There is also a non-standard jdk.compact3 module because a compact3 build of the JDK includes some non-SE API packages, while the other Compact Profile builds do not.
7) The other non-standard modules contain debugging and serviceability tools and APIs (e.g., jdk.jdi, jdk.jcmd and jdk.jconsole), development tools (e.g., jdk.compiler, jdk.javadoc, and jdk.xml.bind), and various service providers (e.g., jdk.charsets, jdk.scripting.nashorn, and jdk.crypto.ec), which are made available to other modules via the existing java.util.ServiceLoader mechanism.
8) The java.smartcardio module is standard but not part of the Java SE Platform Specification, hence its name starts with the string "java." but it is colored blue, and it is not reachable from the java.se module.

The module graph is, in effect, a new kind of API, and will be specified and evolved as such. The subgraph of the module graph rooted at the java.se.ee module, with all non-SE modules and corresponding edges removed, will be proposed for inclusion in the Java SE Platform Specification; its evolution will thereafter be governed by the JCP. The evolution of the remainder of the graph will be covered by future JEPs. In either case, if a module is specified as being available for general use then it will be subject to the same evolutionary constraints as other APIs. Removing such a module or changing it incompatibly, in particular, will require public notice at least one major release in advance.