Probando Spring Roo: Primera parte

Este año me fue imposible asistir a SpringOne debido a la coincidencia de fechas con el curso de Spring impartido en Madrid, pero sin duda uno de los términos que más corrían esos días por Twitter era Spring Roo.

Spring Framework, por si solo, aumenta la productividad del desarrollador encargándose de todo ese “boilerplate code”, como lo llaman en la lengua de Shakespeare, pero si a esto le añadimos generación de código y configuración, la productividad se puede ver incrementada sustancialmente. Aquí es donde entra Spring Roo, aún en fase alpha (versión en el momento de escribir este artículo 1.0.0A2), por lo que no vamos a ser demasiado críticos.

Aprovechando el anuncio que SpringSource Tool Suite pasa a ser gratuito, me he bajado la nueva milestone 2.1.0.M1 que incluye integración con la consola de Spring Roo.

Creando un proyecto Roo

Para crear un proyecto con Spring Roo, deberéis seleccionar File > New > Other y escoger Template Project dentro de SpringSource Tool Suite:

Nuevo Proyecto Roo

En la siguiente pantalla simplemente escoger el template Roo Simple y a continuación deberéis introducir el nombre del proyecto y el paquete para finalizar el proceso.

Template Roo Simple

Con esto, vamos a tener una estructura de proyecto basado en maven, con 3 archivos de configuración básicamente:

  1. applicationContext.xml: Un aplication context básico que da soporte para el uso de anotaciones y escaneado de componentes.
  2. web.xml:Configuración para Log4j, registro de un DispatcherServlet, registro de un ResourceServlet (Spring JS, para servir el contenido estático) y un OpenEntityManagerInViewFilter para JPA.
  3. {nombreDelProyecto}-servlet.xml: Un aplication context para el contexto del DispatcherServlet configurado en el web.xml con escaneo de componentes(@Controller), un ExceptionResolver y un ViewResolver(para JSPs).

Añadiendo clases persistentes

Una vez tenemos la estructura del proyecto, nos interesará añadir algunas clases de nuestro dominio. Para ello vamos a habilitar primero JPA en nuestra aplicación. Esto lo vamos a hacer utilizando la consola de Roo que la podemos habilitar con un simple CTRL + R:

Consola Roo

En nuestro caso vamos a suponer que utilizamos PostgreSQL y Hibernate para JPA. El comando a utilizar es tan simple como:

install jpa -database POSTGRESQL -provider HIBERNATE

¿Que nos va a generar esto?

  1. persistence.xml: Creación de la persistence unit con una configuración básica
  2. database.properties: Creación de un archivo properties con la información de conexión a la BD (driver, url, usuario y password), el cual deberemos rellenar con la información adecuada.
  3. En el applicationContext.xml: creación de un Data Source con la configuración del archivo database.properties accedido por un PropertyPlaceHolder, un Transaction Manager y finalmente una factoría de EntityManager.
  4. Actualización de las dependencias Maven.

Bien, ya estamos preparados para usar JPA, vamos a por las clases de nuestro dominio. Usaremos para ello la siguiente instrucción (la ~ sirve para asignar el paquete que le hemos especificado al proyecto):

new persistent class jpa -name ~.Persona

Y para los atributos de la clase:

add field number -fieldName id -type java.lang.Integer
add field string -fieldName nombre

En este punto es cuando ha venido mi sorpresa: Spring Roo genera 5 archivos!

Created SRC_MAIN_JAVA/Persona.java
Created SRC_MAIN_JAVA/Persona_Roo_Plural.aj
Created SRC_MAIN_JAVA/Persona_Roo_Entity.aj
Created SRC_MAIN_JAVA/Persona_Roo_ToString.aj
Created SRC_MAIN_JAVA/Persona_Roo_Configurable.aj

La clase java que genera es simple, sólo contiene los atributos sin ningún método, pero podemos ver que Spring Roo ha añadido 3 anotaciones a nivel de clase. Esto le va a servir para coger la información de los archivos que ha generado adicionalmente:


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

 private Integer id;

 private String nombre;
}

Pero, ¿dónde está todo lo otro? En los archivos adicionales .aj que ha creado. ¡Ahí está la magia! Cada vez que añadimos un atributo, Spring Roo actualiza esos archivos con la información adicional. Pero no sólo añade getters y setters, sino que también crear un archivo para acceder automáticamente a métodos transaccionales de persistencia como persist(), findPersona(id), y más cosas…Para que os hagáis una idea, veamos la pinta tiene el Persona_Roo_ToString.aj (como su propio nombre indica, va a contener el método toString de la clase):


privileged aspect Persona_Roo_ToString {

 public java.lang.String Persona.toString() {    
 StringBuilder sb = new StringBuilder();        
 sb.append("id: ").append(getId()).append(", ");        
 sb.append("version: ").append(getVersion()).append(", ");        
 sb.append("id: ").append(getId()).append(", ");        
 sb.append("nombre: ").append(getNombre());        
 return sb.toString();        
 }    

}

Más en la segunda parte, hasta aquí por ahora😉

2 pensamientos en “Probando Spring Roo: Primera parte

Responder

Introduce tus datos o haz clic en un icono para iniciar sesión:

Logo de WordPress.com

Estás comentando usando tu cuenta de WordPress.com. Cerrar sesión / Cambiar )

Imagen de Twitter

Estás comentando usando tu cuenta de Twitter. Cerrar sesión / Cambiar )

Foto de Facebook

Estás comentando usando tu cuenta de Facebook. Cerrar sesión / Cambiar )

Google+ photo

Estás comentando usando tu cuenta de Google+. Cerrar sesión / Cambiar )

Conectando a %s