Creando un .EXE a partir de un Jar

Siempre me pregunté como apliaciones como JEdit y Eclipse siendo apliaciones puras en Java utilizaban un ejecutable (.exe) para iniciar. Hace un par de año hice la investigación por curiosidad y no encontré nada práctico.

Nuevamente me encontré con la necesidad de empaquetar un jar y entregarlo como un ejecutable. Para esto encontré dos herramientas (debe haber más, pero mi busqueda solo duro 5 minutos): JSmooth y Launch4J.

JSmooth estaba en en su versión 0.9.7 al momento de este escrito. Se veia amigable pero el código no ha sido actualizado desde el 2007.

Launch4J estaba en su versión 3.0.1 al momento de este escrito. Su último release fue en 2008, por eso me decidí a probarlo.

Fue muy facil crear el exe a partir del jar empaquetado. Es importante notar que el jar que estaba utilizando contenía todas las librerías requeridas. No estoy seguro que haría con jars separados.

No respository found at http://subclipse.tigris.org/update_1.6.x

Hace poco trate de instalar el plugin de Subversion para Eclipse y me encontre que no podia conectarme al repositori http://subclipse.tigris.org/update_1.6.x. Eclipse 3.5.2 me daba un mensaje que leia "No respository found at http://subclipse.tigris.org/update_1.6.x".

Después de verificar que tenia conexión de red y que el sitio esta en linea. Empece a investigar. La verdad es que no econtré nada útil.

En un acto deseperado seleccione "Available Software Sites" en la ventana Install (Se invoca desde el menú Help\Install New Software...). Esto abre la ventana Preferences en donde seleccione la librería con el Location http://subclipse.tigris.org/update_1.6.x e hice clic en "Test Connection".

Después de esto empezo a funcionar.

Templates en Eclipse

Plantillas de Eclipse

Eclipse cuenta por defecto con una serie de plantillas que se pueden invocar tecleando un unas cuantas letras e invocando autocomplete (control+space). Entre mis favoritas están:
sysout : crea una linea de código para System.out.println();
main: crea un metodo main con sus argumentos.

Plantillas Personalizadas

Una de las funcionalidades que más me gusta de Eclipse es poder crear plantillas de código que se usa de forma repetitiva. Por ejemplo acostumbro usar la librería Log4J para crear "loggear" información dentro de mi código. Para poder utilizar la clase Logger debo instanciar un objeto en cada clase, esto implica escribir una línea de código como

private static org.apache.log4j.Logger logger = org.apache.log4j.Logger
   .getLogger(MapAdminPanel.class);

En lo personal su amigo del copy-paste pero el nombre de la clase varía. Esto implica que si copio el código de arriba en otra clase luego debo editar MapAdminPanel y cambiarlo por el nombre de la clase en que lo copie.

Usando una plantilla (Template) puedo teclear lg dar control+space y Eclipse me insertará el código con en nombre de la clase donde lo estoy creando.

Para crear esta plantilla siga los siguientes pasos:

1. Abrir Window\Preferences (Eclipse\Preferences en Mac)



2. Muévase a Java\Editor\Templates y haga clic en New. Llene la pantalla como se muestra.
   Name es el nombre con que se invocara la plantilla en nuestro caso "lg", Context es el contexto en que la plantilla funcionará utilice Java. Pattern es el código que se insertará utilice el siguiente código.
   



private static org.apache.log4j.Logger logger = org.apache.log4j.Logger
   .getLogger(${enclosing_type}.class);


Note que en vez de utilizar el nombre de la clase se utiliza la variable enclosing_type. Eclipse reemplazará por usted el nombre de la clase al ser insertado

3. Haga clic en Ok
4. Haga clic en Ok en la ventana de Preferences.
   

Para probarlo abra una clase existente o cree una nueva. Dentro de la clase teclee lg y control+space y le aparecerá las opción de insertar el código.

Guardando las Plantillas

Eclipse guarda la configuración de las plantillas en el workspace. Esto quiere decir que si crea un workspace nuevo tendría que recrear todas las plantillas nuevamente. Afortunadamente podemos exportarlos a un archivo xml y luego importarlo en el nuevo workspace.

Para demostrar la flexibilidad de exportar e importar plantillas vamos a crear una plantilla personalizada adicional.

Regularmente acostumbro "loggear" los errores de una excepción utilizando Log4J en un formato estándar como se muestra:

                try {
                     passGen.setTemplate("oAAannaonn");
                     passGen.generatePassword();
                     logger.debug("Password template: "+ passGen.getPassword());
             } catch (ParseException e) {
                     String msg = "%s: %s";
                     msg = String.format(msg, e.getClass().getName(), e.getMessage());
                     logger.error(msg);
                     fail(msg);
             }

El código en negrita se repite una y otra vez a lo largo del código.

Siguiendo los pasos anteriores vamos a crear una plantilla con la siguiente información:
Name: lge
Description: log exception to Log4J
Contrext: Java Statement. Esto forzara que la plantilla solo funcione dentro de un método.
Pattern:

 String msg = "%s: %s";
msg = String.format(msg, e.getClass().getName(), e.getMessage());
logger.error(msg);

Para exportar las plantillas siga los siguientes pasos:

1. Abrir Window\Preferences (Eclipse\Preferences en Mac)


2. Muévase a Java\Editor\Templates. Seleccion las plantillas lg y lge.


3. Haga clic en Export. Asignele un nombre apropiado (logging_templates.xml por ejemplo) y listo.

Este archivo puede ser importado en otro workspace o por otro usuario. Esto permite compartir plantillas estándares.

Configuración de Pruebas JUnit

Durante la realización de pruebas unitarias existen variables comunes en todas las pruebas por ejemplo directorios de salida, directorio de datos etc.

En vez de crear estas variables en cada prueba unitaria utilizo la clase TestConfiguration.

TestConfiguration es Singleton que permite accesar el outputPath (directorio de salida) y el testDataPath (directorio con datos de prueba). Además inicializa el Logger de Log4J.

En el constructor de cada prueba unitaria solo hay que insertar el siguiente código y Log4J queda configurado segun el log4jprops.xml (ver código).

  TestConfiguration.getInstance();

El siguiente es el código de TestConfiguration

package org.gissolution.photodb;

import java.io.File;
import java.net.URL;

import org.apache.log4j.xml.DOMConfigurator;

public class TestConfiguration {
        private static org.apache.log4j.Logger logger = org.apache.log4j.Logger
                        .getLogger(TestConfiguration.class);
        private static TestConfiguration testConfig = null;
        private final String outputPath;
        private final String testDataPath;
        protected TestConfiguration() {
                File out = new File("output");
                File data = new File("test_data");
                this.outputPath = out.getAbsolutePath();
                this.testDataPath = data.getAbsolutePath();
                String configfile = "/log4jprops.xml";
                URL url = this.getClass().getResource(configfile);
                DOMConfigurator.configure(url);
                logger.info("Log4j configured with " + url.getFile());
                
        }

        public static TestConfiguration getInstance() {
                if (testConfig == null) {
                        testConfig = new TestConfiguration();
                }
                return testConfig;
        }

        public String getOutputPath() {
                return outputPath;
        }
        
        public String getTestDataPath() {
                return testDataPath;
        }
        
        public static String getExistingTestData(String relativePath) {
                String tpath = TestConfiguration.getInstance().getTestDataPath();
                File f = new File(tpath + File.separator + relativePath);
                if(f.exists()) {
                        return f.getAbsolutePath();
                }else {
                        throw new IllegalArgumentException(f.getAbsolutePath() + " no existe");
                }
        }

        public static void main(String[] args) {
                System.out.println("Output path: " + TestConfiguration.getInstance().getOutputPath());
                System.out.println("Test Data path: " + TestConfiguration.getInstance().getTestDataPath());
        }