Empezando con Grails, parte 1

lunes 07/05/2007

1. Introducción

Los que conozcan Ruby on Rails probablemente habrán oído hablar de conceptos como el "Scaffolding" (creación automática de código de infraestructura para un tipo concreto de aplicación), otros están apunto de descubrirlo con Grails.

Grails es un framework para desarrollo de aplicaciones web construído sobre cinco fuertes pilares:

• Groovy para la creación de propiedades y métodos dinámicos en los objetos de la aplicación.
• Spring para los flujos de trabajo e inyección de dependencias.
• Hibernate para la persistencia.
• Sitemesh para la composición de la vista.
• Ant para la gestión del proceso de desarrollo.
  

Desde el punto de vista del diseño, Grails se basa en los principios "Convención mejor que configuración" y DRY ("No te repitas"). Además, trata siempre de hacer lo más divertida posible la experiencia del desarrollador, con un ciclo de desarrollo muy ágil que te permite centrarte en las funcionalidades en lugar de los requisitos técnicos del framework. Siempre que resulta posible se descubren las características del proyecto en tiempo de ejecución, ahorrando mucha configuración y trabajo previo no relacionado directamente con la aplicación que uno quiere desarrollar.

Este artículo es el primero de una serie de 3, en los que se tratarán los siguientes aspectos:
1. Introducción al entorno Grails.
2. Modelo de datos y relaciones.
3. Consideraciones sobre la puesta en producción.

2. Entrando en materia

La versión 0.5 de Grails incluye muchas mejoras, más de 200 soluciones a fallos de la versión anterior, y algunas funcionalidades nuevas muy interesantes como la posibilidad de escribir gestores de eventos para los procesos del framework o la API que permite que los plugins accedan de forma sencilla a todos los artefactos generados. Además, aunque aún no es momento de optimizar (el framework es joven y sería un error de diseño pensar ahora en el rendimiento), sí se han solucionado incidencias que han proporcionado una reducción del tiempo de puesta en marcha de las aplicaciones y una mejora del rendimiento general de entre un 40% y un 50%. Para una lista detallada de los cambios, consultad las notas de la versión.

Para empezar tenemos que instalar el entorno. Para ello nos descargamos Grails desde la web del proyecto: http://docs.codehaus.org/display/GRAILS/Download, descomprimimos el archivo en la carpeta que elijamos y fijamos la variable $GRAILS_HOME para que apunte a esa carpeta. Si estamos en linux, es posible que tengamos que dar permisos de ejecución a todo lo que esté en $GRAILS_HOME/bin y $GRAILS_HOME/ant/bin

Para comprobar si todo ha ido bien, podemos escribir en una consola el comando "grails help", que nos mostrará un mensaje con la versión del entorno que estamos ejecutando y los scripts que podemos invocar.

3. La primera aplicación

Grails contiene todo lo necesario para desarrollar desde el primer momento, no necesitamos servidor adicional ni base de datos (aunque lógicamente podemos usar los que tengamos instalados, sobre todo en producción). Para comenzar una aplicación Grails nos colocamos en la carpeta donde deseemos tener el proyecto, y escribimos:

$ grails create-app Test

Cuando el proceso termina, tenemos una carpeta de nombre "Test" (o el nombre que le hayamos dado a nuestra aplicación), que contiene una estructura como esta:

Las carpetas donde pasaremos la mayor parte del tiempo son grails-app, que contiene todos los artefactos que el entorno irá generando y que tendremos que modificar para adaptar su funcionamiento a nuestra aplicación, y web-app, que contiene la estructura de nuestra aplicación web. En particular, web-app/css contiene la/s hoja/s de estilo y web-app/images el contenido gráfico.

Si ejecutamos el comando "grails run-app" podremos ver el aspecto de nuestra aplicación (bastante vacío de momento):

Para aprender más sobre la estructura de la aplicación, vamos a generar una primera clase para nuestro modelo de datos:

nacho@shivaIII:~/proyectos/Test$ grails create-domain-class usuario

Como véis, grails me genera el archivo Usuario.groovy en grails-app/domain, y UsuarioTest.groovy en grails-tests. Ahora vamos a empezar a tocar código, así que se nos plantea la cuestión del IDE a utilizar. Los proyectos Grails cuentan con un excelente soporte para eclipse, al generar automáticamente los archivos necesarios para que podamos importarlos directamente al entorno. De todas formas la estructura de las aplicaciones es sencilla y podemos usar cualquier editor de texto o importarlos a Netbeans o Idea sin problemas. Lo que sí hay que tener en cuenta es el soporte para Groovy, que en el caso de Eclipse viene de la mano del GroovyEclipsePlugin: http://groovy.codehaus.org/Eclipse+Plugin.

4. Ya es hora de picar algo de código ¿no?

Como habréis notado, ya tenemos un primer prototipo funcional (aunque sin lógica, es cierto) y aún no hemos escrito ni una sola línea de código. Para entrar en harina, lo primero que haremos es añadir un par de propiedades a la clase Usuario: nombre y apellidos:

class Usuario {
    String nombre
    String apellidos
}    

Lo primero a tener en cuenta es que no hacen falta getters ni setters: Groovy los genera dinámicamente por nosotros. Una vez generada la clase, pidamos a Grails que nos genere todo lo necesario para realizar operaciones CRUD ("Create, Read, Update, Delete") con entidades de tipo usuario:

nacho@shivaIII:~/proyectos/Test$ grails generate-all usuario

[...]

Generating views for domain class [Usuario]
Generating list view for domain class [Usuario]
list view generated at /home/nacho/proyectos/Test/./grails-app/views/usuario/list.gsp
Generating show view for domain class [Usuario]
Show view generated at /home/nacho/proyectos/Test/./grails-app/views/usuario/show.gsp
Generating edit view for domain class [Usuario]
Edit view generated at /home/nacho/proyectos/Test/./grails-app/views/usuario/edit.gsp
Generating create view for domain class [Usuario]
Create view generated at /home/nacho/proyectos/Test/./grails-app/views/usuario/create.gsp
Generating controller for domain class [Usuario]
Controller generated at ./grails-app/controllers/UsuarioController.groovy

Grails nos genera los controladores y vistas necesarios para realizar las tareas básicas con nuestra nueva clase. Para ver el resultado, vamos a ejecutar de nuevo la aplicación con grails run-app:

5. Recopilando...

En este primer artículo hemos hecho una introducción a Grails, hemos montado el entorno básico de desarrollo y hemos escrito nuestra primera aplicación que gestiona un grupo de usuarios con relaciones entre ellos. Todo ello con un número de líneas de codigo (nuestras) ridículo. Sin decirlo explícitamente, hemos estado aprovechando que Grails incorpora Jetty y HSQLDB "de serie", con lo que tenemos una base de datos y servidor de desarrollo sin tener que montarnoslo a nosotros. Por supuesto si ya tenemos nuestro entorno y queremos usarlo podremos hacerlo con unos mínimos cambios de configuración.

En la siguiente entrega de esta serie veremos cómo definir un modelo de datos más cercano al mundo real, y cómo configurar Grails para que utilice una base de datos externa. Esperamos que os haya parecido suficientemente interesante como para animaros a descargarlo y hacer vuestra prueba de los 20 minutos.

facebooktwitterdiggdel.icio.usdzonetechnorattiyahoogooglemeneamewikiofurlredditstumbleupon