Project Jigsaw

|
Jigsaw is the name of the project to build a Java Platform Module System (JPMS) into the Java 9 platform.




Modularizing the Java SE platform has been challenging to implement, and the effort has taken many years.
  • JSR 277: Java Module System was originally proposed in 2005 for Java 7.
  • This JSR was later superseded by JSR 376: Java Platform Module System and targeted for Java 8.
  • The Java SE platform is modularized in Java 9, but only after Java 9 was delayed until September 2017.
The Java platform is modularized into numerous modules in Java 9. The number of modules will clearly change with the new features added to the platform.
Developers can now create custom runtimes consisitng of the only modules needed by the target application. For example, if the application is cli-based, then the runtime might not include the GUI modules and this will considerably reduce the size of runtime.

1. Competitors 

  • JBoss Modules
  • OSGi (extremely complicated)

2. JEPs & JSRs

JEP 200: The Modular JDK
  • http://openjdk.java.net/jeps/200
  • Divide the JDK into a set of modules that can be combined at compile time, build time, and run time into a variety of configurations
JEP 201: Modular Source Code
  • http://openjdk.java.net/jeps/201
  • 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
  • http://openjdk.java.net/jeps/220
  • Restructure the JDK and JRE run-time images to accommodate modules and to improve performance, security, and maintainability.
JEP 260: Encapsulate Most Internal APIs
  • http://openjdk.java.net/jeps/260
  • Encapsulate most of the JDK's internal APIs by default so that they are inaccessible at compile time, and prepare for a future release in which they will be inaccessible at run time.
JEP 261: Module System
JEP 282: jlink: The Java Linker
  • http://openjdk.java.net/jeps/282
  • Create a tool that can assemble and optimize a set of modules and their dependencies into a custom run-time image as defined in JEP 220.
JSR 376: Java Platform Module System
JSR 379: Java SE 9 Platform Umbrella

3. Java 9 Platform Module System (JPMS)

A module is formed of reusable group of related code, packages and resources(such as XML files).

 A module descriptor declares the following properties of the module: 
  • module name
  • dependencies that the module depends on
  • the packages that is made available to other modules
  • offered services
  • consumed services


3.1 Listing the JDK's Modules

  • java --list-modules
  • Names starts with java includes the standard modules that implement the Java Language SE Specification
  • Names starting with javafx JavaFX modules
  • Names starting with jdk JDK-specific modules
  • Names starting with oracle Oracle-specific modules
  • Each module name is followed by a version string—@9 indicates that the module belongs to Java 9

3.2 Module Decleration

Module decleration is done in a file named module-info.java
module modulename { } 

3.3 Module Directives

requires
  • specifies that this module depends on another module
  • this relationship is called a module dependency.
  • requires modulename;
  • requires static
    • a module is required at compile time, but is optional at runtime.
  • requires transitive modulename;
    • known as implied readability
    • specify a dependency on another module
    • and to ensure that other modules reading your module also read that dependency
exports
  • specifies one of the module's packages whose public types (and their nested public and protected types) should be accessible to code in all other modules.
  • exports…to directive enables you to specify in a comma-separated list precisely which module’s or modules’ code can access the exported package—this is known as a qualified export.
provides… with
  • specifies that a module provides a service implementation
  • makes the module a service provider
uses
  • specifies a service used by this module
  • makes the module a service consumer
  • a service is an object of a class that implements the interface or extends the abstract class specified in the uses directive.
opens
  • Allows runtime-only access to a package.
  • opens package
  • opens package to comma-seperated-modules
  • open module module-name


3.4 Module Naming Conventions

  • Like package names, module names must be unique.
  • Typically begin the name with the organization's domain name in reverse order.
  • If a module contains the packages
    • com.test.jtudy.pk1
    • com.test.jtudy.pk2
    • then, you would typically name the module with the common portion of the package names
      • com.test.jtudy

3.5 Module Descriptior

  • Compiling the module declaration creates the module descriptor,
  • which is stored in a file named module-info.class
  • in the module’s root folder.

Viewing the module's description
  • java --module-path mods --describe-module com.test.jtudy

Yorumlar

Yorum Gönder

Popular

Java 14 New Features

|
Java SE 14 was released in March 2020. The full list of new features in JDK 14 can be found here: https://openjdk.org/projects/jdk/14/   In this tutorial, we will look over some of these new features and examine some of them. 1. JEP 305: Pattern Matching for instanceof (Preview) With this JEP, instanceof now allows casting of the checked object to a variable. Before Java 14: if (obj instanceof String) { String s = (String) obj; // use s } With Java 14: if (obj instanceof String s) { // can use s here } else { // can't use s here } 2. JEP 345: NUMA-Aware Memory Allocation for G1 This JEP i mproves G1 performance on large machines by implementing NUMA-aware( non-uniform memory access ) memory allocation. Use the  +XX:+UseNUMA option to enable it. 3. JEP 358: Helpful NullPointerExceptions This JEP  improves the usability of  NullPointerException  generated by the JVM by describing precisely which variable was  null . Let's look over the following code which throw
Devamı

Pretenders, Contenders and Liars

|
Life is a way to the uncertainity. This is an exact fact. In this uncertain journey, we meet kinds of people of having different behaviours, and generally label them according to their behaviours. In this writing, i will try to write my understanding of three of these labels; pretenders, contenders and liars. Pretenders A pretender is a kind of people who pretends :) It does not do what it seems to do. It does what it does not seem to do. We frequently meet pretenders in our daily life. And if we catch a person pretending, then we feel that is not sincere. Okay, then here is a question sincerely to ask yourself; do you ever find yourself pretending ? Contenders A contender is a person who has a goal to reach and do not hesitate to fight for that goal. So a contender is sincere ? Absolutely yes, you may be completely opposite to a contender, but if you know that it's a contender, then you know that it's sincere in its behaviours. And sure it is, if you trus
Devamı

Java 12 New Features

|
Java SE 12 was released in March 2019. The full list of new features in JDK 12 can be found here: https://openjdk.org/projects/jdk/12/   In this tutorial, we will look at some of these new features and examine some of them. 1. JEP 189:  Shenandoah: A Low-Pause-Time Garbage Collector (Experimental) Shenandoah is a new garbage collection (GC) algorithm which reduces GC pause times,  independent of heap size. This GC algorithm is experimental so in order to use it with Java 12, you have to enable it : -XX:+UnlockExperimentalVMOptions -XX:+UseShenandoahGC 2. JEP 325:  Switch Expressions (Preview) This JEP extends the switch statement to be used as either a statement or an expression. Meaning that we can now return a value from a switch expression. Before Java 12, we can return a value by assigning it to a variable: String getColor(int num) { String result = ""; switch (number) { case 1, 2, 3: result = "red, green or blue"; break;
Devamı