TOC

Guia de Criação e execução de um arquivo Jar em Java

Guia de Criação e execução de um arquivo Jar em Java

1. Visão geral

Normalmente, é conveniente agrupar muitos arquivos de classe Java em um único arquivo.

Neste tutorial, vamos cobrirthe ins and outs of working with jar – or Java ARchive – files in Java. 

Especificamente, vamos pegar um aplicativo simples e explorar diferentes maneiras de empacotá-lo e executá-lo como um jar. Também responderemos a algumas curiosidades comohow to easily read a jar’s manifest file ao longo do caminho.

2. Configuração do Programa Java

Antes de podermos criar um arquivo jar executável, nosso aplicativo precisa ter uma classe commain method. Esta classe fornece nosso ponto de entrada no aplicativo: 

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

3. Comando Jar

Agora que estamos todos configurados, vamos compilar nosso código e criar nosso arquivo jar.

Podemos fazer isso comjavac na linha de comando: 

javac com/example/jar/*.java

O comandojavac criaJarExample.class no diretóriocom/example/jar. Agora podemos empacotar isso em um arquivo jar.

3.1. Usando os padrões

Para criar o arquivo jar, vamos usar o comandojar.

Para usar o comandojar para criar um arquivo jar, precisamos usar a opçãoc para indicar que estamos criando um arquivo e a opçãof para especificar o arquivo: 

jar cf JarExample.jar com/example/jar/*.class

3.2. Definindo a classe principal

É útil para o manifesto do arquivo jar incluir a classe principal.

O manifesto é um arquivo especial em um jar localizado no diretórioMETA-INFe denominadoMANIFEST.MF. The manifest file contains special meta information about files within the jar file.

Alguns exemplos para os quais podemos usar um arquivo de manifesto incluem a configuração do ponto de entrada, a configuração de informações de versão e a configuração do caminho de classe.

Usando a opçãoe, podemos especificar nosso ponto de entrada e o comandojar irá adicioná-lo ao arquivo de manifesto gerado.

Vamos executarjar com um ponto de entrada especificado: 

jar cfe JarExample.jar com.example.jar.JarExample com/example/jar/*.class

3.3. Atualizando o conteúdo

Digamos que fizemos uma alteração em uma de nossas classes e a recompilamos. Agora, precisamos atualizar nosso arquivo jar.

Vamos usar o comandojar com a opçãou para atualizar seu conteúdo: 

jar uf JarExample.jar com/example/jar/JarExample.class

3.4. Definindo um arquivo de manifesto

Em alguns casos, podemos precisar ter mais controle sobre o que se passa em nosso arquivo de manifesto. O comandojar fornece funcionalidade para fornecer nossas próprias informações de manifesto.

Vamos adicionar um arquivo de manifesto parcial denominadoexample_manifest.txt ao nosso aplicativo para definir nosso ponto de entrada: 

Main-Class: com.example.jar.JarExample

As informações de manifesto que fornecemos serão adicionadas ao que o comando jar gera, portanto, é a única linha de que precisamos no arquivo.

It’s important that we end our manifest file with anewline. Sem a nova linha, nosso arquivo de manifesto será ignorado silenciosamente.

Com essa configuração, vamos criar nosso jar novamente usando nossas informações de manifesto e a opçãom : 

jar cfm JarExample.jar com/example/jar/example_manifest.txt com/example/jar/*.class

3.5. Saída detalhada

Se quisermos mais informações do comandojar, podemos simplesmente adicionar a opçãov para verbose.

Vamos executar nosso comandojar com a opçãov: 

jar cvfm JarExample.jar com/example/jar/example_manifest.txt com/example/jar/*.class
added manifest
adding: com/example/jar/JarExample.class(in = 453) (out= 312)(deflated 31%)

4. Usando o Maven

4.1. Configuração padrão

Também podemos usar o Maven para criar nosso jar. Como o Maven favorece a convenção sobre a configuração, podemos simplesmente executar o pacote para criar nosso arquivo jar. 

mvn package

Por padrão, nosso arquivo jar será adicionado à pastatarget em nosso projeto.

4.2. Indicando a classe principal

Também podemos configurar o Maven para especificar a classe principal e criar umexecutable jar file. 


    org.apache.maven.plugins
    maven-jar-plugin
    ${maven-jar-plugin.version}
    
        
            
                com.example.jar.JarExample

5. Usando o Spring Boot

5.1. Usando Maven e padrões

Se estivermos usando Spring Boot com Maven, devemos primeiro confirmar se nossa configuração de pacote está definida comojar em vez dewar em nosso arquivopom.xml. 

4.0.0
spring-boot
jar
spring-boot

Depois de saber que está configurado, podemos executar a metapackage: 

mvn package

5.2. Definir o ponto de entrada

Definir nossa classe principal é onde encontramos diferenças entre criar um jar com um aplicativo Java regular e umfat jar for a Spring Boot application. Em um aplicativo Spring Boot,main class é na verdadeorg.springframework.boot.loader.JarLauncher.

Embora nosso exemplo não seja um aplicativo Spring Boot, poderíamos facilmente configurá-lo como umSpring Boot console application.

Nossa classe principal deve ser especificada como a classe inicial: 


    com.example.jar.JarExample

Também podemos usarGradle to create a Spring Boot fat jar.

6. Executando o Jar

Agora que temos nosso arquivo jar, podemos executá-lo. We run jar files using the java command.

6.1. Inferindo a Classe Principal

Já que seguimos em frente e garantimos que nossa classe principal fosse especificada no manifesto,we can use the -jar option of the java command to run our application without specifying the main class: 

java -jar JarExample.jar

6.2. Especificando a classe principal

We can also specify the main class when we’re running our application. Podemos usar a opção-cp para garantir que nosso arquivo jar esteja no classpath e, em seguida, fornecer nossa classe principal no formatopackage.className: 

java -cp JarExample.jar com.example.jar.JarExample

Usar separadores de caminho em vez do formato do pacote também funciona: 

java -cp JarExample.jar com/example/jar/JarExample

6.3. Listando o conteúdo de um jar

Podemos usar o comandojar para listar o conteúdo do nosso arquivo jar: 

jar tf JarExample.jar
META-INF/
META-INF/MANIFEST.MF
com/example/jar/JarExample.class

6.4. Exibindo o arquivo de manifesto

Visto que pode ser importante saber o que está em nosso arquivoMANIFEST.MF, vamos dar uma olhada em uma maneira rápida e fácil de espiar o conteúdo sem sair da linha de comando.

Vamos usar o comandounzip com a opção -p: 

unzip -p JarExample.jar META-INF/MANIFEST.MF
Manifest-Version: 1.0
Created-By: 1.8.0_31 (Oracle Corporation)
Main-Class: com.example.jar.JarExample

7. Conclusão

Neste tutorial, configuramos um aplicativo Java simples com uma classemain.

Em seguida, examinamos três maneiras de criar arquivos jar: usando o comandojar, com Maven e com um aplicativo Maven Spring Boot.

Depois de criarmos nossos arquivos jar, retornamos à linha de comando e os executamos com uma classe principal inferida e uma especificada.

Também aprendemos como exibir o conteúdo de um arquivo e como exibir o conteúdo de um único arquivo em um jar.

Tanto oJava example simples quanto oSpring Boot example estão disponíveis no GitHub.

Related