Criando um JAR executável com dependências usando Maven

Empacotando projetos Maven em um único JAR executável

Ao trabalhar com projetos Java, muitas vezes é necessário empacotar seu aplicativo em um único arquivo JAR executável para facilitar a distribuição. Maven, uma poderosa ferramenta de automação de construção, permite que os desenvolvedores incluam todas as dependências necessárias neste único JAR de saída.

Este artigo irá guiá-lo pelas etapas necessárias para configurar seu projeto Maven para incluir todos os JARs de dependência em seu JAR executável final. Seguindo estas instruções, você simplificará o processo de implantação e garantirá que seu aplicativo funcione perfeitamente em diferentes ambientes.

Comando	Descrição
<plugin>	Define um plugin Maven para usar durante o processo de construção. Os plug-ins podem executar tarefas específicas, como compilar código ou empacotar o projeto.
<groupId>	Especifica o identificador de grupo do projeto Maven, geralmente um nome de domínio reverso.
<artifactId>	Define o identificador do artefato, que é o nome do projeto.
<version>	Indica a versão atual do projeto.
<build>	Contém a configuração de construção do projeto, incluindo plug-ins e recursos.
<descriptorRef>	Faz referência a um descritor predefinido para uso do plug-in Maven Assembly, como "jar-with-dependencies".
<mainClass>	Especifica a classe principal a ser executada quando o arquivo JAR for executado.
<execution>	Define um bloco de execução dentro de um plugin, especificando tarefas a serem executadas em diferentes fases de construção.
mvn clean package	Comando para limpar o projeto e empacotá-lo em um arquivo JAR, incluindo todas as dependências.
java -jar target/...jar	Comando para executar o arquivo JAR gerado, especificando o caminho para o JAR.

Criando e executando um JAR executável com Maven

Os scripts fornecidos acima demonstram como configurar um projeto Maven para empacotar todas as suas dependências em um único arquivo JAR executável. O primeiro script é um Maven arquivo, que contém a configuração do projeto. Dentro deste arquivo, o tag é usada para definir o plug-in Maven Assembly. Este plugin é crucial para criar um JAR executável que inclua todas as dependências. O tag dentro da configuração do plugin especifica o uso do jar-with-dependencies descritor, que garante que todas as dependências do projeto sejam empacotadas no arquivo JAR final. O etiqueta dentro do seção é essencial, pois informa ao Maven qual classe contém o método principal a ser executado quando o JAR é executado.

O O bloco dentro da configuração do plugin é onde a ação acontece. Especifica que o objetivo do plugin deverá ser executado durante o fase do ciclo de vida da construção. É isso que aciona a criação do arquivo JAR com dependências. O segundo script é uma instrução simples de linha de comando: mvn clean package. Este comando limpa o projeto (removendo artefatos de construção anteriores), compila o código-fonte, executa testes e empacota o projeto em um arquivo JAR. O arquivo JAR final estará localizado no diretório do projeto e nomeado de acordo com o e especificado no pom.xml.

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.example</groupId>
    <artifactId>my-app</artifactId>
    <version>1.0-SNAPSHOT</version>
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-assembly-plugin</artifactId>
                <version>3.3.0</version>
                <configuration>
                    <descriptorRefs>
                        <descriptorRef>jar-with-dependencies</descriptorRef>
                    </descriptorRefs>
                    <archive>
                        <manifest>
                            <mainClass>com.example.MainClass</mainClass>
                        </manifest>
                    </archive>
                </configuration>
                <executions>
                    <execution>
                        <id>make-assembly</id>
                        <phase>package</phase>
                        <goals>
                            <goal>single</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>

mvn clean package
# This command will compile the code, run the tests, and create the JAR file
# The JAR file will include all dependencies specified in the pom.xml
# It will be located in the target directory of the project
# The final JAR file will be named my-app-1.0-SNAPSHOT-jar-with-dependencies.jar

# To run the JAR file, use the following command:
java -jar target/my-app-1.0-SNAPSHOT-jar-with-dependencies.jar
# Ensure that the mainClass specified in the pom.xml is correct
# This will start your application with all dependencies included

Técnicas avançadas do Maven para empacotamento de dependências

Além da configuração básica para criar um JAR executável com Maven, existem técnicas adicionais que podem aprimorar seu processo de construção. Uma dessas técnicas envolve o uso do plugin em vez do plugar. O plug-in Maven Shade oferece recursos mais avançados para a criação de uber-JARs (JARs com dependências incluídas). Ele permite renomear pacotes para evitar conflitos de caminho de classe e fornece melhor tratamento para classes e recursos duplicados. Além disso, oferece controle refinado sobre quais dependências são incluídas no JAR final.

Outro aspecto importante é gerenciar o tamanho do seu arquivo JAR. Arquivos JAR grandes podem ser complicados e lentos para transferir ou carregar. O pode ajudar com isso, permitindo excluir arquivos e classes desnecessários, reduzindo assim o tamanho do JAR final. Você também pode configurar o plugin para minimizar o JAR removendo informações não essenciais, como classes não utilizadas ou recursos redundantes. Essas configurações avançadas podem ser particularmente úteis ao trabalhar em projetos grandes com inúmeras dependências.

1. Como especifico a classe principal no meu JAR?
2. Você pode especificar a classe principal usando o etiqueta dentro do seção da configuração do plugin Maven.
3. Como posso excluir dependências específicas do JAR final?
4. Use o tag dentro da configuração do plugin para especificar dependências que não devem ser incluídas no JAR final.
5. O que é um uber-JAR?
6. Um uber-JAR é um arquivo JAR que contém não apenas seu código compilado, mas também todas as suas dependências.
7. Como posso evitar conflitos de classpath no meu JAR?
8. O permite renomear pacotes dentro de dependências para evitar conflitos.
9. Como lidar com classes duplicadas em dependências?
10. Configurar o para gerenciar classes e recursos duplicados, especificando como as duplicatas devem ser tratadas no JAR final.
11. Posso incluir apenas arquivos específicos de uma dependência?
12. Sim, você pode configurar o ou para incluir apenas arquivos específicos de uma dependência.
13. Como executo o JAR empacotado?
14. Use o comando seguido pelo caminho para seu arquivo JAR.
15. Como posso verificar o conteúdo do meu arquivo JAR?
16. Você pode usar o comando para listar o conteúdo do arquivo JAR.
17. E se meu arquivo JAR for muito grande?
18. Use o para excluir arquivos desnecessários e minimizar o tamanho do JAR.

Considerações finais sobre JARs executáveis ​​do Maven

A criação de um JAR executável com dependências usando Maven simplifica o processo de implantação de aplicativos Java. Ao configurar corretamente o arquivo e utilizando plug-ins como o Maven Assembly Plugin ou Maven Shade Plugin, os desenvolvedores podem empacotar todas as dependências necessárias em um único arquivo JAR. Essa abordagem garante que o aplicativo possa ser executado perfeitamente em vários ambientes, simplificando a distribuição e a execução. Seguir essas etapas o ajudará a gerenciar as dependências do seu projeto de maneira eficaz e a criar arquivos JAR executáveis ​​e confiáveis.