Crear un JAR ejecutable con dependencias usando Maven

Empaquetar proyectos de Maven en un único JAR ejecutable

Cuando se trabaja con proyectos Java, a menudo es necesario empaquetar su aplicación en un único archivo JAR ejecutable para facilitar su distribución. Maven, una poderosa herramienta de automatización de compilación, permite a los desarrolladores incluir todas las dependencias necesarias dentro de este JAR de salida única.

Este artículo lo guiará a través de los pasos necesarios para configurar su proyecto Maven para incluir todos los JAR de dependencia en su JAR ejecutable final. Si sigue estas instrucciones, simplificará el proceso de implementación y garantizará que su aplicación se ejecute sin problemas en diferentes entornos.

Crear y ejecutar un JAR ejecutable con Maven

Los scripts proporcionados anteriormente demuestran cómo configurar un proyecto Maven para empaquetar todas sus dependencias en un único archivo JAR ejecutable. El primer guión es un Maven. pom.xml archivo, que contiene la configuración del proyecto. Dentro de este archivo, el <plugin> La etiqueta se utiliza para definir el complemento de ensamblaje Maven. Este complemento es crucial para crear un JAR ejecutable que incluya todas las dependencias. El <descriptorRefs> La etiqueta dentro de la configuración del complemento especifica el uso del jar-with-dependencies descriptor, que garantiza que todas las dependencias del proyecto estén empaquetadas en el archivo JAR final. El <mainClass> etiqueta dentro del <manifest> La sección es esencial ya que le dice a Maven qué clase contiene el método principal a ejecutar cuando se ejecuta el JAR.

El <execution> El bloque dentro de la configuración del complemento es donde ocurre la acción. Especifica que el objetivo del complemento single debe ejecutarse durante el package fase del ciclo de vida de construcción. Esto es lo que desencadena la creación del archivo JAR con dependencias. El segundo script es una simple instrucción de línea de comando: mvn clean package. Este comando limpia el proyecto (eliminando artefactos de compilación anteriores), compila el código fuente, ejecuta pruebas y empaqueta el proyecto en un archivo JAR. El archivo JAR final se ubicará en el target directorio del proyecto y nombrado de acuerdo con el artifactId y version especificado en el 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 avanzadas de Maven para dependencias de empaquetado

Más allá de la configuración básica para crear un JAR ejecutable con Maven, existen técnicas adicionales que pueden mejorar su proceso de compilación. Una de esas técnicas implica el uso de shade complemento en lugar del assembly enchufar. El complemento Maven Shade ofrece funciones más avanzadas para crear uber-JAR (JAR con dependencias incluidas). Le permite cambiar el nombre de los paquetes para evitar conflictos de classpath y proporciona un mejor manejo de clases y recursos duplicados. Además, ofrece un control detallado sobre qué dependencias se incluyen en el JAR final.

Otro aspecto importante es gestionar el tamaño de su archivo JAR. Los archivos JAR grandes pueden resultar engorrosos y lentos de transferir o cargar. El dieciséis puede ayudar con esto permitiéndole excluir archivos y clases innecesarios, reduciendo así el tamaño del JAR final. También puede configurar el complemento para minimizar el JAR eliminando información no esencial, como clases no utilizadas o recursos redundantes. Estas configuraciones avanzadas pueden resultar particularmente útiles cuando se trabaja en proyectos grandes con numerosas dependencias.

Reflexiones finales sobre los JAR ejecutables de Maven

La creación de un JAR ejecutable con dependencias utilizando Maven simplifica el proceso de implementación de aplicaciones Java. Al configurar correctamente el pom.xml y utilizando complementos como Maven Assembly Plugin o Maven Shade Plugin, los desarrolladores pueden empaquetar todas las dependencias necesarias en un solo archivo JAR. Este enfoque garantiza que la aplicación pueda ejecutarse sin problemas en varios entornos, lo que simplifica la distribución y la ejecución. Seguir estos pasos le ayudará a gestionar las dependencias de su proyecto de forma eficaz y a crear archivos JAR ejecutables y fiables.