Arquivos JAR em Java - Criação, Execução e Manifesto

Quando um programa Java é compilado, o resultado é um conjunto de arquivos .class organizados em uma estrutura de diretórios que espelha seus pacotes. Essa estrutura, embora lógica, complica a distribuição da aplicação. Para resolver este problema, foram criados os arquivos JAR (Java ARchive).

Um arquivo JAR é um contêiner que agrupa múltiplos arquivos em um único pacote, facilitando sua distribuição e uso. Ele pode conter não apenas os arquivos .class, mas também outros recursos que a aplicação necessita, como imagens, arquivos de áudio ou de configuração. JARs são a forma padrão de empacotar bibliotecas, plugins e aplicações Java completas.

Tecnicamente, um arquivo JAR utiliza o formato ZIP. Isso significa que ele é, essencialmente, um arquivo compactado, o que ajuda a economizar espaço. Qualquer ferramenta capaz de manipular arquivos ZIP pode ser usada para visualizar o conteúdo de um JAR. Quando você adiciona uma biblioteca externa ao seu projeto, geralmente está incluindo seu arquivo JAR no classpath.

A Ferramenta `jar`

Para trabalhar com arquivos JAR, o JDK fornece a ferramenta de linha de comando jar, localizada no diretório bin da sua instalação Java. O formato geral do comando é:

jar [opções] [arquivo-jar] [arquivos-de-entrada]

Primeiro, são fornecidas as opções que definem a ação, seguidas pelo nome do arquivo JAR e, por fim, os arquivos a serem incluídos ou manipulados.

Principais Opções do Comando `jar`

As opções são semelhantes às do comando tar em sistemas UNIX.

c: Cria um novo arquivo JAR.
C: (Change directory) Altera temporariamente o diretório de origem.
e: Define o ponto de entrada (a classe principal) da aplicação no manifesto.
f: Especifica o nome do file (arquivo) JAR.
i: Gera um arquivo de índice para otimizar a busca em JARs grandes.
m: Inclui um arquivo de manifesto personalizado.
M: Informa para não criar um arquivo de manifesto padrão.
t: Exibe a tabela de conteúdos do arquivo JAR.
u: (Update) Atualiza um arquivo JAR existente.
v: Gera uma saída detalhada (verbose) no console.
x: Extrai os arquivos do JAR.
0: Armazena os arquivos sem aplicar compressão (nível zero).

Criando um Arquivo JAR Simples

A sintaxe mais comum para criar um novo arquivo JAR é jar cvf. Considere um programa simples no arquivo Program.java:

class Program {
    public static void main(String[] args) {
        System.out.println("Olá, Programicio.com");
    }
}

Primeiro, compile o arquivo:

javac Program.java

Isso gerará o arquivo Program.class. Agora, crie um JAR a partir dele:

jar cvf app.jar Program.class

Neste comando, as opções cvf significam:

c - criar um novo arquivo.
v - com saída verbose (detalhada).
f - o nome do file (arquivo) será app.jar.

A saída no console será semelhante a esta:

manifesto adicionado
adicionando: Program.class(entrada = 435) (saída = 301)(deflator 30%)

Para incluir múltiplos arquivos ou todos os arquivos de um diretório, pode-se usar o caractere curinga *:

# Adiciona todos os arquivos .class do diretório atual
jar cvf app.jar *.class

# Adiciona todos os arquivos .class do subdiretório com/programicio
jar cvf app.jar com/programicio/*.class

Inspecionando o Conteúdo de um Arquivo JAR

Como um JAR é um arquivo ZIP, seu conteúdo pode ser inspecionado com o comando unzip -l (em sistemas Linux/macOS) ou jar tf.

jar tf app.jar

A saída revela a estrutura interna:

META-INF/
META-INF/MANIFEST.MF
Program.class

Observe que, além do Program.class, o JAR contém automaticamente um diretório META-INF com um arquivo MANIFEST.MF.

Executando Arquivos JAR

A JVM pode executar um arquivo JAR diretamente com a flag -jar:

java -jar app.jar

Ao tentar executar o app.jar que acabamos de criar, o seguinte erro ocorrerá:

no main manifest attribute, in app.jar

A mensagem informa que a JVM não encontrou o atributo Main-Class no manifesto do JAR. Este atributo é essencial, pois diz à JVM qual classe contém o método main para iniciar a execução.

Criando um JAR Executável

Para que um JAR seja executável, é preciso definir a classe principal. Existem duas abordagens principais.

Abordagem 1: A Opção `-e` (Ponto de Entrada)

A forma mais direta é usar a opção e durante a criação. O comando especifica o nome do JAR, a classe principal e os arquivos a serem incluídos.

jar cvfe app.jar Program Program.class

Aqui, cvfe significa criar, verbose, nome do file e ponto de entrada. Program é definido como a classe principal. Agora, o JAR pode ser executado com sucesso:

java -jar app.jar

Saída: Olá, Programicio.com

Se a classe estivesse em um pacote, seu nome completo deveria ser fornecido. Por exemplo, para com.programicio.Program, o comando seria:

jar cvfe app.jar com.programicio.Program com/programicio/Program.class

Em sistemas operacionais com interface gráfica (Windows, macOS), um JAR executável pode muitas vezes ser iniciado com um duplo clique.

Abordagem 2: O Manifesto Personalizado com a Opção `-m`

A segunda maneira é fornecer um arquivo de manifesto personalizado.

Crie o arquivo de manifesto: Crie um arquivo de texto, por exemplo, manifesto.txt, com o seguinte conteúdo:
```
Manifest-Version: 1.0
Main-Class: Program
```
Importante: O arquivo de texto deve terminar com uma linha em branco, caso contrário, o último atributo pode ser ignorado.
Crie o JAR com a opção m: A opção m instrui a ferramenta jar a usar um manifesto externo.
```
jar cfm app.jar manifesto.txt Program.class
```
Aqui, cfm significa criar, nome do file e usar o manifesto.

O app.jar resultante será igualmente executável. Para atualizar o manifesto de um JAR existente, a opção u (update) é usada: jar ufm app.jar manifesto-atualizado.txt.

Detalhes do Arquivo de Manifesto (`MANIFEST.MF`)

O manifesto é um arquivo de metadados que descreve o JAR. Ele está localizado em META-INF/MANIFEST.MF e contém pares de chave-valor.

Atributos Comuns do Manifesto:

Manifest-Version: A versão do arquivo de manifesto (geralmente 1.0).
Created-By: A versão do JDK usada para gerar o JAR.
Main-Class: O nome completo da classe que contém o método main. Essencial para JARs executáveis.
Class-Path: Uma lista de JARs externos dos quais esta aplicação depende, com caminhos relativos separados por espaços.

Resumo

Arquivo JAR: Um contêiner no formato ZIP usado para distribuir aplicações e bibliotecas Java.
Ferramenta jar: A principal ferramenta de linha de comando do JDK para criar e gerenciar arquivos JAR.
Manifesto: O arquivo META-INF/MANIFEST.MF contém metadados sobre o JAR.
JAR Executável: Para ser executável, o manifesto do JAR deve conter o atributo Main-Class, que especifica a classe principal da aplicação.
Criação de JAR Executável: Pode ser feita de forma direta com a opção e (jar cvfe) ou manualmente, fornecendo um arquivo de manifesto com a opção m (jar cfm).

Arquivos JAR em Java - Criação, Execução e Manifesto

A Ferramenta jar

Principais Opções do Comando jar