Generar un archivo ejecutable con Java

En Java, en principio, no se pueden crear autoejecutables ya que este es un lenguaje multiplataforma y los archivos autoejecutables son dependientes de la plataforma. Esto provoca que tengamos que usar la consola para ejecutar nuestros programas; lo que supone un gran inconveniente para usuarios sobre todo acostumbrados a los entornos gráficos.

Existen varias soluciones para este asunto. Aquí se explican tres de ellas. La primera es la de crear ejecutables dependientes de la plataforma ; la segunda permite hacer más fácil la ejecución en cada plataforma sin impedir su ejecución en otra plataforma; la tercera es válida para cualquier plataforma y aporta otras muchas posibilidades.


 

Podemos crear un ejecutable de la plataforma de varias maneras:

Podemos usar traducir el código java a código C con Toba o J2C. De esta forma sólo nos queda compilar el código C para crear el ejecutable. Toba es un proyecto libre cuyo desarrollo ha quedado estancado cuando Java iba por la versión 1.1, pero podemos descargarlo todavía desde su página web. J2C lo puedes encontrar aquí (creo; cuando veas la página sabrás el porqué de mis dudas),

Existe un compilador que además de permitirnos, como cualquier otro compilador, crear bytecodes a partir de ficheros .java, nos da la posibilidad de compilar el fuente (archivos .java) para obtener un ejecutable de la plataforma y también permite crear un ejecutable de la plataforma a partir del bytecode. De esta forma el código obtenido es mucho más rápido. El programa se llama GJC y forma parte la familia de compiladores GCC del proyecto GNU que se desarrolla bajo la GPL (General Public License).

Si lo que queremos es crear un archivo ejecutable .exe (para plataforma Windows) y prescindir de la cualidad de multiplataforma de este lenguaje, lo que hay que hacer es conseguir un programa que realice esta tarea. Esto lo hacen algunas IDE’s y el programa JtoExe. Al crear un .exe lo que hacemos es sustituir los archivos de clase de Java, al contrario que la siguiente opción que complementa y no sustituye. En particular el programa JtoExe necesita de la máquina virtual de Java para poder ejecutar el programa de modo seguiremos necesitando instalar la JVM al contrario que las dos opciones anteriores.


Crear scripts

Otra posibilidad, que nos permite mantener la multiplataforma es crear un script para cada plataforma. Esto lo que nos permite es facilitar la ejecución dentro de cada plataforma sin evitar que podamos ejecutar el programa en otra para la que no hayamos creado un script. Bueno para el que no haya entendido nada hasta aquí o no sepa lo que es un script lo voy a explicar más claramente. Un script no es más que un archivo en el que se guardan los comandos que se teclearían en la consola (es decir, lo que teclearías en una ventana MS-DOS en caso de usar este Sistema Operativo o en una shell para los que usen Unix) para que fuera interpretados por el intérprete de comandos.

Archivos .bat

Los script de Windows/MS-DOS se llaman archivos por lotes de MS-DOS, y su extensión es .bat. De este modo solamente tenemos que crear un archivo de este tipo cuya única línea sea la siguiente:

javaw ClasePrincipal

Ya sólo nos queda ejecutarlo con un doble click en el navegador de archivos y se lanzará la aplicación por medio del programa javaw del JDK (deberá estar indicada la ruta de este programa en la variable de entorno PATH). También podríamos haber usado el programa java.exe. Esta solución tiene un inconveniente: se abre una ventana de MS-DOS muy incómoda. Si usamos el programa javaw.exe esta ventana podrá cerrarse nada más ser lanzada la aplicación y si usamos el programa java.exe sólo podrá cerrarse una vez finalizada la aplicación.

Scripts en Unix

Para los que usen Unix crear el script no debe tener mucha dificultad. Podemos crearlo desde la shell de la siguiente forma:

shell>echo ‘java ClasePrincipal’ > nombre_archivo_del_script

Siendo ClasePrincipal la clase que se ha de ejecutar y estando la ruta hacia el programa java en la variable de entorno PATH y la ruta hacia ClasePrincipal en la variable de entorno CLASSPATH. Y posteriormente ejecutarlo de la siguiente forma:

shell>sh nombre_archivo_del_script

Aunque también podríamos ejecutarlo, aunque para ello deberíamos darle los permisos adecuados. Una vez dados estos permisos lo podríamos ejecutar desde la shell de la siguiente forma:

shell>./nombre_archivo_del_script

O de la siguiente si en la variable de entorno PATH se ha especificado el directorio actual

shell>nombre_archivo_del_script


Ejecutar directamente desde Linux

Desde la versión del Kernel 2.2.10 existe una posibilidad a la hora de compilar el kernel que nos permite ejecutar directamente un bytecode como si se tratara de un binario para Linux. Para ello necesitaremos compilar un kernel con la opción de Misc Binaries. Tendremos que crear un script para lanzar las clases (esto no será necesario para los applets). De este modo bastará con cambiar los permisos del bytecode para permitir su ejecución y ya podremos lanzar nuestro applet o aplicación como un ejecutable más. Todo ello se explica en la documentación del kernel 2.2.10.


Archivos jar

La última y más recomendada posibilidad es la de hacer un archivo jar ejecutable. Los archivos jar permiten introducir todos los archivos necesarios para ejecutar nuestra aplicación (clases, imágens, sonidos, archivos de texto, …) en uno solo con la posibilidad de comprimirlos. Pero además ofrecen otras posibilidades, entre las que se encuentra la posibilidad de añadir información adicional: versión del programa, quién lo ha creado, … y la que en nuestro caso nos interesa: indicar la clase principal (la que contiene el método main) para poder ejecutarla con el intérprete del JDK (el programa java). Esta información se guarda en un archivo dentro del jar, que se llama MANIFEST.MF cuya ruta dentro del archivo jar será siempre META-INF/MANIFEST.MF. Este archivo es creado por defecto siempre que se crea un archivo jar. Este archivo se puede personalizar, y ahora veremos como:

Para administrar un archivo jar se usa el programa jar del JDK.

Crear un arhchivo jar

A continuación se muestra un ejemplo de cómo crear un archivo jar con las opciones más usuales.

jar cfv MiArchivo.jar Clase1.class Clase2.class Imagen.gif Sonido.au OtrosArchivos

En esta ocasión se ha creado un archivo jar de nombre MiArchivo.jar que contendrá los archivos Clase1.class, Clase2.class, Imagen.gif y Sonido.au y el directorio OtrosArchivos. Como se puede observar en un archivo jar podemos meter cualquier tipo de archivo, incluso directorios. Si exite alguna referencia a archivos dentro de otro directorio estas se mantendrán sin producirse errores ya que la jerarquía de directorios se mantiene dentro del archivo. En el ejemplo se han empleado las opciones c, f y v de la línea de comandos. Estas opciones y otras se explican a continuación:

c .- Indica que vamos a crear un archivo.
f .- Indica que la salida quieres que vaya a un fichero, y no a la salida estandar.
v .- Indica que quieres 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.

Modificar el archivo de manifiesto

Llegados a este punto tenemos que crear el archivo de manifiesto. El archivo de manifiesto es un archivo de texto plano (sin formato) por lo que podrá ser creado con cualquier editor de textos convencional. El archivo podrá tener cualquier nombre y/o extensión ya que lo que el programa jar lo que hará será mezclar el contendio de este archivo con el que se crea por defecto.

En nuestro caso el archivo de manifiesto tendrá una sola línea en la que indicaremos la clase principal (la que contiene el método main). Esto se hace de la siguiente forma:

Main-Class: ClasePrincipal

De este modo se indica cual es la clase principal (sin .class). Ahora deberemos crear el archivo jar con esta información. A continuación se muestra un ejemplo:

jar cfm MiManifiesto.mf MiArchivo.jar ClasePrincipal.class OtraClase.class Imagen.gif

Se observa que tras las opciones, en las que está la opción m explicada anteriormente, se indica el nombre del archivo de manifiesto. Ahora solamente tendremos que indicar que los archivos .jar se abran con el programa java y con la opción -jar en la línea de comandos. Esto ya lo hace el instalador del J2SDK por lo que no será necesario hacerlo a mano.

Gimenete
http://gimenete.net/

One Comment

Leave A Comment?