Garbage In, Garbage Out

Surefire es el plugin de Maven que se encarga de los tests. Por defecto, deja sus informes en un fichero en el directorio target.

Para la mayoria de la gente (como yo) es tedioso tener que acceder al fichero, abrirlo, y buscar la linea que te interesa. Con este comando haces que surefire saque los informes por consola:

mvn test -Dsurefire.useFile=false

EasyMock es una libreria muy util para hacer pruebas unitarias con JUnit. Nos sirve para crear cualquier objeto fantasma (mock) y hacer que devuelva un resultado concreto para una entrada concreta.

Por ejemplo, si queremos probar un servicio que necesita un DAO para obtener un dato, podemos crear un DAO fantasma (mock) que realice esa funcion y asi librarnos de dependencias y probar el servicio unitariamente.

Para usar EasyMock tan solo hay que hacer 3 cosas:

1. Crear el objeto fantasma (mock) con createMock

    IMyDAO mockDAO = EasyMock.createMock(IMyDAO.class);
    

2. Proporcionar los parametros de entrada concretos y los objetos de salida concretos (si es necesario) con expect:

    DAOPK pk = new DAOPK("111"); // clave de lo que se busca
    DAOReturn return = new DAOReturn("Alex");
    EasyMock.expect(mockDAO.find(pk)).andReturn(return);
    

3. Generar la implementacion del mock con replay:

    EasyMock.replay(mockDAO);

Asi ya tendriamos un mock para el DAO y podriamos probar el servicio pasandole este mock:

 MyService service = new MyService();
 service.setDao(mockDAO);
 
 Customer customer = new Customer("111");
 service.findCustumer(customer);
 

Acabo de encontrar un plugin para Eclipse muy util que inserta en el menu contextual (el menu que sale con el boton derecho) opciones para poder ver la implementacion de un metodo de una interfaz:

Implementors Eclipse Plug-in

Es decir, si tenemos un bean que usa una interfaz de este tipo:

 public class MyClass {
   
   private MyInterface bean;
   ...
   public void myMethod {
       bean.callMethod();
   }
 }
 

Si hacemos clic con el boton derecho sobre "callMethod", veremos una opcion "Open Implementation" que nos permitira ver el codigo de la implementacion en lugar de ir a la declaracion del metodo en la interfaz.

A mi me ha pasado muchas veces que al cuarto o quinto despliegue en Tomcat, saltan excepciones del tipo PermGen OutOfMemoryError.

Gracias a mi red en del.icio.us , he encontrado una posible solucion añadiendo los siguientes parametros a la maquina virtual que ejecuta Tomcat (o el contenedor J2EE que tengas):

 
 -XX:+UseConcMarkSweepGC
 -XX:+CMSPermGenSweepingEnabled
 -XX:+CMSClassUnloadingEnabled
 -XX:MaxPermSize=128m
 
 

La explicacion en ingles en: Notes to self .

Supongo que muchos ya sabeis las diferencias entre String y StringBuffer. Basicamente, String es sincrono y por tanto mas lento, y StringBuffer es asincrono y mas rapido. Hay mas diferencias, pero os remito a la API JDK5 .

En JDK5 hay una clase nueva llamada StringBuilder que tiene el mismo API que StringBuffer , es asincrona, pero es mas rapida. Se supone que va a sustituir StringBuffer asi que es mejor usar la nueva.

[Perdonad las faltas de ortografia, pero los britanicos no tienen acentos ni enies]

Nueva version de JDK, problemas de compatibilidad con lo antiguo. Gracias a mi red en del.icio.us , he encontrado este plugin "retrotranslator" para maven que transforma clases JDK5 a JDK1.4. Gracias dahernan! Siempre ojo avizor. ;)

Hasta que he empezado a trabajar en mi nueva empresa, nunca me había dado de las novedades en el lenguaje en Java 1.5.

1. Tipos de datos parametrizados, es decir, ahora se puede especificar el tipo de datos que contienen estructuras tales como Vector o Map.

   // Vector de cadenas
    Vector<String> v = new Vector<String>();
    v.addElement("Hola");
    String s = v.getElementAt(0);
    v.addElement(new Integer(20));// Daría error!!
    
    // HashMap con claves enteras y valores de vectores
    HashMap<Integer, Vector> hm = new HashMap<Integer, Vector>();
    hm.put(1, v);
    Vector v2 = hm.get(1);

   Esto permite evitar el uso de castings y de autoboxing:

   Vector<Integer> v = new Vector<Integer>();
    v.addElement(30);
    Integer n = v.getElementAt(0);
    n = n+1;

2. Mejoras en blucles. Ahora existe un nuevo for para recorrer colecciones y arrays sin usar Iterator:

   // Recorre e imprime todos los elementos de un array
    int[] arrayInt = {1, 20, 30, 2, 3, 5};
    for(int elemento: arrayInt)
    System.out.println (elemento);
    
    // Recorre e imprime todos los elementos de un Vector
    Vector<String> v = new Vector<String>();
    for(String cadena: v)
    System.out.println (cadena);

3. Tipo Enum.

   // Define una lista de 3 valores y luego comprueba en un switch 
    // cuál es el valor que tiene un objeto de ese tipo
    enum EstadoCivil {soltero, casado, divorciado};
    EstadoCivil ec = EstadoCivil.casado;
    ec = EstadoCivil.soltero;
    switch(ec)
    {
    case soltero:System.out.println("Es soltero");
    break;
    case casado:System.out.println("Es casado");
    break;
    case divorciado:System.out.println("Es divorciado");
    break;
    }

4. Imports estáticos. Permiten usar métodos y propiedades estáticas sin tener que referenciar la clase específicamente.

   import static java.awt.Color;
    import static java.lang.Math;
    
    public class... 
    {
    ...
    JLabel lbl = new JLabel();
    lbl.setBackground(white);  // Antes sería Color.white
    ...
    double raiz = sqrt(1252.2);// Antes sería Math.sqrt(...)
    }

5. Argumentos variables. Ahora se puede pasar una lista de argumentos variable a una función como en C:

   // Funcion que tiene un parámetro String obligatorio
    // y n parámetros int opcionales
    
    public void miFunc(String param, int... args) 
    {
    ...
    // Una forma de procesar n parametros variables
    for (int argumento: args)
    {
    ...
    }
    ...
    }
    
    ...
    miFunc("Hola", 1, 20, 30, 2);
    miFunc("Adios");
    

6. Metainformación. Ahora se pueden añadir directivas que transmitan información a las herramientas de desarrollo tipo Eclipse, del mismo modo que @deprecated permite que el compilador muestre la palabra tachada. Por ejemplo:

   // Definición de una interfaz mediante metainformacion
    
    public @interface MiInterfaz
    {
    int metodo1();
    String metodo2();
    }

Hay muchas más novedades relacionadas con la máquina virtual y con las librerías. Te recomiendo leer este documento de donde he extraído yo la información más relevante.

Así se las gastan algunas empresas londinenses para contratar gente.

Test para una entrevista en Londres como Java Developer .

No os dejéis impresionar, no todas son tan tocap...