Java Modules (JPMS) in Java

Master the Java Platform Module System (JPMS) including module definition, module-info.java, module content exposure, and reflection and modules for the OCP 21 exam.

Table of Contents

• 1. Modules Overview
• 2. Module Definition
• 3. module-info.java
• 4. Module Directives
• 5. Reflection and Modules
• 6. Exam Key Points

1. Modules Overview

The Java Platform Module System (JPMS), introduced in Java 9, provides a way to organize code into modules with explicit dependencies and encapsulation.

1.1 What are Modules?

A module is a collection of packages with a module descriptor (module-info.java). Modules provide:

• Strong Encapsulation: Packages are not accessible unless explicitly exported
• Explicit Dependencies: Modules must declare their dependencies
• Reliable Configuration: Module system validates dependencies at startup

1.2 Benefits of Modules

• Better organization and structure
• Improved security through encapsulation
• Faster startup times
• Smaller runtime images
• Clearer dependencies

2. Module Definition

2.1 Module Structure

Example:

// Module directory structure
com.example.mymodule/
    module-info.java
    com/
        example/
            mymodule/
                MyClass.java
                AnotherClass.java

2.2 Module Naming

• Module names should follow reverse domain naming convention
• Use dots to separate components: com.example.mymodule
• Module names are case-sensitive
• Avoid using reserved keywords

3. module-info.java

The module-info.java file is the module descriptor that defines the module's name, dependencies, and exports.

3.1 Basic Module Declaration

Example:

// Simple module with no dependencies or exports
module com.example.mymodule {
}

// Module with dependencies
module com.example.mymodule {
    requires java.base;           // Implicit, but can be explicit
    requires java.sql;
    requires com.example.othermodule;
}

// Module with exports
module com.example.mymodule {
    exports com.example.mymodule.api;
    exports com.example.mymodule.util;
}

4. Module Directives

4.1 requires Directive

The requires directive declares a dependency on another module.

Example:

module com.example.mymodule {
    requires java.sql;                    // Standard dependency
    requires com.example.othermodule;     // Application module dependency
    
    requires static com.example.optional;  // Optional dependency (compile-time only)
    requires transitive java.logging;      // Transitive dependency (re-exported)
}

4.2 exports Directive

The exports directive makes packages accessible to other modules.

Example:

module com.example.mymodule {
    exports com.example.mymodule.api;           // Export to all modules
    exports com.example.mymodule.util to com.example.consumer;  // Export to specific module
}

4.3 opens Directive

The opens directive allows reflective access to packages (for frameworks like Spring, Hibernate).

Example:

module com.example.mymodule {
    opens com.example.mymodule.internal;                    // Open to all modules
    opens com.example.mymodule.config to com.example.framework;  // Open to specific module
    open module com.example.mymodule { }                    // Open entire module
}

4.4 uses and provides Directives

Example:

// Service interface
package com.example.service;
public interface MyService { }

// Service implementation
package com.example.impl;
public class MyServiceImpl implements MyService { }

// Consumer module
module com.example.consumer {
    uses com.example.service.MyService;  // Uses the service
}

// Provider module
module com.example.provider {
    provides com.example.service.MyService 
        with com.example.impl.MyServiceImpl;  // Provides implementation
}

5. Reflection and Modules

Modules affect reflection access. By default, reflection cannot access non-exported packages.

5.1 Reflection Restrictions

Example:

// Module com.example.mymodule does NOT export com.example.mymodule.internal
module com.example.mymodule {
    exports com.example.mymodule.api;
    // com.example.mymodule.internal is NOT exported
}

// In another module - this will fail
Class<?> clazz = Class.forName("com.example.mymodule.internal.InternalClass");
// IllegalAccessException - package not exported

// Solution: Use opens directive
module com.example.mymodule {
    opens com.example.mymodule.internal;  // Allow reflection access
}

6. Exam Key Points

Critical Concepts for OCP 21 Exam:

• Module: Collection of packages with module-info.java
• module-info.java: Module descriptor file
• requires: Declares dependency on another module
• exports: Makes packages accessible to other modules
• opens: Allows reflective access to packages
• uses: Declares use of a service interface
• provides: Provides service implementation
• transitive: Re-exports dependency to dependent modules
• static: Optional dependency (compile-time only)
• java.base: Implicitly required by all modules
• Reflection: Restricted to exported/opened packages
• Module Naming: Reverse domain naming convention