Entrada extra
Cuando trabajamos en un proyecto en lenguaje java nos habremos de dar cuenta que hacemos uso de muchos archivos e inclusive directorios para almacenar nuestro trabajo, y sabemos que si deseamos que alguien más pueda ejecutar nuestro proyecto en su computadora tendríamos que enviarle todos estos archivos y directorios para que lo pueda compilar y ejecutar en su computadora.
Entonces surge el ideal de colocar todos estos archivos y directorios en un único fichero comprimido. Java nos ofrece el comando jar, que nos permite hacer esto. Este comando junta todo lo que le indiquemos, ya sean carpetas completas, clases, imágenes o archivos de datos, y todo lo coloca en un archivo nuevo con extensión .jar.
Este nuevo .jar es similar a ficheros que ya conocemos como los .zip, .rar o los .tar que ya hemos manejado antes. Inclusive descompresores winrar o winzip puedes abrir el contenido de nuestro nuevo fichero con extensión jar.
Además Java nos permite ejecutar el contenido del fichero .jar sin necesidad de desempaquetarlo.
El comando jar
$ jar
A este comando desde el terminal podemos incluirle las siguientes opciones:
c - Indica que vamos a crear un archivo, y si existe ya uno se eliminará.
f - Indicar el nombre del fichero, que va inmediatamente después.
v - Indica que queremos obtener información durante el proceso de creación del archivo.
m - Indica al programa que queremos personalizar el archivo de manifiesto para añadir información adicional.
M - Indica que no se cree el archivo de manifiesto.
0 - Indicamos que no queremos que se comprima el contenido del archivo.
Crear un fichero jar
Antes de la creación de nuestro fichero jar, debemos procurar que nuestros archivos estan compilados y funcionan correctamente.
Nota: Ya que el proceso de compilar y ejecutar archivos java ya es un tanto repetitivo a estas alturas, me salto este paso.
Cuando las clases del programa no pertenecen a paquetes
En este caso solo debemos meter las clases en el .jar, así que nos ubicamos en el directorio donde se encuentran contenidas nuestros archivos .class y ejecutamos el siguiente comando desde el terminal:
$ jar -cf Nuevo.jar fichero1.class fichero2.class fichero3.class
La opción "c" indica que queremos crear un fichero.jar nuevo.
La opción "f" sirve para indicar el nombre del fichero.
Finalmente se pone una lista de ficheros .class, o de cualquier otro tipo que queramos meter en nuestro jar.
También se pueden usar comodines, como *.class para meter todos los .class del directorio.
Cuando las clases del programa pertenecen a paquetes
Para esto debemos meter la estructura de directorios equivalente a los paquetes del proyecto completo.
Nos vamos al directorio padre de donde empiece nuestra estructura de paquetes.
$ jar -cf Nuevo.jar nombredelpaquete
Esto colocará el paquete dentro de nuestro jar.
También podemos incluir los .class indicando el camino relativo para llegar a ellos:
$ jar -cf Nuevo.jar nombredelpaquete/Hola.class
Ejecutar el jar
Tenemos que colocar nuestro fichero .jar en el CLASSPATH, para poder recurrir a él.
Para ejecutar el archivo escribiríamos lo siguiente en el terminal:
$ java -cp ./Nuevo.jar prueba.Hola
Ejecutar de esta manera no es lo mejor, ya que tenemos que ponerle opciones al ejecutar, además debemos conocer el nombre de la clase principal y en que paquete se encuentra.
Afortunadamente java nos ofrece otra posibilidad de forma que no ocupemos tanto rollo. Se trata de un fichero de texto donde metemos una línea en la que se ponga cual es la clase principal. Este fichero se conoce como fichero de manifiesto y su contenido es tan simple como este:
Main-Class: prueba.Hola
El archivo de manifiesto es un archivo de texto plano por lo que podrá ser creado con cualquier editor de textos convencional. El archivo podrá tener cualquier nombre y extensión, ya que lo que el programa jar hará, será mezclar el contenido de este archivo con el que se crea por defecto.
Crear jar agregando nuestro archivo manifiesto
Cuando construimos el jar, debemos incluir este fichero de la siguiente forma. Por ejemplo, si el fichero lo llamamos manifiesto.mf y lo ponemos en el directorio donde vamos a construir el jar, el comando para hacerlo sería este:
$ jar cmf manifiesto.mf Nuevo.jar prueba/Hola.class
Agregamos la opción "m" para indicar que vamos a añadir un fichero de manifiesto.
Importante el orden en que colocamos las cosas; como en las opciones colocamos mf, debemos indicar primero lo que requiere "m" en este caso el archivo manifiesto, y después "f" el nombre de nuestro jar.
Ejecutar nuestro jar
Una vez construido, se ejecuta de la siguiente manera:
$ java -jar Nuevo.jar
La opción "-jar" indica que se va a ejecutar el Nuevo.jar que se ponga a continuación haciendo caso de su fichero de manifiesto y como este fichero de manfiesto dice que la clase principal es prueba.Hola, será esta la que se ejecute.
Con esto podemos entregar directamente nuestro fichero jar a un amigo y listo, no tendrá problemas para ejecutarlo.
Ejemplos
Jar con archivo manifiesto
Como ven en la secuencia de comando de la captura de ventana hago lo siguiente:
-Ver los archivos contenidos de la carpeta "hola".
-Visualizar el contenido del archivo "manifiesto.mf".
-Compilar el archivo "Hola.java".
-Ejecutar "Hola" para verificar que funciona.
-Crear el fichero jar.
-Ver nuevamente el contenido de la carpeta.
-Ejecutar el contenido del fichero jar.
Así se ven los archivos finales:
Jar con archivo manifiesto y clases contenidas en un paquete
Ahora una prueba con otro ejemplo, en este caso lo realizado fue:
-Primero compilo los archivos .java contenidos en el paquete "graficador".
-Ejecuto la clase principal del paquete para corroborar que funciona.
-Vemos los archivos contenidos en el directorio actual.
-Creamos el fichero jar.
-Volvemos a ver los archivos contenidos, y vemos que se creo nuestro jar.
.Por último ejecutamos el jar para probar.
Esta es una imagen de como resulta después de la ejecución del jar:
Espero les haya servido para que ustedes hagan sus propios jar y puedan compartir sus proyectos. Cabe mencionar que es posible crear estos jar sin necesidad de incluir los archivos .java para evitar que alguien nos copie, y al solo incluir los .class solo podrán ejecutar y ver como va nuestro proyecto.
Les dejo los .jar de los ejemplos para que prueben verlos.
Descargar ejemplos desde MediaFire:
HolaMundo.jar
Graficador.jar
Referencias:
Ficheros JAR
Jar ejecutable
