Qi4j y Programación Orientada a Compuestos

Hace unas semanas un amigo me recomendó esta pagina de un nuevo framework Qi4j que se centra en el desarrollo del modelo de dominio y usa conceptos de AOP, DI (Dependency Injection) y DDD (Domain Driven Design).

El framework es una implementación de un nuevo paradigma de programación que es la Programación Orientada a Compuestos (Composites) (COP - por sus siglas en Ingles) usando Java 5 puro.

Los principios de la COP son:
- El comportamiento de un objeto depende del contexto.
- El desacoplamiento es una virtud.
- Las reglas de negocio importan mas.
- Las Clases han muerto, larga vida a las Interfaces.

Ellos argumentan que la Programación Orientada a Objetos (OOP) tiene ciertos problemas para realmente modelar el ciclo de vida de los objetos. Por ejemplo, un objeto no siempre tiene los mismos atributos y estos pueden variar (tener menos o mas atributos) en el tiempo, incluso el comportamiento de un objeto no es el mismo siempre ya que puede variar según el contexto donde se encuentre ejecutando.

Este tipo de cosas ha sido muy difícil implementarlas usando OOP y aunque se pueden implementar debería ser mas "natural".

A todos nos ha pasado que empezamos un sistema haciendo el análisis de los conceptos y reglas de negocio y buscamos hacer un diseño que represente y cumpla con todos esos requisitos lo mejor posible. Pero cuando llega la hora de codificar terminamos enfocando mas nuestros esfuerzos en la infraestructura y terminamos teniendo un modelo de dominio anémico (Martin Fowler explica esto aquí).

La Programación Orientada a Compuestos esta muy influenciada por el libro de Erick Evans (Domain Driven Design) donde propone conceptos y patrones de diseño para diseñar sistemas mas enfocados al modelo de dominio.

En la COP existen dos niveles de composición:

- Un nivel de composición para ensamblar objetos compuestos a partir de piezas mas pequeñas llamadas Fragmentos.
- Y un segundo nivel de composición para ensamblar Módulos a partir de compuestos (objetos del primer nivel de composición), Capas a partir de Módulos y terminar con una Aplicación compuesta de Capas.

Los Fragmentos a partir de los cuales se puede formar un objeto compuesto son:
- Mixins. Representan el estado de un objeto compuesto.
- Restricciones (Constraints). Reglas de validación tanto de entrada como de salida para los argumentos.
- Intereses (Concerns). Interceptan llamadas de métodos. Su uso se aplica generalmente a comportamientos que aplican a todo el sistema (cross-cutting behaviours).
- Efectos Secundarios (Side Effects). Se ejecutan después de la ejecución de un método pero no influyen en los datos de salida que entregan los métodos.

En fin, el framework Qi4j se ve muy interesante y vale la pena echarle un ojo para ver la forma en que trabaja.

Links de interés:

- Resumen del libro de Erick Evans DDD. http://www.infoq.com/minibooks/domain-driven-design-quickly

Primeros Pasos con Spring Roo en Spring Source Tool Suite

Este ejemplo de primeros pasos esta hecho con el SpringSource Tool Suite, sin embargo, es posible hacerlo también desde la consola de Roo.

Vamos a crear una pequeña aplicacion de libreta de direcciones para este ejemplo.

Lo primero es crear el proyecto del tipo "Roo Project" con el nombre "PrimerosPasos" (el nombre puede ser de su eleccion solo recuerden que con ese nombre tendrá el contexto web).

Esto crea un proyecto con la estructura:

Para aquellos que usan maven se darán inmediatamente cuenta que es una estructura de un proyecto maven.

Para crear/configurar las cosas en Spring Roo se corren comandos desde la consola Roo, la cual desde el SpringSource Tool Suite se puede ejecutar con click derecho sobre el proyecto luego la opcion Spring Tools -> Open Roo Shell.

Ya en la vista de la consola Roo existe un campo de texto donde tecleamos los comandos que pueden ir creando el código de la aplicación. Si teclean "hint" el mismo Roo les dará pistas sobre que comandos teclear según lo ya creado dentro del proyecto.

Lo primero que hay que configurar el proveedor y la base de datos de la aplicación, y de hecho este es el primer punto que pide Roo crear si teclean "hint".

persistence setup --database MYSQL --provider HIBERNATE

Esto imprime como salida en la consola de roo:

roo> persistence setup --database MYSQL --provider HIBERNATE
Created SRC_MAIN_RESOURCES/META-INF/persistence.xml
Created SRC_MAIN_RESOURCES/META-INF/spring/database.properties
please enter your database details in src/main/resources/database.properties
Managed SRC_MAIN_RESOURCES/META-INF/spring/applicationContext.xml
Managed ROOT/pom.xml
Managed ROOT/pom.xml
Managed ROOT/pom.xml
Managed ROOT/pom.xml
Managed ROOT/pom.xml
Managed ROOT/pom.xml
Managed ROOT/pom.xml
Managed ROOT/pom.xml
Managed ROOT/pom.xml
Managed ROOT/pom.xml
Managed ROOT/pom.xml
Managed ROOT/pom.xml
Managed ROOT/pom.xml
Managed ROOT/pom.xml

Dentro de los archivos que fueron creados esta el "database.properties" en el cual hay que configurar los parámetros para conectarnos a nuestra base de datos en mysql.

Ya configurados los parametros para conectarnos a la base de datos es necesario empezar a crear las entidades de nuestra aplicacion. Dado que nuestra aplicacion sera una libreta de direcciones empezaremos con la entidad "Persona".

Una vez mas podemos teclear "hint" en la consola de roo para que nos ayude.

Para crear una entidad hay que teclear el comando "entity" el cual recibe un argumento obligatorio y es el nombre de la clase de la entidad que vamos a crear.

entity --class com.jabaddon.roo.libretadirecciones.dominio.Persona

Sin embargo el comando "entity" puede recibir mas argumentos los cuales nos puede mostrar la consola de roo si tecleamos "--" y luego CRTL+SPACE.

Una vez ejecutado el comando "entity" esta es la salida en la consola de roo:

roo> entity --class com.jabaddon.roo.libretadirecciones.dominio.Persona
Created SRC_MAIN_JAVA/com/jabaddon/roo/libretadirecciones/dominio
Created SRC_MAIN_JAVA/com/jabaddon/roo/libretadirecciones/dominio/Persona.java
Created SRC_MAIN_JAVA/com/jabaddon/roo/libretadirecciones/dominio/Persona_Roo_Entity.aj
Created SRC_MAIN_JAVA/com/jabaddon/roo/libretadirecciones/dominio/Persona_Roo_ToString.aj
Created SRC_MAIN_JAVA/com/jabaddon/roo/libretadirecciones/dominio/Persona_Roo_Configurable.aj

Notaran que la única clase java creada fue "Persona.java" y que si abren el código solo verán lo siguiente:

@Entity
@RooJavaBean
@RooToString
@RooEntity
public class Persona {
}

Los otros archivos "*.aj" son Aspectos agregados a la clase Persona.

En este punto si volvemos a teclear "hint" en la consola de roo nos dará consejos para crearle atributos a nuestra clase.

Agregaremos el atributo nombre a nuestra clase Persona ejecutando el siguientes comando en la consola:

field string --fieldName nombre

roo> field string --fieldName nombre
Managed SRC_MAIN_JAVA/com/jabaddon/roo/libretadirecciones/dominio/Persona.java
Created SRC_MAIN_JAVA/com/jabaddon/roo/libretadirecciones/dominio/Persona_Roo_JavaBean.aj
Managed SRC_MAIN_JAVA/com/jabaddon/roo/libretadirecciones/dominio/Persona_Roo_ToString.aj

Ok, en este punto del ejemplo me gustaría recalcar algo y para lograrlo primero hay que crear una clase de prueba de la clase Persona con el siguiente código:

package com.jabaddon.roo.libretadirecciones.dominio;

import org.apache.log4j.Logger;
import org.junit.Test;

public class PersonaTest {

private static final Logger LOGGER = Logger.getLogger(PersonaTest.class);

@Test
public void imprimirNombrePersona() {
Persona persona = new Persona();
persona.setNombre("Jimmy");
LOGGER.debug("El nombre es = " + persona.getNombre());
}
}

Lo siguiente es crear un archivo "log4j.propeties" en src/test/resources y configurarlo para que imprima el nivel debug de la siguiente forma: (si quieren pueden copiar el log4j.properties que se genero en src/main/resources/META-INF/spring/log4j.properties, pero hay que cambiarle el nivel a debug).

log4j.rootLogger=debug, consola

log4j.appender.consola=org.apache.log4j.ConsoleAppender
log4j.appender.consola.layout=org.apache.log4j.PatternLayout
log4j.appender.consola.layout.ConversionPattern=%d [%t] %-5p %c - %m%n

Una vez creada la prueba unitaria y el archivo log4j.properties, hay que ejecutar las pruebas del proyecto dando click derecho sobre el archivo pom.xml y ejecutar la opcion "Run As -> Maven Test". Con esto ejecutaremos las pruebas unitarias del proyecto y la salida de ejecutar esta acción es la siguiente (o pueden ejectuar las pruebas corriendo el comando "mvn test" en una consola normal):

...
-------------------------------------------------------
T E S T S
-------------------------------------------------------
Running com.jabaddon.roo.libretadirecciones.dominio.PersonaTest
2010-01-10 21:52:35,441 [main] DEBUG org.springframework.beans.factory.wiring.BeanConfigurerSupport - BeanFactory has not been set on BeanConfigurerSupport: Make sure this configurer runs in a Spring container. Unable to configure bean of type [com.jabaddon.roo.libretadirecciones.dominio.Persona]. Proceeding without injection.
2010-01-10 21:52:35,444 [main] DEBUG com.jabaddon.roo.libretadirecciones.dominio.PersonaTest - El nombre es = Jimmy
Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.931 sec

Results :

Tests run: 1, Failures: 0, Errors: 0, Skipped: 0
...

Ok, todo fue bien el nombre Jimmy se imprimió bien. Ahora miremos de nuevo el código de la clase Persona.java:

package com.jabaddon.roo.libretadirecciones.dominio;

import javax.persistence.Entity;
import org.springframework.roo.addon.javabean.RooJavaBean;
import org.springframework.roo.addon.tostring.RooToString;
import org.springframework.roo.addon.entity.RooEntity;

@Entity
@RooJavaBean
@RooToString
@RooEntity
public class Persona {

private String nombre;
}

Alguien puede explicarme porque al crear la prueba unitaria la clase Persona contenía los métodos setNombre y getNombre si el código java no lo tiene?!??!?!?!. La respuesta son dos palabras: Aspectos y Addons.

Recuerdan que al crear la entidad Persona Spring Roo creo unos archivos .aj? estos son los Aspectos. Vía aspectos y anotaciones Spring Roo agrega funcionalidad a las clases. Estos aspectos agregados por anotaciones a las clases son los llamados "Addons".

Los "Addons" son una característica que propone Spring Roo y es muy interesante ya que así podemos agregar funcionalidad a las clases de acuerdo a las necesidades y circunstancias. En algun post siguiente en el blog veremos mas a detalle acerca de los aspectos y addons de Spring Roo incluso para crear uno propio, por ahora continuemos con el ejemplo.

Ok, nuestra clase Persona ya tienen un atributo y es el nombre. Ahora vamos a agregarle otros atributos como: apellido y numero telefonico con los comandos siguientes:

                            
field string --fieldName apellido
field string --fieldName numeroTelefonico

Ahora crearemos la parte web de la aplicación creando los controllers. Para que roo nos ayude hay que teclean "hint controllers" en la consola de roo.

Para crear un controller que contenga las operaciones clasicas de altas, bajas y modificaciones (CRUD) ejecutamos el comando:

controller scaffold --class com.jabaddon.roo.libretadirecciones.web.PersonaController --entity com.jabaddon.roo.libretadirecciones.dominio.Persona

La salida de la ejecucion de este comando es la siguiente:

roo> controller scaffold --class com.jabaddon.roo.libretadirecciones.web.PersonaController --entity com.jabaddon.roo.libretadirecciones.dominio.Persona
Created SRC_MAIN_JAVA/com/jabaddon/roo/libretadirecciones/web
Created SRC_MAIN_JAVA/com/jabaddon/roo/libretadirecciones/web/PersonaController.java
Created SRC_MAIN_WEBAPP/WEB-INF/spring
Created SRC_MAIN_WEBAPP/WEB-INF/spring/webmvc-config.xml
Created SRC_MAIN_JAVA/com/jabaddon/roo/libretadirecciones/web/PersonaController_Roo_Controller.aj
Created SRC_MAIN_WEBAPP/images
Created SRC_MAIN_WEBAPP/images/nl.png
Created SRC_MAIN_WEBAPP/images/update.png
Created SRC_MAIN_WEBAPP/images/es.png
Created SRC_MAIN_WEBAPP/images/delete.png
Created SRC_MAIN_WEBAPP/images/add.png
Created SRC_MAIN_WEBAPP/images/resultset_previous.png
Created SRC_MAIN_WEBAPP/images/resultset_next.png
Created SRC_MAIN_WEBAPP/images/favicon.ico
Created SRC_MAIN_WEBAPP/images/banner-graphic.png
Created SRC_MAIN_WEBAPP/images/resultset_last.png
Created SRC_MAIN_WEBAPP/images/gb.png
Created SRC_MAIN_WEBAPP/images/springsource-logo.png
Created SRC_MAIN_WEBAPP/images/it.png
Created SRC_MAIN_WEBAPP/images/show.png
Created SRC_MAIN_WEBAPP/images/sv.png
Created SRC_MAIN_WEBAPP/images/list.png
Created SRC_MAIN_WEBAPP/images/resultset_first.png
Created SRC_MAIN_WEBAPP/images/de.png
Created SRC_MAIN_WEBAPP/styles
Created SRC_MAIN_WEBAPP/styles/standard.css
Created SRC_MAIN_WEBAPP/styles/alt.css
Created SRC_MAIN_WEBAPP/WEB-INF/classes
Created SRC_MAIN_WEBAPP/WEB-INF/classes/standard.properties
Created SRC_MAIN_WEBAPP/WEB-INF/classes/alt.properties
Created SRC_MAIN_WEBAPP/WEB-INF/layouts
Created SRC_MAIN_WEBAPP/WEB-INF/layouts/default.jspx
Created SRC_MAIN_WEBAPP/WEB-INF/layouts/layouts.xml
Created SRC_MAIN_WEBAPP/WEB-INF/views
Created SRC_MAIN_WEBAPP/WEB-INF/views/views.xml
Created SRC_MAIN_WEBAPP/WEB-INF/views/resourceNotFound.jspx
Created SRC_MAIN_WEBAPP/WEB-INF/views/index.jspx
Created SRC_MAIN_WEBAPP/WEB-INF/views/uncaughtException.jspx
Created SRC_MAIN_WEBAPP/WEB-INF/views/dataAccessFailure.jspx
Created SRC_MAIN_WEBAPP/WEB-INF/views/controller-index.jspx
Created SRC_MAIN_WEBAPP/WEB-INF/tags
Created SRC_MAIN_WEBAPP/WEB-INF/tags/language.tagx
Created SRC_MAIN_WEBAPP/WEB-INF/tags/theme.tagx
Created SRC_MAIN_WEBAPP/WEB-INF/tags/pagination.tagx
Created SRC_MAIN_WEBAPP/WEB-INF/i18n
Created SRC_MAIN_WEBAPP/WEB-INF/i18n/messages_sv.properties
Created SRC_MAIN_WEBAPP/WEB-INF/i18n/messages.properties
Created SRC_MAIN_WEBAPP/WEB-INF/i18n/messages_nl.properties
Created SRC_MAIN_WEBAPP/WEB-INF/i18n/messages_it.properties
Created SRC_MAIN_WEBAPP/WEB-INF/i18n/messages_es.properties
Created SRC_MAIN_WEBAPP/WEB-INF/i18n/messages_de.properties
Created SRC_MAIN_WEBAPP/WEB-INF/i18n/application.properties
Managed SRC_MAIN_WEBAPP/WEB-INF/i18n/application.properties
Created SRC_MAIN_WEBAPP/WEB-INF/views/persona
Created SRC_MAIN_WEBAPP/WEB-INF/views/persona/list.jspx
Created SRC_MAIN_WEBAPP/WEB-INF/views/persona/show.jspx
Created SRC_MAIN_WEBAPP/WEB-INF/views/persona/create.jspx
Created SRC_MAIN_WEBAPP/WEB-INF/views/menu.jspx
Managed SRC_MAIN_WEBAPP/WEB-INF/i18n/application.properties
Managed SRC_MAIN_WEBAPP/WEB-INF/i18n/application.properties
Managed SRC_MAIN_WEBAPP/WEB-INF/i18n/application.properties
Managed SRC_MAIN_WEBAPP/WEB-INF/i18n/application.properties
Managed SRC_MAIN_WEBAPP/WEB-INF/views/menu.jspx
Created SRC_MAIN_WEBAPP/WEB-INF/views/persona/update.jspx
Managed SRC_MAIN_WEBAPP/WEB-INF/i18n/application.properties
Managed SRC_MAIN_WEBAPP/WEB-INF/i18n/application.properties
Managed SRC_MAIN_WEBAPP/WEB-INF/views/menu.jspx
Created SRC_MAIN_WEBAPP/WEB-INF/views/persona/views.xml
Created SRC_MAIN_WEBAPP/WEB-INF/urlrewrite.xml
Created SRC_MAIN_WEBAPP/WEB-INF/web.xml
Managed SRC_MAIN_WEBAPP/WEB-INF/web.xml
Managed ROOT/pom.xml
Managed ROOT/pom.xml
Managed ROOT/pom.xml
Managed ROOT/pom.xml
Managed ROOT/pom.xml
Managed ROOT/pom.xml
Managed ROOT/pom.xml
Managed ROOT/pom.xml
Managed ROOT/pom.xml
Managed ROOT/pom.xml
Managed ROOT/pom.xml
Managed ROOT/pom.xml

Como verán, Spring Roo ha creado todos los archivos necesarios para tener una aplicación básica de altas, bajas y modificaciones sobre nuestra entidad Persona.

Para correr la aplicación bien podemos dar click derecho sobre el proyecto de Spring Source Tool Suite y darle "Run As -> Run on Server" o en una consola normal "mvn jetty:run".

Una vez que ha levantado el servidor vayan a la direccion http://localhost:8080/PrimerosPasos y listo!

Notaran que en la base de datos ya existe una tabla llamada "persona" con los atributos iguales a los que tiene nuestra entidad Persona.

NOTA: Yo tuve problemas ejecutando este ejemplo con Java 1.5 en una Mac pero todo corrió bien con Java 1.6.

Spring 3: Spring Expression Language (SpEL)

En la versión 3 de Spring podemos encontrar una nueva característica y es el SpEL (Spring Expression Language). Es una nueva forma para inyectar valores a las propiedades de los beans.

Por ejemplo, todo hijo hereda el apellido del padre:

Al ejecutar el siguiente codigo java:

      ApplicationContext appContext =
              new ClassPathXmlApplicationContext("classpath:spring3-config.xml");
      Persona padre = (Persona) appContext.getBean("padre");
      Persona hijo = (Persona) appContext.getBean("hijo");
      System.out.println("Apellido del padre = " + padre.getApellido());
      System.out.println("Apellido del hijo = " + hijo.getApellido());

El resultado es el siguiente:

Apellido del padre = Lara
Apellido del hijo = Lara

Spring evalúa la expresión "#{padre.apellido}" y la traduce a una llamada el método "getApellido" del bean "padre". El resultado es inyectado a la propiedad "apellido" del bean "hijo". Esta nueva característica del Spring 3 es muy interesante ya que no solo permite acceder a propiedades de otros beans, también llamar metodos de otros beans, obtener valores de propiedades del sistema y hasta llamar métodos estáticos.

Veamos algunos ejemplos:

• Acceder a propiedades del sistema: #{ systemProperties['valor.systema]}.
• Llamar métodos estáticos: #{ T(java.lang.Math).random() }.
• Acceder a elementos de un arreglo: #{ arreglo[1] }.
• Acceder a elementos de un mapa: #{ mapa['key'] }.
• Llamar a métodos (con todo y argumentos): #{ 'cadena'.substring(2, 3) }.
• Operaciones aritméticas: #{ (2 + 2) * 5 }
• Crear objetos: #{ new String('Hola') }.

En fin, hay muchas otras cosas mas que se pueden hacer con esta nueva característica que viene con Spring 3

Pueden leer mas en la documentación de referencia aquí.

Instalacion de Jackbe Presto en Windows Vista

Hace poco quise instalar Jackbe Presto en Windows Vista y me tope con un problema ya que al correr el bat que hace la instalación 'setup.bat' mandaba un error (no recuerdo el error :P).

El contenido del archivo setup.bat tiene lo siguiente:

cscript //NoLogo setup_win.js

Al agregarle la siguiente opción la instalación funciono sin problemas:

cscript //NoLogo setup_win.js //E:javascript

Muse - The Resistance

Mañana es el día (15-Septiembre-2009) en que la banda inglesa de rock alternativo Muse saca a la venta (por lo menos en iTunes Music Store) su nuevo disco titulado 'The Resistance'.

El disco esta compuesto por los siguientes tracks:

1. Uprising. Gran rola y el primer single oficial del disco.
2. Resistance.
3. Undisclosed Desires. Muy buenos arreglos y coros.
4. United States of Eurasia. Buenos coros, me recuerdan a Queen, y termina con un gran toque de musica clasica (Nocturna Op. 9 No. 2 de Chopin).
5. Guiding Light. Un poco melosa y con falta de cambio de ritmos.
6. Unnatural Selection. Otra buena rola, buena guitarra rítmica muy de Muse.
7. MK Ultra.
8. I Belong to You. Muy buen ritmo y termina excelentemente con un fragmento de la opera "Samson et Dalila" de Camille Saint-Saêns.
   
9. Exogenesis: Symphony, Pt. 1 (Overture).
10. Exogenesis: Symphony, Pt. 2 (Cross-pollination).
11. Exogenesis: Symphony, Pt. 3 (Redemption). Gran piano.

En general es un disco no tan roquero como los anteriores de Muse pero que da una muestra del talento que tienen los Muse para componer música sobre todo de Mattew Bellamy. Muy recomendable.

Ruby on Rails

¿Porque Ruby y Ruby on Rails tienen tanta popularidad en estos días?

¿Esta próxima la muerte de Java para aplicaciones Web?

Navegando en la red me encontré con esta imagen que dice mucho del porque Ruby on Rails ha ganado tanta popularidad entre los desarrolladores.

¿Y cual es esa ventaja de Ruby on Rails sobre Java?

La respuesta es su simplicidad. La simplicidad es el atractivo que ha hecho que muchos desarrolladores voltearan a ver Ruby on Rails. La simplicidad de ejecutar unos cuantos

comandos para generar los Controladores o los objetos del domino basados en la estructura de la base de datos. Su lema es convención sobre configuración.

Ahora podemos ver que hay un proyecto llamado Grails basado en la forma de trabajo de Ruby on Rails (la respuesta de Java a Ruby on Rails). Este proyecto usa como lenguaje base Groovy que es un lenguaje script dinámico para la plataforma Java y tiene integración con Spring y Hibernate.

Desde mi punto de vista no creo que Java muera pronto, Java se ha ganado el lugar donde esta debido a su poder y robustez y, es mas, gracias a proyectos como Grails lo que creo es que Java en lugar de morir va a transformarse para adaptarse a las necesidades del futuro. Tampoco le estoy haciendo el feo a Ruby on Rails ya que su simplicidad y sencillez puede ayudarnos a desarrollar proyectos pequeños mas rápido.

La red social Twitter esta hecha con Ruby on Rails, sin embargo, como se puede leer en la pagina de wikipedia sobre Ruby on Rails, están migrando a otro lenguaje llamado Scala (que corre sobre la maquina virtual de Java) ya que han encontrado problemas de escalabilidad sobre todo con la base de datos.

Lo que si estoy esperando ver en un futuro es la interacción del lenguaje Ruby a plataformas Java y .NET de tal forma que sea lo mismo programar una clase en Ruby y usarla con Java o con C# y viceversa. Incluso poder usar las librerías de Java y/o .NET indistintamente en, para el caso de Java, Java y Ruby o, para el caso de .NET, en C# y Ruby.

No esta de mas aprender Ruby, es un buen lenguaje con características interesantes que nos puede ayudar a hacer herramientas que apoyen a nuestros proyectos.

En esta liga podemos ver un estudio que se hizo para ver la popularidad de los lenguajes programación. En este podemos ver que Ruby se encuentra en en lugar numero 10 y que los lenguajes muy fuertes siguen siendo Java, C y C++.

Last.fm

Hace tiempo cree mi cuenta en Last.fm y empecé a usarlo. Me encanto la idea de Last.fm de escuchar música en streaming y al mismo tiempo crear tus propias estaciones de radio de acuerdo a tus gustos y/o recomendaciones de genero de música.

Incluso me fascino que existe una aplicación para el iPhone/iPod touch de Last.fm que en combinación con unas bocinas para el iPod y la red Wi-fi de la casa podía escuchar la música como si estuviese escuchando la radio. Eso esta muy chido sobre todo cuando reunes a los amigos en la casa para echar unos tragos.

A mi me gusta escuchar nueva música y conocer grupos nuevos y Last.fm era una fuente muy buena para conocer nuevas cosas ya que te hace recomendaciones de acuerdo a los artistas que tienes agregados a tu colección.

Ahora que vuelvo a entrar después de no haberlo usando un buen rato me encuentro con la sorpresa de que ya van a cobrar 3 dolares al mes por usarlo (triste). Era de esperarse la idea del servicio que ofrece Last.fm es muy buena y tenian que sacar algun provecho.

Así que si tienen 3 dolares que les sobre al mes y les gusta la música vayan a Last.fm.

Bamboo Fun

Este es mi primer dibujo en mi recien adquirida Bamboo Fun Pen Tablet. Un producto muy recomendable.



En la medida de lo posible ire poniendo mas dibujos que haga con la Bamboo Fun de Wacom.

Tutorial Spring Batch - File Converter, Parte 2

Ya un rato sin poner algo en el blog. Y dado que tengo pendiente la parte 2 del tutorial de Spring Batch, pues empecemos...

La primera parte de este tutorial se enfoco mas a la teoría y los conceptos básicos que maneja Spring Batch. Esta segunda parte sera mas practica y nos enfocaremos a crear el miniproyecto tutorial que demuestre un poco las funciones de este framework. Solo espero no extenderme tanto y no hacer una segunda parte de esta segunda parte :P.

Para este ejercicio vamos a suponer que tenemos que hacer un sistema que toma archivos de texto con información de contactos donde los datos vienen separados por comas y que se tiene que transformar a otro archivo de texto donde la información vendrá en registros de tamaño fijo. Cada linea del archivo separado por comas representa la información de un contacto en el siguiente estructura:

1. Nombre
2. Apellido
3. e-mail personal
4. e-mail del trabajo
   
5. telefono
6. pagina web
   

Empezaremos creando la plantilla del proyecto con maven 2 y el plugin archetype ejecutando el siguiente comando:

$> mvn archetype:create -DgroupId=<aqui-va-el-groupId> -DartifactId=<aqui-va-el-artifactId>

En este caso use groupId=com.jabaddon.tutorials.springbatch.fileconverter y artifactId=file-converter. Para mas información de maven 2 y el uso del plugin archetype consulten la referencia que dejo al final.

Una vez ejecutado el comando tendremos una plantilla de proyecto simple en maven 2. Para poder hacer uso de Spring Batch tendremos que indicarle a nuestro proyecto en maven donde encontrar las librerías necesarias de Spring Batch para empezar a codificar. Como usaremos la versión 2.0.0.RC2 hay que agregar a nuestro pom.xml el repositorio de spring-batch:

12:    <repositories>
13:        <repository>
14:            <id>spring-s3</id>
15:            <name>Spring Maven MILESTONE Repository</name>
16:            <url>http://s3.amazonaws.com/maven.springframework.org/milestone</url>
17:        </repository>
18:    </repositories>

Y las librerías que usaremos son:

20:    <dependencies>
21:        <!-- Para las pruebas unitarias -->
22:        <dependency>
23:            <groupId>junit</groupId>
24:            <artifactId>junit</artifactId>
25:            <version>3.8.1</version>
26:            <scope>test</scope>
27:        </dependency>
28:
29:        <!-- Para las pruebas unitarias con Spring -->
30:        <dependency>
31:            <groupId>org.springframework</groupId>
32:            <artifactId>spring-test</artifactId>
33:            <version>2.5.5</version>
34:            <scope>test</scope>
35:        </dependency>
36:
37:        <!-- Para el logging -->
38:        <dependency>
39:            <groupId>log4j</groupId>
40:            <artifactId>log4j</artifactId>
41:            <version>1.2.8</version>
42:        </dependency>
43:
44:        <!-- Spring batch -->
45:        <dependency>
46:            <groupId>org.springframework.batch</groupId>
47:            <artifactId>spring-batch-core</artifactId>
48:            <version>2.0.0.RC2</version>
49:        </dependency>
50:
51:        <!-- Spring batch -->
52:        <dependency>
53:            <groupId>org.springframework.batch</groupId>
54:            <artifactId>spring-batch-execution</artifactId>
55:            <version>1.0.0.m4</version>
56:        </dependency>
57:
58:        <!-- Para la conexion a la base de datos -->
59:        <dependency>
60:            <groupId>commons-dbcp</groupId>
61:            <artifactId>commons-dbcp</artifactId>
62:            <version>1.2</version>
63:        </dependency>
64:
65:        <!-- El driver jdbc para mysql -->
66:        <dependency>
67:            <groupId>mysql</groupId>
68:            <artifactId>mysql-connector-java</artifactId>
69:            <version>5.1.6</version>
70:        </dependency>
71:
72:    </dependencies>

Ahora, yo tuve problemas a la hora de compilar el proyecto ya que intentaba el compilador hacerlo usando la versión 1.3 de java, por lo que tuve que agregarle lo siguiente al pom.xml para obligarlo a compilar con java 1.5:

74:    <build>
75:        <plugins>
76:            <plugin>
77:                <groupId>org.apache.maven.plugins</groupId>
78:                <artifactId>maven-compiler-plugin</artifactId>
79:                <configuration>
80:                    <source>1.5</source>
81:                    <target>1.5</target>
82:                    <archive>
83:                        <manifest>
84:                            <addClasspath>true</addClasspath>
85:                        </manifest>
86:                    </archive>
87:                </configuration>
88:            </plugin>
89:        </plugins>
90:    </build>

Job

El Job de este proyecto solo consistira de un paso, el cual se encargara de leer la informacion de un archivo para escribirlo en otro. El bean en el xml de spring de este Job lo definiremos como:

66:    <job id="process">
67:        <step id="loadNWriteFile">
68:            <tasklet reader="reader" writer="writer" commit-interval="1"/>
69:        </step>
70:    </job>

El Step esta definido por un tasklet que se compone de un reader y un writer. El bean del reader lo definimos como:

56:    <beans:bean id="reader" scope="step" class="org.springframework.batch.item.file.FlatFileItemReader">
57:        <beans:property name="resource" value="#{jobParameters[input.file.name]}" />
58:        <beans:property name="lineMapper" ref="lineMapper" />
59:    </beans:bean>

Lectura (reader)

El 'reader' tiene dos propiedades. La propiedad 'resource' indica la url del archivo que leera y la propiedad 'lineMapper' define un bean que mapea cada linea del archivo a un POJO (que nosotros definiremos como la clase Contacto).

Como se logra notar el valor de la propiedad 'resource' del bean 'reader' tiene el valor de '#{jobParameters[input.file.name]}', esto es asi porque de esta forma le indicamos a Spring Batch que el valor lo tome del parametro que recibe el job con el nombre 'input.file.name'.

El lineMapper que usa el reader esta definido de la siguiente forma:

51:    <beans:bean id="lineMapper" class="org.springframework.batch.item.file.mapping.DefaultLineMapper">
52:        <beans:property name="lineTokenizer"><beans:ref bean="tokenizer" /></beans:property>
53:        <beans:property name="fieldSetMapper"><beans:ref bean="fieldSetMapper" /></beans:property>
54:    </beans:bean>

Un LineMapper en Spring Batch es el encargado de (con ayuda de un Tokenizer) leer las lineas de una archivo para estos datos mapearlos a un POJO via el FieldSetMapper.

Como nuestro archivo esta separado por comas el Tokenizer que definimos es uno al cual se le puede especificar el caracter que divide los datos de una linea del archivo:

41:    <beans:bean id="tokenizer"
42:        class="org.springframework.batch.item.file.transform.DelimitedLineTokenizer">
43:        <beans:property name="delimiter"><beans:value>,</beans:value></beans:property>
44:        <beans:property name="names" value="nombre,apellido,mailPersonal,mailTrabajo,telefono,paginaWeb" />
45:    </beans:bean>

Este tokenizer tiene dos propiedades. La propiedad 'delimiter' indica el caracter por el cual vendra separada la informacion que en nuestro caso es una coma ','. La propiedad 'names' indica el nombre que le pondremos a cada uno de los valores en la linea de informacion en el archivo.

El fieldSetMapper es una clase que nosotros escribimos implementando de la clase de Spring Batch org.springframework.batch.item.file.mapping.FieldSetMapper y sobreescribiendo el metodo mapFieldSet, mismo que recibe como argumento un objeto de la clase org.springframework.batch.item.file.transform.FieldSet con la cual tenemos acceso a los campos definos en el tokenizer. Por ejemplo, la implementacion del metodo mapFieldSet en el codigo del tutorial luce asi:

 8:    public Contacto mapFieldSet(FieldSet fieldset) {
 9:        Contacto newContacto = new Contacto();
10:
11:        newContacto.setNombre(fieldset.readString("nombre"));
12:        newContacto.setApellido(fieldset.readString("apellido"));
13:        newContacto.setMailPersonal(fieldset.readString("mailPersonal"));
14:        newContacto.setMailTrabajo(fieldset.readString("mailTrabajo"));
15:        newContacto.setTelefono(fieldset.readString("telefono"));
16:        newContacto.setPaginaWeb(fieldset.readString("paginaWeb"));
17:
18:        return newContacto;
19:    }
20:

Como se logra ver la clase FieldSet contiene varios metodos readXXX con la cual se puede leer cada uno de los valores definidos en el tokenizer.

Escritura (writer)

La informacion que lee un reader es pasada a un writer para que este haga lo que tenga que hacer con esa informacion. En nuestro caso lo que vamos a hacer con esa informacion es escribirla en otro formato a otro archivo. El bean del writer lo definimos como:

61:    <beans:bean id="writer" scope="step"
62:        class="com.jabaddon.tutorials.springbatch.fileconverter.ContactoItemWriter">
63:        <beans:property name="archivoSalida" value="#{jobParameters[output.file.name]}" />
64:    </beans:bean>

Este writer es una clase que nosotros escribimos implementando la clase org.springframework.batch.item.ItemWriter e implementado el metodo write(List items). A esta clase se le agrego una propiedad en la que le mandamos como parametro del job la ruta y nombre del archivo en el cual se va a escribir '#{jobParameters[output.file.name]}'. El metodo write de la clase que escribimos luce asi:

26:    public void write(List<? extends Contacto> items) throws Exception {
27:        LOGGER.debug("### -> write() ###");
28:        BufferedWriter out = null;
29:        try {
30:            new File(archivoSalida).createNewFile();
31:            out = new BufferedWriter(new FileWriter(archivoSalida, true));
32:            LOGGER.info("-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*");
33:            for (Contacto item : items) {
34:                LOGGER.info("Escribiendo item : " + item);
35:                out.write(item.toString());
36:                out.write("\n");
37:            }
38:            LOGGER.info("-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*");
39:        }
40:        finally {
41:            if (out != null) {
42:                out.close();
43:            }
44:        }
45:        LOGGER.debug("### <- write() ###");
46:    }

En esta clase es donde esta la logica de escribir el otro archivo.

JobRepository

Para que Spring Batch trabaje y guarde bitacora de los procesos que corre y persista valores es necesario crear una base de datos en la cual guarda todos estos valores. Actualmente tiene soporte para las bases de datos: db2, derby, hsqldb, mysql, oracle10 y postgresql. En el caso de este tutorial se uso mysql.

El JobRepository es la interfaz con la cual un Job interactua con la base de datos para realizar la persistencia y busqueda de datos. El bean del Job, aunque no lo tiene especificado, apunta por default a otro bean con nombre 'jobRepository' el cual lo definimos asi:

32:    <beans:bean id="jobRepository"
33:        class="org.springframework.batch.core.repository.support.JobRepositoryFactoryBean"
34:        p:dataSource-ref="dataSource" p:transactionManager-ref="transactionManager" />
35:

De esta forma el bean dataSource y transactionManager estan definidos asi:

13:    <beans:bean id="dataSource"
14:        class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
15:        <beans:property name="driverClassName" value="com.mysql.jdbc.Driver"/>
16:        <beans:property name="url" value="jdbc:mysql://localhost/springbatch_tutorial"/>
17:        <beans:property name="username" value="root"/>
18:        <beans:property name="password" value="admin"/>
19:        <beans:property name="maxActive" value="5"/>
20:        <beans:property name="initialSize" value="1"/>
21:    </beans:bean>
22:
23:    <beans:bean id="transactionManager"
24:        class="org.springframework.jdbc.datasource.DataSourceTransactionManager" lazy-init="true">
25:        <beans:property name="dataSource" ref="dataSource" />
26:    </beans:bean>

Los diversos scripts para crear el esquema de la base de datos lo trae el zip de la distribucion de Spring Batch.

JobLauncher

Ya creado todo para poder usar Spring Batch necesitamos definir un ultimo bean el cual nos ayudara a levantar y correr los Jobs. Este bean es el jobLauncher y lo definimos asi:

32:    <beans:bean id="jobLauncher"
33:        class="org.springframework.batch.core.launch.support.SimpleJobLauncher">
34:        <beans:property name="jobRepository" ref="jobRepository" />
35:    </beans:bean>  

Este bean como lo mencione antes con el cual vamos a poder iniciar Jobs mandandole los parametros adecuados para que corran. En el caso de este tutorial se definio una clase de prueba unitaria la cual tiene el metodo siguiente:

51:    public void testJob() throws Exception {
52:        LOGGER.debug("### -> testJob() ###");
53:        String userdir = System.getProperty("user.dir");
54:        String inputFileName = "file:///" + userdir + "/src/test/files/datos-contactos.csv";
55:        String outputFileName = userdir + "/target/datos-contactos.txt";
56:        JobLauncher jobLauncher = (JobLauncher) this.getApplicationContext().getBean("jobLauncher");
57:        JobParametersBuilder paramsBuilder = new JobParametersBuilder();
58:        paramsBuilder.addLong("date.miliseconds", System.currentTimeMillis());
59:        paramsBuilder.addString("input.file.name", inputFileName);
60:        paramsBuilder.addString("output.file.name", outputFileName);
61:        JobExecution jobExecution =
62:            jobLauncher.run((Job) this.getApplicationContext().getBean("process"),
63:                    paramsBuilder.toJobParameters());
64:      
65:        LOGGER.debug("### <- testJob() ###");
66:    }

En este metodo se definen las rutas de los archivos a leer y a escribir y se crean los parametros que se le enviaran al Job y con ayuda del bean JobLauncher se ejecuta el Job.

Referencias

Maven 2: http://maven.apache.org/

Spring Batch: http://static.springframework.org/spring-batch/trunk/

Spring Batch downloads: http://static.springframework.org/spring-batch/trunk/downloads.html

Codigo del tutorial: http://rapidshare.com/files/236120391/file-converter.rar o https://dl.getdropbox.com/u/439363/file-converter.rar

Stop dumping money into a giant hole!!!

Me gustaría saber donde esta este hoyo gigante donde los Norteamericanos tiran el dinero.

A ustedes no?

http://www.theonion.com/content/video/in_the_know_should_the_government