Surefire a STDOUT

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

servido por gigo sin comentarios compártelo favorito

Tests con EasyMock

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);

servido por gigo 2 comentarios compártelo favorito

Plugin para Eclipse que permite acceder a las implementaciones de las interfaces

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.

servido por gigo sin comentarios compártelo favorito

Solucion al PermGen OutOfMemoryError

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 .

servido por gigo 3 comentarios compártelo favorito

StringBuilder en lugar de StringBuffer en JDK5

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]

servido por gigo 1 comentario compártelo favorito

Retrotranslator Maven Plugin

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. ;)

servido por gigo sin comentarios compártelo favorito

Novedades en Java 1.5

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.

servido por gigo sin comentarios compártelo favorito

Test para una entrevista de trabajo en Londres

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...

servido por gigo sin comentarios compártelo favorito