Arquivo JAR Modular em Java

Os arquivos JAR (Java ARchive) são a forma tradicional de empacotar programas Java. Eles reúnem classes compiladas e recursos necessários para execução. Com a introdução do sistema de módulos (JPMS) a partir do Java 9, surgiu também o JAR modular — um arquivo .jar que, além das classes, contém um descritor de módulo (module-info.class). Esse descritor define o nome do módulo e, se necessário, suas dependências e pacotes exportados.

Estrutura do módulo

Vamos criar um módulo simples chamado demo, contendo uma classe que imprime uma mensagem no console. A estrutura do projeto será:

demo
 ├── com
 │   └── programicio
 │       └── hello
 │           └── Hello.java
 └── module-info.java

O arquivo module-info.java define o módulo:

module demo { }

E a classe principal (Hello.java) fica assim:

package com.programicio.hello;

public class Hello {
    public static void main(String[] args) {
        System.out.println("Hello PROGRAMICIO.COM!");
    }
}

Compilação do módulo

No terminal, acesse o diretório que contém a pasta demo e execute:

javac --module-source-path . -d mods demo/module-info.java demo/com/programicio/hello/Hello.java

O parâmetro --module-source-path indica onde estão os arquivos-fonte, e -d mods define o diretório de saída. Após a compilação, o diretório mods conterá o módulo compilado:

mods
 └── demo
     ├── module-info.class
     └── com/programicio/hello/Hello.class

Criação do JAR modular

Para empacotar o módulo, usamos o utilitário jar:

jar -c -v -f demo.jar -C mods/demo .

• -c cria um novo arquivo JAR
• -v exibe o processo detalhado
• -f demo.jar define o nome do arquivo de saída
• -C mods/demo . adiciona o conteúdo do módulo compilado

O resultado será o arquivo demo.jar, já contendo o descritor module-info.class.

Tornando o JAR executável

Se quisermos que o módulo seja executável, podemos indicar a classe principal ao empacotar:

jar -c -v -f demo.jar -e com.programicio.hello.Hello -C mods/demo .

O parâmetro -e (ou --main-class) define o ponto de entrada do módulo.

Executando o módulo

Com o JAR pronto, basta rodar o módulo com:

java --module-path demo.jar --module demo

O console exibirá:

Hello PROGRAMICIO.COM!

Conclusão

O JAR modular é uma evolução natural do empacotamento em Java. Além das classes compiladas, ele contém metadados que descrevem o módulo, permitindo uma distribuição organizada e compatível com o Java Platform Module System (JPMS). Esse formato melhora a visibilidade de dependências, reduz conflitos entre pacotes e favorece a construção de aplicações Java mais bem estruturadas e seguras.