java modules maven

Mickey 104 Published: 10/09/2024

java modules maven

I'd be happy to help!

Java modules are a feature introduced in Java 9 that allows for better encapsulation and reuse of code. A module is a set of related classes, interfaces, and other resources packaged together as a single unit.

In Maven, you can create modules by creating separate directories within your project's directory structure. Each directory should contain its own module-info.java file, which defines the module's name and the packages that it contains.

Here are some basic steps to create a Java module in Maven:

Create a new directory for your module: 
mkdir my-module
Create a module-info.java file within this directory: 
cd my-module

touch module-info.java
In the module-info.java file, define your module's name and the packages that it contains: 
@MODULE

public class MyModule {


public requires public "org.example";


public provides org.example.MyClass;


}
Create a separate directory for each package that you want to include in your module: 
mkdir org/example
Place your Java source files within these directories. In your pom.xml file, define the modules and their dependencies: 
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">


4.0.0


com.example


my-project


1.0-SNAPSHOT


jar


org.example


my-module


1.0-SNAPSHOT


org.apache.maven.plugins


maven-compiler-plugin


1.8

1.8


my-module
Build and run your module: 
mvn package

That's it! You've successfully created a Java module in Maven.

Note that you can have multiple modules within a single project, each with its own dependencies and requirements.

java module-info

I'm happy to respond in English for you!

A Java module-info is a declaration file that specifies the details of a Java module, such as its name, requires clauses, provides clauses, and exports clauses. This file serves as a contract between the module and other modules or applications that use it.

The basic structure of a module-info file is as follows:

module  {

// Module declaration


}

Let's break down the different parts of a module-info file:

Module name: This is the unique identifier for your Java module. It should match the directory name where your module's source files are stored. Requires clauses: These specify dependencies between modules. A requires clause tells other modules that your module depends on them and may also require other modules or API versions. For example: 
requires java.base;

requires org.example.moduleA;

This means that your module depends on the Java standard library (java.base) and another module called org.example.moduleA.

Provides clauses: These specify what APIs, types, or services your module provides to other modules or applications. For example: 
provides type org.example.api.MyInterface;

provides service org.example.service.MyService with org.example.impl.MyServiceImpl;

This means that your module provides an interface called MyInterface and a service called MyService along with its implementation.

Exports clauses: These specify which parts of your module's API or services are visible to other modules or applications. For example: 
exports org.example.api;

export org.example.service.MyService;

This means that your module exports the entire org.example.api package and a specific service called MyService.

Uses clauses: These specify which modules or APIs your module uses internally, but does not provide as services to other modules. For example: 
uses org.example.moduleB;

uses java.time.DateTime API 1.8;

This means that your module uses another module called org.example.moduleB and the Java Time API with version 1.8.

In summary, a module-info file is used to declare the details of a Java module, including its dependencies, provided APIs or services, exported parts, and internal usages. It serves as a contract between the module and other modules or applications that use it.

I hope this helps! Let me know if you have any further questions.

Related Articles