Empezando con Grails, parte 3

lunes 28/05/2007

Hola, comenzamos la tercera entrega de esta serie de introducción a Grails. En los dos primeros artículos hemos hecho una introducción al framework, cómo instalarlo y comenzar un nuevo proyecto, y cómo definir un modelo de datos con relaciones y validación. En esta ocasión vamos a ver las novedades que se introdujeron en la versión 0.5, que han sido muchas y muy interesantes.

Aquí podéis comprobar la cantidad de cambios y soluciones de fallos que trajo esta última versión de Grails. Sin entrar en las mejoras, entre las que destacan las validaciones en cascada, las mejoras en las librerías de etiquetas, o la mejora general de rendimiento de entre un 40% y un 50%, vamos a dar un repaso de las nuevas funcionalidades:

URLs a gusto del consumidor

Hasta ahora, las urls en grails tenían un formato fijo: http://<dominio>/<contexto>/<controller>/<action>/<id>, de forma que la url http://localhost/miAp/user/show/25 invocaría a mi controlador de nombre "UserController", y pasaría a la acción definida como def show = {...}, el parámetro estándar de nombre "id" con valor "25" (por supuesto, puedo pasar todos los parámetros que necesite, pero este en particular ya existe por defecto).

Pues bien, a partir de la versión 0.5, puedo definir una clase que gestione el mapeo de URLs de mi aplicación, con una estructura parecida a esta:

class MyUrlMappings {
  static</span> mappings = {
    "/product/$id" {
         controller = "product"
         action = "show
    }
    "/$id/$year/$month/$day" {
         controller = "blog"
         action = "show"

         constraints {
              year(matches:/\d{4}/)
              month(matches:/\d{2}/)
              day(matches:/\d{2}/)
         }
    }
  }
}

De esta forma definimos que urls del tipo "/product/xy" se gestionan en el controlador "productController", con la acción "show", y que las urls del tipo "/xy/yyy/mm/dd" van al controlador "blogController", a la acción "show". Fijaros en cómo puedo establecer restricciones: si las partes de la url no satisfacen las expresiones regulares, entonces no se reconoce la url.

Validación de Formularios

Esta nueva funcionalidad es muy útil en casos en los que tenemos un formulario que no está relacionado con ninguna clase del dominio. Nos permite definir el equivalente a un backing bean de JSF, que guarde los datos del formulario y contenga las restricciones necesarias para su validación. Por ejemplo:

class LoginController {
  def login = { LoginCommand cmd ->
         if(cmd.hasErrors()) {
                redirect(action:'loginForm')
         }
         else {
            // do something else
        }
  }
}

class LoginCommand {
   String username
   String password
   static constraints = {
           username(blank:false, minSize:6)
           password(blank:false, minSize:6)
   }
}

Al definir la closure con un parámetro: def login = {LoginCommand cmd-> ...} , grails instanciará automáticamente mi clase LoginCommand, poblará sus propiedades y validará los campos antes de invocar mi código.

Soporte de Listas y Mapas en GORM

Como vimos en la pasada entrega, hasta ahora las colecciones se mapeaban siempre como implementaciones de Set. Desde ahora, podemos definir un campo com List para forzar a Grails a utilizar una lista (y por tanto mantener el orden de los elementos). Además, ahora podemos utilizar Mapas en nuestro modelo.

Composiciones

Otra de las novedades relacionadas con las clases del dominio es el soporte de composición: miembros de clases del modelo de datos que no son de tipos simples, sino de tipos complejos definidos por nosotros. Un ejemplo:

class Direccion {
    String calle
    Integer numero
    Integer codPostal
}

class Usuario{
    Direccion direccion1
    Direccion direccion2
    String nombre
    String apellidos
}

Un nuevo codec: Base64

Grails incorpora un conjunto de métodos dinámicos que nos permiten codificar cadenas de texto en diferentes formatos, por ejemplo, puedo hacer esto:

<p>Hola ${session.user.name.encodeAsHtml()}</p>

Pues bien, en la versión 0.5 se añade un nuevo codec que permite codificar en Base64, como en este ejemplo:

<p>Tu codigo de registro es este: ${session.user.code.encodeAsBase64()}</p>


Gestión de dependencias con Ivy

Ivy es un proyecto de Apache que permite gestionar las dependencias de un proyecto de forma sencilla. Grails incorpora soporte para Ivy, aunque primero tenemos que instalar el plugin:

grails install-ivy

y después podemos invocarlo así:

grails get-dependencies

Metadatos del proyecto

A partir de esta versión, todos los proyectos tendrán un fichero de metadatos que declarará la versión de Grails que requieren (entre otras cosas), para evitar corrupciones en caso de convivir distintas versiones del framework.

Creación automática de loggers para TODOS los artefactos

Hasta ahora sólo los controladores recibían un loger personalizado, de forma que podíamos hacer log.debug("...") sin necesidad de declarar la variable log. Desde ahora, también tendrán loggers los trabajos cron, las taglibs, etc.

Bueno, pues hasta aquí el repaso de las novedades. Básicamente hemos hecho una traducción comentada de las notas de la versión, que podéis encontrar aquí. Además, también podréis encontrar una descripción de las mejoras sobre funcionalidades que ya estaban presentes. Esperamos que os haya resultado útil este repaso, y que os haya animado a investigar, porque os aseguramos que hay muchísimo más en Grails que lo visto hasta ahora.

En la proxima -y última- entrega de esta serie, pondremos nuestra aplicación de ejemplo a funcionar en producción, y repasaremos algunas de las cosas que hay que tener en cuenta a ese respecto.

Hasta la próxima!

facebooktwitterdiggdel.icio.usdzonetechnorattiyahoogooglemeneamewikiofurlredditstumbleupon