Creando un demo con Spring Roo

Aprovechando que he instalado el paquete STS de Spring para desarrollar aplicaciones con Spring MVC, me he decidido a hacer una pequeña demo con Spring Roo.

Spring Roo es una herramienta de desarrollo rápido de aplicaciones o RAD, que permite el desarrollo de aplicaciones Java EE de forma muy productiva y cómoda para el desarrollador.

Así que allá vamos. Basándome en el tutorial http://static.springsource.org/spring-roo/reference/html/beginning.html intento explicar aquí el mismo ejemplo pero adaptado a mi configuración del equipo (utilizando Eclipse, Maven…)

En este artículo vamos a construir paso a paso y de manera rápida una aplicación web utilizando Spring Roo.

Antes de empezar es necesario descargar Spring Roo y descomprimirlo en algún lugar. Después cuando le demos a crear proyecto Spring Roo tendremos que seleccionar esta carpeta.

Este diagrama representa de manera simplificada el dominio del problema

Creando el proyecto

La configuración que tengo en mi equipo y las aplicaciones que tengo instaladas son:

–          Eclipse Juno

–          Spring Roo descargado

–          JDK instalado

–          Plugins de eclipse M2Eclipse, Spring Tool Suite

–          PostgreSQL o cualquier otra BD relacional

–          Xampp En realidad con Tomcat sería Suficiente

–          Tengo configurado Maven para desplegar directamente en  Tomcat  (Está en un post anterior 😉

Abrimos eclipse, seleccionamos el workspace que queramos, cuando arranque vamos a File->new->Spring Roo Project le ponemos como nombre “Pizza” y como paquete “com.jesuslc.demo” y decimos que nos lo empaquete como archivo .WAR

**TIP Antes de continuar hay que asegurarse de que el proyecto tiene en las propiedades JDK como librería.

Empezando con el proyecto

Una vez que pulsamos en finalizar y terminé de cargarse el proyecto Spring Roo aparecerá una consola en la que podemos empezar a escribir los comandos.

Con Ctrl+Space podemos autocompletar, algo que viene de lujo ya que algunos comandos han cambiado un poco.

Para ver si todo esta correcto escribimos hint para ver cómo responde la consola. Al final de este paso lo que obtenemos es algo parecido a esto.

TIP: Ahora si queremos desplegar directamente en tomcat abriremos el pom.xml y escribiremos esto:

      <plugin>
            <groupId>org.codehaus.mojo</groupId>
            <artifactId>tomcat-maven-plugin</artifactId>
            <version>1.2-SNAPSHOT</version>
            <configuration>
                  <url>http://127.0.0.1:8080/manager</url>
                  <server>TomcatServer</server>
                  <path>/Pizza</path>
            </configuration>
      </plugin>

Creando la base de datos

Llegados a este punto vamos a crear la base de datos utilizando JPA y algunas entidades 😉

En la ventana de comandos escribimos:

jpa setup --provider HIBERNATE --database POSTGRES --databaseName springroo 

Abrimos el archive database.properties y configuramos el nombre y la contraseña de PostgreSQL

Así que llegados a este punto se ha instalado Hibernate para poder hacer un mapeo objeto-relacional(ORM). Hemos elegido PostgreSQL para poder ver las tablas a través de “pgAdmin”. Aunque por el hecho de usar Hibernate, no debemos preocuparnos demasiado de la base de datos (al menos de momento) ya que podremos modificar sin excesivo esfuerzo.

Creando Entidades

Ahora es el momento de crear nuestros objetos de dominio y los campos que están en el diagrama. En primer lugar crearemos la entidad “topping”que se creará con Test JUnit automáticos. Para ello solo tenemos que escribir en la consola:

entity jpa --class ~.domain.Topping --testAutomatically

TIP, el símbolo ~ se escribe con Alt gr+ 4

Como vemos el comando no solo crea las clases JPA, sino que también crea la estructura de carpetas. Como siguiente paso tenemos que añadir campos a la entidad “topping”. Si vemos el diagrama la entidad solo tiene un campo llamado nombre,, así que vamos a crearlo escribiendo:

field string --fieldName name --notNull --sizeMin 2

Utilizando el commando “hint” o el autocompletado (ctrl+space) podemos agregar restricciones a los campos que vayamos creando. Seguro que te habrás dado cuenta que en la ventana de comandos (prompt) nos indica dentro de que nivel estamos, es decir, nos dice sobre qué entidad estamos definiendo campos.

Ahora de un tirón vamos a crear las entidades “base” y “pizza” junto con sus campos así:

entity jpa --class ~.domain.Base --testAutomatically
field string --fieldName name --notNull --sizeMin 2
entity jpa --class ~.domain.Pizza --testAutomatically
field string --fieldName name --notNull --sizeMin 2
field number --fieldName price --type java.lang.Float

Llegados a este punto tenemos un árbol de proyecto como este:

Ya estamos casi al final, solo tenemos que relacionar las entidades. Vamos con la relación m:n ->una pizza puede tener muchos topping y un ingrediente se puede aplicar a muchas pizzas ¿no es cierto? Pues para las relaciones m:n está el siguiente comando

field set --fieldName toppings --type ~.domain.Topping

Como se puede ver, es fácil definir esta relación aún sin saber exactamente las anotaciones JPA necesarios para crear este mapeo en nuestra entidad Pizza. De la misma manera se puede definir la relación  m: 1 entre  “pizza” “base” mediante este comando

field reference --fieldName base --type ~.domain.Base

Ya para terminar solo nos queda crear la entidad PizzaOrder con sus campos correspondientes de esta manera:

entity jpa --class ~.domain.PizzaOrder --testAutomatically 
field string --fieldName name --notNull --sizeMin 2
field string --fieldName address --sizeMax 30
field number --fieldName total --type java.lang.Float 
field date --fieldName deliveryDate --type java.util.Date
field set --fieldName pizzas --type ~.domain.Pizza

Llegados a este punto ya hemos completado todo el modelo de domino, vamos a ver ahora un poco los tests.

Test de integración

Para ver si todo funciona podríamos lanzar una batería de test ¿no?  Por suerte cuando definimos las entidades en todas hemos escrito al final algo así como “testAutomatical” esto hace que Spring Roo cree unas baterías de test para los objetos de dominios, para lanzar dichos test solo tenemos que escribir:

perform tests
...
-------------------------------------------------------
 T E S T S
-------------------------------------------------------

Tests run: 36, Failures: 0, Errors: 0, Skipped: 0

También podemos hacer clic en Run As->Junit Test y lanzará la misma batería de test

Creando la aplicación. Paso Final

Si tienes configurado maven y tomcat para que maven pueda desplegar sin problemas en tomcat este paso será un plis, si has llegado hasta aquí sin hacerlo te sugiero que retomes mi anterior post.

Para crear la capa web de nuestra aplicación solo nos queda escribir en el prompt algo parecido a esto:

~.domain.PizzaOrder roo> web mvc setup
 
~.domain.PizzaOrder roo> web mvc all --package ~.web

Ahora le damos a Run As-> maven build y escribimos “tomcat deploy” así:

Listo si todo ha ido bien, ya tendremos una cosilla como esta al entrar en http://localhost:8080/Pizza

Referencias

Me he basado en este tutorial para realizar este post http://static.springsource.org/spring-roo/reference/html/beginning.html

Aquí está un pdf con la documentación oficial (inglés) : http://static.springsource.org/spring-roo/reference/pdf/spring-roo-docs.pdf

Conclusiones

Es una framework que permite crear un proyecto CRUD rápidamente, me ha permitido crear un ejemplo sencillo como este en un rato. A veces es algo lento y he tenido algunos problemas con AspectJ (compatibildad con Maven,…).

No soy ningún experto, pero se ve un framework muy interesante, que permite muchas cosas. Aunque bien es cierto, para proyectos complejos si que podría ser complicado afrontarlos con Roo.