An Introduction to Java Module With Example

Java Module is a feature introduced in Java 9 to improve the maintainability, scalability, and security of Java applications. A module is a collection of Java packages and resources that are grouped together and can be treated as a single unit of deployment, distribution, and execution.

Before Java 9, Java applications were organized using the Java classpath, which was a flat namespace that allowed all classes to access each other without any restrictions. This made it difficult to manage dependencies, prevent naming conflicts, and ensure that only required classes were loaded at runtime. Java Module addresses these issues by introducing the concept of module boundaries, which restricts access to classes and resources within a module unless explicitly exposed.

A Java module is defined by a module descriptor file (module-info.java) that specifies the module’s name, version, dependencies, and exported packages. A module can require other modules to function correctly and can export packages that are intended to be used by other modules. This allows for better control over dependencies, reduces the risk of conflicts, and improves the security of the application.

Java modules also provide a way to optimize the size and performance of Java applications by allowing the JVM to load only the required modules at runtime. This can help reduce the startup time, memory usage, and overall footprint of the application. By adopting Java modules, developers can improve the maintainability, scalability, and security of their applications and stay up to date with the latest best practices in Java development.

1. Benefits of Using Java Module

There are several benefits of using Java Module in Java development:

1. Improved Modularity: Java Module helps to improve modularity in Java applications by grouping related packages and resources together into a module. This helps to manage dependencies, prevent naming conflicts, and ensure that only required classes are loaded at runtime.
2. Better Security: Java Module allows developers to define module boundaries, which restrict access to classes and resources within a module unless explicitly exposed. This helps to improve the security of Java applications by preventing unauthorized access to sensitive classes and resources.
3. Simplified Dependencies: Java Module helps to simplify dependencies by allowing developers to explicitly specify which modules are required for an application to function correctly. This helps to reduce the complexity of managing dependencies and makes it easier to update and maintain applications.
4. Improved Performance: Java Module provides a way to optimize the size and performance of Java applications by allowing the JVM to load only the required modules at runtime. This helps to reduce the startup time, memory usage, and overall footprint of the application.
5. Better Encapsulation: Java Module helps to improve encapsulation by allowing developers to define which packages and resources are exposed by a module. This helps to prevent accidental access to sensitive classes and resources and improves the overall robustness of the application.
6. Improved Testing: Java Module helps to improve testing by allowing developers to create isolated test environments that only contain the required modules for a specific test case. This helps to improve the accuracy and reliability of testing and reduces the risk of errors and bugs.

In summary, using Java Module in Java development provides several benefits, including improved modularity, better security, simplified dependencies, improved performance, better encapsulation, and improved testing. By adopting Java Module, developers can improve the maintainability, scalability, and security of their applications and stay up to date with the latest best practices in Java development.

2. Example of a Modular Sample Application in Java

Assume we have an application that consists of two modules, “core” and “gui”. The “core” module provides the main business logic and data model for the application, while the “gui” module provides a graphical user interface for interacting with the core module.

1. Create Module Descriptor Files:

We start by creating module descriptor files for each module. In the “core” module, we create a file called “module-info.java” with the following contents:

module com.example.core {
    exports com.example.core;
}

This declares that the module is named “com.example.core” and exports the package “com.example.core” to other modules.

In the “gui” module, we create a file called “module-info.java” with the following contents:

module com.example.gui {
    requires com.example.core;
    exports com.example.gui;
}

This declares that the module is named “com.example.gui”, requires the “com.example.core” module, and exports the package “com.example.gui” to other modules.

2. Create Module-Specific Classes:

Next, we create module-specific classes for each module. In the “core” module, we create a class called “DataModel” that represents the application’s data model:

package com.example.core;

public class DataModel {
    // implementation details
}

In the “gui” module, we create a class called “MainWindow” that represents the main window of the graphical user interface:

package com.example.gui;

import com.example.core.DataModel;

public class MainWindow {
    private DataModel dataModel;

    public MainWindow() {
        dataModel = new DataModel();
    }

    // implementation details
}

Note that the “MainWindow” class imports the “DataModel” class from the “core” module.

3. Build and Run the Application:

Finally, we build and run the application using the “javac” and “java” commands:

javac -d out/core src/core/com/example/core/DataModel.java src/core/module-info.java
javac -d out/gui --module-path out -sourcepath src/gui src/gui/com/example/gui/MainWindow.java src/gui/module-info.java
java --module-path out -m com.example.gui/com.example.gui.MainWindow

This compiles the “core” module and places the compiled class files in the “out/core” directory. Then, it compiles the “gui” module, sets the module path to include the “out” directory, and runs the “MainWindow” class from the “com.example.gui” module.

This is just a basic example of a modular sample application in Java. In practice, modular applications can become more complex and involve multiple modules with many interdependencies. Nonetheless, the principles remain the same: define module boundaries, create module-specific classes, and manage dependencies using the module system.

3. Can I use third-party libraries with Java modules?

You can use third-party libraries with Java modules. In fact, one of the main benefits of using modules is better dependency management, which includes managing dependencies on third-party libraries.

To use a third-party library with a Java module, you need to specify the module dependency in your module descriptor file using the “requires” directive. For example, let’s say you want to use the popular Jackson JSON library in your module. You would add the following line to your module-info.java file:

requires com.fasterxml.jackson.databind;

This declares that your module requires the “com.fasterxml.jackson.databind” module, which is the module that includes the Jackson library.

Once you have declared the module dependency, you can use the third-party library in your code as you normally would. However, keep in mind that some libraries may not be modularized yet and may not have a module descriptor file. In this case, you can still use the library by adding it to the classpath as usual. However, this may result in less optimal dependency management compared to using a modularized version of the library.

4. Can I convert an existing Java application to a module?

΅We can convert an existing Java application to a module. However, depending on the complexity of your application, it may require some refactoring.

To convert your Java application to a module, you need to create a module descriptor file called module-info.java. This file specifies the name of the module, its dependencies, and the packages it exports. Here are the steps to convert your application to a module:

• Create a module-info.java file in the root of your application’s source directory.
• Define the name of your module using the “module” keyword and specify the name of the module. For example, if your application is called “MyApp”, your module-info.java file would look like this:

module myapp {
}

• Add the “requires” directive to specify any modules that your application depends on. For example, if your application depends on the Jackson JSON library, you would add the following line to your module-info.java file:

requires com.fasterxml.jackson.databind;

• Add the “exports” directive to specify which packages in your application should be visible to other modules. For example, if your application has a package called “com.mycompany.myapp”, you would add the following line to your module-info.java file:

exports com.mycompany.myapp;

• Compile your application with the module path option using the “javac” command. For example, if your application’s source code is in the “src” directory and your module descriptor file is in the “src/main/java” directory, you would use the following command:

javac -d outdir --module-source-path src/main/java --module myapp

• Run your application with the module path option using the “java” command. For example, if your main class is in the “com.mycompany.myapp.Main” package, you would use the following command:

java --module-path outdir -m myapp/com.mycompany.myapp.Main

Note that converting an existing application to a module may require some additional refactoring. For example, if your application relies heavily on reflection or classpath scanning, it may need to be refactored to use explicit module dependencies.

5. What is the difference between a module and a package in Java?

In Java, a package is a namespace that groups related classes and interfaces. A module, on the other hand, is a higher-level construct that groups related packages and provides explicit dependency information to other modules.

Packages provide a way to organize code within a single application or library, while modules provide a way to organize and manage dependencies between multiple applications and libraries.

Here are some of the key differences between modules and packages in Java:

1. Visibility: In Java, packages control visibility and access to classes and interfaces. A class or interface in one package can only be accessed by code in the same package or by code in a package that imports that package. Modules, on the other hand, control visibility and access to packages. A package in one module can only be accessed by code in another module if that module explicitly declares a dependency on the first module.
2. Dependency Management: Packages do not provide any explicit dependency management capabilities. Modules, on the other hand, provide a way to declare dependencies on other modules, making it easier to manage complex application and library dependencies.
3. Encapsulation: Packages provide some level of encapsulation by controlling visibility and access to classes and interfaces. However, this encapsulation is not as strong as the encapsulation provided by modules. Modules provide stronger encapsulation by allowing packages to explicitly declare which other modules can access their contents.

In summary, while packages provide a way to organize code within a single application or library, modules provide a higher-level construct for managing dependencies between multiple applications and libraries.

6. Conclusion

In this article, we discussed Java modules, their benefits, and how to define and use them. Java modules provide a way to manage dependencies between multiple applications and libraries, making it easier to develop and maintain complex software systems. By using Java modules, you can achieve better encapsulation, strong dependency management, and improved performance.

We also discussed how to define a Java module using the module-info.java file and how to convert an existing Java application to a module. Additionally, we answered a couple of common questions related to Java modules, including using third-party libraries and the difference between modules and packages in Java.

Overall, Java modules are a powerful tool that can help you build more modular, maintainable, and scalable software systems. By adopting Java modules in your development projects, you can take advantage of their benefits and create better software.

Do you want to know how to develop your skillset to become a Java Rockstar?

Subscribe to our newsletter to start Rocking right now!

To get you started we give you our best selling eBooks for FREE!

1. JPA Mini Book

2. JVM Troubleshooting Guide

3. JUnit Tutorial for Unit Testing

4. Java Annotations Tutorial

5. Java Interview Questions

6. Spring Interview Questions

7. Android UI Design

and many more ....

I agree to the Terms and Privacy Policy

Sign up

Thank you!

We will contact you soon.