En Grails los archivos de la vista tienen extensión .gsp y están alojados en el directorio grails-app/views/. Las plantillas tienen por convenio que el nombre del archivo empieza con un subrayado bajo. La típica plantilla que nos podemos encontrar en cualquier aplicación web se refiere al pie de la misma. Podríamos tener algo así:

Una vez creada la plantilla, el siguiente paso será insertarla en aquellas páginas donde la queramos mostrar. Para eso Grails dispone de la etiqueta <g:render/> a la que debemos pasarle el parámetro template con la ubicación y el nombre de la plantilla que acabamos de generar, con lo que tendríamos algo asi: <g:render template="/common/piedepagina"/>. Como puedes comprobar, hemos obviado el subrayado bajo al inicio del nombre de la plantilla, puesto que aquello sólo era un convenio.

Si queremos modificar la apariencia de nuestro pie de página, debemos modificar el archivo css ubicado en web-app/css/main.css y añadir o modificar los descriptores necesarios.

Etiquetas en Grails

Posiblemente hayamos visto una de las etiquetas más utilizadas en Grails como es <g:render/>. Sin embargo, ésta no es la única y Grails cuenta con etiquetas para realizar operaciones lógicas, de iteración, de asignación, relativas a enlaces, AJAX, de formularios, de interfaz de usuario y renderización de contenido y de validación.

En la página oficial de Grails http://www.grails.org/GSP+Tag+Reference encontraréis un listado de completo de todas las etiquetas disponibles.

Vamos a desarrollar una aplicación ejemplo utilizando scaffolding. Esta aplicación sería un sistema tipo twitter y lo primero que vamos a hacer es crear la aplicación con el comando

Nuestra aplicación ejemplo sólamente va a tener dos clases de dominio, Usuario y Tweet y la única relación existente entre ellos será que los usuarios van a poder publicar muchos tweets. Para crear estas dos clases de dominio podemos utilizar las siguientes comandos

Este comando creará las clases de dominio necesarias para nuestra aplicación. Posteriormente debemos añadir las propiedades necesarias a estas.

La relación entre los usuarios y los tweets la hemos especificado con la variable hasMany. También hemos añadido una serie de validaciones que deben cumplir cada uno de los campos. El siguiente paso será crear los controladores e indicarle que queremos hacer scaffolding de los mismos. Para crear los controladores debemos hacer

Una vez creados, debemos indicarles que queremos hacer scaffolding de las clases de dominio asociadas a cada uno de los controladores.

Si por último, arrancamos la aplicación mediante el comando

ya tendremos funcionando una primera versión de nuestra copia de twitter, a la que por supuesto le faltarán todavía muchas cosas, que iremos desarrollando en próximas entradas.

Como la mayoría de los framework de desarrollo web, Grails está basado en el patrón Modelo Vista Controlador (MVC). En Grails los modelos son tratados como clases de dominio que permiten a la aplicación mostrar los datos en la vista. A diferencia de en otros frameworks, las clases de dominio de Grails son automáticamente persistidas y es incluso posible generar el esquema de la base de datos. Los controladores por su parte, permiten gestionar las peticiones a la aplicación y organizar los servicios proporcionados. Por último, la vista por defecto en Grails son las Groovy Server Pages (GSP) y habitualmente nos muestra el contenido en formato HTML.

Grails permite al programador olvidarse de gran parte de la configuración típico que incluyen los frameworks MVC. Además Grails se aprovecha de un lenguaje dinámico como Groovy para acortar los tiempos de desarrollo para simplemente dejarlos en escribir código, actualizar, testear y depuración de fallos. Esto hace que el desarrollo de la aplicación sea mucho más ágil que con otros frameworks MVC.

Además, Grails es una plataforma completa, puesto que incluye también un contenedor web, bases de datos, sistemas de empaquetado de la aplicación y un completo sistema para la realización de tests sobre nuestra aplicación. De esta forma, no debemos perder el tiempo buscando y descargando un servidor web para nuestra futura aplicación o un gestor de base de datos. Ni tan siquiera será necesario escribir complicados scripts de configuración para el empaquetado de la aplicación. Todo esto se convierte en una tarea tan sencilla como instalar Grails.

Características principales de Grails

• Convención sobre configuración

En lugar de tener que escribir interminables archivos de configuración en formato XML, Grails se basa en una serie de convenciones para que el desarrollo de la aplicación sea mucho más rápido y productivo. Además, gracias al uso de convenciones, se refuerza el otro principio del que hablábamos anteriormente, DRY (don’t repite yourself) o no te repitas.

• Tests

Uno de las partes más importantes en el desarrollo de software se refiere a los tests implementados que garantizan un software de calidad y el fácil mantenimiento de una aplicación. Gracias a estos tests, es muy sencillo detectar y solucionar fallos provocados por cambios en el código. Cada vez que se genera en Grails una clase de dominio o un controlador, paralelamente se genera también un test para comprobar la nueva clase o controlador.

Grails distingue entre tests unitarios y tests de integración. Los tests unitarios son tests sin dependencias de ningún tipo, salvo algún que otro objeto mock. Por otro lado, los tests de integración tienen acceso completo al entorno de Grails, incluyendo la base de datos. Además, Grails permite también la creación de tests funcionales para comprobar la funcionalidad de nuestra aplicación web.

• Scaffolding

Grails permite también utilizar scaffolding en nuestras aplicaciones. El scaffolding es una característica de determinados frameworks que permite la generación automática de código para las cuatro operaciones básicas de cualquier aplicación, que son la creación, lectura, edición y borrado, lo que en inglés se conoce como CRUD (create, read, update and delete). El scaffolding en Grails se consigue escribiendo muy pocas líneas de código, con lo que podemos centrarnos en especificar las propiedades, comportamientos y restricciones de nuestras clases de dominio.

• Mapeado objeto-relacional

Grails incluye un potente framework para el mapeado objeto-relacional conocido como GORM (Grails Object Relational Mapping). Como cualquier framework de persistencia, GORM permite mapear objetos contra bases de datos relacionales y representar relaciones entre dichos objetos del tipo uno-a-uno o uno-a-muchos.

• Plugins

Sin embargo, Grails no siempre es la solución a cualquier problema que se nos pueda plantear en el desarrollo de aplicaciones web. Para ayudarnos, Grails dispone de una arquitectura de plugins con una comunidad de usuarios detrás (cada vez más grande) que ofrecen plugins para seguridad, AJAX, testeo, búsqueda, informes y servicios web. Este sistema de plugins hace que añadir complicadas funcionalidades a nuestra aplicación se convierte en algo muy sencillo.

Los archivos XML son un tipo de archivo ampliamente extendido para el intercambio de información entre aplicaciones. Groovy quiere ayudarnos en la generación de estos archivos, tratando que escribamos el código para construir esos archivos XML de la forma más sencilla y clara posible y el builder encargado de esa labor es MarkupBuilder, el cual nos ayudará a escribir tanto archivos XML como HTML.

El ejemplo que vamos a ver consiste en crear un archivo XML referido a facturas de una empresa. Cada factura contendrá una serie de items, cada uno con un producto. El siguiente fragmento de código generaría el archivo XML de ejemplo:

Lo que produciría el siguiente archivo XML.

Como puedes comprobar, la limpieza del código escrito para generar el archivo XML es increíble y prácticamente, el código sigue el mismo tabulado que el posterior archivo XML, con lo que la lectura del código por terceras personas se facilita muchísimo.

Otros buildes interesantes en Groovy son los que se refieren a la automatización de tareas con Ant o el diseño de interfaces gráficas.

¿Qué son los DSLs?

Un DSL es un lenguaje de programación reducido que permite representar el conocimiento de un campo específico. Imaginemos que debemos desarrollar una aplicación que se encargue de la toma de decisiones en el entorno financiero. Para realizar la programación en Java o Groovy (o cualquier otro lenguaje), quien se encargue de la programación debería tener los conocimientos necesarios tanto del sistema financiero así como del lenguaje de programación utilizado.

Utilizando un DSL nos ahorraremos las reglas específicas del lenguaje de programación, centrando nuestros objetivos en la especificación de las reglas financieras necesarias para el correcto funcionamiento del sistema. De esta forma, vamos a poder encargar la parte relacionada con las reglas financieras a algún experto en la materia.

¿Por que Groovy?

Pues simplemente porque es un lenguaje dinámico que nos proporciona mucha libertad a la hora de crear estructuras necesarias en un contexto particular. Las características de Groovy que lo hacen idóneo para escribir DSLs son:

• Los Builders nos permiten crear estructuras en forma de árbol estructurado
• Se pueden añadir nuevos métodos y propiedades a través de categorías y metaclases. Incluso se puede hacer esto con los números para especificar cosas como 4.veces o 24.horas
• La mayoría de los operadores se pueden sobrecargar para poder hacer cosas como totalMinutos = 4.dias + 12.horas
• Podemos utilizar un mapa como parámetro en un método, lo cual es muy intuitivo. Por ejemplo mover(x:500.metros, y:2:kilometros)
• También podemos crear nuevas estructuras de control utilizando los closures, como por ejemplo siFaltaMenosDeUnDia{…}

Ejemplo de DSL

Un ejemplo de DSL puede ser GORM (Groovy Object Relational Mapping). GORM es el framework de persistencia utilizando en Grails. Basado en Hibernate, podemos utilizar GORM sin haber visto en nuestra vida nada sobre Hibernate, simplemente conociendo el modelo de datos. Imaginemos que tenemos una clase Persona mapeada contra una tabla de la base de datos. Gracias a GORM, podríamos acceder a los datos de la siguiente forma:

Aquí os dejo un enlace donde se crea un DSL para realizar el cálculo de distancias