style="display:inline-block;width:728px;height:90px"
data-ad-client="ca-pub-5164839828746352"
data-ad-slot="7563230308">

Grails Parte 01, Introducción y cómo iniciar.

Veo que no ha habido aquí ningún artículo de introducción a Grails, por lo que me decidí a crearlo.

Esto pretende ser una serie de artículos al estilo de los que ya se han publicado aquí, como los de Tapestry de ezamudio o los de Play! de wishmaster, o como el de RTFS de luxspes... bueno como este último no.

Grails es un framework para desarrollo de aplicaciones web sobre la plataforma Java, escrito en el lenguaje Groovy, creado por Graeme Rocher y mantenido en un inicio por G2One, ahora parte de SpringSource.

La idea de Grails, es crear un marco de desarrollo que favorezca la productividad al crear aplicaciones web, integrando de facto configuraciones comunes a la mayoría de los escenarios, en resumen: convention over configuration.

Una de las características de Grails que han hecho que me llame la atención fuertemente, incluso para integrarlo como framework de desarrollo para proyectos en Sintel TI, es que funciona como una capa que debajo de sí misma integra tecnologías ya conocidas y de probada efectividad, como Spring (core, mvc) y Hibernate. Esto resulta conveniente al momento en el que Grails realiza de facto muchas cosas por nosotros, sin embargo si deseamos que alguna de éstas sea diferente existe la flexibilidad de modificar lo que convenga, ya que sabemos cómo funciona por debajo. No se trata solamente de un framework que es fácil, también es flexible y altamente configurable y extensible.

Algunas características aparte de la que mencioné que me han gustado sobre Grails son las siguientes:

  • Grails integra en un mismo framework lo que varios frameworks por separado cubren. Con la creación de un nuevo proyecto Grails, ya contamos con capacidades out-of-the-box para MVC basadas en Spring MVC, un completo ORM basado en Hibernate, unit testing basado en JUnit, taglibs, soporte para internacionalización, webservices, seguridad básica, soporte AJAX, layouts, etc, etc, etc... Normalmente esto es lo que se integra en muchos proyectos, la diferencia es que no tenemos que lidiar con implementar dicha integración o con los problemas que resulten a partir de ella, porque en Grails las partes integradas ya se hablan bien entre sí.
  • Lo que pudiera faltar a nuestro proyecto, es probable que ya está disponible mediante algún plugin, o se puede desarrollar como tal. Grails está diseñado para ser extensible mediante plugins que cubren determinada área. Por ejemplo, existen plugins para integrar Grails con Spring Security, Neo4j, Scala o para CAS. Existen plugins para muchos propósitos.
  • Un proyecto Grails ya está preconfigurado para switchear entre ambientes de desarrollo, pruebas y producción.
  • Al iniciar un proyecto Grails en ambiente de desarrollo, cuando hagamos cambios en el código, Grails hará live class reloading, lo que nos libra de tener que detener el servidor, hacer nuevamente el despliegue y volverlo a iniciar para ver el cambio reflejado. Grails actualiza incluso archivos de recursos, como messages.properties.
  • Grails integra para algunos tipos de clases métodos dinámicos, por ejemplo para clases de dominio (lo que serían entities en JPA) ya existen métodos que Grails integra a la metaclase para guardar, buscar, eliminar y esas cosas que regularmente tienen el mismo comportamiento en cualquier aplicación.
  • Seguramente hay muchas características relevantes más... si se les ocurre alguna siéntanse en confianza de señalarla en los comentarios.

Ahora sí...

Instalando Grails.

Para esta primera parte, haremos algo muy sencillo que expondrá la simplicidad y rapidez de Grails. La instalación está de trámite:

  • Se requiere tener instalado JDK 5 o superior.
  • Descargar Grails: http://grails.org/Download
  • Extraer y dar de alta GRAILS_HOME, que apunte hacia la carpeta donde se extrajo Grails. Nota: Se requiere también JAVA_HOME que me imagino ya tendrán seteada.
  • Agreguen $GRAILS_HOME/bin a su variable PATH, o %GRAILS_HOME%/bin en caso de Windows.
  • Prueben el comando "grails" en consola, si les aparece algo que inicia con "Welcome to Grails 1.3.6 - http://grails.org/" entonces voilà!

Creando un proyecto.

Grails se conduce mediante comandos, verán lo fácil que es crear un proyecto base y correrlo.

Para indicarle a Grails que queremos crear un proyecto, escribimos en consola el comando:

$ grails create-app GrailsTest

En el log que va desplegando la consola podemos ver que crea la estructura de carpetas de nuestro proyecto, y al final nos indica: "Created Grails Application at /Users/benek/Dev/GrailsTest".

La estructura que creó es esta:

/grails-app
-- conf
-- controllers
-- domain
-- i18n
-- services
-- taglib
-- utils
-- views
/lib
/scripts
/src
-- groovy
-- java
/test
/webapp

Dentro de /grails-app reside todo el ecosistema de Grails, seccionado por convención.

  • conf. Configuración de cómo operará Grails: al arranque (bootstrap), datasources, dependencias, nivel de logging, etc...
  • controllers. Clases controller, son como los controllers de Spring MVC, se encargan de gestionar las peticiones que provienen desde la vista y preparar la respuesta.
  • domain. Clases de dominio, son las clases que estarán asociadas con entidades (tablas) en la base de datos.
  • i18n. Debajo de esta carpeta pondremos todos los archivos de propiedades destinados para internacionalización que necesitemos.
  • services. Grails provee esta capa de servicios para que situemos aquí las clases que implementarán la lógica de la aplicación, y no contaminemos los controllers con ella.
  • taglib. Para librerías de etiquetas que vayamos a crear.
  • utils. Clases comunes o de utilería.
  • views. Donde pondremos las Groovy Server Pages (GSP), estilo JSP's pero de Grails.

Para el directorio /lib, el objetivo está más que claro. En /src/groovy y /src/java pondremos clases Java o Groovy que queramos que sean compiladas y estén dentro del classpath para utilizarlas. Dentro de /scripts podemos poner scripts de Gant, que es un wrapper de Ant para hacer scripts utilizando Groovy. Debajo de /webapp está el contenido estático como hojas de estilo, imágenes y js.

Bien, como ejemplo crearemos una clase de dominio: Pais. Como clase de dominio, estará mapeada a una tabla PAIS en una base de datos, en donde guardaremos los datos de los países del mundo. En la consola de Grails ejecutamos:

$ grails create-domain-class org.javamexico.grailstest.Pais

Esto creará la clase de dominio org.javamexico.grailstest.Pais y su test unitario. Ahora abrimos la clase y su contenido será:

package org.javamexico.grailstest

class Pais {

    static constraints = {
    }
}

Agregamos un par de properties: idPais y nombre. Aquí mismo declaramos constraints, que actúan validando la información de cada propiedad, por ejemplo, haremos que ninguna de las dos pueda estar vacía. Quedaría así:

package org.javamexico.grailstest

class Pais {

    String idPais
    String nombre

    static constraints = {
        idPais(blank: false)
        nombre(blank: false)
    }
}

Bien, ahora haremos un controlador para Pais. Éste gestionará la vista que debe ser presentada. Para crear dicho controlador también ocupamos un comando, así:

$ grails create-controller org.javamexico.grailstest.Pais

Y con esto se crea PaisController y su test. Ahora abramos el controller, el contenido es el siguiente:

package org.javamexico.grailstest

class PaisController {

    def index = { }

}

Modificamos para que quede así:

package org.javamexico.grailstest

class PaisController {

    def scaffold = Pais

}

Guardamos y ahora ejecutamos:

$ grails run-app

La salida al final debe indicarnos:

Running Grails application..
Server running. Browse to http://localhost:8080/GrailsTest

Abrimos nuestro navegador en http://localhost:8080/GrailsTest y si todo salió bien veremos lo siguiente:

Si accedemos a la URL del controller de Pais, podremos ver que ya tenemos operaciones para crear nuevos Países, listar, eliminar y modificar con los "constraints" que definimos: http://localhost:8080/GrailsTest/pais




Automágicamente Grails ya hizo algunas cosas por nosotros.

  • Grails descarga Apache Tomcat y monta la aplicación en él, luego lo inicia.
  • Por defáult, Grails utiliza HSQLDB como base de datos, ésta corre en memoria. Grails genera los scripts para crear la estructura de la BD en base a las clases de dominio.
  • El scaffolding es un método popularizado por Ruby on Rails. La definición que pusimos: def scaffold = Pais, crea el andamiaje de un CRUD básico para la clase de dominio Pais, es por esto que cuando iniciamos la aplicación el controller de Pais ya tiene vistas para esto.

Ya en este punto, con muy pocos pasos logramos tener una base muy sólida para soportar un proyecto y hasta el CRUD de una entidad de la base de datos. Mucho avance para pocos pasos.

En la siguiente entrega, veremos cómo crear por nuestra cuenta operaciones en los controllers como las que generó Grails con scaffolding, y cómo a partir del scaffolding que crea Grails podemos también generar éstas. En resumen, el comportamiento de los controllers y GSP's.

¡Saludos a todos!

Comentarios

Opciones de visualización de comentarios

Seleccione la forma que prefiera para mostrar los comentarios y haga clic en «Guardar las opciones» para activar los cambios.

Interesante

Excelente post. Ahora veo lo que se busca con Groovy, mantener a la gente que piensa "Java" y que quiera extender sus horizontes sin ser tan radical (Play!).

Lo único que no me gustó de Grails (cuando buscaba un framework que fuera bien conmigo) fue el uso de Groovy, de verdad que no me pude hacer a la sintáctica Groovyera se veía cómo algo raro, ya la entiendo más y todo ahora tiene sentido.

Con un pie dentro y otro fuera.
Tengo entendido que Grails pertenece a una división de Spring, por lo que en parte es cómo "morderse a sí mismo", o más bien fuera de la programación orientada a aspectos considero que Spring Roo está en problemas. Ahora, no sé que tanto alguien haya usado Spring Roo por aquí, yo utilicé Roo hace un rato pero sólo a modo de aprendizaje y nada profesional, no sé si @benek quien creó el post o alguien más podría decirme o no que tal.

Imagen de ezamudio

Opciones

Grails es ahora parte de SpringSource. Te ofrecen Grails, Spring Roo y Spring MVC. No tienen por qué apostarle a una sola cosa, si pueden proveer distintas opciones. Es como Apache, que ofrece Tapestry, Wicket, Click y algunas otras opciones más oscuras, en paralelo a sus implementaciones de JEE estándar.

No creo que Grails vaya a desplazar a Spring Roo ni a Spring MVC. Cada uno tiene su lugar, sobre todo porque el ecosistema de Java es muy vasto y así como hay quienes pueden y quieren tomar el camino de Grails o de Play, habrá quienes quieren actualizar aplicaciones JEE existentes y la ruta más sencilla es integrar Spring MVC o puro Spring Web.

Re: Opciones

Exacto, pero por ejemplo la división si se ve entre Spring MVC y Grails; digamos Spring MVC es algo más "Enterprise" por llamarle de una manera y Grails es más apostando a por las tecnologías ágiles. Pero ¿y Roo?...En un principio se suponía que Roo era la solución para sin tener que aprender otra cosa pudieras hacer proyectos de manera más rápida, apostando a por la AOP. Aunque aquí pudiese venir la respuesta ¿que tan AOP es Grails?

Imagen de benek

Confusión

Spring MVC y Roo no compiten, Roo es una herramienta RAD, con ella puedes crear y gestionar muy fácilmente proyectos basados en Spring MVC/Hibernate/AOP, aunque al final la herramienta no quede como parte del proyecto, solamente ayuda en su generación. La estructura de un proyecto generado con Roo es muy parecida a la que genera Grails.

La diferencia con Grails es que Grails es todo el paquete: La herramienta RAD, el framework MVC, el ORM y más.

Spring MVC es un solamente un módulo para la parte web, la parte que gestiona las peticiones, respuestas y las vistas. SI quisieramos empatar Grails con las demás tecnologías de SpringSource entonces sería Grails vs Spring Roo/MVC/Hibernate (aunque Hibernate no es de SS), algo así.

Imagen de AlexSnake

Wow que impresión!!!!

Valla valla valla, estoy bastante sorprendido de lo mucho que se puede hacer con tan poco, me siento emocionado y como si estuviera en la escuela nuevamente. Pero ahora me surgen muchas dudas, se puede combinar esto con Ajax? puedo ocupar los jar de java como el mysqlconector o javamail(supongo que si, pero es simplemente para confirmar)? Lo puedo trabajar con algun IDE (eclipse :P)?

Por cierto excelente aporte, buena introducción, facil de entender, ya estoy ancioso por ver la 2da parte .....

Re: Confusión

Pues de hecho me has confundido más =P.

A ver, Spring Roo entonces ¿que es, un framework ágil para desarrollo de aplicaciones o un módulo extra de Spring?...A lo que había visto/leído de Roo es que era una manera ágil de desarrollar aplicaciones web, incluyendo AOP e integrando otras tecnologías tanto de Spring cómo estándar.

Re: Wow que impresión!!!!

Pero ahora me surgen muchas dudas, se puede combinar esto con Ajax? puedo ocupar los jar de java como el mysqlconector o javamail(supongo que si, pero es simplemente para confirmar)? Lo puedo trabajar con algun IDE (eclipse :P)?

Todo tiene respuesta de: Si. Ya que Groovy es un lenguaje que corre sobre la JVM y el código generado es a bytecode por lo que puedes usar los jars y librerías que necesites. Lo de los IDE es cuestión de buscar los plugins necesarios (el de Groovy y el de Grails); en lo personal te recomendaría usar IntelliJ IDEA ya que tiene soporte Groovy out of box. Y pues con lo de AJAX, es obvio que se puede, cualquier aplicación moderna cuenta con AJAX en menor o mayor medida, sería ilógico que no se permitiera el uso de AJAX en cualquier framework "moderno".

Imagen de AlexSnake

Grax wishmaster77

Cierto, de hecho estaba revisando el dir y veo que combina JQuery y entre más voy explorando más dudas me van surgiendo pero espero poder despejarlas poco a poco y en las sucesivas entregas de este tuto.

Imagen de ezamudio

Respuestas

Respondo algunas de sus dudas, con lo que he resuelto por mi cuenta en Grails, y algo de lo que he visto de Roo.

Roo, como ya dijo Benek, es una herramienta para RAD (Rapid Application Development). Con unos cuantos comandos tienes una aplicación funcional con clases de dominio, vistas, etc.

Hay que tener cuidado de estar aventando la palabra ágil por todas partes, porque ya en sistemas no solamente tiene el significado del diccionario, sino que se asocia con las metodologías ágiles (o sea, decir que Roo es ágil puede dar a entender que es una implementación de alguna metodología ágil).

Si Roo usa AOP o no, y a qué grado lo use, es bronca de Roo; yo cuando vi una demo de Roo, no vi que hubiera que usar mucho AOP para programar; de hecho ni código vi en ningún lenguaje, porque era definir las clases de dominio con unos cuantos comandos y luego salían las vistas para administrar dichas clases también con un par de comandos (similar al scaffolding de Grails). Recuerdo que Roo generaba unos archivos que no eran fuente de Java sino eran otra cosa y esos son los que luego se pueden modificar para de ahí generar todo el código Java, pero creo que hasta ahí llega mi conocimiento de Roo.

En Grails probablemente se pueden hacer cosas con AOP, a la manera de Groovy, pero hasta ahora no he tenido necesidad de usar AOP (realmente he tenido muy poca necesidad de usar AOP en general).
En cuanto a dependencias externas, supongo que ya vendrá algo de esto en los siguientes artículos que haga Benek, pero mientras tanto una probadita: la configuración de una aplicación Grails incluye manejo de dependencias, tipo Maven, donde se indican las dependencias requeridas para compilar, para tiempo de ejecución y para pruebas. Ahí se incluyen los drivers JDBC y cualquier otra librería externa que se requiera usar, como lo de JavaMail.

Aunque, cuando se desarrolla en Grails conviene echar un ojo a los plugins porque hay una colección bastante extensa de plugins para Grails; uno de ellos es por ejemplo el plugin para mail, que al ver lo que hace y cómo se usa, se da uno cuenta del poder de los plugins en Grails.

En cuanto a IDE's, pues dicen que el mejor para Grails es IDEA, pero el soporte para Grails solamente viene en la versión Ultimate, que es la de paga. Spring da soporte a Grails que va mejorando constantemente, en su STS (que no es otra cosa que un Eclipse con varias cosas adicionales que le pone SpringSource, está bueno). Supongo que ese mismo soporte se puede poner en Eclipse, pero no sé qué tan complicado sea. Honestamente, es lo de menos; lo que me ha gustado de Grails es que se puede usar muy bien sin necesidad de un IDE.

Cuando aprendo alguna herramienta nueva, trato de usar un IDE de la manera más simple, sin requerir plugins nuevos, etc, para poder distinguir muy bien lo que hace el framework que estoy aprendiendo, de lo que hacen los plugins. Y con Grails he podido ya hacer bastantes cosas editando todo con puritito jEdit, con el plugin de Groovy. Esto porque con Grails se trabaja muy bien desde la línea de comando, ejecutando comandos para crear clases de dominio, controladores, vistas, etc. Y he trabajado bastante a gusto; ya luego me meteré a usar Grails con STS a ver si mejora mucho la experiencia o si es casi lo mismo (el tiempo de arranque de jEdit contra el de Eclipse es órdenes de magnitud menor).

Imagen de ezamudio

AJAX

En cuanto a AJAX, hay plugins para eso también, que facilitan muchísimo las cosas. Yo he estado usando el GrailsUI que se basa en YUI y la verdad está regalado, no he tenido que teclear una sola línea de javascript para presentar diálogos arrastrables o modales, campos de fecha con calendarios, pestañas, etc.

Para jQuery hay este plugin y este otro, eso lo encontré en una búsqueda al aventón, seguramente hay otros que pueden ser más fáciles o más complejos de usar, etc.

Lo importante es saber que un gsp de Grails puede ser tan simple como se necesite, no tiene dependencias forzosas con ninguna biblioteca o framework de javascript, a diferencia de otros (como Tapestry 5 que ya viene con Prototype y si quieres usar jQuery es un rollo cambiar). Por lo tanto puedes meter "a patín" el framework o librería de AJAX que más te guste, o ayudarte de algún plugin que facilite su uso, y de paso puedes contribuir a dicho plugin si es que no hace algo que necesites...

Re: Respuestas

Es cierto lo de IntelliJ, es que cómo en la escuela tienen licencia classroom pues tengo la ultimate, pero según yo también puedes usar Grails con la community (es cuestión de encontrar el plug-in), ya que viene con soporte para Groovy y Gradle.

Imagen de ezamudio

IDEA community

La versión community de IDEA solamente soporta Groovy, no Grails. La "cuestión de encontrar el plugin" es que tendrías que crackearlo o algo así, porque el soporte oficial de IntelliJ para Grails sólo viene en la versión Ultimate. Por tanto manera legal, sólo tienes soporte para Grails usando la versión Ultimate de IDEA.

Imagen de VictorManuel

orale!!!

Orale que chido esta!! me latio, espero saques mas ondas de estas!!! gracias por compartir :p

style="display:inline-block;width:728px;height:90px"
data-ad-client="ca-pub-5164839828746352"
data-ad-slot="7563230308">