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.

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 pom.xml arquivo, que contém a configuração do projeto. Dentro deste arquivo, o <plugin> 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 <descriptorRefs> 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 <mainClass> etiqueta dentro do <manifest> seção é essencial, pois informa ao Maven qual classe contém o método principal a ser executado quando o JAR é executado.

O <execution> O bloco dentro da configuração do plugin é onde a ação acontece. Especifica que o objetivo do plugin single deverá ser executado durante o package 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 target diretório do projeto e nomeado de acordo com o artifactId e version 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 shade plugin em vez do assembly 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 maven-shade-plugin 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.

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 pom.xml 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.