Module System in Java: Structuring Code with Project Jigsaw

Java 9 introduced the Module System as part of Project Jigsaw, aiming to improve the modularity of the Java platform. The Module System enables developers to create modular JARs, allowing for better organization, encapsulation, and reusability of code. Let’s explore the key concepts and benefits of the Module System.

Key Concepts:

1. Module:

  • A module is a self-contained unit of code that encapsulates its implementation details and declares its dependencies. Modules are defined in module-info.java files and provide a clear boundary for code organization.
   // Module definition in module-info.java
   module com.example.myapp {
       requires java.base;
       requires java.sql;
       exports com.example.mymodule;

2. Module Declaration:

  • The module declaration specifies dependencies (requires), exports packages (exports), and defines services. It serves as a blueprint for the module’s structure and interactions.

3. Module Path:

  • The module path is a replacement for the classpath. It specifies the location of modules, and the Java launcher uses it to resolve dependencies between modules.
   java --module-path <path-to-modules> -m com.example.myapp/com.example.mymodule.Main

4. Module Visibility:

  • Modules control which packages are visible to other modules. A module exports specific packages, making them accessible to other modules. Unexported packages are internal to the module.

5. Module Dependency Resolution:

  • The Module System resolves dependencies between modules at compile time and runtime. It ensures that the required modules are present and compatible.


1. Encapsulation:

  • Modules enforce strong encapsulation by allowing developers to hide implementation details within a module. Only exported packages are accessible externally.

2. Improved Maintainability:

  • Modularization leads to more maintainable code. Modules provide clear boundaries, reducing the likelihood of unintended dependencies and making it easier to reason about the codebase.

3. Reusability:

  • Modules can be reused in different projects, promoting a modular and component-based development approach. This reusability is facilitated by explicitly declaring dependencies.

4. Dependency Management:

  • The Module System simplifies dependency management. Modules declare their dependencies, and the system ensures that the required modules are available, reducing classpath issues.

Creating a Modular Project:

1. Project Structure:

  • Organize your project with a modular structure. Create a module-info.java file in the source directory of each module.
   └── com.example.myapp
       ├── module-info.java
       └── com
           └── example
               └── mymodule
                   └── Main.java

2. Module Declaration:

  • Declare modules and their dependencies in the module-info.java file.
   // Module definition in module-info.java
   module com.example.myapp {
       requires java.base;
       requires java.sql;
       exports com.example.mymodule;

3. Compile and Run:

  • Compile the modules and run the application using the module path.
   javac -d out/com.example.myapp src/com.example.myapp/module-info.java src/com.example.myapp/com/example/mymodule/Main.java
   java --module-path out -m com.example.myapp/com.example.mymodule.Main

Challenges and Best Practices:

1. Circular Dependencies:

  • Be cautious of circular dependencies between modules. The Module System prevents cycles, and resolving them may require refactoring.

2. Access Control:

  • Use access modifiers (public, protected, private) judiciously. Unintentional exposure of internal details can hinder encapsulation.

3. Migration from Classpath:

  • Migrating an existing project from the classpath to the module path may require addressing dependencies and module declarations.

4. Service Provider Interface (SPI):

  • Leverage the ServiceLoader API for creating and consuming service provider interfaces. It promotes a modular and extensible architecture.


The Module System in Java brings a new level of modularity to the language, promoting encapsulation, maintainability, and reusability. While adopting modules may pose challenges, the benefits in terms of code organization and dependency management make it a valuable addition to the Java platform. Developers are encouraged to embrace the Module System when starting new projects or modularizing existing codebases to enjoy the advantages of a more structured and scalable architecture.