Grails

De Wikipedia, la enciclopedia libre
Saltar a: navegación, búsqueda
Grails
Grails logo.png
Desarrollador
Graeme Rocher
grails.org
Información general
Última versión estable 2.4.2
26 de junio de 2014
Género Framework de aplicaciones web
Sistema operativo Multiplataforma (JVM)
Licencia Licencia Apache 2.0

Grails es un framework para aplicaciones web libre desarrollado sobre el lenguaje de programación Groovy (el cual a su vez se basa en la Java platform). Grails pretende ser un marco de trabajo altamente productivo siguiendo paradigmas tales como convención sobre configuración o no te repitas (DRY), proporcionando un entorno de desarrollo estandarizado y ocultando gran parte de los detalles de configuración al programador.

Grails ha sido impulsado principalmente por la empresa G2One,[1] la cual fue adquirida por la desarrolladora de software libre SpringSource en noviembre de 2008.[2] En agosto de 2009 SpringSource fue a su vez adquirida por VMWare, empresa especializada en virtualización de sistemas. [3]

Grails fue conocido como 'Groovy on Rails' (el nombre cambió en respuesta a la petición de David Heinemeier Hansson, fundador de Ruby on Rails).[4] Se inició en julio de 2005, con la versión 0.1 29 de marzo de 2006 y la versión 1.0 anunciada el 18 de febrero de 2008. En diciembre de 2009 se publicó la versión 1.2, y en mayo de 2010 la version 1.3.

Características[editar]

Grails se ha desarrollado con una serie de objetivos en mente:

  • Ofrecer un framework web de alta productividad para la plataforma Java.
  • Reutilizar tecnologías Java ya probadas como Hibernate y Spring bajo una interfaz simple y consistente.
  • Ofrecer un framework consistente que reduzca la confusión y que sea fácil de aprender.
  • Ofrecer documentación para las partes del framework relevantes para sus usuarios.
  • Proporcionar lo que los usuarios necesitan en áreas que a menudo son complejas e inconsistentes:
    • Framework de persistencia potente y consistente.
    • Patrones de visualización potentes y fáciles de usar con GSP (Groovy Server Pages).
    • Bibliotecas de etiquetas dinámicas para crear fácilmente componentes web.
    • Buen soporte de Ajax que sea fácil de extender y personalizar.
  • Proporcionar aplicaciones ejemplo que muestren la potencia del framework.
  • Proporcionar un entorno de desarrollo orientado a pruebas.
  • Proporciona un entorno completo de desarrollo, incluyendo un servidor web y recarga automática de recursos.

Grails se ha diseñado para ser fácil de aprender, fácil para desarrollar aplicaciones y extensible. Intenta ofrecer el equilibrio adecuado entre consistencia y funcionalidades potentes.

Alta productividad[editar]

Grails tiene tres características que intentan incrementar su productividad comparándolo con los framework Java tradicionales:

  • Inexistencia de configuración XML.
  • Entorno de desarrollo preparado para funcionar desde el primer momento.
  • Funcionalidad disponible mediante métodos dinámicos.

Inexistencia de configuración XML[editar]

Crear aplicaciones web en Java tradicionalmente implica configurar entornos y frameworks al inicio y durante el desarrollo. Esta configuración a menudo está en ficheros XML para facilitar dicha configuración y evitar tenerla en el código fuente. XML fue inicialmente bienvenido para proporcionar consistencia para configurar aplicaciones. Sin embargo aunque el XML es muy útil para la configuración resulta complicado y tedioso utilizarlo para los entornos de desarrollo. La productividad de los programadores baja mucho mientras pasan tiempo configurando y manteniendo los frameworks mientras la aplicación crece. Añadir o modificar configuración en las aplicaciones que utilizan la configuración XML añade un paso extra al proceso de escribir aplicaciones que repercute en la productividad, reduciéndola y hace que el proceso completo sea poco ágil.

Grails elimina la necesidad de configurar ficheros XML. En su lugar el framework utiliza una serie de reglas de convención mientras examina el código de las aplicaciones basadas en Grails. Por ejemplo, una clase que termina en Controller es considerada un controlador web.

Entorno de desarrollo preparado para funcionar desde el primer momento[editar]

Mientras usamos herramientas Java tradicionales, es tarea del desarrollador ensamblar los componentes, lo cual puede ser tedioso. Grails tiene un servidor web integrado preparado para desplegar la aplicación desde el primer momento. Todas las librerías requeridas son parte de la distribución de Grails y están preparadas para ser desplegadas automáticamente.

Funcionalidad disponible mediante métodos dinámicos[editar]

Grails proporciona métodos dinámicos en varias de sus clases. Un método dinámico se añade a la clase en tiempo de ejecución, como si su funcionalidad hubiera sido compilada. Estos métodos dinámicos permiten a los desarrolladores realizar operaciones sin tener que implementar interfaces o heredar clases base. Grails proporciona método dinámicos basándose en el tipo de clase. Por ejemplo, la clases de dominio tienen métodos para automatizar operaciones de persistencia, como save para salvar, delete para borrar y find para buscar.

Framework web[editar]

El framework web de Grails se ha diseñado según el paradigma Modelo Vista Controlador.

Controladores[editar]

Grails usa controladores para implementar el comportamiento de las páginas web. A continuación hay un ejemplo de un controlador:

 class BookController {
    def list = {
       [ books: Book.findAll() ]
    }
 }

El controlador tiene una acción list que devuelve un modelo conteniendo todos los libros de la base de datos. Para crear este controlador se usa un comando grails:

grails create-controller

Este comando recoge el nombre del controlador y crea una clase en el directorio grails-app/controller del proyecto Grails. Crear la clase del controlador es suficiente para que Grails lo reconozca. La acción list se mapea a la dirección http://localhost:8080/book/list en el entorno de desarrollo.

Vistas[editar]

Grails soporta JSP y GSP. En el siguiente ejemplo se muestra un vista escrita en GSP que lista los libros del modelo preparado por el controlador anterior:

<html>
  <head>
    <title>Our books</title>
  </head>
  <body>
    <ul>
      <g:each in="${books}">
        <li>${it.title} (${it.author.name})</li>
      </g:each>
    </ul>
  </body>
</html>

Esta vista debe estar en grails-app/views/book/list.gsp del proyecto Grails. Esta localización es mapeada automáticamente por el BookController y la acción list.

Existe también una referencia a las Tags GSP.

Soporte Ajax[editar]

Grails soporta varias librerías Ajax incluidas OpenRico, Prototype, Dojo y YUI.[5] Existen librerías de tags para crear HTML con código Ajax. También existe la posibilidad de crear librerías de tags propias.

Librerías de tags[editar]

Grails proporciona un gran número de tag libraries. De todas maneras se pueden crear y reutilizar librerías de tags fácilmente:

 def formatDate = { attrs ->
    out << new java.text.SimpleDateFormat(attrs.format).format(attrs.date)
 }

El tag formatDate formatea el objeto java.util.Date a String. Este tag debe ser situado en el directorio grails-app/taglib para que Grails lo reconozca automáticamente.

A continuación un trozo de código de una GSP que utiliza el tag formatDate:

<g:formatDate format="yyyyMMdd" date="${myDate}"/>

Para usar una librería de tags en una página GSP no son necesarios import. Las librerías de tag también pueden ser utilizadas en JSP aunque esto requiere un poco más de esfuerzo. [1]

Persistencia[editar]

Modelo[editar]

El modelo de datos en Grails se graba en la base de datos utilizando GORM (Grails Object Relational Mapping). Las clases de dominio se graban en el directorio grails-app/domain y se pueden crear utilizando el comando grails así:

grails create-domain-class

Este comando recibe el nombre de la clase y crea los ficheros adecuados. A continuación se muestra el código de la clase Book:

 class Book {
    String title
    Person author
 }

Crear esta clase es todo lo que se necesita para que sea persistida de forma automática por Grails. A partir de Grails 0.3, GORM ha sido mejorado y añade las propiedades id y version automáticamente si no se declaran. En la propiedad id se almacena la clave única de la tabla, mientras version se utiliza para gestionar el bloqueo optimista.

Métodos[editar]

Las clases de dominio gestionadas por GORM tienen métodos dinámicos y estáticos para realizar operaciones de persistencia sobre estas clases y sus objetos. [2]

Métodos dinámicos de instancia[editar]

El método save() salva un objeto en la base de datos:

 def book = new Book(title:"The Da Vinci Code", author:Author.findByName("Dan Brown"))
 book.save()

El método delete() borra un objeto de la base de datos:

 def book = Book.findByTitle("The Da Vinci Code")
 book.delete()

El método refresh() refresca el estado de un objeto de la base de datos:

 def book = Book.findByTitle("The Da Vinci Code")
 book.refresh()

El método ident() recupera el identificador del objeto de la base de datos:

 def book = Book.findByTitle("The Da Vinci Code")
 def id = book.ident()

Métodos dinámicos Static[editar]

El método count() recupera el número de registros de una clase dada:

 def bookCount = Book.count()

El método exists() devuelve verdadero si el objeto existe en la base de datos con el identificador dado:

 def bookExists = Book.exists(1)

El método find() devuelve el primer objeto de la base de datos que corresponde con la consulta realizada:

 def book = Book.find("from Book b where b.title = ?", [ 'The Da Vinci Code' ])

La sintaxis utilizada es Hibernate HQL.

El método findAll() devuelve todos los objetos existentes en la base de datos:

 def books = Book.findAll()

El método findAll() también puede recibir una consulta como parámetro:

 def books = Book.findAll("from Book")

El método findBy*() devuelve el primer objeto de la base de datos que coincide con el patrón especificado:

 def book = Book.findByTitle("The Da Vinci Code")

También:

 def book = Book.findByTitleLike("%Da Vinci%")

El método findAllBy*() devuelve una lista de objetos de la base de datos que coincide con el patrón especificado:

 def books = Book.findAllByTitleLike("The%")

El método findWhere*() devuelve el primer objeto de la base de datos que coincide con los parámetros especificados:

 def book = Book.findWhere(title:"The Da Vinci Code")

Scaffolding[editar]

Grails soporta scaffolding para implementar operaciones CRUD (Create, Read, Update, Delete). Cualquier clase de dominio puede crear su "Scaffolding" como se muestra a continuación:

 class BookController {
    def scaffold = true
 }

Creando esta clase se pueden realizar operaciones CRUD en la dirección http://localhost:8080/book. Actualmente no todas las relaciones entre entidades están soportadas por Grails.

Bases de datos heredadas[editar]

El mecanismo de persistencia en GORM se implementa mediante Hibernate. Las bases de datos heredadas pueden ser mapeadas a clases GORM utilizando lo ficheros de Mapeo Hibernate.

Orientación a pruebas[editar]

Grails ha sido creado teniendo como objetivo el facilitar la labor del desarrollador a la hora de realizar pruebas automáticas, lo que lo hace apto para algoritmos complejos. Se han implementado utilizando Groovy Tests.

Grails organiza los test en fases y tipos. Una fase se refiere al estado de la aplicación durante el test, y el tipo se refiere al mecanismo de test. Grails soporta cuatro fases de test (unitarios, integración, funcional y otros) y tipo JUnit para las fases unitarios e integración. Estos tipos tienen el mismo nombre que la fase.

Creando un proyecto Grails[editar]

Un proyecto Grails se crea así:

  • Sigue las instrucciones de descarga e instalación del sitio web de Grails.[6]
  • Abre una pantalla de terminal:
grails create-app

Este comando recibe el nombre del proyecto como parámetro y crea el directorio del proyecto con el mismo nombre. Hay que entrar en dicho directorio para poder ejecutar otros comandos dentro del proyecto.

Ejecutando el comando grails run-app puedes probar la aplicación en la URL http://localhost:8080/

¿Para quién es?[editar]

Los posibles usuarios de Grails son:

  • Desarrolladores Java que buscan un entorno de desarrollo integrado para crear aplicaciones web.
  • Desarrolladores sin experiencia en Java buscando un entorno de alta productividad para desarrollar aplicaciones web.

Integración con la plataforma Java[editar]

Grails está construido sobre la plataforma Java, con lo que es muy fácil integrarlo con librerías Java, framework y código existente. La mejor característica que Grails ofrece en este ámbito es una integración transparente con clases mapeada mediante el framework Hibernate ORM. Esto significa que aplicaciones existentes que utilicen Hibernate pueden utilizar Grails sin recompilar el código o reconfigurar las clases Hibernate, aprovechando los métodos de persistencia que se mencionan anteriormente. [3]

Una consecuencia es que se puede utilizar scaffolding con las clases Java mapeadas con Hibernate. Otra consecuencia es que las capacidades de Grails están totalmente disponibles para estas clases y las aplicaciones que las usan.

Revista[editar]

Empresas que proporcionan servicios Grails[editar]

Bibliografía[editar]

Véase también[editar]

Referencias[editar]