Un murciano en el Polo

Streams en Java

2025-02-25T17:55:00.027+01:00

Los streams de Java se introdujeron en Java 8 como parte de la API de Streams 🔗, proporcionando una forma moderna y funcional de procesar colecciones de datos. Los Streams permiten realizar operaciones de manera declarativa y paralela, mejorando la legibilidad y el rendimiento del código.

Hoy en día prácticamente su uso se ha convertido en un must para cualquier profesional que se dedique a la programación.

Algunas ventajas de utilizar Java Streams 👀💥:

Código más conciso y legible

Las operaciones con Streams son más compactas y fáciles de leer.

Paralelismo

Los Streams permiten ejecutar operaciones en paralelo de manera sencilla.

Inmutabilidad

Los Streams no modifican las colecciones originales, lo que ayuda a evitar errores.

Composición de operaciones

Los Streams permiten encadenar múltiples operaciones de manera fluida.

Mejor rendimiento

Las operaciones con Streams pueden ser más eficientes gracias a optimizaciones internas.

Tipos de operaciones sobre streams

Comencemos por lo super básico... el inicio del source

	    
    List<Employee> employees = List.of(
        new Employee("Alice", 30, 70000, "Company A", List.of("Java", "Spring", "SQL")),
        new Employee("Bob", 25, 60000, "Company B", List.of("JavaScript", "React", "Node.js")),
        new Employee("Charlie", 35, 50000, "Company C", List.of("Java", "Spring", "SQL"))
    );

Source 🔥

En el ejemplo de arriba el source o fuente de datos será la lista con los tres empleados.

Operaciones intermedias 🔌

Son con las que vamos realizando las transformaciones a nuestro stream original.

map

Con map (operación intermedia) transformamos un objeto Employee a un String, en este caso el nombre del empleado en mayúsculas.

			    //Map
    List<String> employeeNames =
    employees.stream()
        .map((s) -> s.name().toUpperCase())
        .collect(Collectors.toList());
    System.out.println(employeeNames);

Output:
ALICE
BOB
CHARLIE

flatMap

En particular yo la utilizo frecuentemente y nos sirve para aplanar un stream en el que los elementos son colecciones de otros elementos o bien tienen alguna propiedad de tipo colección. Os muestro un ejemplo en el que devolvemos los skills únicos de los empleados en un Set:

				        
            // flatMap
    Set<String> uniqueSkills = employees.stream()
        .flatMap(employee -> employee.skills().stream())
        .collect(Collectors.toSet());
    System.out.println(uniqueSkills);

Output:
[Java, JavaScript, Node.js, Spring, React, SQL]

filter

Es una operación intermedia por la que podemos filtrar elementos del stream. En este caso filtramos los empleados mayores a 30 años antes de realizar el map.

		
    // Filter
    List<String> employeeFiltered = employees.stream()
        .filter((e) -> e.age()> 30)
        .map (Employee::name)
        .collect(Collectors.toList());
        System.out.println(employeeFiltered);

Output:

[Charlie]

sort

Es una operación intermedia por la que podemos ordenar los elementos del stream, de menor a mayor por edad.

			
            // Sort
    List>Employee> sortedEmployees = employees.stream()
        .sorted(Comparator.comparingInt(Employee::age))
        .collect(Collectors.toList());
    System.out.println(sortedEmployees);

Output:

[Employee[name=Bob, age=25, salary=60000.0, company=Company B], Employee[name=Alice, age=30, salary=70000.0, company=Company A], Employee[name=Charlie, age=35, salary=50000.0, company=Company C]]

Y con reversed de mayor a menor por salario:

			
      // Sort
    sortedEmployees = employees.stream()
        .sorted(Comparator.comparingDouble(Employee::salary).reversed())
        .collect(Collectors.toList());
    System.out.println(sortedEmployees);

Output:

[Employee[name=Alice, age=30, salary=70000.0, company=Company A], Employee[name=Bob, age=25, salary=60000.0, company=Company B], Employee[name=Charlie, age=35, salary=50000.0, company=Company C]]

limit

Con limit nos quedamos con los n primeros elementos del stream:

			
 	// limit
    List<Employee> limitedEmployees = employees.stream()
        .limit(2)
        .collect(Collectors.toList());
    System.out.println(skipEmployees);

Output:

[Employee[name=Alice, age=30, salary=70000.0, company=Company A], Employee[name=Bob, age=25, salary=60000.0, company=Company B]]

skip

Con skip ignoramos los n últimos elementos del stream:

				      // skip
    List<Employee> skipEmployees = employees.stream()
        .skip(1)
        .collect(Collectors.toList());
    System.out.println(skipEmployees);

Output:
[Employee[name=Bob, age=25, salary=60000.0, company=Company B], Employee[name=Charlie, age=35, salary=50000.0, company=Company C]]

Operaciones finales 📕

Para realizar la operación final de nuestro stream original, ya sea devolver algún resultado o ejecutar una acción sobre los elementos del stream resultante.

foreach

Es una operación final, lo que hace es realizar una acción sobre cada elemento del Stream. Para ello recibe un Consumer.

			  void forEach(Consumer<? super T> action)

        
    	List<Employee> employees = List.of(
        new Employee("Alice", 30, 70000, "Company A"),
        new Employee("Bob", 25, 60000, "Company B"),
        new Employee("Charlie", 35, 50000, "Company C")
    );

    employees.stream()
        .map((s) -> s.name().toUpperCase())
        .forEach(System.out::println);

En este caso lo que hacemos es pintar por salida el nombre de los empleados en mayúscula:

Output:
[ALICE, BOB, CHARLIE]

count

Con count podemos devolver el número de elementos después de realizar nuestras transformaciones. En el ejemplo devolvermos por ejemplo los empleados mayores de edad.

				        // count
    long adulltsCount = employees.stream()
        .map(Employee::age)
        .filter(a -> a > 18)
        .count();
    System.out.println(adulltsCount);

Output:
3

allMatch

Nos dice si todos los elementos del stream cumplen un predicado que se pasa como parámetro. Por ejemplo, ¿todos los empleados cobran más de 60000?

				
      // allMatch
    boolean allMatch = employees.stream()
        .allMatch(e -> e.salary()> 60000);
    System.out.println("Are all the employees rich : " + allMatch);

Output:

Are all the employees rich : false

noneMatch

Nos dice si ningún elemento del stream cumplen un predicado que se pasa como parámetro. Por ejemplo, ¿ningún empleado es mayor a 65 años?

			
      // noneMatch
    boolean noneMatch = employees.stream()
        .noneMatch(e -> e.age() > 65);
    System.out.println("Are all the employees below 65 : " + noneMatch);

Output:

Are all the employees below 65 : true

min

Nos devuelve el minimo elemento del stream en base a un criterio de comparación. En este caso le pesamos el criterio de edad, por lo que devolveré el empleado con menor edad.

	  
    // Min
    Optional<Employee> minAgeEmpOpt = employees.stream()
        .min(Comparator.comparing(Employee::age));
    Employee minAgeEmp = minAgeEmpOpt.get();
    System.out.println("Employee with minimum age is : " + minAgeEmp);

Output:

Employee with minimum age is : Employee[name=Bob, age=25, salary=60000.0, company=Company B, skills=[JavaScript, React, Node.js]]

max

Nos devuelve el máximo elemento del stream en base a un criterio de comparación. En este caso le pesamos el criterio de edad, por lo que devolveré el empleado con mayor edad.

														
      // Max
    Optional<Employee> maxAgeEmpOpt = employees.stream()
        .max(Comparator.comparing(Employee::age));
    Employee maxAgeEmp = maxAgeEmpOpt.get();
    System.out.println("Employee with maximum age is : " + maxAgeEmp);

Output:

Employee with maximum age is : Employee[name=Charlie, age=35, salary=50000.0, company=Company C, skills=[Java, Spring, SQL]]

Collectors

Y por último tenemos los maravillosos Collectors. 💣

Son estructuras modificables que reciben todos los elementos de un Stream y construyen un resultado como por ejemplo un Set, Map o un List.

Existen muchos Collectors que podemos utilizar. Incluso, podemos crear nuestros propios Collectors.

Algunos son los siguientes:

Collectors.groupingBy()
Collectors.averagingInt()
Collector.toList()
Collectors.toSet()
Collectors.toMap()

Los Collectors están compuestos por tres parámetros tipo Collector<T, A, R>. El primero representa el tipo de los elementos del Stream, el segundo representa el tipo que realiza la acumulación y el tercero representa el tipo de retorno.

El movimiento se demuestra andando. 🏃

En el primer ejemplo devolvemos los nombres de los empleados en un List:

												    
    // Collectors

    List<String> collectorList =
        employees.stream()
            .map(Employee::name)
            .collect(Collectors.toList());
    System.out.println(collectorList);

Output:
[Alice, Bob, Charlie]

En este otro ejemplo obtenemos un Map con el nombre de la compañia junto con la lista de empleados que la compone:

   
    List<Employee> allEmployees = List.of(
        new Employee("Alice", 30, 70000, "Company A", List.of("Java", "Spring", "SQL")),
        new Employee("Bob", 25, 60000, "Company B", List.of("JavaScript", "React", "Node.js")),
        new Employee("Charlie", 35, 50000, "Company C", List.of("Java", "Spring", "SQL")),
        new Employee("David", 28, 55000, "Company A", List.of("Java", "Spring", "SQL"))
    );

    // Group employees by company
    Map<String, List<Employee>> employeesByCompany = allEmployees.stream()
        .collect(Collectors.groupingBy(Employee::company));

    System.out.println(employeesByCompany);

Output:
{Company A=[Employee[name=Alice, age=30, salary=70000.0, company=Company A, skills=[Java, Spring, SQL]], Employee[name=David, age=28, salary=55000.0, company=Company A, skills=[Java, Spring, SQL]]], Company B=[Employee[name=Bob, age=25, salary=60000.0, company=Company B, skills=[JavaScript, React, Node.js]]], Company C=[Employee[name=Charlie, age=35, salary=50000.0, company=Company C, skills=[Java, Spring, SQL]]]}

¿Y si juntamos todo?

Vamos a mostrar un ejemplo con varias operaciones intermedias usando peek y reduce, además de mostrar el paralelismo que es una de las ventajas de usar streams en nuestro código.

El peek lo utilizo para hacer debug y revisar qué esta pasando en nuestras expresiones, aunque normalmente es una operación que no suele subir a entornos productivos. 👀👮.

El reduce es muy potente 🚀 y a partir del stream inicial, un elemento inicial y un bioperador ( operación que toma dos parámetros), genera un valor del mismo valor que el tipo del stream.

En este ejemplo calculamos la suma de salarios 💰de los empleados, primero obteniendo el stream de la forma habitual y a continuación obteniendo el stream para procesamiento paralelo. En este caso el stream es tan pequeño que no se notará la diferencia de rendimiento pero si lo hará en streams de mucho mayor tamaño.

																	    // peek, reduce y parallel
   
          
	Double salary = employees.stream()
        .peek(System.out::println)
        .map(Employee::salary)
        .reduce(0.0, Double::sum);
    System.out.println("Sum of all salaries: " + salary);

    Double salaryParallel = employees.stream().parallel()
        .peek(System.out::println)
        .map(Employee::salary)
        .reduce(0.0, Double::sum);
    System.out.println("Sum of all salaries parallel way: " + salaryParallel);

Output:

Employee[name=Alice, age=30, salary=70000.0, company=Company A, skills=[Java, Spring, SQL]]
Employee[name=Bob, age=25, salary=60000.0, company=Company B, skills=[JavaScript, React, Node.js]]
Employee[name=Charlie, age=35, salary=50000.0, company=Company C, skills=[Java, Spring, SQL]]
Sum of all salaries: 180000.0
Employee[name=Bob, age=25, salary=60000.0, company=Company B, skills=[JavaScript, React, Node.js]]
Employee[name=Charlie, age=35, salary=50000.0, company=Company C, skills=[Java, Spring, SQL]]
Employee[name=Alice, age=30, salary=70000.0, company=Company A, skills=[Java, Spring, SQL]]
Sum of all salaries parallel way: 180000.0

En el siguiente artículo vemos como migrar código tradicional a streams y algunos hacks muy útiles. 💪

Fuentes: jignect

Ganar dinero por internet

2024-08-28T20:18:00.002+02:00

Quién no ha deseado alguna vez tener la suficiente independencia económica como para no tener que levantarse por la mañana cada día mientras que tu cuenta bancaria crece cada días más...

Pues con algunas aplicaciones que circulan por Internet vas a conseguir... seguir levantándome igual... pero con algún eurillo de más. Si bien no te dará por viajar por el mundo o comprarte el último modelo híbrido para algún capricho sin pretensiones si te podría dar, como regalarle a tu cuñado algo del Temu... 😁.

Mucho 👀, os paso alguna lista de las aplicaciones para móvil que he probado últimamente y en las que si eres constante se puede ganar algún eurillo.

WeWard

De la lista no sé si es la que más dinero ganas diariamente pero si la que podrías obtener mayores premios. Básicamente se vende como una app que te paga por tus pasos, pero los mayores premios se obtienen realizando encuestas en diferentes plataformas (CPX, TheoremReach, BitLabs, InBrain y TapResearch) y jugando a videojuegos (Ayet Studios, Play to Earn, Revu...).

Te lee de alguna app instalada en tu móvil de contador de pasos como Salud, MyFit... y recibes wards diarios dependiendo del número de pasos. También consigues wards con juegos y encuestas, tirando a la ruleta (te deja varias veces al día) y comprando en tiendas conocidas como Amazon, Booking, Miravia...

Otro punto divertido es que puedes coleccionar cartas de diferentes ciudades y cuando completas una te suman 50 wards a tu cuenta. Estos cromos normalmente los puedes recoger en un maps integrado en la propia aplicación.

Mi código de patrocinio es JPAS-mWHYr, si lo sigues te darán 50W al crear la cuenta y 100W más al introducir el código

El mínimo para extraer dinero a paypal es de 20 euros, o lo que es lo mismo 4000 wards.

Fuente: https://www.wewardapp.com/es

Muestras a casa

Es mi segunda aplicación preferida aunque últimamente ha subido exigencias respecto a tiempos pasados. Básicamente una vez que te registras tienes que cumplimentar una serie de tareas diarias que no te llevarán más de 5 minutos como contestar encuestas sencillas, contestar una pregunta, hacer click sobre algun link....

Además si eres constante por hacerlo en varios días te multiplica los puntos (rachas).

El mínimo de puntos que debes acumular para pasar dinero a Paypal son 5000 (10 euros), antes era de 1500 (5 euros).

Tip: para conseguir los puntos del cofre tienes que pinchar las subcategorias que te aparecen y en una de ellas está el iconito del cofre, cuesta verlo al principio.

Fuente: https://rewards.muestrasacasa.com/login

SmartmeApp

Esta app te da puntos por tenerla simplemente activa en el móvil y entrar diariamente. También puedes realizar campañas que te sumarán más puntos y llegarás al objetivo minimo para extraer dinero.

El mínimo son 100000 puntos que se traducen en 10 euros, es la que requieres menos esfuerzo, casi sumas sin enterarte.

Fuente:http://www.smartmeapp.com/

ZapSurveys

Otra aplicación más de realizar encuestas en plataformas (InBrain y TapResearch), aunque personalmente me parece que funciona bastante mal. Solo sumas por las encuestas que realices, pues no tiene otro tipo de tareas diarias. Además muchas veces estas haciendo una encuesta varios minutos y se pierde sesión sin obtener ninguna recompensa.

Últimamente además muchas de las encuestas requieren registro en otras plataformas. Si no mejora no la recomendaría.

El mínimo para extraer dinero es 10 euros y no es fácil conseguirlo.

Mi enlace de referido es: https://bdr3.app.link/fwchkif4qMb

Fuente: https://www.zapsurveys.com/

AttaPoll

Esta app es muy parecida a la anterior, te dan dinero por realizar encuestas, aunque los criterios para extraer dinero a paypal son menos restrictivos, siendo de tan solo 3 euritos.

Te la recomiendo para comenzar e introducirte en el mundillo de las encuestas por Internet.

Mi código es UPDMV.

Fuente: https://attapoll.com/es/

Espero que os animéis a probar alguna y si utilizais alguna otra me encantaría que me escribierais en comentarios para probarla.

Saludos y buena suerte a todos 🍀🍀🍀.

SOLUCIONES STUMP ME

2019-12-06T12:11:00.001+01:00

Hola amigos,

a continuación os voy poniendo las soluciones de este divertido juego que está entre los más populares en plataformas móviles:

Nivel 1. Escoger la fruta amarilla.

Nivel 2. Apartar el microondas, la taza, la mesa... hasta que quede libre el mando a distancia.

Nivel 3. La opción D.Blanco (que está en amarillo para liar).

Nivel 4. Eliminar el agua de las botellas haciendo drag hasta que no queda agua en ninguna de ellas.

Nivel 5. Arrastrar los objetos todos los objetos, incluyendo la frase de la pregunta!!!

Nivel 6. Hacer que los peces mas grandes se coman a los más pequeños.

Nivel 7.Sacudir el móvil hasta abrir el tapón de las botellas. Una de ellas tiene espuma roja.

Nivel 9. Quitar el pelo de la chica. Ponemos a cero el contador y pulsamos OK.

Nivel 10. Romper el ticket con el movimiento de dedos de hace zoom.

Nivel 11. 0 caramelos, no hay ninguna mesa!!!

Nivel 12. 1 , si 1 = 10 , 10 será igual a 1.

Nivel 13. Es la palabra fruta de la frase de la pregunta.

Nivel 14. Pasar el dedo al coche como si lo estuvieras limpiando realmente...

Nivel 15. Pasar el dedo al termometro hasta que suba a 37 grados.

Nivel 16. Arrastrar el sol hasta que aparezca la luna y se haga de noche.

Nivel 17. Hay 8 agujeros. El cuello, las 2 mangas, la parte de abajo y dos por cada agujero que ves (por la parte de adelante y atrás).

Nivel 18. Hacemos primero el elefante pequeño con el movimiento de dedos de zoom. Después lo arrastramos a la nevera.

Nivel 19. Hay que agitar el movil.

Nivel 20. Pulsar la bombilla de arriba donde se consiguen las pistas.

Nivel 21. Poner la hora del reloj de tu movil y pulsar OK.

Nivel 22. Pulsar varias veces la cerradura, como si estuvieras tocando la puerta para que te abran.

Nivel 23. Mezclar el roja y el amarillo. Falta el naranja !!

Nivel 24. Poner un dedo en un extremo del cable y otro dedo en el otro para conducir la electricidad.

Nivel 25. Agita el móvil hasta que todas las botellas estén vacías.

Nivel 26. Aparta la mochila y mira el número chaval.

Nivel 27. Arrastrar la palabra hueso hasta la boca del perro.

Nivel 28. Arrastrar la palabra próximo hasta el botón vacío y después pulsarlo.

Nivel 29. Aunque te parezca cruel, taponale la nariz hasta que no pueda respirar... y se despierta!!!

Nivel 30. Arrastra el círculo con los tres patos abajo a la izquierda de la pantalla y aparecerá lo que buscas.

Nivel 31. Hacer click 1o veces. Abajo pondrá solo 9 porque un click no aumenta el contador. Luego pulsar el boton Pasar.

Nivel 32. Haz el símbolo del zoom en la hormiga para hacerla muuy muuy grande.

Nivel 33. Pulsa el 33 del NIVEL 33 de arriba de la pantalla.

Nivel 34. Junta el vestido con el sol.

Nivel 35. Haz el símbolo del zoom con la caja.

Nivel 36. Pon el trapecio a un lado de la pantalla hasta que sea visible solo la parte rectangular del trapecio.

Nivel 37. El plato.

Nivel 38. Frota con el dedo la madera hasta producir fuego.

Nivel 39. Agita el móvil hasta que caiga el limon.

Nivel 40. El punto de la frase.

Nivel 41. Arrastra el puntero del ratón al Play de la tele para volver la reproducción activa.

Nivel 42. Pulsa sobre el soporte del papel metálico de arriba del panel para que se caiga.

Nivel 43. Pon el teléfono al revés. Es el 87.

Nivel 44. Hacia la izquierda.

Nivel 45. Dale click a tarea.

Nivel 46. Junta todos los fuegos y luego quema al mostruo.

Nivel 47. Arrastra el botón verde hacia la derecha y luego a la izquierda.

Nivel 48. Arrastra la palabra manzana al plato de la derecha.

Nivel 49. Rompe la hucha y sumalas.

Nivel 50. 80021, por la imagen reflejada.

Nivel 51. Pon el dedo en la pantalla para que se distraiga chupando la sangre y luego aplástalo con otro dedo.

Nivel 52. 1225. Mes y año de la Navidad, como las fechas anglosajonas.

Nivel 53. El mosquito porque lo hemos matado en el 51!!

Nivel 54. Arrastramos un cuadrado al segundo término de la suma. Dos espacios en blanco hacen otro espacio en blanco. Como sumar 0 mas 0.

Nivel 55. Golpea la carretera para torcerla y rodará solo...

Nivel 56. Pulsa sobre el 6 de la frase Convierte 5 barras de caramelo en 6 y se intercambiarán.

Nivel 57. Todo son lineas rectas, es un efecto óptico. Hay 0.

Nivel 58. Pulsa sobre la palabra fruta + fruta rosa + sandia + platano + fruta amarilla.

Nivel 59. Pulsa sobre la palabra volcán.

Nivel 60. Agita el móvil. Todos se rompen y sale un pollito.

Nivel 61. La respuesta es 6. El 9 al reves es 6.

Nivel 62. Saca todos los animales de la balanza.

Nivel 63. Es la interrogación amarilla.

Nivel 64. Cuando aparece la manzana haz click sobre la palabra eso.

Nivel 65. Pon el teléfono al revés y saca la carta arrastrando con el dedo.

Nivel 66. Arrastra el ascensor hacia abajo con el dedo.

Nivel 67. Haz click muchas veces y muy rápido para romper el record.

Nivel 68. 2019. Fijate en los vacios, es como el libro del Danone de hace mil años.

Nivel 69. Arrastra los globos al boton Saltar. el que no se rompe es el más fuerte.

Nivel 70. Mueve el solo hasta que se convierta en Luna.

HOSTING 123SYSTEMS

2018-01-24T10:27:00.002+01:00

Hace más de año tenía muchas ganas de probar Wordpress como gestor de contenidos. Qué mejor manera de hacerlo que migrar mi propio blog a este CMS. Me puse manos a la obra y busqué un hosting que soportaba wordpress a un precio económico, avalado por algunos comentarios de foros.

El hosting en cuestión se llama 123systems y creo que... fue una de las peores ideas de mis últimos años. Migré desde blogger con una herramienta automática aunque tuve que dedicar bastante tiempo en formatear todo para que la apariencia fuera un poco mejor que espantosa.

Al fin lo conseguí e hice algunas optimizaciones para los buscadores. Todo bien los primeros meses hasta que llegaron los cortes. Un día entraba y no funcionaba nada. A veces una vez al mes, otras bastantes veces y sin avisar. Lo peor estaba por llegar. Cuando caduca la suscripción del hosting pagué un año más y ahora mismo lo tengo activo pero no puedo entrar a mi cPanel, ni por supuesto tengo acceso a Wordpress ni recuperar los posts desde 2015. Los tickets abiertos de incidencias no me los responden ni tampoco tienen idea de devolver el dinero por la mala gestión.

Concluyendo, a veces lo barato sale caro, aún por el precio, que son 5$ al año, no os recomiendo para nada este hosting. La próxima vez probaré con un servicio de hosting profesional...

Saludos.

QUE ES LA LUZ

2015-10-18T11:04:00.001+02:00

BOOTSTRAP FOR DUMMIES

2015-10-16T10:59:00.004+02:00

Bootstrap es un framework que puedes utilizar en las páginas de tu aplicación web para que sean responsive, es decir, para que se adapten automáticamente al tamaño de la pantalla en la que se visualizan (tablets, móviles, pantallas de TV...).

Incorpora una series de plantillas CSS y archivos Javascript, además de integrarse perfectamente con librerías como jquery. Además cada día se amplia más la comunidad y se pueden obtener fácilmente plantillas basadas en Bootstrap tanto gratuitas como de pago para no empezar tu web desde 0. La versión actual es la 3 y próximamente está previsto el lanzamiento de la 4.

Por ejemplo dispondremos de clases CSS para las contenedores (divs) con las que podremos indicar si nuestra Web ocupará todo el espacio disponible en la pantalla o por el contrario solo una parte de la misma:

Contenedor ocupando un espacio acotado en pantalla

Contenedor ocupando todo el espacio de pantalla

<div class="container-fluid">
</div>

Contenedor mixto

Otro ejemplo sería un contenedor que ocupa toda la pantalla con una imagen de fondo que contendría a otro contenedor con el contenido de nuestra página.

<div class="container-fluid">
  <div class="container"></div>
</div>

Las resoluciones de pantalla que se definen en Bootstrap son 4:

Pantallas grandes (lg). A partir de 1200 pixels. Ordenadores

Pantallas medias (md). A partir de 992 pixels. Ordenadores

Pantallas pequeñas (sm). A partir de 768 pixeles. Tablets

Pantallas muy pequeñas (xs). Por debajo de 768 pixels. Móviles

Para la disposición de los diferentes elementos de nuestras páginas lo más importante que tenemos que conocer es el modelo de rejillas de Bootstrap. Este framework considera que cada fila de la pantalla contiene 12 columnas (que ocuparan un número determinado de pixels dependiendo en el tipo de pantalla en la que nos encontremos).

Para entender mejor la forma de dividir la pantalla con Bootstrap, imaginemos que tenemos 4 bloques de contenidos y que queremos mostrarlos de la siguiente forma:

En pantallas grandes queremos 4 bloques por cada fila. Como tenemos 4 bloques y 12 columnas, cada bloque debe ocupar 3 columnas. Para ello utilizamos la clase CSS col-lg-3.

En pantallas medias queremos 3 bloque por cada fila. Como tenemos 3 bloques por cada fila y 12 columnas, cada bloque debe ocupar 4 columnas. La clase que utilizaremos será col-md-4.

En pantallas pequeñas queremos 2 bloques por cada fila. Como tenemos 2 bloques por cada fila y 12 columnas, cada columna debe ocupar 6 columnas. La clase que se usa será col-sm-6.

En pantallas muy pequeñas queremos un bloque en cada fila. Como tenemos solamente un bloque, cada bloque debe ocupar 12 columnas para ocupar toda la fila. La clase que se usa será col-xs-12.

El código HTML con el que tenemos en cuenta los 4 casos será el siguiente:

<div class="row borde"> 
   <div class="col-lg-3 col-md-4 col-sm-6 col-xs-12">
     <canvas height="200px" width="200px" id="micanvas1">
   </div> 
    <div class="col-lg-3 col-md-4 col-sm-6 col-xs-12">
      <canvas height="200px" width="200px" id="micanvas2">
    </div> 
    <div class="col-lg-3 col-md-4 col-sm-6 col-xs-12">
      <canvas height="200px" width="200px" id="micanvas3">
    </div> 
    <div class="col-lg-3 col-md-4 col-sm-6 col-xs-12">
      <canvas height="200px" width="200px" id="micanvas4">
    </div> 
</div>

La pantalla se verá de la siguiente forma según la resolución del dispositivo en la que la visualizamos:

Además de facilitar la disposición de contenidos, Bootstrap contiene botones, menus, diálogos modales muy útiles para el desarrollo de nuestras aplicaciones. La web oficial está muy bien documentada y los ejemplos son muy claros. Otros frameworks para realizar páginas web responsive son Foundation o Skeleton. Si pulsas aquí podrás echar un ojo a frameworks similares para poder comparar tú mismo.

El código del ejemplo es el siguiente:

 
<!DOCTYPE html> 
<html lang="en">
  <head>
    <meta charset="utf-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <!-- The above 3 meta tags *must* come first in the head; any other head content must come *after* these tags --> 
    <title>Bootstrap 101 Template</title>
    <!-- Bootstrap --> 
    <link href="css/bootstrap.min.css" rel="stylesheet">
    <!-- HTML5 shim and Respond.js for IE8 support of HTML5 elements and media queries --> <!-- WARNING: Respond.js doesn't work if you view the page via file:// --> <!--[if lt IE 9]> <script src="https://oss.maxcdn.com/html5shiv/3.7.2/html5shiv.min.js"></script> <script src="https://oss.maxcdn.com/respond/1.4.2/respond.min.js"></script> <![endif]--> 
    <style type="text/css"> .borde {border: black 1px solid; } </style>
    <script> function pintarCuadrados() { var i = 1; var canvas; var ctx; for (i = 1; i <=4; i ) { canvas = document.getElementById("micanvas" i); ctx = canvas.getContext("2d"); ctx.fillRect(10,10,200,200); ctx.fillStyle="#f00"; } } </script> 
  </head>
  <body onload="pintarCuadrados()">
    <!-- jQuery (necessary for Bootstrap's JavaScript plugins) --> <script src="https://ajax.googleapis.com/ajax/libs/jquery/1.11.3/jquery.min.js"></script> <!-- Include all compiled plugins (below), or include individual files as needed --> <script src="js/bootstrap.min.js"></script> <br/> 
    <div class="container">
      <div class="row borde">
        <div class="col-lg-3 col-md-4 col-sm-6 col-xs-12">
          <canvas height="200px" width="200px" id="micanvas1">
        </div>
        <div class="col-lg-3 col-md-4 col-sm-6 col-xs-12">
          <canvas height="200px" width="200px" id="micanvas2">
        </div>
        <div class="col-lg-3 col-md-4 col-sm-6 col-xs-12">
          <canvas height="200px" width="200px" id="micanvas3">
        </div>
        <div class="col-lg-3 col-md-4 col-sm-6 col-xs-12">
          <canvas height="200px" width="200px" id="micanvas4">
        </div>
      </div>
    </div>
  </body>
</html>

Fuente: proyectobds

EJEMPLO REFLECTION EN JAVA

2015-06-05T11:33:00.000+02:00

Hoy vamos a realizar un ejemplo completo con el API Reflection de Java. Con este API podemos por ejemplo obtener el nombre y el valor de los atributos de cualquier clase, crear una instancia de ella utilizando cualquiera de sus constructores o ejecutar sus métodos.

El objetivo del artículo es crear un clase genérica que a partir de una lista genérica de items sea capaz de generar código JSON cuyo nombre sea el resultado de la ejecución de un método concreto y como parámetros sean los nombres y valores de de sus atributos.

Por tanto en el ejemplo aglutinamos varios conceptos que seguramente nos encontraremos a lo largo de nuestra trayectoria profesional como programadores:

API Reflection
Genericidad
JSON, muy utilizado para el intercambio de información entre aplicaciones. La implementación que se utiliza para realizar el mapping es la librería jackson.

Creamos una clase parametrizada por una clase. Dicha clase recibirá una lista de items de una clase determinada G. Definimos como constantes varios prefijos que seran los que utilizamos para dar nombre a cada nodo JSON para genera el código asociado:

item, se utiliza a nivel global para cada elemento de la clase G de la lista de items (item1, item2, itemN)

name, representa el nombre de cada item. En este ejemplo se extraerá de llamar al método llamado getItemNameValue. Si la clase G no implementa este método, se devolverá la cadena vacia.

data, representa los parámetros del item. Dichos parámetros se extraen de los atributos de la clase G que tengan un método get publico asociado.

name, value, representan el nombre y el valor de cada atributo de la clase.

public class JsonGenerator<G> {

    private static final String METHOD_ITEM_NAME = "getItemNameValue";
    private static final String PREFFIX_DATA = "data";
    private static final String PREFFIX_ITEM = "item";
    private static final String PREFFIX_NAME = "name";
    private static final String PREFFIX_VALUE = "value";
    private static final String GET = "get";

    /**
     * Lista de items que se parsea para obtener la salida JSON
     */
    private List items;

A continuación creamos un método que obtiene el valor del método getItemNamevalue. Es un método que obtiene una instancia de la clase java.lang.reflect.Method para invocar un determinado método de una clase genérica G. El método se obtiene con la operación getDeclaredMethod de la clase Class pasando como parámetro el nombre del método. Utilizando el método invoke de la clase Method ya tenemos el valor de cada item.

NOTA: Notad que se utiliza la nueva notación de Java 7 para la definición de excepcion con los separadores barra.

private String getItemNameValue(Class cls) {
        // Buscando el método
        Method method = null;
        // no paramater  
        Class noparams[] = {};
        try {
            Object obj = cls.newInstance();
            method = cls.getDeclaredMethod(METHOD_ITEM_NAME, noparams);
            String res = (String) method.invoke(obj, new Object[0]);
            return res;
        } catch (SecurityException | NoSuchMethodException | IllegalArgumentException | IllegalAccessException | InvocationTargetException | InstantiationException e) {
            return StringUtils.EMPTY;
        }
    }

Tendremos un método para obtener los campos de la clase G. Este método devuelve un array de la clase del API Reflection java.lang.reflect.Field. Esta clase representa un atributo concreto de una clase y nos servirá como punto de partida para acceder al nombre como al valor del mismo. Observad que el método es recursivo, primero obtiene los atributos de la clase y posteriormente se llama a sí mismo para recuperar los atributos definidos en la superclase. Fijaos también que los atributos con el modificador static se evita añadirlos a la lista, sólo se recuperan los atributos sin el modificador static para evitar añadir constantes.

private Field[] getAllFields(Class klass) {
        List fields = new ArrayList<>();
        fields.addAll(Arrays.asList(klass.getDeclaredFields()));
        if (klass.getSuperclass() != null) {
            fields.addAll(Arrays.asList(getAllFields(klass.getSuperclass())));
        }

        Iterator fAux = fields.iterator();
        while (fAux.hasNext()) {
            Field field = fAux.next();
            if (java.lang.reflect.Modifier.isStatic(field.getModifiers())) {
                fAux.remove();
            }
        }
        return fields.toArray(new Field[]{});
    }

Una vez que tengamos todos los atributos de la instancia de una clase necesitaremos métodos para acceder a su nombre e invocar al método get asociado para obtener su valor. Estos dos métodos se definen a continuación:

private Object getFieldValue(Object userInstance, Field field) {
        try {
            String methodName = GET + StringUtils.capitalize(field.getName());
            return MethodUtils.invokeExactMethod(userInstance, methodName, new Object[0]);        
        } catch (IllegalArgumentException | IllegalAccessException | NoSuchMethodException | InvocationTargetException e) {
            return StringUtils.EMPTY;
        }
    }

private List<String> getFieldsNames(Field[] fields) {
        List l = new ArrayList<>();
        for (Field field : fields) {
            l.add(field.getName());
        }
        return l;
    }

private List<String> getFieldsValues(Field[] fields, Object obj) {
        List l = new ArrayList<>();
        for (Field field : fields) {
            Object value = getFieldValue(obj, field);
            l.add((value == null) ? StringUtils.EMPTY : value.toString());
        }
        return l;
    }

Una vez que tenemos toda la información de la clase G únicamente nos queda generar el código JSON. Para ello vamos a utilizar la clase org.codehaus.jackson.node.ObjectNode, que representa un elemento JSON y la clase org.codehaus.jackson.node.JsonNodeFactory que se encargará de ir creando cada nodo JSON. Finalmente con la clase org.codehaus.jackson.map.ObjectMapper generaremos una cadena a partir de un nodo JSON raíz que representa el código JSON de la clase.

 private void addSimpleObject(ObjectNode node, String name, String value) {
        node.put(name, value);
    }

private void addComplexObject(ObjectNode node, String name, ObjectNode value) {
        node.put(name, value);
    }

private void addListObject(ObjectNode node, List names, List values) {

        for (int i = 0; i < names.size(); i++) {
            String name = names.get(i);
            String value = values.get(i);
            ObjectNode atributos = factory.objectNode();
            atributos.put(preffixName, name);
            atributos.put(preffixValue, (value == null) ? StringUtils.EMPTY : value);
            node.put(preffixData + (i + 1), atributos);
        }

    }

Y el método pegamento que utiliza todo lo anterior para generar el código JSON:

public String generateJson() throws JsonGenerationException, JsonMappingException, IOException {
        if (CollectionUtils.isEmpty(items)) {
            return StringUtils.EMPTY;
        }
        for (int i = 0; i < items.size(); i++) {
            G item = items.get(i);
            ObjectNode elementoItem = factory.objectNode();

            String itemNameValue = getItemNameValue(item.getClass());
            addSimpleObject(elementoItem, preffixName, itemNameValue);

            List<String> names = getFieldsNames(getAllFields(item.getClass()));
            List<String> values = getFieldsValues(getAllFields(item.getClass()), item);

            addListObject(elementoItem, names, values);
            addComplexObject(root, preffixItem + (i + 1), elementoItem);
        }     
        return mapper.writerWithDefaultPrettyPrinter().writeValueAsString(root);
    }

Para cada uno de los elementos de la lista de tipo G:

Se añade el nodo JSON simple con el nombre del item (instancia de clase G) al nodo JSON que representa al item.

Se añade el nodo JSON complejo para cada uno de los atributos del item (instancia de clase G) al nodo JSON que representa al item.

Se añade el nodo JSON que representa al item al nodo raiz.

Vamos a ejecutar la clase con una lista de 3 items de tres clases diferentes dentro de una jerarquía: Nivel1, Nivel2 y Nivel3. Nivel1 es padre de Nivel2 y Nivel2 es a su vez padre de Nivel. Cada una de ellas encapsula un atributo llamado campo1, campo2 y campo3 respectivamente.

...
...
     List<nivel1> elementos = new ArrayList<>();

     Nivel1 nivel1 = new Nivel1("1");
     Nivel2 nivel2 = new Nivel2("2", "3");
     Nivel3 nivel3 = new Nivel3("4","5","6");
     
     elementos.add(nivel1);
     elementos.add(nivel2);
     elementos.add(nivel3);
     
     JsonGenerator<nivel1> jsonGenerator = new JsonGenerator<>();
     jsonGenerator.setItems(elementos);
  
     System.out.println(jsonGenerator.generateJson());
...
...

La salida para este caso concreto sería:

{
"item1" : {
"name" : "",
"data1" : {
"name" : "campo1",
"value" : "1"
}
},
"item2" : {
"name" : "",
"data1" : {
"name" : "campo1",
"value" : "2"
},
"data2" : {
"name" : "campo2",
"value" : "3"
}
},
"item3" : {
"name" : "",
"data1" : {
"name" : "campo1",
"value" : "4"
},
"data2" : {
"name" : "campo2",
"value" : "5"
},
"data3" : {
"name" : "campo3",
"value" : "6"
}
}
}

El código del proyecto en Netbeans lo podéis descargar de aquí.

Saludos.

EL CAMINO FACIL

2015-02-07T09:57:00.000+01:00

Dos caminos se bifurcaban en un bosque y yo,

Yo tomé el menos transitado,

y eso hizo la diferencia, Robert Fross

Fuente: clubsuperacion

GUARDAR ICONOS ESCRITORIO

2015-02-06T09:53:00.001+01:00

Hoy os voy a mostrar un truco relacionado con los iconos del escritorio. ¿Eres de los que le gusta tener cientos de iconos en tu escritorio para (des)organizarte? ¿Seguro que no has perdido nunca la configuración que tenías de iconos verdad?

Las opciones por defecto de Windows son bastante pobres. Nos permiten ordenar los iconos por varios criterios pero no dejan espacio para la personalización. Si por ejemplo pulsamos en el escritorio botón derecho > Ver > Ordenar Iconos Automáticamente nos lo ordena muy bonito en formato cuadrícula pero, eso no es lo que queremos Windows!!!!!

Hay un software que te permite guardar exactamente la configuración de iconos de tu escritorio, es decir, cada icono con su posición exacta en la resolución de escritorio actual. Podrías tener una configuración de iconos para diferentes resoluciones si lo necesitas. El programita en cuestión se llama Desktop Restore y lo puedes descargar aquí.

Cuando lo instalamos y pulsamos botón derecho sobre el Escritorio nos aparecen 3 nuevas opciones:

Con SaveDesktop guardamos la configuración actual de iconos. Si pulsas Custom Save/Restore puedes guardar la configuración en un archivo y exportarla a otro PC o modificar el nombre de tu configuración.

Y eso es todo por hoy.... Pero vendrán más cosicas.

Un saludo.

ORGANIZA YA TU DESKTOP. FENCES VS NIMI PLACES

2014-10-05T13:50:00.000+02:00

Harto de ver el escritorio de mi PC como una constelación de iconos he estado buscando herramientas para evitar una situación como esta:

Mi posible escritorio

He encontrado dos que parece que sobresalen sobre el resto, una gratuita (Nimi Places) y otra de pago con un periodo de prueba de 30 días (Fences).

Vamos primero con Nimi Places. Cuando instalas la aplicación te crea varios contenedores que se corresponden con un directorio de nuestro PC.

Escritorio con varios contenedores

Una cosa que no me gusta nada es que no puedes ocultar los archivos y directorios del escritorio, es decir, aparecen replicados tanto en el contenedor como en el escritorio.

Podemos modificar el aspecto de los contenedores con varios temas disponibles pero otro punto negativo es que es muy complicado para un usuario medio gestionar las reglas para manejar los nuevos archivos que vamos creando, ya que se hace con expresiones regulares.

Gestión de archivos y directorios con Nimi Places

Personalmente Fences me parece muy superior tanto en diseño y facilidad de uso. Al instalarlo esta es la apariencia que tendremos:

Escritorio organizado con Fences

Podemos cambiar también el diseño de los 'Fences' o contenedores pero cada uno de ellos no tiene asociado un directorio del PC. Puedes colocar tú los archivos del escritorio haciendo drag and drop y puede haber archivos o directorios en la misma localización del PC entre varios contenedores. Es justo el comportamiento que yo estaba buscando para organizar el escritorio.

Además la gestión de reglas referentes a los nuevos directorios y archivos creados es mucho más intuitiva:

Creación de reglas de organización con Fences

Podemos fácilmente crear reglas simplemente haciendo check sobre los tipos de archivos más comunes o directorios y eligiendo el 'Fence' o contenedor de destino. Por ejemplo, podremos hacer que las nuevas imágenes vayan a un contenedor de imágenes, los archivos del paquete Office a otro contenedor... También puedes hacer que todos los archivos vayan a un Fence oculto y tener el escritorio sólo con contenedores de accesos directos...

Conclusiones

Utiliza Nimi Places si quieres tener una gestión de archivos más controlada del PC en general, no sólo del Escritorio, y estas familiarizado con expresiones regulares. La ventaja principal: es gratis.

Fences es tu programa si eres un usuario medio que quieres una magnífica gestión de tu escritorio de una forma rápida y sencilla. El pequeño problema: la licencia vale 9,99$.

Tú eliges, ya no tienes excusa para limpiar ese desastre que tienes ahí montado, y lo sabes!!!

REALIDAD DE UN INFORMATICO EN ESPAÑA

2014-03-08T11:37:00.001+01:00

LO QUE UN INFORMÁTICO ESPAÑOL CREE CUANDO ACABA LA CARRERA

LA CRUDA REALIDAD...

¿PRUEBAS DE ACEPTACION? CONCORDION ES TU FRAMEWORK

2013-12-19T13:21:00.000+01:00

Algo indispensable en nuestras aplicaciones es el desarrollo de pruebas para comprobar que nuestro código funciona y además que cumple con los requisitos deseados por los clientes.

Fuente: sg.com.mx

En muchos lugares donde he trabajado se realizan las pruebas unitarias y de integración y luego se construye un documento Word o HTML donde se especifican las pruebas que se han realizado de nuestra aplicación, para que el cliente compruebe si se satisfacen o no todas sus necesidades de negocio con el código desarrollado. Pero, ¿y si pudieramos realizar las pruebas a la misma vez que generamos documentación?

Para esto sirve precisamente el framework Concordion:

Escribimos las pruebas de aceptación de nuestra aplicación mediante un documento XHTML bien formado y describimos el comportamiento de nuestro código.

Asociado a este documento tendemos una clase Java donde implementaremos el código Java de las pruebas.

Las clases Java de pruebas y los documentos HTML deben estar en el mismo paquete. Como estandar se crea una carpeta llamado specs en nuestro proyecto. Para generar la documentación, ejecutaremos la clase Java como un test de Junit normal y se generarán los documentos XHTML del mismo paquete pero con la partes correspondientes al test iluminadas en verde (si ha ido bien), rojo (si ha ido mal) o amarillo (si se ha producido una excepción). Los documentos se generarán en el directorio indicado por java.io .mpdir que suele ser el directorio por defecto del usuario.

También existe un plugin de Maven para integrar la ejecución de los test de Concordion con el ciclo de vida de Maven.

Como el movimiento se demuestra andando pongamos un ejemplo para que todo esto se vea más claro.

Primero nos creamos un proyecto simple con Maven y le añadimos la dependencia de Concordion.

<dependency>
    <groupId>org.concordion</groupId>
    <artifactId>concordion</artifactId>
    <version>1.4.4</version>
</dependency>

También podemos crear un proyecto Java normal y descargar la distribución de Concordion aquí.

Una vez que lo hemos hecho deberiamos tener un proyecto parecido al siguiente:

Nos creamos una clase Calculadora con tres operaciones básicas de suma, resta y producto:

package es.jpascu.concordion;

public class Calculadora {

 public Calculadora() {
 }

 public static Integer suma(Integer a, Integer b) {
  return a + b;
 }

 public static Integer resta(Integer a, Integer b) {
  return a - b;
 }

 public static Integer producto(Integer a, Integer b) {
  return a * b;
 }
}

Después creamos la clase de test de nuestra clase Calculadora. Podremos acceder a los métodos de esta clase en nuestro XHTML:

package es.jpascu.concordion;

import org.concordion.integration.junit4.ConcordionRunner;
import org.junit.runner.RunWith;

@RunWith(ConcordionRunner.class)
public class CalculadoraFixture {

 public Integer testSuma(Integer a, Integer b) {
  Integer c = Calculadora.suma(a, b);
  return c;
 }

 public Integer testResta(Integer a, Integer b) {
  Integer c = Calculadora.resta(a, b);
  return c;
 }

 public Integer testProducto(Integer a, Integer b) {
  int c = Calculadora.producto(a, b);
  return c;
 }
}

Por último escribimos nuestros test funcionales en nuestro XHTML:

<body>

<h1>Pruebas de aceptacion de Calculadora</h1>

El resultado de 4 más 3

debe ser 7

El resultado de 4 menos 3

debe ser 1

El resultado de 4 por 3

debe ser 12

</body>

</html>

Como estamos viendo primero definimos el namespace de concordion dentro de nuestro XHTML dentro de la etiqueta HTML. Cuando el navegador encuentre una etiqueta con este namespace la ignorará.

Con la etiqueta concordion:set establecemos el valor de una variable y con concordion:assertEquals comprobamos que el método testXYX devuelve un valor concreto.

El resultado al ejecutar la clase de pruebas como JUnit es un documento de pruebas de aceptación en formato HTML como nosotros definamos:

Vemos que el resultado de assertEquals se ilumina en verde siempre que el test haya sido OK.

Espero que os haya servido para haceros una idea del proposito de este framework e iniciaros con el mismo.

Salu2.

TUTORIAL ARQUILLIAN (I)

2013-12-16T11:40:00.000+01:00

¿Qué es Arquillian?

Arquillian es un framework de test que nos permite levantar un contexto embebido CDI y realizar test unitarios y test funcionales en nuestros proyectos.

En nuestras aplicaciones tenemos que probar componentes cuyo ciclo de vida es manejado por el servidor de aplicaciones como EJB´s o JPA´s y nos volvemos locos perdiendo tiempo en crear mocks o probando estos componentes posteriormente en pruebas funcionales cuando deberían tener sus propias pruebas unitarias.

Con Arquillian vamos a poder probar todos estos componentes levantando un contexto CDI, inyectando estos componentes en la propia clase de test que a su vez correrá dentro del contenedor.

Se integra fácilmente en nuestros proyectos con Maven y funciona con librerías de test como JUnit 4 o TestNG. Para desplegar desplegables JAVA (JARS, WARS) con las clases disponibles en el contexto CDI utiliza el framework ShrinkWrap.

Escribiendo un test de integración con Arquillian

Para poder ejecutar test con Arquillian vamos a necesitar tener como mínimo Maven instalado y JDK 1.5. Podemos crear un proyecto Maven en Eclipse con el plugin m2e o crearlo manualmente mediante la línea:

mvn archetype:generate -DarchetypeGroupId=net.avh4.mvn.archetype \

-DarchetypeArtifactId=java-1.6-archetype

y posteriormente importarlo creando los archivos con el goal eclipse:eclipse.

Una vez que hemos creado el proyecto nos debería aparecer algo como lo siguiente:

En el pom nos debería aparecer lo básico, el plugin para compilar con la JDK 1.6 y la librería de JUnit para los test unitarios:

<build>

<artifactId>maven-compiler-plugin</artifactId>

</configuration>

</plugin>

<artifactId>maven-surefire-plugin</artifactId>

</plugin>

</plugins>

</build>

…

<groupId>junit</groupId>

<artifactId>junit</artifactId>

</dependency>

<groupId>org.jboss.spec</groupId>

<artifactId>jboss-javaee-6.0</artifactId>

<version>1.0.0.Final</version>

<scope>provided</scope>

</dependency>

A continuación creamos en nuestro proyecto un componente el cual utilizaremos para probar la inyección de dependencias en un servidor embebido (JBOSS, GLASSFISH…):

public class Greeter {

private PhraseBuilder phraseBuilder;

@Inject

public Greeter(PhraseBuilder phraseBuilder) {

this.phraseBuilder = phraseBuilder;

}

public void greet(PrintStream to, String name) {

to.println(createGreeting(name));

}

public String createGreeting(String name) {

return phraseBuilder.buildPhrase("hello", name);

}

Para añadir el soporte de Arquillian a nuestro proyecto añadimos primero las dependencias transitivas de Arquillian dentro de la sección dependencyManagement:

<groupId>org.jboss.arquillian</groupId>

<artifactId>arquillian-bom</artifactId>

<version>1.0.3.Final</version>

<scope>import</scope>

</dependency>

</dependencies>

</dependencyManagement>

A continuación añadimos la dependencia que nos servirá de puente para utilizar Arquillian con JUnit 4, que añadirá también las dependencias de ShrinkWrap para desplegar artefactos Java. En este punto hay que decir que tenemos la opción de utilizar Arquillian con otras librerías de pruebas como el framework TestNG:

<groupId>org.jboss.arquillian.junit</groupId>

<artifactId>arquillian-junit-container</artifactId>

</dependency>

Una vez que hacemos esto ya podemos escribir nuestro primer test unitario. Para ello creamos una clase de Test, inyectamos nuestro componente con las anotaciones CDI, creamos y desplegamos con ShrinkWrap un JAR con nuestra clase y un archivo beans.xml vacío pero necesario para que funcione todo correctamente por la especificación JEE 6

El código del test unitario es el siguiente:

@RunWith(Arquillian.class)

public class GreeterTest {

@Deployment

public static JavaArchive createDeployment() {

JavaArchive jar = ShrinkWrap.create(JavaArchive.class)

.addClasses(Greeter.class, PhraseBuilder.class)

.addAsManifestResource(EmptyAsset.INSTANCE, "beans.xml");

return jar;

}

@Inject

Greeter greeter;

@Test

public void should_create_greeting() {

Assert.assertEquals("Hello, Earthling!",

greeter.createGreeting("Earthling"));

greeter.greet(System.out, "Earthling");

}

· @RunWith: el test corre bajo el soporte de Arquillian

· @Deployment: anotación sobre el método que crea el desplegable Java

· @Inject: para instanciar nuestro componente en la clase de test

· @Test: anotación para indicar qué es un método de test

Ahora viene lo mejor. Estos test unitarios deben correr bajo un contenedor pero, ¿Cuál? Pues podremos elegir varios contenedores compatibles con el modelo de programación de nuestra prueba siempre y cuando exista un adaptador en Arquillian con este contenedor. Para el test de inyección de CDI podremos utilizar JBoss 7, Glassfish 3 o Weld (implemenación de referencia de CDI). Arquillian también permite ejecutar los test con un servidor real sin cambiar una sola línea de código (previamente a las pruebas deberemos tener levantado dicho servidor). Si utilizamos por ejemplo Glassfish 3 deberemos añadir las siguientes dependencias:

<groupId>org.jboss.arquillian.container</groupId>

<artifactId>arquillian-glassfish-embedded-3.1</artifactId>

</dependency>

<groupId>org.glassfish.main.extras</groupId>

<artifactId>glassfish-embedded-all</artifactId>

<scope>provided</scope>

</dependency>

Para resumir el tema de las dependencias están:

· La dependencia de integración de Arquillian y JUnit.:

<groupId>org.jboss.arquillian.junit</groupId>

<artifactId>arquillian-junit-container</artifactId>

</dependency>

· La dependencia de Arquillian para el contenedor:

<groupId>org.jboss.arquillian.container</groupId>

<artifactId>arquillian-glassfish-embedded-3.1</artifactId>

</dependency>

· Y el ambiente de ejecución del contenedor:

<groupId>org.glassfish.main.extras</groupId>

<artifactId>glassfish-embedded-all</artifactId>

<scope>provided</scope>

</dependency>

Finalmente probamos nuestro test en Eclipse ejecutándolo como un test unitario normal: Run As Junit Test.

Fuentes: arquillian.org | elblogdelfrasco

ESTAFAS CON BENFORD

2013-11-29T12:20:00.003+01:00

Hoy os voy a hablar de un curioso fenómeno que ocurre con conjuntos de datos que existen en la vida real como es el caso de las longitudes de los rios, la población de las ciudades, el importe de nuestras facturas, las tasas de mortalidad, los números primos e incluso para la serie de Fibonacci... Lo conocía con otro nombre pero está recogido en una ley y se llama: LA LEY DE BENFORD.

Este fenómeno fue descubierto por primera vez por Simon Newcomb en 1881, porque se dio cuenta que las primeras páginas de las tablas de logaritmos estaban más usadas que las finales por lo que se dio cuenta que los primeros digitos de los números que se consultaban no son equiprobables. En 1938 Benford postuló una ley comprobandolo empíricamente con diversos conjuntos de datos.

Resumiendo asegura que el 1 aparece con mayor frecuencia en estos conjuntos de datos como el primer dígito o digito más significativo (el 30% de las veces) y cuanto mayor es el dígito menor es la probabilidad que aparezca como primer digito. El dígito más significativo de un número es el primer número distinto de 0 que aparece más a la izquierda en su expresión decimal. Ejemplo: el digito mas significativo de 3.1415 es 3 y y el 1 es el de la expresión 0,0134.

Esto se puede calcular mediante una fórmula matemática:

P(1ªcifra no nula N) = log10 (N+1) - log10 (N)

La fórmula también es válida para más de una cifra, es decir, la probabilidad de que un número comience por 10, 99 o 5675.

Las probabilidades que se obtienen para los 9 primeros digitos son:

No todos los conjuntos de datos cumplen la ley de Benford. Por ejemplo, la altura de las personas o las marcas en horas de los corredores de una maraton. Para estos conjuntos de datos los digitos signitificativos estarán limitados a un sólo subconjunto del 1 al 9.

Yo no me lo creía así que he comprobado esta ley utilizando como datos de entrada la población en millones de habitantes de los paises y el resultado ha sido el siguiente:

y expresado mediante una gráfica:

Como podemos observar, sino es exactamente igual se parece mucho...

Pero esta ley tiene una gran utilidad práctica sobre todo en los tiempos que corren y es la de detectar fraudes fiscales. Hay corruptos y evasores de impuestos en este país que no saben de esta ley así que al tratar de realizar una contabilidad que permita evadir pagar más impuestos de lo que creen necesario tienden a modificar datos de forma uniforme con todas las cifras. Ahí es donde un inspector puede detectar si la contabilidad de una empresa es sospechosa de haber sido maquillada o no.

Algunos casos reales de aplicación de la ley de Benford son los siguientes:

El profesor de Ciencias Políticas en la Universidad de Michigan Walter Mebane aplicó la Ley de Benford con algunas modificaciones a a las elecciones de Irán en el 2009 donde Ahmadinejad sacó el 63% de los votos. Las desviaciones eran tan grandes que el fraude era obvio. Fuente: guioteca

En febrero de este mismo año el profesor titular de Análisis Matemático de la Universidad de Sevilla,Miguel Lacruz Martín, escribe hoy una carta al director de ABC en la que revela que los propios números que contienen los supuestos papeles de Luis Bárcenas dejan en evidencia a su autor realizando un estudio de los asientos de la contabilidad B. Fuente: ABC

Espero que os haya gustado y que comprobéis la ley por vosotros mismos.

Un saludo.
Fuente: Wikipedia | ABC | kleinproject

TRUCOS EN GOOGLE CHROME

2013-11-19T23:50:00.001+01:00

El navegador de Google es el tercer navegador más utilizado después de Microsoft Internet Explorer y Mozilla Firefox y en mi caso se ha convertido en mi ojito derecho, todos tenemos nuestros programas preferidos, ¿no es así?. Hoy os traigo una serie de tips muy útiles de Google Chrome que te ayudaran a mejorar la experiencia de uso con este navegador:

Ranking navegadores 2013 (Imagen: uchceu)

Tip 1: Fijar pestaña

Esta opción nos sirve para mantener abiertas nuestras páginas favoritas. Normalmente cuando abres el navegador consultas el correo, periódicos, redes sociales, tu blog favorito (como por ejemplo Un Murciano en el polo, ;)... Si cuando abres una página en una pestaña pulsas botón derecho sobre la pestaña y haces click sobre la opción Fijar Pestaña, la próxima vez que abras el navegador esta página se abrirá automáticamente por defecto y no tendrás que hacerlo cada día. Además te elimina el nombre de la página y sólo te deja el favicon por lo que ganamos un valioso espacio en la barra de pestañas.

Tip 2: Ampliar espacio en barra de marcadores

Cuando añadimos páginas a nuestra barra de marcadores llega un momento en que nos quedamos sin espacio. Siempre podemos organizarlos en carpetas pero otra opción para tenerlos disponibles en la propia barra es pulsar con el botón derecho del raton sobre el marcador y hacer click sobre Editar. Lo único que tenemos que hacer es borrar el campo Nombre y pulsar sobre Guardar. A partir de ahora tendremos nuestro marcador solo con su favicon en la barra y podremos añadir muchas más páginas...

Tip 3: Recuperar pestañas abiertas

A veces vamos con prisa o se te abren popup con publicidad y cuando cerramos el Chrome nos damos cuenta que hemos cerrado todas las ventanas abiertas. Podemos configurar el GC para que cuando lo abramos de nuevo restaure las pestañas que estaban abiertas cuando se cerró por última vez. Para ello debemos pulsar sobre el botón Pesonaliza y controla Google Chrome (esquina superior derecha) y luego pulsar sobre Configuración. Una vez abierta la página de Configuración pulsamos sobre la opción Continuar como lo dejé todo antes de cerrar en la sección al Iniciar.

Otro problema que podemos tener es haber cerrado una pestaña sin querer. La podemos recuperar si pulsamos CTRL+SHIFT+T.

Tip 4: Arrastrar y Soltar

A veces nos bajamos alguna imagen con el Chrome y nos la guardará en el directorio de Descargas que tengamos configurado. Si queremos recuperarlo al instante solo tenemos que arrastrarlo al Escritorio u otra carpeta que queramos y listo.

Tip 5: Administración de Tareas

A veces abrimos alguna página y se queda en estado No Responde porque falla algún Complemento del Chrome al abrir los contenidos o por cualquier error que se pueda producir. Si queremos cerrar una pestaña en concreto podemos abrir el Administrador de Tareas pulsando SHIFT + ESC y luego elegir la pestaña que nos está dando guerra y pulsar sobre el botón Finalizar Proceso.

Tip 6: Navegar en modo incognito

Si quieres iniciar una sesión sin que tus páginas se queden en el historial de búsqueda o almacenen cookies debes pulsar CTRL+MAY+N y se abrirá una nueva pestaña en la que podrás navegar en modo incognito. En este modo además las extensiones estarán deshabilitadas por defecto.

Espero que os haga la vida más fácil.

Salu2. Pascu.

HTML5: DRAG & DROP NATIVO

2013-07-26T18:14:00.002+02:00

HTML5 incorpora muchas funcionalidades y etiquetas que harán la vida más sencilla a los desarrolladores web. En este artículo vamos a ver dos de ellas en dos ejemplos: el Drag & Drop nativo y los nuevos métodos de acceso al árbol DOM. Se supone que en el futuro todos los navegadores deberán implementar todas las características del estándar aunque a día de hoy no todos los navegadores cumplen con estos estándares. Para comprobar el nivel de compatibilidad de la versión de vuestro navegador podéis pulsar sobre el siguiente enlace.

Anteriormente a HTML5 podíamos simular el proceso de Drag & Drop con librerías como MooTools o JQuery. El nuevo HTML5 ya incorpora está característica de forma nativa y vamos a verlo con el siguiente ejemplo.

En en el proceso de Drag & Drop hay un objeto que es arrastrado y otro elemento al que se pueden arrastrar objetos. A continuación explicamos los atributos y métodos que debemos implementar en cada uno de los elementos para que puedan ser arrastrados o arrastrar objetos a él.

Objetos arrastrables

Para hacer un objeto arrastrable debemos añadir los siguientes atributos:

draggable = true. Con esto indicamos que el elemento puede ser arrastrado.

ondragstart. Aquí se define la función que se llevará a cabo cuando se comience a arrastrar el elemento.

ondragend. Aquí se define la acción que se lleva a cabo cuando se termina de arrastrar el elemento.

Objetos a los que podemos arrastrar otros objetos

ondragenter. Aquí se define la acción que se lleva a cabo cuando un elemento arrastrable entra dentro del elemento.

ondragover. Aquí se define la acción que se realiza cuando un elemento arrastrable está sobre el elemento. Debemos definir que tipos de objetos puedes soltarse aquí.

ondragleave. Aquí se define la acción que se ejecuta cuando el elemento arrastrable dejar de estar encima del elemento.

ondrop. Aquí se indica la acción que se lleva a cabo cuando se suelte el elemento arrastrable sobre el objeto contenedor.

En el primer ejemplo tenemos dos contenedores en el que tenemos varios personajes de Juegos de Tronos y los tenemos que clasificar en Buenos y Malos. El código completo lo podemos descargar de aquí.

Cada personaje es un enlace (<a>) y está contenido en un fieldset. Hay tres fieldset: uno para personajes, otra para los personajes buenos y otro para los malos.

Para hacer arrastrable a un personaje:

<a draggable="true" onDragStart="dragItem(this, event)" onDragEnd="dragEnd(this, event)" class="item" id="ES">Eddard Stark</a>

A continuación implementamos las acciones asociadas al drag:

function dragItem(item, event) {
        event.dataTransfer.setData('Dato', item.id);
        item.style.opacity = '0.3';
    }
    
    function dragEnd(item, event) {
        item.style.opacity = '';        
    }

En dragItem nos guardamos el id del elemento arrastrable para tenerlo disponible en el drop y aplicamos transparencia al elemento para distinguir cuando lo estamos arrastrando. En dragEnd restablecemos la opacidad del elemento.

Y por último lo que haríamos sobre el elemento al que se pueden arrastrar elementos es lo siguiente:

<fieldset id="buenos" class="container" onDrop="dropItem(this, event)" onDragEnter="return false" onDragOver="return false">

En las funciones onDragEnter y onDragOver no hacemos nada. Al no hacer nada en onDragOver vamos a permitir que cualquier personaje puede arrastrarse hasta este contenedor. En la función onDrop comprobamos el fieldset al que estamos arrastrando el personaje para cambiar de color el fondo del mismo y posteriormente lo añadimos al contenedor.

function dropItem(target, event) { 
        var dato = event.dataTransfer.getData('Dato');
        var item = document.getElementById(dato)
        if (target.id == 'buenos') {
         item.className = 'item itemBueno';
        } else if (target.id == 'malos') {
         item.className='item itemMalo';
        } else if (target.id == 'origen') {
         item.className='item';
        }
        target.appendChild(item);
    }

En el contenedor al que se arrastran objetos podemos establecer que actúe como una papelera o también como un clonador de objetos. Os pongo lo que habría que poner en la función dropItem para clonar objetos:

function dropItem(target, event) { 
        var dato = event.dataTransfer.getData('Dato');
        var item = document.getElementById(dato);   
        target.appendChild(item.cloneNode(true));
    }

Un ejemplo con la clonación de objetos lo podéis ver aquí. Es parecido al caso anterior aunque ahora tendremos dos contenedores, uno para artículos y otro para la lista de la compra. Iremos arrastrando los artículos a la lista pero ahora no se borrarán porque podemos tener varias unidades de un mismo artículo. Las posibilidades que nos permite el Drag & Drop son muy amplias y depende de nuestra imaginación el valor añadido que podamos dar a nuestro proyectos.

Por último hemos visto en el primer ejemplo hay dos botones con los que podemos consultar los personajes que hemos arrastrado tanto a buenos como a malos. Para ellos utilizamos las nuevas funciones de HTML5 para acceder al árbol DOM. En nuestro caso utilizamos la función querySelectorAll para recuperar los elementos de tipo <a> dentro de un fieldset concreto. Aquí tenéis un ejemplo para recuperar los personajes buenos:

 function verBuenos(){
  var buenos = document.querySelectorAll('#buenos a');
  for (var i=0; i < buenos.length; i++) {
   alert(buenos[i].innerHTML);
  }
    }

Espero que os sea útil.

Salu2.

FRASES CELEBRES Y JUEGO DE TRONOS

2013-07-23T13:15:00.000+02:00

Hoy he hecho un mix con frases célebres que perfectamente podían haber dicho los personajes de Juego de Tronos si existieran en realidad. No leáis si no habéis visto la serie porque pueden contener spoilers.... Podéis continuar las frases en los comentarios, seguro que se os ocurren frases mucho más ingeniosas. Sólo apto para fan de la serie.

No se trata de ser el primero, sino de llegar con todos y a tiempo, Twyin Lannister

Cada persona forja su propia grandeza, Veo los peligros de la vida presente; peligro en el mar, peligro en la tierra y peligro en los falsos hermanos, Tyrion Lannister

Antes de negar con la cabeza, asegúrate de que la tienes, Eddard Stark

No considero nada vergonzoso honrar a los hermanos , Cersei Lannister

Tener hijos no lo convierte a uno en padre, del mismo modo en que tener un piano no lo vuelve pianista, Walder Frey

Yo también tengo amigos mas falsos que billetes con decimales, Robb Stark

No dejes de beber hoy lo que no puedas beber mañana, Rey Robert

Yo no digo mentiras sino verdades distorsionadas, Peter Baelish

El ego es como tu perro. El perro tiene que seguir al amo y no el amo al perro. Hay que hacer que el perro te siga. No hay que matarlo, sino que domarlo, Principe joffrey

Salu2.

TUTORIAL TESTNG: FRAMEWORK PARA TUS TESTS

2013-07-19T16:39:00.000+02:00

TestNG (Next Generation) es un framework de testing inspirado en JUnit y NUnit pero introduciendo nuevas caractarísticas como los test de dependencia y el concepto de grouping. Su uso nos permite realizar todas las categorías de test como pruebas unitarias, de integración, end-to-end, pruebas funcionales, etc...

Instalación en Eclipse

Instalar el plugin de TestNG para Eclipse es sencillo. En mi caso es Eclipse JUNO y únicamente para instalarlo lo único que tenemos que hacer es buscarlo con la herramienta Eclipse MarketPlace y pulsar el botón de Install.

Crear una clase para nuestros test con TestNG es igualmente sencillo. En nuestro proyecto creamos una nueva clase TestNG. Pulsamos NEXT y después seleccionamos las anotaciones que deseamos que aparezcan en nuestra clase:

Cuando creamos nuestra clase TestNG nos dará fallos en las anotaciones. Esto es porque debemos incluir en nuestro proyecto las librerías del framework. Para ello pulsamos sobre las Properties de nuestro proyecto y en Java Build Path añadimos la librería de TestNG.

Ejemplo con anotaciones básicas

A continuación repasamos las anotaciones básicas y un ejemplo con su resultado:

@BeforeClass. Código ejecutado antes de ejecutar los test. Aquí se podría inicializar por ejemplo alguna fuente de datos para utilizarla en nuestros test.

@AfterClass. Código ejecutado después de ejecutar todos nuestros test. Aquí se podrían cerrar todos los recursos que hemos abierto en el código bajo la etiqueta @BeforeClass.

@BeforeMethod. Código ejecutado antes de cada test.

@AfterMethod. Código ejecutado después de cada test.

@Test. Indica que el método es un test.

Un ejemplo:

package es.jpascu.testng;

import java.util.ArrayList;
import java.util.Collection;

import org.testng.Assert;
import org.testng.annotations.AfterClass;
import org.testng.annotations.AfterMethod;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;

public class TestNGBasic {
 private Collection collection;

 @BeforeClass
 public void oneTimeSetUp() {
  // one-time initialization code
  System.out.println("@BeforeClass - oneTimeSetUp");
 }

 @AfterClass
 public void oneTimeTearDown() {
  // one-time cleanup code
  System.out.println("@AfterClass - oneTimeTearDown");
 }

 @BeforeMethod
 public void setUp() {
  collection = new ArrayList();
  System.out.println("@BeforeMethod - setUp");
 }

 @AfterMethod
 public void tearDown() {
  collection.clear();
  System.out.println("@AfterMethod - tearDown");
 }

 @Test
 public void testEmptyCollection() {
  Assert.assertEquals(collection.isEmpty(), true);
  System.out.println("@Test - testEmptyCollection");
 }

 @Test
 public void testOneItemCollection() {
  collection.add("itemA");
  Assert.assertEquals(collection.size(), 1);
  System.out.println("@Test - testOneItemCollection");
 }

}

Ejemplo con características avanzadas

En este ejemplo añadimos otros ejemplos de características avanzadas que se se pueden utilizar en nuestros tests con TestNG:

@Test(expectedExceptions=TipoException.class). El test unitario pasa aunque en el test se lanza la excepción de tipo TipoException.class.

@Test(enabled=false). El test unitario no se ejecuta.

@Test(timeout=1000). Si tarda más de 1 segundo el test unitario pasará como FAILED, pero nos aseguramos que finalice su ejecución.

Un ejemplo:

package es.jpascu.testng;

import org.testng.annotations.Test;

public class TestNGAdvanced {

 @Test(expectedExceptions = NullPointerException.class)
 public void testException() {
  String s = null;
  s.charAt(0);
 }

 @Test(enabled = false)
 public void testIgnore() {
  System.out.println("Esto no se ejecuta!!");
 }

 @Test(timeOut = 1000)
 public void testBucleInfinito() {
  while (true)
   ;
 }

}

Ejemplo con parámetros básicos y complejos

Podemos definir una suite, que es un XML en el que entre otras cosas se pueden definir varios clases de test que se ejecuten juntas. Además podemos definir parámetros simples (int, float) como objetos complejos (ArrayList, String, etc..).

Primero vemos un ejemplo en el que se define un parámetro de tipo int en el suite.xml que estará disponible en la ejecución de nuestras clases de test. Para definirlo en nuestro test se emplea la anotacion @Parameters.

package es.jpascu.testng;

import org.testng.annotations.Parameters;
import org.testng.annotations.Test;

public class TestNGBasicParameter {
  @Test
  @Parameters(value="number")
  public void testWithBasicParameter(int number) {
   System.out.println("El valor del paámetro es: " + number);
  }
}

Ahora vemos como TestNG gestiona el paso de parámetros complejos. Para ello se utiliza la anotación @DataProvider. En el ejemplo vemos como se pasan tipos complejos como colecciones.

package es.jpascu.testng;

import java.util.ArrayList;

import org.testng.annotations.DataProvider;
import org.testng.annotations.Test;

public class TestNGComplexParameter_1 {
 @Test(dataProvider = "dp")
 public void parameterArrayListInTest(ArrayList list) {
    System.out.println("Primer Elemento Lista : " + list.get(0));
    System.out.println("Segundo Elemento Lista : " + list.get(1));
 }
 
 //This function will provide the parameter data
 @DataProvider(name = "dp")
 public Object[][] parameterIntTestProvider() {
  ArrayList lista = new ArrayList();
  lista.add("1");
  lista.add("2");
  return new Object[][]{
    
     {lista}
        };
 }
}

En este otro ejemplo vemos como se pasa un POJO como parámetro:

package es.jpascu.testng;

public class Pojo {
 private int numero;
 
 private String mensaje;

 public Pojo(int numero, String mensaje) {
  super();
  this.numero = numero;
  this.mensaje = mensaje;
 }

 public int getNumero() {
  return numero;
 }

 public void setNumero(int numero) {
  this.numero = numero;
 }

 public String getMensaje() {
  return mensaje;
 }

 public void setMensaje(String mensaje) {
  this.mensaje = mensaje;
 }
 
 
}

package es.jpascu.testng;

import org.testng.annotations.DataProvider;
import org.testng.annotations.Test;

public class TestNGPojoParameter_1 {
 @Test(dataProvider = "dp")
 public void parameterPojoListInTest(Pojo obj) {
    System.out.println("Pojo - numero : " + obj.getNumero());
    System.out.println("Pojo - mensaje : " + obj.getMensaje());
 }
 
 //This function will provide the parameter data
 @DataProvider(name = "dp")
 public Object[][] parameterPojoTestProvider() {
  Pojo pojo = new Pojo(1, "Hola");
  
  return new Object[][]{
    
     {pojo}
        };
 }
}

Concepto de grouping

En este apartado vemos un ejemplo del concepto de grouping que no existe en JUnit 4. Por ejemplo, imaginemos que tenemos una clase de test en la que probamos operaciones a LDAP y a bases de datos. Podemos ejecutar los test agrupados por su funcionalidad, en nuestro caso, LDAP y BBDD. Si queremos ejecutar sólo los test relacionados con LDAP haríamos lo siguiente:

package es.jpascu.testng;

import org.testng.annotations.Test;

public class TestConnection {

 @Test(groups="ldap")
 public void testLDAP_OP1() {
  System.out.println("Method - testLDAP_OP1");
 }

 @Test(groups="ldap")
 public void testLDAP_OP2() {
  System.out.println("Method - testLDAP_OP1");
 }

 @Test(groups="bbdd")
 public void testBBDD_Oracle() {
  System.out.println("Method - testBBDD_Oracle");
 }

 @Test(groups="bbdd")
 public void testBBDD_SQLServer() {
  System.out.println("Method - testBBDD_SQLServer");
 }
}

Test Dependientes

Otro concepto que añade TestNG son los test dependientes. Podemos definir en nuestras clases de test que un método de test determinado dependa de uno o varios métodos de test. Para ello utlizamos el atributo dependsOnMethod.

Aquí os pongo un ejemplo en el que nuestro testA depende del testB y el testC.

package es.jpascu.testng;

import org.testng.annotations.Test;

public class TestNGDepends {

 @Test(dependsOnMethods={"testB","testC"})
 public void testA() {
  System.out.println("testA");
 }

 @Test
 public void testB() {
  System.out.println("testB");
 }

 @Test
 public void testC() {
  System.out.println("testC");
 }

}

Conclusiones. JUnit4 vs TestNG.

Por último os pongo una tabla comparativa entre JUnit4 y TestNG para observar la funcionalidad que cubre cada uno de los dos frameworks:

TestNG es superior en los test de grupo, en parametrización de objetos complejos y en los test de dependencia además de cubrir todas las funcionalidades de JUnit 4.

Otro punto a su favor es que para ejecutar varios ficheros de test juntos (Suite Test) se realiza mediante la definición de un fichero XML y no mediante anotaciones en una clase Java como se hace en JUnit 4. Además se puede integrar perfectamente con herramientas tan utilizadas como Maven o Selenium.

En general se puede recomendar la utilización de este framework en lugar de JUnit 4 ya que cubre toda la funcionalidad de este último, es más flexible y añade nuevas capacidades.

Salu2.

Fuente: mkyong

HTML5: LOCALSTORAGE VS SESSIONSTORAGE

2013-07-17T12:05:00.001+02:00

HTML5 está muy de moda. Muchas ofertas de empleo tienen como requisito indispensable conocer HTML5 para el desarrollo del front-end de aplicaciones. Muchas navegadores soportan en mayor o menor grado sus características: nuevas etiquetas, nuevos componentes para formularios, soporte para drag&drop nativo, geolocalización, soporte para contenido multimedia, web workers, web sockets, almacenamiento local... Es de esto último de lo que hablaremos en el post, explicando para que sirve, los tipos de almacenamiento local y un ejemplo de uso.

Cookies 2.0. Almacenamiento de datos en cliente.

Las aplicaciones web han utilizado las cookies para almacenar datos de cliente en el navegador. Pero éstas contaban con una serie de problemas:

Las cookies se mandaban con la petición HTTP una y otra vez, lo que hacia la comunicación cliente-servidor más lenta además de que siempre no era necesario.

Suponían un problema de seguridad si nuestra aplicación no corría sobre protocolos seguros como SSL.

La limitación de almacenamiento de datos, sólo podíamos guardar 4KB lo que a veces podía ser insuficiente.

Con el almacenamiento local de HTML5 que algunos llaman Cookies 2.0 superamos todas estas limitaciones:

Posibilidad de almacenar gran cantidad de datos (normalmente 5MB), lo que nos permite trabajar con una aplicación web como si fuera una aplicación de escritorio offline.

No se transmite con cada petición HTTP al servidor.

Tipos de almacenamiento local

Hay dos tipos de almacenamiento local que implementan la interface Storage: Local Storage y Session Storage.

Los dos son métodos accesibles desde el objeto window. La diferencia es que Session Storage actúa sobre la sesión de un cliente, por lo que cuando el usuario cierra la ventana del navegador desaparecen los datos guardados. Con Local Storage los datos persisten aunque se cierre la ventana del navegador.

La interfaz Storage define una serie de atributos y métodos con los que se pueden guardar, borrar y recuperar datos:

getItem(key): devuelve un string con el valor del elemento con clave key.

setItem(key, value): almacena un valor (value) referenciado por una clave (key).

removeItem(key): elimina el par clave/valor con clave igual a key.

length: atributo que contiene el número de elementos (pares clave/valor) almacenados.

key(index): devuelve un string con la clave (no el valor) del elemento que ocupe la posición index dentro de la colección de datos.

clear(): elimina todos los elementos.

Además podemos registrar un listener (storage) para saber cuando se ha modificado el valor de una clave y realizar una acción al respecto.

Ejemplo de uso.

He hecho un página HTML en la que se pueden ver las diferencias entre el local storage y el session storage y su uso trivial. Para comprobar que tu navegador tiene compatibilidad con Local Storage y Session Storage utilizamos la siguiente función:

function compruebaCompatibilidad() {
  if (window.sessionStorage && window.localStorage) {
   alert('Tu navegador acepta almacenamiento local');
  } else {
   alert('Lo siento, pero tu navegador no acepta almacenamiento local');
  }
 }

Para obtener un valor del Local Storage se utiliza el siguiente código:

localStorage.getItem('DATOL')

Para establecer un valor en el Local Storage se utiliza el siguiente código:

 localStorage.setItem("DATOL",  $("#valueL").val());

Para borrar todos los datos del Local Storage se utiliza el siguiente código:

localStorage.clear();

Para borrar un dato del Local Storage se utiliza el siguiente código:

localStorage.removeItem("DATOL");

El código completo lo podéis descargar aquí.

En el ejemplo podemos almacenar el valor de una variable en el Local Storage (DATOL) y en la Session Storage (DATOS). También podemos comprobar la compatibilidad con nuestro navegador y borrar todas las variables almacenadas en el Local Storage y en el Session Storage.

Con Google Chrome (imagino que también con otros navegadores) podemos ver el contenido del Local Storage y Session Storage si pulsamos Herramientas > Consola Javascript > Resources:

Si guardamos un valor en el Local Storage y otro en el Session Storage y cerramos nuestra ventana en el navegador cuando la abramos de nuevo sólo aparecerá la variable del Local Storage (en la ventana de ejemplo se recargan las variables si existen en cada uno de los Storage).

Espero que os haya servido.

Salu2.

¿POR QUÉ NO HABLAS CASTELLANO?

2013-04-18T14:10:00.000+02:00

Hoy estaba navegando por la red y debo decir que una noticia me ha sorprendido. El joven neoyorquino Timothy Doner ha colgado un video en Youtube hablando en más de 20 idiomas. Y no diciendo las típicas frases de las galletas de los chinos, no, hablando más o menos fluidamente en cada uno de ellos.

Más sorprendente si cabe es que tan sólo tiene 17 años y que ha aprendido todos los idiomas en un plazo de 4 años. No recuerdo lo que hacía a esa edad pero seguro que no estaba aprendiendo ruso ni tampoco persa. Quizá me sorprenda tanto porque la capacidad para aprender idiomas no está entre mis grandes virtudes y si entre entre mis asignaturas pendientes. O quizá es que vivo en España y estamos un pelín por debajo en hablar idiomas respecto a otros países...

El caso es que demuestra su capacidad políglota durante 15 minutos con francés, suajili, hausa, wolof, ruso, alemán, yidish, hebrero, árabe, pastún, persa, chino mandarín, italiano, turco, indonesio, holandés, xhosa, ojibwa o hindi. Pero este portento de los idiomas NO HABLA CASTELLANO!!!. Parafraseando a un portugúes famoso... ¿POR QUÉ? ¿POR QUÉ?

Aquí os dejo el video:

FREEMARKER VS VELOCITY

2013-03-26T19:40:00.001+01:00

Hoy nos ponemos en faena para comparar dos conocidos motores de plantillas: FreeMarker y Velocity. Veremos las ventajas de utilizar uno contra otro y como siempre un ejemplo sencillo de cada uno de los motores con Eclipse y Java. Vosotros decidiréis cual utilizar para vuestro proyecto en cuestión.

Utilizando tanto un motor como el otro podremos realizar nuestras vistas o informes dinámicos mediante plantillas pasando los datos mediante un programa en Java (puede incluso utilizarse para sustituir a las JSPs). También nos permitirán generar salidas para diferentes formatos de archivo: HTML, RTF, XML, etc... y ser integrados en aplicaciones web dependientes de un servidor como en aplicaciones 'standalone'.

Imagen: memegenerator

Velocity vs FreeMarker

Velocity es un motor más simple, sin embargo, con FreeMarker se pueden realizar algunas tareas que con Velocity es imposible de realizar, además de tener un lenguaje de plantillas más potente.

Algunas tareas complejas comunes a muchas aplicaciones están implementadas en el core de FreeMarker, sin embargo, en Velocity no es así y deberemos utilizar soluciones como añadir objetos java a nuestras plantillas (lo que viola la idea del patron MVC de no incluir código en nuestras vistas).

Una ventaja de Velocity es que cuenta con el soporte de una mayor comunidad de usuarios, por lo que será fácil dar solución a los problemas con los que nos vayamos encontrando por el camino. Según los autores de FreeMarker, este motor no necesitará de tanto soporte debido a que muchas características que querremos incorporar a nuestras aplicaciones ya las tendremos implementadas en el core.

Como siempre, que el sentido común decida por vosotros. Dependerá del tamaño de vuestra aplicación y lo que queráis hacer con el motor de plantillas en la misma.

Para descargar la última versión de FreeMarker pulsa aquí y para descargar la última versión de Velocity aquí.

Ejemplo con FreeMarker

Nuestro proyecto resultante en Eclipse debe tener la siguiente estructura:

Lo primero que hacemos es crear nuestras plantillas auxiliares de FreeMaker con extensión .ftl, en nuestro caso, serán header.ftl y footer.ftl. La carpeta para crearlas será templates/common

header.ftl


<title>Tutoriales de JPASCU: ${mensaje1}</title>
<body>

footer.ftl


</body>

Posteriormente creamos nuestra plantilla principal main.ftl en el directorio templates. En ella incluimos las otras plantillas. A partir de ella el motor de FreeMarker genera una página HTML con los valores que se pasan desde una clase Java.

main.ftl

<#include "./common/header.ftl"> 
<#if container??>
  <div id="${container}">
<#else>
  

<div id="default">
</#if>


<ul>
<#list jugadores as jugador>
<li>${jugador_index + 1}.${jugador.getName()}</li>
</#list>
</ul>
<h1>
${mensaje2.getName()}</h1>
</div>
<#include "./common/footer.ftl">

Destacamos tres puntos en el código de la plantilla:

Utilizamos la directiva <#include> para incluir otras plantillas

Podemos utilizar condiciones para poner un código HTML u otro dependiendo de las variables pasadas desde Java. Por ejemplo, <#if container??> es verdadero si la variable container es pasada al motor de FreeMaker. Si no existe la expresión será falsa. OJO: el ?? no funciona en versiones antiguas de FreeMaker.

También podemos utilizar bucles y llamar a métodos de objetos Java desde nuestra plantilla .ftl.

Por último, creamos las clases Java, una clase holder (podría ser un String) y la clase de prueba en la que creamos una instancia del motor y le pasamos las variables para que haga el 'merge' con la plantilla. El código Java de las clases es el siguiente:

JugadorFutbol.java

package es.jpascu.engine.freemarker;

public class JugadorFutbol {

 private String name;

 public JugadorFutbol(String name) {
  super();
  this.name = name;
 }

 public String getName() {
  return name;
 }

 public void setName(String name) {
  this.name = name;
 }
}

TestFreeMaker.java

package es.jpascu.engine.freemarker;

import java.io.File;
import java.io.FileWriter;
import java.io.OutputStreamWriter;
import java.io.Writer;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import freemarker.template.Configuration;
import freemarker.template.Template;

public class TestFreeMarker {

  public static void main(String[] args) {

    // Creamos la configuración
    Writer file = null;
    Configuration cfg = new Configuration();

    try {
      // Seleccionamos el directorio donde se encuentran nuestras plantillas
      cfg.setDirectoryForTemplateLoading(new File("templates"));
      // Cargamos las plantillas
      Template template = cfg.getTemplate("main.ftl");

      // Pasamos los parámetros
      Map input = new HashMap();
      input.put("mensaje1", "Ejemplo con FreeMarker");
      input.put("container", "test");

   
      List jugadores = new ArrayList();

      jugadores.add(new JugadorFutbol("Messi"));
      jugadores.add(new JugadorFutbol("Iniesta"));
      jugadores.add(new JugadorFutbol("Xavi"));
      jugadores.add(new JugadorFutbol("Villa"));
      jugadores.add(new JugadorFutbol("CR7"));

      input.put("jugadores", jugadores);

      JugadorFutbol exampleObject = new JugadorFutbol("¿Pero qué equipo es este?");
      input.put("mensaje2", exampleObject);

      // Escribimos en un fichero HTML
      file = new FileWriter(new File("output.html"));
      template.process(input, file);
      file.flush();

      // Escribimos en la salida estandar
      Writer out = new OutputStreamWriter(System.out);
      template.process(input, out);
      out.flush();

    } catch (Exception e) {
      System.out.println(e.getMessage());

    } finally {
      if (file != null) {
        try {
          file.close();
        } catch (Exception e2) {
        }
      }
    }

  }
}

En la clase TestFreeMaker cabe destacar lo siguiente:

Cargamos la configuración (cfg) del motor con la clase freemarker.template.Configuration.

Podemos seleccionar el directorio de plantillas con cfg.setDirectoryForTemplateLoading

Cargamos la plantilla con cfg.getTemplate("main.ftl")

Generamos una salida con template.process(input, file), donde input es un map de tipo parámetro-valor con los valores con los que queremos rellenar nuestra plantilla y file es un stream de salida (salida estandar, fichero HTML, fichero RTF...).

Ejemplo con Velocity

Nuestro proyecto resultante en Eclipse debe tener la siguiente estructura:

Lo primero que hacemos es crear nuestras plantillas auxiliares de Velocity con extensión .vm, en este ejemplo serán header.vm y footer.vm.

header.vm



<title>Tutoriales de JPASCU: $mensaje1</title>
<body>

footer.vm


</body>

Posteriormente creamos nuestra plantilla principal main.vm. En ella incluimos las otras plantillas. A partir de ella el motor de Velocity genera una página HTML con los valores que se pasan desde una clase Java.

main.vm

#parse("header.vm")
#if ($container)
  <div id="$container">
#else
  <div id="default">
#end
<ul>
#set ($counter = 0)
#foreach ($jugador in $jugadores)
 #set ($counter = $counter + 1)
<li>$counter.$jugador.getName()</li>
#end
</ul>
<h1>
$mensaje2.getName()</h1>
</div>
#parse("footer.vm")

Veamos ahora las diferencias de notación con FreeMaker:

Utilizamos la directiva #parse para incluir otras plantillas con variables. Si queremos incluir alguna plantilla con texto o código HTML estático podemos utilizar #include.

También podemos utilizar condiciones para poner un código HTML u otro dependiendo de las variables pasadas desde Java. Utilizamos la directiva #if para realizar una comparación de una variable. Deberemos cerrar las sentencias en las plantillas con #end.

También podemos utilizar bucles con la sentencia #foreach y llamar a métodos de objetos Java desde nuestra plantilla .vm con la notación punto igual que en FreeMaker.

Por último, creamos las clases Java, una clase holder (podría ser un String) y la clase de test en la que creamos una instancia del motor de Velocity y le pasamos las variables para que haga el 'merge' con la plantilla, igual que en el caso anterior. El código Java de las clases es el siguiente:

JugadorFutbol.java

package es.jpascu.engine.freemarker;

public class JugadorFutbol {

 private String name;

 public JugadorFutbol(String name) {
  super();
  this.name = name;
 }

 public String getName() {
  return name;
 }

 public void setName(String name) {
  this.name = name;
 }
}

TestVelocity.java

package es.jpascu.engine.velocity;

import java.io.File;
import java.io.FileWriter;
import java.io.OutputStreamWriter;
import java.io.Writer;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.velocity.Template;
import org.apache.velocity.VelocityContext;
import org.apache.velocity.app.VelocityEngine;

public class TestVelocity {

 public static void main(String[] args) {

  Writer file = null;
  /* Inicializamos el motor de Velocity */
  VelocityEngine ve = new VelocityEngine();
  ve.init();

  try {

   // Cargamos las plantillas

   Template t = ve.getTemplate("main.vm");

   // Creamos el contexto donde pasaremos los parámetros
   VelocityContext context = new VelocityContext();

   // Pasamos los parámetros
   Map input = new HashMap();
   context.put("mensaje1", "Ejemplo con Velocity");
   context.put("container", "test");

   List jugadores = new ArrayList();

   jugadores.add(new JugadorFutbol("Messi"));
   jugadores.add(new JugadorFutbol("Iniesta"));
   jugadores.add(new JugadorFutbol("Xavi"));
   jugadores.add(new JugadorFutbol("Villa"));
   jugadores.add(new JugadorFutbol("CR7"));

   context.put("jugadores", jugadores);

   JugadorFutbol exampleObject = new JugadorFutbol(
     "¿Pero qué equipo es este?");
   context.put("mensaje2", exampleObject);

   // Escribimos en un fichero HTML
   file = new FileWriter(new File("output.html"));
   t.merge(context, file);
   file.flush();

   // Escribimos en la salida estandar
   Writer out = new OutputStreamWriter(System.out);
   t.merge(context, out);
   out.flush();

  } catch (Exception e) {
   System.out.println(e.getMessage());

  } finally {
   if (file != null) {
    try {
     file.close();
    } catch (Exception e2) {
    }
   }
  }

 }
}

En la clase TestVelocity cabe destacar lo siguiente:

Inicializamos el motor de Velocity (org.apache.velocity.app.VelocityEngine)

El directorio de plantillas lo configuramos en el archivo de configuración de Velocity velocity.properties, en el que también configuramos otras propiedades del motor.

Cargamos la plantilla con ve.getTemplate("main.vm")

Creamos el contexto que encapsulara los parámetros que le pasaremos al motor de Velocity para generar la salida.

Generamos una salida con t.merge(context, file), donde context es el objeto Contexto de Velocity (org.apache.velocity.VelocityContext) de tipo parámetro-valor con los valores con los que queremos rellenar nuestra plantilla y file es un stream de salida (salida estandar, fichero HTML, fichero RTF...).

Por último, os muestro el contenido del fichero velocity.properties, en el que le decimos al motor que cargue la plantillas del classpath:

velocimacro.library=macros/VM_global_library.vm

resource.loader=classpath 
classpath.resource.loader.description=Velocity Classpath Resource Loader 
classpath.resource.loader.class=org.apache.velocity.runtime.resource.loader.ClasspathResourceLoader 
classpath.resource.loader.cache=true 
classpath.resource.loader.modificationCheckInterval=2

Espero que el ejemplo sea útil para que profundicéis en el mundo de los motores de plantillas.

Ahh, se me olvidaba, la página resultante para el caso de Velocity es la siguiente:

Salu2.

Fuente: FreeMarker | javaworld | vogella | Velocity

Inyección de dependencias. Spring y Google Guice

2013-02-19T19:24:00.001+01:00

¿Qué es la inyección de dependencias?

La inyección de dependencias (DI) procede de un patrón de diseño más general que es el patrón de Inversión de Control (IoC). Básicamente recomienda que las dependencias de una clase no sean creadas desde el propio objeto, sino que sean configuradas desde fuera de la clase.

Una clase A es dependiente de otra B cuando utiliza una instancia de B bien llamando a su constructor o bien obteniendo una instancia de un método estático...

Si utilizamos el patrón de inyección de dependencias la clase B se pasará una instancia de B a A:

Por el constructor de la clase A (inyección por constructor o constructor injection)
Por un campo de la clase A (inyección por campo o field injection)
Por un método setter (inyección por método set o setter injection)

Al aplicar este patrón hacemos que nuestras clases sean independientes unas de otras e incrementamos la reutilizacion y la extensibilidad de nuestra aplicación, además de facilitar las pruebas unitarias de las mismas.

Desde el punto de vista de Java, un diseño basado en DI puede implementarse mediante el estandar del lenguaje. Una clase puede leer las dependencias de una clase por medio del API Reflection de Java y crear una instancia de dicha clase inyectándole sus dependencias.

Veamos un ejemplo de uso del patrón. Imaginemos que una clase A contiene un método DAO . Si aplicamos el patron DI, la clase A dependerá de una interfaz Java AccessDAO. Podemos implementar un AccessDAOImpl para acceder a una base de datos concreta y otro llamado AccessDaoImplTest que sería un objeto 'mock' para hacer tests unitarios de la clase sin tener que crear una conexión física a la base de datos. Con el patrón DI, podremos insertar uno u otro objeto si cambiar ni una línea de código de la clase A.

Hay frameworks que nos simplifican la aplicación del patron DI como el archiconocido Spring y Google Guice. En los siguientes apartados realizaré dos ejemplos de ambos frameworks.

Inyección de dependencias con Spring

Spring proporciona un contenedor encargado de la inyección de dependencias (Spring Core Container). Este contenedor nos posibilita inyectar unos objetos sobre otros. Para ello, los objetos deberán ser simplemente JavaBeans. La inyección de dependencias será bien por constructor o bien por métodos setter.

La configuración podrá realizarse bien por anotaciones Java o mediante un fichero XML (XMLBeanFactory). Para la gestión de los objetos tendrá la clase (BeanFactory). Todos los objetos serán creados como singletons sino se especifica lo contrario.

Lo primero que deberemos hacer es descargar de la web de Spring la distribución del framework donde encontraremos los jars necesarios para nuestra pequeño test de IoC y crear y un proyecto en Eclipse que yo he llamado TestSpring.

He utilizado la versión 2.5.4 por estar disponible ya en mi máquina aunque podéis utilizar otra posterior. Con el spring-{VERSION}.jar, descargaremos también las librerías commons-logging.jar y log4j-{VERSION}.jar y creamos un directorio libs dentro del proyecto con las mismas.

Proyecto en Eclipse finalizado

A continuación crearemos nuestras clases:

LectorDatosClientes.java

package es.jpascu.ioc.services;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service("lectorDatosClientes")
public class LectorDatosClientes {

 private IClienteDao clientesDao;

 @Autowired
 public void setClientesDao(IClienteDao clientesDao) {
  this.clientesDao = clientesDao;
 }

 public void escribirDatosCliente(String id) {
  clientesDao.leerClienteDao(id);
 }
}

Como vemos esta clase no está acoplada a ninguna clase concreta y sí a una interfaz. Es el contenedor de Spring el que posteriormente inyectará una implementación de esta interfaz. Vamos a realizar la configuración mediante anotaciones, aunque también podemos hacerlo mediante XML.

La anotación Service quiere decir que será un bean gestionado por Spring. Está a nivel de clase. La anotación Autowired está a nivel de método set e indica a Spring que debe pasar en el método setClientesDao una instancia de un objeto que implementa dicha interfaz.

A continuación os muestro el código de la interfaz y su implementación.

IClienteDao.java

package es.jpascu.ioc.services;

public interface IClienteDao {

 public void leerClienteDao(String id);
}

ClienteDao.java

package es.jpascu.ioc.services;

import org.springframework.stereotype.Service;

@Service
public class ClienteDaoJdbc implements IClienteDao {

 @Override
 public void leerClienteDao(String id) {
  System.out.println("Datos de cliente: " + id);  
 }
}

En la clase ClienteDAO también se encuentra la anotación Service, ya que Spring lo instanciará y lo inyectará como dependencia en la clase LectorDatosClientes.

Por último, creamos el fichero de configuración applicationContext.xml y lo guardamos en el directorio src/META-INF.

El contenido de este fichero es el siguiente:

Con el elemento context:component-scan le indicamos el paquete donde Spring encontrará los servicios en el código fuente. Por último para probar todo el ejemplo nos creamos una clase de prueba con el siguiente código:

package es.jpascu.ioc.test;

import org.springframework.beans.factory.BeanFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import es.jpascu.ioc.services.LectorDatosClientes;

public class TestSpring {

 public static void main(String args[]) {
  ApplicationContext context = new ClassPathXmlApplicationContext("META-INF/applicationContext.xml");
     BeanFactory factory = context;
     LectorDatosClientes test = (LectorDatosClientes) factory
         .getBean("lectorDatosClientes");
     test.escribirDatosCliente("jpascu");
 }
}

Inyección de dependencias con Google Guice

Google Guice es una librería java de Google que implementa el estandar de inyección de dependencias JSR-330. Al igual que con Spring, podemos utilizarlo para tener clases Java independientes entre sí, teniendo mediante el patron DI un diseño más extensible, mantenible y fácil de testear. manteniente.

A continuación vamos a implementar el ejemplo del apartado anterior con Google Guice. Las librerías nos las podemos descargar de la web del proyecto.

LectorDatosClientes.java

package es.jpascu.ioc.googleguice.services;

import com.google.inject.Inject;

public class LectorDatosClientes {

 private IClienteDao clientesDao;

 @Inject
 public void setClientesDao(IClienteDao clientesDao) {
  this.clientesDao = clientesDao;
 }

 public void escribirDatosCliente(String id) {
  clientesDao.leerClienteDao(id);
 }
}

En lugar de la anotación Autowired ahora ponemos la anotación Inject. Ya veremos más tarde cómo se realizará el binding a la clase particular.

Las clases IClienteDao y ClienteDao quedarían con el mismo código que antes pero sin ninguna anotación:

IClienteDao.java

package es.jpascu.ioc.googleguice.services;

public interface IClienteDao {

 public void leerClienteDao(String id);
}

ClienteDaoJdbc.java

package es.jpascu.ioc.googleguice.services;

public class ClienteDaoJdbc implements IClienteDao {

 @Override
 public void leerClienteDao(String id) {
  System.out.println("Datos de cliente: " + id);
 }

}

Ahora desde la clase donde queramos utilizar nuesto LectorDatosClientes deberemos incluir la lógica para crear dicha clase y sus dependencias mediante com.google.inject.Injector. Aquí no se cargará la configuración desde un fichero XML. Un ejemplo vale más que 1000 palabras:

TestGoogleGuice.java

package es.jpascu.ioc.test;

import com.google.inject.AbstractModule;
import com.google.inject.Guice;
import com.google.inject.Injector;

import es.jpascu.ioc.googleguice.services.ClienteDaoJdbc;
import es.jpascu.ioc.googleguice.services.IClienteDao;
import es.jpascu.ioc.googleguice.services.LectorDatosClientes;

public class TestGoogleGuice {
 public static void main(String args[]) {
  Injector injector = Guice.createInjector(new JdbcInjectionModule());
  LectorDatosClientes lectorClientes = injector
    .getInstance(LectorDatosClientes.class);

  lectorClientes.escribirDatosCliente("jpascu");
 }

 public static class JdbcInjectionModule extends AbstractModule {
  @Override
  protected void configure() {
   bind(IClienteDao.class).to(ClienteDaoJdbc.class);
  }

 }
}

Ahora tenemos una clase interna que es una subclase de la clase AbstractModule, encargada del 'binding' de una interfaz con una implementación concreta. Para ello se debe implementar el método configure.

Una vez que hemos creado nuestro JdbcInjectionModule lo pasaremos como parámetro al objeto de la clase com.google.inject.Guice.Injector. A través de este objeto obtendremos una instancia singleton de nuestro LectorDatosClientes con la dependencia correctamente asociada. Por último sólo nos queda utilizarla...

Hasta aquí el artículo. Espero que os haya ayudado a comprender mejor la inyección de dependencias y daros dos puntos de vista mediante ejemplos con dos frameworks diferentes: Spring y Google Guice.

Fuente: Vogella1 | Vogella2 | metafisicainformatica

JUEGO BARCENAS PARA TU ANDROID

2013-02-11T10:43:00.002+01:00

Hace ya algunas semanas que estalló el 'Caso Bárcenas' en nuestro país en plena crisis económica y financiera, la guinda del pastel que faltaba para generar más inestabilidad en este nuestro país. En los medios de comunicación oímos todos los días palabras como corrupción, PP, Bárcenas, los papeles, contabilidad B, etc.. Y muchos de nosotros nos levantamos cada día a trabajar para seguir adelante con el día a día y con la esperanza que la situación cambié algún día, al menos para los que vienen después de nosotros...

Bajo este panorama poco esperanzador no todo iba a ser TODO malo. Para conseguir una sonrisa mi compañero Héctor y un servidor hemos creado un juego para Android mezcla de ironía, humor y diversión llamado BarcenasGate. En él te vas a convertir en el cartero del famosísimo Bárcenas y tu misión principal será repartir 'regalitos' para tus 'amigos más queridos'. Cuanto mayor sea el regalo, mayor será la recompensa que obtienes y más dificultad tendrás para entregarlo. Entrega el mayor número de sobres en el menor tiempo posible!!! Pero ten cuidado cartero porque alguien podría vigilarte y sorprenderte al FINAL del juego.

Al entrar al JUEGO te aparece un menú principal donde puedes activar/desactivar el sonido y la vibración, una pantalla de Ayuda donde se te explica tu misión y por supuesto el botón de Jugar para que empieces a cumplir tu misión.

Los PERSONAJES con los que puedes interactuar son:

BARCENAS. El personaje más buscado. Si entregas un sobre a BARCENAS recibirás 10.000 euros de recompensa. Únicamente sale dos veces y a toda pastilla así que tendrás que estar muy atento.

RAJOY. Si entregas un sobre al 'presi' recibirás una recompensa de 1000 euros.

CASCOS. Recompensa de 800 euros.

ARENAS. Recompensa de 500 euros.

TRILLO. Recompensa de 400 euros.

MAYOR OREJA. Recompensa de 300 euros.

COSPEDAL. Recompensa de 100 euros.

Cuanto mayor sea la recompensa, más rápido se moverá el personaje y más dificil será entregarle el sobre!!!

Podéis descargarlo en en la siguiente página https://play.google.com/store/apps/details?id=es.jpascu.games.barcenasgate.

Espero que lo disfrutéis.

Un saludo.

APLICACION ANDROID PARA BEBES

2013-01-28T13:06:00.000+01:00

Te levantas a las 7:00 AM con el sonido infernal del móvil. Te duchas, desayunas y llegas al trabajo después de superar con éxito una hora de atascos. Al mediodía comida con exceso de calorías y después de 10 horas de duro trabajo y acidez de estómago vuelves a casa con una sonrisa para ver de nuevo a tu dulce bebé. ¿Y qué hace él? Pues te llora, te llora tanto que el eco hace retumbar todas las paredes de tu casa.

Cuando tienes un pequeño en casa las cosas son así y no se pueden cambiar. Es lo que hay. Por ello tuve la 'genial' idea de crear una de las millones de aplicaciones Android que ya existen en la Play Store con música para bebés.

La aplicación se llama LullabyDroid y su entrada en la PlayStore es: https://play.google.com/store/apps/details?id=es.soundroid.activity.

Es muy simple. Cuando entras te aparece un simpático pingüino y un botón con el que puedes seleccionar entre 3 canciones para bebés. Son composiciones clásicas de artistas tan ilustres como Bach o Pachelbel.

Una vez que has escogido tu canción puedes elegir también el tiempo de duración que quieres escoger para la reproducción. También tienes la opción que la canción se reproduzca indefinidamente, aunque las baterías de los smartphones seguramente lo impedirán.

Además cada vez que cambiamos de canción el fondo de pantalla se cambia por una imagen diferente. El favorito de mi hijo es el pingüino 'Pingui' pero la imagen de 'Toby' tampoco está nada mal:

Espero que os guste y sobre todo que os ayude en las noches más estresantes.

POSTDATA: Ah, se me olvidaba, por supuesto, es gratuita.

Saludos.

Frase

2013-01-15T10:16:00.001+01:00

Veo mucho potencial, pero está desperdiciado. Toda una generación trabajando en gasolineras, sirviendo mesas, o siendo esclavos oficinistas.La publicidad nos hace desear coches y ropas, tenemos empleos que odiamos para comprar mierda que no necesitamos. Somos los hijos malditos de la historia, desarraigados y sin objetivos, no hemos sufrido una gran guerra, ni una depresión. Nuestra guerra es la guerra espiritual, nuestra gran depresión es nuestra vida. Crecimos con la televisión que nos hizo creer que algún día seríamos millonarios, dioses del cine, o estrellas del rock. Pero no lo seremos, y poco a poco lo entendemos, lo que hace que estemos muy cabreados - Tyler Durden en El Club de la Lucha.