Jigsaw: Intro to Java Platform Module System

Introduction

Create Modular Applications

In this section, we will create and run three applications using modules.

1-Create a Vehicle application

From Eclipse, create a new project with Java 11, project name com.jones.moduledemo.vehicle.

Step-1:Create module-info.java

module com.jones.moduledemo.vehicle {
	exports com.jones.moduledemo.vehicle;
}

Step-2:Create a Vehicle class

package com.jones.moduledemo.vehicle;
public class Vehicle {	
	public static void main(String[] args) {
		System.out.println("From The Vehicle class");
	}
}

Step-3:Eclipse workspace : Output

Step-4:Export Module

In Eclipse, export the project and create a module jar

2-Create a Car application

Create a Car Application, and add the com.jones.moduledemo.vehicle module to module-path.

Step-1:Create module-info.java

module com.jones.moduledemo.cars {
	exports com.jones.moduledemo.cars;
	requires transitive com.jones.moduledemo.vehicle;
}

Transitive: The module-info.java file needs com.jones.moduledemo.vehicle as a transitive dependency, which means any module that adds com.jones.moduledemo.cars module need not separately add vehicle module into their module-info.java file.

Cyclic dependency: JPMS does not allow cyclic dependencies. A cyclic dependency is when two requires modules are directly or indirectly depend on each other.

Step-2:Add com.jones.moduledemo.vehicle to modulepath

RightClick on Project -> BuildPath -> ConfigureBuildPath -> Libraries -> Add ExternalJar

Step-3:Create a Car Class

package com.jones.moduledemo.cars;
public class Car {
	public static void main(String[] args) {
		Vehicle vehicle = new Vehicle();
		System.out.println(" Inside cars");
	}
}

Step-4:Eclipse workspace : Output

3-Create a Driver application

Step-1:Create module-info.java file

module com.jones.moduledemo.driver {
	exports com.jones.moduledemo.driver;
	requires com.jones.moduledemo.cars;
}

Import cars, and Vehicle modules into the application module path

Step-2:Create the Driver Class

We will use the Vehicle, Car classes in Driver module for showing java9 modular features.

package com.jones.moduledemo.driver;
import com.jones.moduledemo.cars.Car;
import com.jones.moduledemo.vehicle.Vehicle;

public class Driver {
	public static void main(String[] args) {
		Vehicle vehicle = new Vehicle();
		Car car = new Car();
		System.out.println("Inside Driver");
	}
}

Output

Additional command line options

We are able to use both Vehicles, and Car in the driver application using module applications from IDE like Eclipse, now let us see different command-line options given in Java9.

Different type of Modules

• Named Modules
  • A named module contains a module-info.java file in Jar, also the jar should be in module path.
• Automatic Modules
  • A automatic module does not have module-info.java file in Jar, but the jar is in module path.
  • The name for automatic module is decided by following order if present-
    • Defined in MANIFEST.MF
    • JAR name, i.e after ramoving version, and changing values other than letters and numbers to dots.
• Unnamed Modules
  • An unnames module does not have module-info.java in Jar, but the jar is in classPath.

Creating a Service

A service has an interface, any classes the interface references, and a way of looking(service locator) the implementations of the interface. The implementations are not part of the service and are termed as Service Provider.

Create Service Interface

Step-1: Create module-info file

module com.jones.moduledemo.engine {
	exports com.jones.moduledemo.engine;
}

Step-2: Create Interface file

package com.jones.moduledemo.engine;
public interface Engine {
	String engineName();
	int acquisitionCost();
	int environmentCost();
	int maintanenceCost();
	int totalCost();m
}

Export com.jones.moduledemo.engine jar file, similar to how we have done above.

Create Service Provider

Step-1: Create module-info file

Provides directive helps us to specify that we provide an implementation of the interface with a specific implementation class.

module com.jones.moduledemo.combustionengines {
 requires com.jones.moduledemo.engine;
 requires java.base;
 provides com.jones.moduledemo.engine.Engine with com.jones.moduledemo.combustionengines.CombustionEngine;
}

Step-2: Create Service Implementation

A service provider(CombustionEngine) is implementing the interface. A side note is that Java allows only one service provider for a service interface in a module. Finally export com.jones.moduledemo.combustionengines module.

package com.jones.moduledemo.combustionengines;
import com.jones.moduledemo.engine.Engine;
public class CombustionEngine  implements Engine {
	
	private static Integer INITIAL_COST = 30;
	private static String ENGINE_NAME = "Combustion Engine";
	private static Integer ENVIRONMENTAL_COST = 15;
	private static Integer MAINTANENCE_COST = 15;
	public static void main(String[] args) {
		System.out.println("From CombustionEngine");
	}
	@Override
	public String engineName() {
		return ENGINE_NAME;
	}
	@Override
	public int acquisitionCost() {
		return INITIAL_COST;
	}
	@Override
	public int environmentCost() {
		return ENVIRONMENTAL_COST;
	}
	@Override
	public int maintanenceCost() {
		return MAINTANENCE_COST;
	}
	@Override
	public int totalCost() {
		return acquisitionCost() + environmentCost() + maintanenceCost();
	}
}

Create Service Consumer

We will update the Vehicle class to consume the Engine interface.

Step-1: Update module-info file

module com.jones.moduledemo.vehicles  {
	requires com.jones.moduledemo.engine;
	provides com.jones.moduledemo.engine.Engine with com.jones.moduledemo.vehicles.ElectricEngine;
	uses com.jones.moduledemo.engine.Engine;
}

Step-2: Create second service implementation

Let’s create a second service implementation to be used by our consumers.

package com.jones.moduledemo.vehicles;
import com.jones.moduledemo.engine.Engine;
public class ElectricEngine implements Engine {
	
	private static Integer INITIAL_COST = 40;
	private static String ENGINE_NAME = "Electric Engine";
	private static Integer ENVIRONMENTAL_COST = 5;
	private static Integer MAINTANENCE_COST = 10;
	public static void main(String[] args) {
		System.out.println("From ElectricEngine");
	}	
	@Override
	public String engineName() {
		return ENGINE_NAME;
	}	
	@Override
	public int acquisitionCost() {
		return INITIAL_COST;
	}	
	@Override
	public int environmentCost() {
		return ENVIRONMENTAL_COST;
	}
	@Override
	public int maintanenceCost() {
		return MAINTANENCE_COST;
	}
	@Override
	public int totalCost() {
		return acquisitionCost() + environmentCost() + maintanenceCost();
	}
}

Step-3: Create service consumer

ServiceLoader Class picks all the service provider implementations and provides them to the application, note that we need to add a CombustionEngine jar in the module path for the service Loader to locate.

package com.jones.moduledemo.vehicles;
import java.util.OptionalInt;
import java.util.ServiceLoader;
import java.util.ServiceLoader.Provider;
import com.jones.moduledemo.engine.Engine;
public class Vehicle {
	public static void main(String[] args) {
		System.out.println("From The Vehicle class");
		Vehicle vehicle = new Vehicle();
		vehicle.describeEngine();
	}

	private void describeEngine() {
		OptionalInt maxCost = ServiceLoader.load(Engine.class)
				.stream()
				.map(Provider::get)
				.mapToInt(Engine::totalCost)
				.max();
		maxCost.ifPresent(System.out::println);
		OptionalInt minCost = ServiceLoader.load(Engine.class)
				.stream()
				.map(Provider::get)
				.mapToInt(Engine::totalCost)
				.min();
		minCost.ifPresent(System.out::println );
	}
}

Step-4: Output

The output shows that both Service Providers’ values are printed on the console. Also, the module path is shown in the screenshot.

Opinion of JPMS

JPMS’s primary aim was to reduce the size of JRE, which although completed but took a lot of time to complete. Converting old projects to modules may not be the right approach for a project. There are many open-source dependencies that real-world projects would be using and probably they won’t be migrating to Modules. I would comment that it would be wise to start new projects with modules and leave old projects as it is for now.

I started with command-line options in creating modules, however, the approach was unfriendly, hence I tried to create a Java project in eclipse using java11. This was the simpler approach and writing code was easier, however, I faced some issues with the module not being found a few times, and those times I just created a new project and copied the Java classes.