What is the Java platform module system (JPMS)?

JPMS solves modularity issues in Java by introducing strong encapsulation and explicit dependencies. It addresses Jar Hell, weak encapsulation, and unreliable configuration through module-info.java, which defines module names, required dependencies, exported packages, and service usage. This enables reliable dependency management, improved performance, smaller runtime images via jlink, and cleaner architecture with hidden internal APIs, making large applications more maintainable and scalable.

The Java Platform Module System (JPMS) is a feature introduced in Java 9 that brings modularity to the Java platform. It enables developers to create more robust, maintainable, and scalable applications by organizing code into well-defined modules.

What Problem Does JPMS Solve?

Before Java 9, the classpath model allowed loose coupling between JAR files, but it lacked strong encapsulation and dependency management. This often led to issues like:

• Jar Hell: Conflicts due to multiple versions of the same library.
• Weak Encapsulation: All public classes were accessible, even if they weren’t meant for external use.
• Lack of Reliable Configuration: No way to declare explicit dependencies, leading to runtime errors if required libraries were missing.

JPMS addresses these by introducing a module system that enforces compile-time and runtime checks on dependencies and access control.

Key Features of JPMS

Modules are defined using a module-info.java file at the root of a package. This file declares:

• Module Name: A unique identifier for the module.
• Dependencies: Other modules this module requires.
• Packages to Export: Which packages are publicly accessible to other modules.
• SPI Usage or Service Provision: Support for service loaders with clear contracts.

Benefits of Using JPMS

• Strong Encapsulation: Classes not in exported packages are inaccessible by default—even if they’re public.
• Reliable Dependency Management: Modules must explicitly declare what they depend on, improving clarity and reducing errors.
• Improved Performance and Scalability: The JVM can optimize loading and memory usage when it knows exactly which modules are needed.
• Smaller Runtime Images: Tools like jlink allow building custom JREs containing only required modules, reducing footprint.

How JPMS Changes Application Design

With JPMS, developers think in terms of components with clear boundaries. You design modules based on functionality, define their dependencies, and control visibility precisely. This makes large-scale applications easier to maintain and evolve.

It also encourages cleaner architecture—internal implementation details stay hidden, reducing unintended dependencies across teams or libraries.

Basically, JPMS modernizes Java’s architecture, making it more suitable for complex, enterprise-grade applications while supporting better tooling and deployment options.

The above is the detailed content of What is the Java platform module system (JPMS)?. For more information, please follow other related articles on the PHP Chinese website!