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.

Dominio	Descripción
<plugin>	Define un complemento de Maven para usar durante el proceso de compilación. Los complementos pueden ejecutar tareas específicas, como compilar código o empaquetar el proyecto.
<groupId>	Especifica el identificador de grupo para el proyecto Maven, normalmente un nombre de dominio inverso.
<artifactId>	Define el identificador del artefacto, que es el nombre del proyecto.
<version>	Indica la versión actual del proyecto.
<build>	Contiene la configuración de compilación para el proyecto, incluidos complementos y recursos.
<descriptorRef>	Hace referencia a un descriptor predefinido para que lo utilice el complemento de ensamblaje de Maven, como "jar-with-dependencies".
<mainClass>	Especifica la clase principal que se ejecutará cuando se ejecute el archivo JAR.
<execution>	Define un bloque de ejecución dentro de un complemento, especificando las tareas que se realizarán en diferentes fases de compilación.
mvn clean package	Comando para limpiar el proyecto y empaquetarlo en un archivo JAR, incluidas todas las dependencias.
java -jar target/...jar	Comando para ejecutar el archivo JAR generado, especificando la ruta al JAR.

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. archivo, que contiene la configuración del proyecto. Dentro de este archivo, el 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 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 etiqueta dentro del 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 El bloque dentro de la configuración del complemento es donde ocurre la acción. Especifica que el objetivo del complemento debe ejecutarse durante el 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 directorio del proyecto y nombrado de acuerdo con el y 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 complemento en lugar del 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 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.

1. ¿Cómo especifico la clase principal en mi JAR?
2. Puede especificar la clase principal usando el etiqueta dentro del sección de la configuración del complemento Maven.
3. ¿Cómo puedo excluir dependencias específicas del JAR final?
4. Utilizar el etiqueta dentro de la configuración del complemento para especificar dependencias que no deben incluirse en el JAR final.
5. ¿Qué es un uber-JAR?
6. Un uber-JAR es un archivo JAR que contiene no sólo el código compilado sino también todas sus dependencias.
7. ¿Cómo puedo evitar conflictos de classpath en mi JAR?
8. El le permite cambiar el nombre de los paquetes dentro de las dependencias para evitar conflictos.
9. ¿Cómo manejo clases duplicadas en dependencias?
10. Configurar el para gestionar clases y recursos duplicados especificando cómo se deben manejar los duplicados en el JAR final.
11. ¿Puedo incluir sólo archivos específicos de una dependencia?
12. Sí, puedes configurar el o para incluir solo archivos específicos de una dependencia.
13. ¿Cómo ejecuto el JAR empaquetado?
14. Utilizar el comando seguido de la ruta a su archivo JAR.
15. ¿Cómo puedo verificar el contenido de mi archivo JAR?
16. Puedes usar el comando para enumerar el contenido del archivo JAR.
17. ¿Qué pasa si mi archivo JAR es demasiado grande?
18. Utilizar el para excluir archivos innecesarios y minimizar el tamaño del JAR.

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