Blog 7 mins reading time

Article 1 – Understanding Java Modules and Dependency Management: The Foundation of Secure Applications

Before diving into the core of dependency management, it’s important to understand the role of Java modules. Java modules allow for better organization and separation of concerns in large applications. They can impact visibility at both compile time and runtime, offering a means to encapsulate code and reduce unnecessary exposure of internal details.

Building Reusable Java Applications: Unveiling Java Modules, Dependency Management, and the Runtime

Introduction

Reusability is one of the most powerful concepts in software development. It allows developers to assemble applications using prebuilt components, saving time and effort while enabling them to focus on their unique application logic. In Java, modules and dependencies are the primary vehicles for achieving reusability. However, to fully understand their potential, we must first delve into how the Java runtime environment (JRE) operates.

This article explores the synergy between Java modules, dependency management, and the inner workings of the runtime, helping you develop an intuition about how Java applications are structured and executed.

Reusability in Java: A Building Block Approach

Think of building a software application as constructing a complex structure. Instead of carving every stone by hand, you can use pre-fabricated blocks, arches, and beams. Similarly, in Java, you can reuse modules and dependencies, the “building blocks” of software, to craft complex systems efficiently.

  • Modules: Self-contained units of functionality, introduced in Java 9, that encapsulate code and manage dependencies explicitly.
  • Dependencies: External libraries or components integrated into your project to provide additional features or functionality.

Together, these elements not only save development time but also make code more organized, scalable, and maintainable.

The Java Runtime Environment: The Heart of Execution

The Java runtime environment is where your application comes alive. It is responsible for loading your classes, resolving dependencies, and executing your code. Understanding how the runtime operates is crucial for managing reusable components effectively.

1. Class Loaders: The Gatekeepers of Code

Class loaders are responsible for loading Java classes into memory. Java uses a hierarchical class loader structure:

  • Bootstrap Class Loader: Loads core Java classes like java.lang.String from the Java standard library.
  • Extension Class Loader: Loads classes from the ext directory (deprecated in recent versions).
  • Application Class Loader: Loads classes defined in your application and its dependencies.
  • Custom Class Loaders (optional): Developers can define their own class loaders to control how and where classes are loaded.

Key Property: A class is loaded once per class loader. This means a class with the same fully qualified name (e.g., com.example.LibraryClass) cannot be loaded in multiple versions within the same class loader. This restriction simplifies memory management but introduces challenges when handling conflicting dependency versions.

The diagram below shows the layered approach java uses to load classes systematically.

2. Single-Version Rule: A Double-Edged Sword

In the Java runtime:

  • If two modules or dependencies require different versions of the same library, only one version will be loaded, often the first encountered. This behavior, known as the single-version rule, ensures consistency but can lead to version conflicts.

Example Conflict:

  • Module A depends on Library X version 1.2.
  • Module B depends on Library X version 2.0.
  • The runtime loads only one version (e.g., 1.2), potentially causing Module B to break if it relies on features introduced in version 2.0.

The diagram below shows how the runtime’s single-version rule results in a conflict when modules need different versions of a library.

3. Transitive Dependencies and the Dependency Tree

Dependencies often have their own dependencies, creating a dependency tree. For example:

  • Your project depends on Library A.
  • Library A depends on Library B and Library C.
  • Library C depends on Library D.

The diagram below clarifies the dependency tree structure, showing how each component relates to others.

The runtime resolves this tree to determine which classes to load. However, conflicts can arise when different branches of the tree require incompatible versions of the same dependency.

Java Module System

The Java Module System, introduced in Java 9, adds structure to how code is organized and executed in the runtime. It integrates seamlessly with the runtime, introducing several enhancements:

1. Encapsulation of Classes

Modules define what parts of their code are accessible to other modules. By default, classes and packages are hidden, and only explicitly exported packages are visible.

Example:

In the runtime:

  • Encapsulation reduces the risk of unintended interactions between modules.
  • Non-exported classes are not visible, minimizing naming conflicts.

The diagram below illustrates how encapsulation protects the internal workings of modules while exposing only essential functionality.

2. Explicit Dependencies

The module descriptor (module-info.java) explicitly defines what a module depends on. This information allows the runtime to construct a module graph, ensuring that:

  • All required modules are loaded.
  • Circular dependencies are identified and resolved during startup.

Module Graph Example:

This graph improves clarity and reduces surprises during runtime.

3. Module Layers and Class Loader Integration

The Java runtime uses module layers to manage the class loader hierarchy. Each module layer has its own namespace, allowing better organization of loaded classes. However, it still adheres to the single-version rule unless custom mechanisms are introduced.

Challenges in Reusability at Runtime

While modules and dependencies enhance reusability, certain runtime behaviors can complicate their integration:

1. Version Conflicts

When multiple modules require different versions of the same library, the single-version rule can cause breakages. For instance:

  • A library updated to fix a bug may inadvertently introduce a feature incompatible with older versions.
  • The runtime cannot load both versions simultaneously in the same class loader.

2. Transitive Dependency Hell

Complex dependency trees can lead to unexpected conflicts when:

  • An indirect dependency (transitive dependency) is incompatible with other parts of the project.
  • The runtime struggles to resolve which version of a dependency to load.

The diagram below clearly illustrates how transitive dependencies can lead to conflicts, particularly when different parts of the project rely on incompatible versions of the same dependency.

3. Limited Visibility of Transitive Dependencies

With modules, only explicitly declared dependencies are visible to other modules, reducing the risk of accidental usage of transitive dependencies. However, this can also create challenges when integrating older libraries that rely on traditional dependency management.

Techniques to Mitigate Runtime Challenges

The runtime challenges of reusability can be mitigated using advanced techniques:

1. Custom Class Loaders

Developers can define separate class loaders for different modules or subsystems. This approach isolates dependencies, allowing multiple versions of the same library to coexist.

The diagram below shows how Separate class loaders prevent version conflicts by creating isolated namespaces for each version of a library.

2. Shading

Shading involves renaming the packages of a library so that different versions can coexist in the runtime. Tools like the Maven Shade Plugin automate this process.

The Impact of Java Modules on the Runtime

The Java Module System deeply integrates with the runtime, enhancing:

  • Encapsulation: Reducing the risk of unintentional interference between modules.
  • Startup Efficiency: Loading only the necessary modules.
  • Error Detection: Identifying circular dependencies and missing modules early.

However, it also introduces stricter rules for dependency declaration and visibility, requiring developers to rethink how they structure applications.

Conclusion

Reusability is a key driver of productivity in Java development, made possible by modules and dependencies. The Java runtime plays a central role in managing these components, ensuring they work harmoniously. By understanding the behavior of the runtime—particularly the class loader hierarchy, single-version rule, and module system—developers can make informed decisions about structuring their applications.

As we continue this series, the next article will shift focus to the security implications of reusability, including how to manage vulnerabilities in dependencies. Stay tuned for insights into building not just reusable, but also secure applications.


Keen to explore how adorsys can guide your company into this world? Reach out to us here, our team will be delighted to discuss tailored solutions for your organisation.

Written by Jude Nkwa, Fullstack Software Engineer at adorsys.

Next Post: