Java Platform Module System (Jpms): An In-Depth Introduction

Learn the tools for creating modular and space-optimized software in Java.

What you'll learn

Get clear & in-depth understanding of JPMS and how it enables stronger encapsulation, reliable configuration, and creation of smaller distributables

Learn how to create modular code via modules from both within and outside of Eclipse

Learn how non-modular code can work with modular code and vice-versa

Learn how to create Custom Space-Optimized JRE with only required Modules

Requirements

Knowledge of Core Java

Description

This course provides an in-depth understanding of the Java Platform Module System (JPMS) and how it enables the creation of modular, strongly encapsulated, and space-optimized software. JPMS is a major feature of Java 9, introduced as part of Project Jigsaw to address challenges faced by earlier versions of Java.When building large, complex software, it is crucial that the code is easy to understand, maintain, secure, and extend. These are essential goals for any well-designed system. Prior to Java 9, achieving these goals relied heavily on design principles like Information Hiding, which utilized packages and access modifiers. However, in some cases, packages and access modifiers fell short, compromising these objectives. Java also faced significant issues with configuration (commonly referred to as JAR hell) and the tendency to ship as a monolithic library. JPMS resolves these limitations by introducing modules, a new layer of abstraction that ensures better encapsulation, more reliable configuration, and the ability to create space-optimized software.In this course, we begin by exploring the problems JPMS was designed to solve, helping you understand its purpose clearly. Next, we’ll dive into the anatomy of a module and how to create them from both the command line and Eclipse. You’ll also learn how modular and non-modular code can interoperate. One of the most exciting features of JPMS is the ability to create custom runtime images (JREs) or smaller distributables, and in this course, you’ll learn exactly how to do that—an essential skill for every developer.Each concept is thoroughly explained with realistic examples, clear illustrations, and practical demonstrations to ensure you grasp the material fully.

Overview

Section 1: Introduction

Lecture 1 Course Introduction

Section 2: The Java Platform Module System (JPMS)

Lecture 2 Chapter Introduction & Agenda

Lecture 3 Motivation: Stronger Encapsulation

Lecture 4 Motivation: Ease of Understanding

Lecture 5 Motivation: Smaller Distributables

Lecture 6 Motivation: Reliable Configuration

Lecture 7 Anatomy of a Module

Lecture 8 Demo: Creating Downloader & Indexer Modules

Lecture 9 Interoperability: Pre-Java 9 Code on Java 9 & Later

Lecture 10 Module Path & Module Resolution in JPMS

Lecture 11 Demo: Creating Modular JARs

Lecture 12 Demo: Achieving Reliable Configuration with Modules

Lecture 13 Demo: Creating Modules from within Eclipse

Lecture 14 Demo: Creating Modular JAR from within Eclipse

Lecture 15 Unnamed Modules: Using Modular Code

Lecture 16 Unnamed Modules: Using Modular Code from Command Line

Lecture 17 Minor Correction in Previous Lecture

Lecture 18 Automatic Modules: Migrating Non-Modular Code into JPMS

Lecture 19 Demo: Automatic Modules

Lecture 20 Note on Auto-Suggest Option in Previous Lecture

Lecture 21 Chapter Summary

Section 3: Custom Runtime Images

Lecture 22 Custom Runtime Images: Introduction

Lecture 23 Demo: Custom Runtime Image with Platform Modules

Lecture 24 Minor Note on Previous Lecture

Lecture 25 Custom Runtime Image with few Application Modules: A First Look

Lecture 26 jdeps: Java Dependency Analysis Tool

Lecture 27 Converting Automatic Module into Explicit Module

Lecture 28 Custom Runtime Image with Application Modules

Lecture 29 Important Note on Executing App Module in Previous Lecture

Lecture 30 Custom JRE: Conclusion

Developers who are not familiar with JPMS