Java.lang.module Page

java.lang.module

Return to Java Modules, java.lang, java.base, JDK 17 API Specification, Java Docs, Java, Java DevOps - Java SRE - Java CI/CD, Cloud Native Java - Java Microservices - Serverless Java, Java Security - Java DevSecOps, Functional Java, Java Concurrency, Java Data Science - Java and Databases, Java Machine Learning, Java Bibliography, Java Courses, Java Glossary, Awesome Java, Java GitHub, Java Topics

https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/module/package-summary.html

Overview

The `java.lang.module` package is a core part of the Java Platform Module System (JPMS), introduced in Java 9. It provides classes and interfaces to interact with and manage modules at runtime. This package allows developers to programmatically access information about modules, their dependencies, exported packages, and more.

Key Classes and Interfaces

* **Module**: Represents a named module in the Java runtime. Provides methods to access module metadata, dependencies, and exported packages.
* **ModuleDescriptor**: Describes a module's name, dependencies, exported and opened packages, and other module-level attributes.
* **ModuleLayer**: Represents a layer in the module system's hierarchical structure, containing a set of modules and their dependencies.
* **ModuleFinder**: An interface for locating modules, typically used to discover modules available on the module path or in the classpath.
* **Configuration**: Represents a resolved set of modules and their dependencies, ensuring that all required modules are present and compatible.

Common Use Cases

* **Accessing Module Information:** Developers can use the `Module` class to retrieve information about a module at runtime, such as its name, version, dependencies, and exported packages.
* **Dynamic Module Loading:** The `ModuleLayer` and `ModuleFinder` interfaces can be used to dynamically load modules at runtime, enabling more flexible application architectures.
* **Module Reflection:** The `java.lang.reflect.Module` class provides reflective access to module information, allowing tools and frameworks to introspect modules at runtime.

Example

```java
Module currentModule = getClass().getModule();
System.out.println("Module Name: " + currentModule.getName());

currentModule.getPackages().forEach(System.out::println);

for (ModuleDescriptor.Requires dependency : currentModule.getDescriptor().requires()) {
System.out.println("Requires: " + dependency.name());
}
```

This code snippet demonstrates how to obtain the current module, print its name, list its exported packages, and iterate over its dependencies.

Additional Resources

* Oracle Documentation on `java.lang.module`: [invalid URL removed]
* Baeldung: Java 9 Module API: [https://www.baeldung.com/java-9-module-api](https://www.baeldung.com/java-9-module-api)

Classes to support Java module descriptors and creating configurations of modules by means of resolution and Java service binding.

Java.lang.module Package

The `java.lang.module` package in Java provides classes and interfaces for working with modules, introduced in Java 9 as part of the Java Platform Module System (JPMS). Modules in Java are a way to encapsulate code and resources, define dependencies between components, and enforce access controls at compile time and runtime. Key components of the `java.lang.module` package include **ModuleDescriptor**, which represents a module's descriptor containing metadata such as its name, version, and dependencies; **ModuleFinder**, which provides a way to find modules based on specified criteria; **ModuleReader**, which allows reading resources from a module; and **ModuleLayer**, which represents a layer of modules with a defined configuration and class loading behavior. The `java.lang.module` package is essential for developing modular Java applications, enabling better organization, encapsulation, and dependency management of code and resources. It provides tools and APIs for creating, discovering, and interacting with modules at both compile time and runtime, enhancing the modularity, maintainability, and scalability of Java applications.

" (OCP17SelBoy 2022)