Guía para crear y ejecutar un archivo Jar en Java

Programación

1. Información general

Por lo general, es conveniente agrupar muchos archivos de clase Java en un solo archivo.

En este tutorial, vamos a cubrir los entresijos de trabajar con archivos jar - o J ava AR chive - en Java.

Específicamente, tomaremos una aplicación simple y exploraremos diferentes formas de empaquetarla y ejecutarla como un jar. También responderemos algunas curiosidades como cómo leer fácilmente el archivo de manifiesto de un jar en el camino.

2. Configuración del programa Java

Antes de que podamos crear un archivo jar ejecutable, nuestra aplicación necesita tener una clase con un método principal . Esta clase proporciona nuestro punto de entrada a la aplicación:

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

3. Jar Command

Ahora que estamos todos configurados, compilemos nuestro código y creemos nuestro archivo jar.

Podemos hacer esto con javac desde la línea de comando:

javac com/baeldung/jar/*.java

El comando javac crea JarExample.class en el directorio com / baeldung / jar . Ahora podemos empaquetar eso en un archivo jar.

3.1. Uso de los valores predeterminados

Para crear el archivo jar, usaremos el comando jar .

Para usar el comando jar para crear un archivo jar, necesitamos usar la opción c para indicar que estamos creando un archivo y la opción f para especificar el archivo:

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

3.2. Configuración de la clase principal

Es útil que el manifiesto del archivo jar incluya la clase principal.

El manifiesto es un archivo especial en un contenedor ubicado en el directorio META-INF y llamado MANIFEST.MF . El archivo de manifiesto contiene metainformación especial sobre archivos dentro del archivo jar.

Algunos ejemplos de para qué podemos usar un archivo de manifiesto incluyen configurar el punto de entrada, configurar la información de la versión y configurar la ruta de clases.

Al usar la opción e , podemos especificar nuestro punto de entrada y el comando jar lo agregará al archivo de manifiesto generado.

Ejecutemos jar con un punto de entrada especificado:

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

3.3. Actualización de los contenidos

Digamos que hicimos un cambio en una de nuestras clases y la volvimos a compilar. Ahora, necesitamos actualizar nuestro archivo jar.

Usemos el comando jar con la opción u para actualizar su contenido:

jar uf JarExample.jar com/baeldung/jar/JarExample.class

3.4. Configuración de un archivo de manifiesto

En algunos casos, es posible que necesitemos tener más control sobre lo que va en nuestro archivo de manifiesto. El comando jar proporciona funcionalidad para proporcionar nuestra propia información de manifiesto.

Agreguemos un archivo de manifiesto parcial llamado example_manifest.txt a nuestra aplicación para establecer nuestro punto de entrada:

Main-Class: com.baeldung.jar.JarExample

La información del manifiesto que proporcionamos se agregará a lo que genera el comando jar, por lo que es la única línea que necesitamos en el archivo.

Es importante que terminemos nuestro archivo de manifiesto con una nueva línea . Sin la nueva línea, nuestro archivo de manifiesto se ignorará en silencio.

Con esa configuración, creemos nuestro jar nuevamente usando nuestra información de manifiesto y la opción m :

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

3.5. Salida detallada

Si queremos obtener más información del comando jar , simplemente podemos agregar la opción v para verbose.

Ejecutemos nuestro comando jar con la opción v :

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

4. Usando Maven

4.1. Configuración predeterminada

También podemos usar Maven para crear nuestro tarro. Dado que Maven favorece la convención sobre la configuración, podemos simplemente ejecutar el paquete para crear nuestro archivo jar.

mvn package

De forma predeterminada, nuestro archivo jar se agregará a la carpeta de destino en nuestro proyecto.

4.2. Indicar la clase principal

También podemos configurar Maven para especificar la clase principal y crear un archivo jar ejecutable.

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

5. Usando Spring Boot

5.1. Uso de Maven y valores predeterminados

If we're using Spring Boot with Maven, we should first confirm that our packaging setting is set to jar rather than war in our pom.xml file.

4.0.0 spring-boot jar spring-boot

Once we know that's configured, we can run the package goal:

mvn package

5.2. Setting the Entry Point

Setting our main class is where we find differences between creating a jar with a regular Java application and a fat jar for a Spring Boot application. In a Spring Boot application, the main class is actually org.springframework.boot.loader.JarLauncher.

Although our example isn't a Spring Boot application, we could easily set it up to be a Spring Boot console application.

Our main class should be specified as the start class:

 com.baeldung.jar.JarExample

We can also use Gradle to create a Spring Boot fat jar.

6. Running the Jar

Now that we've got our jar file, we can run it. We run jar files using the java command.

6.1. Inferring the Main Class

Since we've gone ahead and made sure our main class is specified in the manifest, 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. Specifying the Main Class

We can also specify the main class when we're running our application. We can use the -cp option to ensure that our jar file is in the classpath and then provide our main class in the package.className format:

java -cp JarExample.jar com.baeldung.jar.JarExample

Using path separators instead of package format also works:

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

6.3. Listing the Contents of a Jar

We can use the jar command to list the contents of our jar file:

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

6.4. Viewing the Manifest File

Since it can be important to know what's in our MANIFEST.MF file, let's look at a quick and easy way we can peek at the contents without leaving the command line.

Let's use the unzip command with the -p option:

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

7. Conclusion

In this tutorial, we set up a simple Java application with a main class.

Then we looked at three ways of creating jar files: using the jar command, with Maven and with a Maven Spring Boot application.

Después de que creamos nuestros archivos jar, volvimos a la línea de comando y los ejecutamos con una clase principal inferida y una especificada.

También aprendimos cómo mostrar el contenido de un archivo y cómo mostrar el contenido de un solo archivo dentro de un jar.

Tanto el ejemplo simple de Java como el ejemplo de Spring Boot están disponibles en GitHub.