Artículo de introducción a la plataforma de desarrollo Grails. ¿Qué pasaría si uniéramos en una misma plataforma de desarrollo, por un lado, un lenguaje dinámico basado en Java, y por el otro, los frameworks más utilizados y aceptados en la comunidad de libre distribución? ¡La solución dentro de este artículo!

Autor:

¡Hola! Llevo más de 15 años en el mundo de las TI. He sido testigo de cómo ha ido evolucionando la tecnología Java enfocada en aplicaciones web, especializándome en la plataforma Grails. Puedes ver más tutoriales de Grails en Observatorio de Grails o visitar mi proyecto más ambicioso cuestamenos.com.

Historia del desarrollo web en Java (para iniciados, sufridores y escépticos)

Desde que el lenguaje Java fue diseñado a principio de la década de los 90, el principal hueco que pretendió ocupar fue el de alternativa mucho más sencilla y portable al lenguaje C++ (principalmente en términos de gestión de memoria y librerías de clases). Posteriormente, con la aparición en el año 1993 de la WWW, Java (y Sun) se adelantó al resto de sus competidores y se convirtió ipso-facto en el estándar de desarrollo de aplicaciones web empresariales, donde actualmente comparte la mayor parte del nicho de mercado junto con la tecnología .NET de Microsoft.

Inicialmente Java se convirtió en poco tiempo en el estándar de desarrollo de aplicaciones empresariales. Hoy comparte el puesto con .NET de Microsoft.

Sin embargo, la evolución que Java ha ido experimentando en términos de facilidad de uso y productividad a la hora del desarrollo de aplicaciones, principalmente web, se ha visto seriamente comprometida desde sus inicios por los tediosos y burócratas procesos establecidos por Sun en torno a sus JCPs (Java Community Process) para producir JSRs (Java Specification Request), esto es, especificaciones estándar para la tecnología Java.

Java VS .NET

De esta forma, hasta hace sólo unos pocos años, eran las grandes empresas de software las encargadas de decidir qué, cómo y cuándo se podía aplicar una determinada tecnología mediante una especificación a la plataforma Java, en la mayoría de los casos, inexplicablemente compleja y enreversada, como lo prueban ejemplos de sus primeras criaturas denominadas EJBs (Enterprise Java Bean).

La comunidad libre impulsó con una cantidad masiva de proyectos la plataforma Java, mejorándola y haciéndola mucho más potente con adaptaciones de todo tipo.

Como no hay mal que por bien no venga (o como dicen mis amigos americanos, es una bendición disfrazada), y puesto que Java acuñó desde sus inicios una licencia de uso completo y sin modificaciones para la ejecución de programas, esta actitud provocó la masiva respuesta de la comunidad de libre distribución (open-source) en forma de una ingente cantidad de proyectos.

Estos proyectos intentaban complementar las deficiencias de Java como plataforma de desarrollo (cuidado, el lenguaje en sí siempre ha estado a la altura), tanto a nivel web (Struts, Tapestry, Velocity, etc.) como de acceso a datos (Hibernate, iBatis, etc.) o incluso gestión de dependencias (Spring, Guice, etc.). Muchos de estos proyectos open-source son ahora referentes y estándares de-facto en el desarrollo Java, por mucho que desde el comité de JCPs se empeñen en obviarlos (aunque cada vez menos, al césar lo que es del césar).

Lenguajes dinámicos o cómo evitar la verbosidad del lenguaje

Seamos sinceros; a mi me encanta el lenguaje Java, amo el lenguaje Java y para los que jugueteamos, años ha, con Cobol, Fortran, Prologue, OS/2, Clipper, Basic, C/C++ y algunos otros que ya ni quiero recordar, supuso un regalo en forma de tecnología orientada a objetos imposible de rechazar.

Estableciendo esta premisa inicial, la crítica constructiva (aunque a veces pase por destructiva) es un ejercicio de salud tecnológica al que no podemos renunciar, y seguramente en mis primeros desarrollos estaba cegado por el árbol que no me dejaba ver el bosque. Y es que ese bosque apareció delante de mi, por sorpresa, sin realmente buscarlo, cuando tuve noticias del proyecto Groovy, un lenguaje dinámico para Java.

Groovy

Por entonces, yo ya me tenía que pelear en ocasiones con Javascript (que recordemos no tiene nada que ver con Java, pero incorpora mucha de su sintaxis orientada a objetos, por lo que sus autores probablemente utilizaron el “bombo y platillos” en torno a Java para establecer su nombre), y he de reconocer que sentía una envidia sana por sus características dinámicas y su débil (por no decir inexistente) tipado. Pero ante mi surgió Groovy y mi vida de desarrollador cambió radicalmente a mejor, a mucho mejor, a volver a disfrutar desarrollando. Y no exagero, ni un ápice.

Groovy nos permite ejecutar código precompilado en Java y también código Java en Groovy sin compilación previa.

Para aquellos que no conozcáis Groovy, se trata de un lenguaje de scripting, ágil y orientado a objetos, que nace, vive y muere en la propia máquina virtual de Java. Esto quiere decir que podemos ejecutar código Groovy (previamente compilado a código Java) desde Java, y Java (sin ningún tipo de proceso de compilación) directamente en Groovy, abriéndose ante nosotros las puertas al infinito y más allá. Aunque no es el objetivo de este artículo el detallar las bondades de Groovy, sí me voy a permitir un ejemplo muy gráfico por eso de que “una imagen vale más que mil palabras”:

Ejemplo en Java

import java.util.List;
import java.util.ArrayList;

class Erase {
    private List removeLongerThan(List strings, in length) {
        List result = new ArrayList();
        for (int i = 0; i < strings.size(); i++) {
            String s = (String) strings.get(i);
            if (s.length() <= length) {
                result.add(s);
            }
        }
        return result;
    }

    public static void main(String[] args) {
        List names = new ArrayList();
        names.add("Enrique"); names.add("Adrian");
        names.add("Javier"); names.add("Marisa");
        System.out.println(names);
        Erase e = new Erase();
        List shortNames = e.removeLongerThan(names, 6);
        System.out.println(shortNames.size());
        for (int i = 0; i < shortNames.size(); i++) {
            String s = (String) shortNames.get(i);
            System.out.println(s);
        }
    }
}

Ejemplo en Groovy

names = ["Enrique", "Adrián", "Javier", "Marisa"]
println names
shortNames = names.findAll{ it.size() <= 3 }
println shortNames.size()
shortNames.each{ println it }

Como supongo ya habréis adivinado, ambos códigos producen exactamente el mismo resultado, sólo que si tuviérais que elegir uno, ¿con cuál os quedaríais? No me lo digáis, yo también.

Grails: la búsqueda del grial… ¿ha concluido?

Sin ser, ni pretender ser un buen estratega militar, el objetivo que perseguía con las dos primeras secciones de este artículo, era el de despertar la curiosidad del lector ante un escenario tan sumamente heterogéneo de tecnologías en torno a Java, pero a la vez tan aprovechable utilizando la perla dinámica de Groovy. Espero haberlo conseguido, y como ya no puedo ocultarlo más, pues aquí os presento a Grails, la plataforma de desarrollo (web) que ha cambiado mi aura programadora.

grails logo

Y es que Grails es uno de esos proyectos que si no existiera habría que inventarlo, porque ha conseguido mediante unas de las técnicas más antiguas del desarrollo, el “no te repitas a ti mismo y no reinventes la rueda” (DRY, en inglés), un framework “completo” (aunque a mi me gusta llamarlo plataforma) compuesto de la unión de otros frameworks “pegamento”. Veamos qué se esconde detrás de este ejercicio de verbilocuencia.

Framework “completo” contra framework “pegamento” (en inglés, ‘full-stack’ vs ‘glue’ frameworks)

  • Un framework “completo” es aquel cuyos objetivo principal es proporcionar un conjunto simple de componentes que permitan cubrir el espectro completo de las necesidades requeridas para construir aplicaciones (web), y asegurar que dichos componentes trabajan y se integran de forma óptima unos con otros.
  • Un framework “pegamento”, por el contrario, persigue proporcionar un conjunto de adaptadores y código de interfaz que permita gestionar los diferentes componentes en cada capa del desarrollo, y asegurar que dichos adaptadores funcionan correctamente con tantas combinaciones de los componentes como sea posible. Como ejemplo, un framework especializado o focalizado bien en una capa específica, como la capa de presentación (web), o la capa de acceso a datos.

En Grails, no sólo se superan los objetivos marcados por un framework “completo” con matrícula de honor cum-laude, sino que se elevan a la máxima potencia otorgando al desarrollador una plataforma integrada de ejecución de los propios desarrollos, que además es intercambiable, y que permite el “cambio en caliente” del código (algo que muchos desarrolladores no-Java darán por sentado, pero que no estaba tan claro en el mundo Java, salvo con complicadas maniobras de birlibirloque).

Otro punto a favor de Grails es la gran cantidad de plugins que permiten extender la funcionalidad base, son ya más de 500 y no dejan de crecer día a día.

Y si esto no calmara nuestra avivada sed de curiosidad por si sólo, destacar que la arquitectura de Grails ha sido diseñada con orientación abierta y “enchufable”, de forma que existe un ecosistema de más de 500 plugins que permiten extender la funcionalidad de nuestra aplicación con el único techo de nuestra capacidad como desarrolladores.

Diseccionando a Grails de arriba a abajo

Quedaría este artículo huérfano, y similar a una zanahoria flotando eternamente a unos centímetros de la boca del asno (siempre en sentido figurado, que nadie se me ofenda), si no presentáramos las piezas que forman el puzzle mágico del que hablamos. Así, Grails es:

  • Una capa de abstración denominada GORM para acceso a datos construida sobre el ORM (Object Relational Mapping) más utilizado por la comunidad Java (y otras muchas más): Hibernate.
  • Una tecnología expresiva de presentación / vista, basada en plantillas, denominada GSP (Groovy Server Pages).
  • Una capa de control basada en Spring MVC, reconocida como la mejor tecnología MVC del mercado.
  • Un entorno de scripting de línea de comando construido sobre Gant, una extensión Ant basada en Groovy.
  • Un contenedor Tomcat embebido, configurado para la recarga “en caliente” (fly reloading).
  • Gestión de inyección por dependencia (DI) mediante el contenedor de Spring.
  • Soporte para internacionalización / localización (i18n) a partir del concepto MessageSource de Spring.
  • Gestión transaccional “gratuita” basada en la abstracción transaccional de Spring.

Y recordemos, todas estas piezas sólo como núcleo principal o plataforma, sin olvidar la posibilidad ya comentada de inyectar todo tipo de plugins con todo tipo de funcionalidades: búsqueda “full-text” con Lucene/Solr, integración social con Facebook/Twitter/Tuenti, almacenes NoSQL como MongoDB, GemFire, Redis, CouchDB, seguridad integrada de autenticación/autorización con Spring Security, librerías de widgets gráficos RIA, y un largo etcétera sólo por nombrar unos pocos. Encuentra aquí la lista completa.

Conclusión

Existen múltiples y variados frameworks Java de desarrollo que proporcionan algunas de las piezas del puzzle web, pero se echaba en falta un pegamento que permitiera aglutinarlas en una plataforma “completa” y “extensible” de desarrollo.

Grails ha conseguido este objetivo combinando el lenguaje dinámico Groovy con aquellas tecnologías abiertamente aceptadas como estándares de-facto en la comunidad Java. El “grial” Java ya está aquí, y ha venido para quedarse.

Si quieres ver una aplicación real en acción, deja tu comentario y anímame a ponerme a escribir un tutorial de desarrollo en Grails.

¡Nos vemos en el próximo artículo!

Te sugerimos otras entradas relacionadas...

¿Necesitas desarrollar un proyecto web o para móviles? ¡Estamos disponibles!

Visitar Cokidoo

Cokidoo, los creadores de Ontuts, desarrollamos proyectos tecnológicos centrados en redes sociales y aplicaciones web, aplicaciones móviles y consultoría web y bases de datos.

Somos jóvenes, inquietos, versátiles, apasionados por la innovación y enfocados en las nuevas tecnologías. Con Ontuts tratamos de compartir nuestro conocimiento adquirido en los distintos proyectos, ayudando a la comunidad y mostrando nuestra capacidad tecnológica.

Si necesitas un presupuesto sin compromiso, estamos disponibles, no dudes en contactar con nosotros.

Comentarios en esta publicación (22 comentarios)

¿Te ha gustado esta publicación? ¡Puedes compartir tu opinión con todos nosotros! Simplemente pincha aquí mismo.

Muchas gracias por la aportación Enrique y bienvenido al barco de Ontuts!

Por mi parte, estoy empezando a hacer mis pinitos con rails.. pero tirando de ruby, nunca me he llevado bien del todo con Java, pero espero que se me quite esa sensación con algún tutorial práctico :)

Enrique Medina Montenegro

He de reconocer que yo empecé con Rails, e incluso me compré un libro de dicha tecnología, pero entre que venía del mundo Java y que no me terminaba de convencer (no me preguntes a estas alturas por qué, ya que no lo recuerdo), me olvidé del tema hasta que oí hablar de Grails.

Creo que sólo el hecho de usar Groovy ya hace que merezca la pena ;-)

Muy buena introducción y motivación para usar Grails. Espero que sirva para abrir los ojos a muchos lectores como a mi cuando me hablaste de Grails hace ya un año y lo que me ha facilitado los desarrollos. Gracias! Y espero leer pronto tu tutorial de desarrollo.

Juan

Se programar cosas básicas en java, me gustaría saber un poco más y esto se nota muy interesante.
Gracias

Enhorabuena por el artículo.
No creo que llegue a usar grails, yo soy más de PHP, pero lo vendes de una manera que apetece dejar lo que llevas y lanzarte a programar java.

Enrique Medina Montenegro

Alex, tu comentario me sirve para volver a destacar algo que incido en el artículo: la ventaja de usar Grails es que por debajo está Groovy, por lo que no hay que pelearse con Java si no se quiere (te puedo asegurar que no he implementado una sola línea de Java en ninguna de las aplicaciones que he desarrollado con Grails y que sigo desarrollando).

Groovy es un lenguaje muy similar a cualquier de los lenguajes dinámicos que existen por ahi, como por ejemplo, Javascript, por lo que si te encuentras cómodo trabajando con JS, seguro que la curva de aprendizaje de Groovy va a ser muy llevadera, por no decir incluso divertida :-)

Personalmente he estado trasteando mucho últimamente con Scala y Lift, y he visto también cosas de Groovy y Rails.

¿Qué opinas?
¿Conoces ambos?

¿Por qué crees que Grails es mejor si es que lo crees?

Personalmente veo más capaz a Lift + Scala, pero me gustaría conocer tu opinion.

Enrique Medina Montenegro

Alberto, reconozco que he oido hablar de Scala y Lift, he leido algo sobre el tema, pero no soy ni lo más alejado a un experto en ese tema, lo cual no me impide en cualquier caso darte mi opinión.

La primera diferencia que veo es la de framework “glue” vs framework “completo”. Sin entrar si Scala es mejor que Groovy como lenguaje dinámico (lo cual tengo mis serias dudas), lo que sí queda claro es que Lift es un “simple” framework web frente a Grails que es una plataforma “completa”, es decir, es el framework “web” más todo el resto de piezas para completar el puzzle de una aplicación. Aquí habría que discutir, quizás, si es mejor realmente Lift o Spring MVC, porque al final Grails lo que hace es simplificar de forma dinámica (mediante el concepto de controladores y generación automática de CRUD – scaffolding) el uso de Spring MVC.

Luego según he leído en artículos y documentación sobre Lift, este framework está mucho menos orientado a peticiones HTTP y más “optimizado” para sitios interactivos Ajax/Comet/JSON. No creo que esto limite su aplicación a otros ámbitos, pero es curioso que sus propios creadores lo identifiquen de forma tan clara, ¿verdad?

Pero creo que volviendo de nuevo al principio de mi comentario, el “problema” con Lift es el que denuncio en el propio artículo, y es el hecho de que se trata de sólo una parte del puzzle, de forma que luego tienes que seguir trabajando en integrarlo con otras tecnologías, como por ejemplo para el acceso a datos, donde por cierto, los propios autores incluso recomiendan integrarlo con la parte GORM de Grails ;-)

Como conclusión, no sabría decirte si Lift es mejor que Grails desde el ámbito exclusivo de la capa MVC, pero sí puedo decirte sin lugar a dudas, que Lift no puede competir con Grails a nivel completo de aplicación por su propia naturaleza. Por ello, si realmente consideras que Lift es mejor que Spring MVC (o la capa web de Grails), estupendo, porque precisamente lo bueno de la arquitectura de Grails es que le puedes cambiar sus capas principales y “enchufarle” otra tecnología, y así usar Lift como capa MVC y luego Grails para la capa de negocio y acceso a datos.

Gracias por la respuesta.

Te lo comentaba, sobre todo porque vi que el autor de Groove hizo unas declaraciones diciendo que si hubiera conocido o existiera Scala antes que Groove no lo hubiera creado.

La verdad es que no conozco tanto Lift, pero en cuanto al lenguaje en sí me parecieron muy curiosas esas declaraciones :)

Enrique Medina Montenegro

Desconozco dichas declaraciones, en cualquier caso te comento…

La mayor ventaja de Groovy son las “AST Transformations”, que permiten hacer prácticamente lo que quieras, al hacer posible la demarcación de clases, métodos, propiedades, y prácticamente cualquier elemento del lenguaje, en aras de inyectarle funcionalidad extendida y enriquecida.

Un ejemplo muy claro es la anotación @Immutable en Groovy, que permite “marcar” una clase como “final”, con sus propiedades “privadas”, etc. Pues los defensores de Scala (y detractores de Groovy) argumentan que esta característica ya está embedida en el propio lenguaje “per se”.

Sin embargo, de nuevo pongo el refrán de que “el árbol no les deja ver el bosque”, y seguramente los amantes de Scala no se han parado a pensar que lo que hace a Groovy único (ojo, no digo ni mejor ni peor) y diferente es que con las “AST Transformations”, el desarrollador tiene un lenguaje “extensible” donde podemos elegir la funcionalidad que necesitemos y no limitarnos a lo que el propio lenguaje proporciona, por muy bueno, bonito y barato que sea. Es decir, @Immutable es una extensión que, aunque actualmente se distribuye con el “core” de Groovy, podría haberse escrito como un proyecto separado, lo cual es el camino opuesto a tener algo “que mola” como parte del propio lenguaje.

Si tienes curiosidad, echa un vistazo a un par de ejemplos como Spock y GContracts y verás de lo que hablo ;-)

David

Bueno.. pues que no sea por no pedírtelo. A poner ese tutorial ya! :-) Te leeré encantado.. Saludos.

DMR

Este documento es realmente interesante. LLevo un par de años con J2EE concretamente con SEAM, pero como tengo un amigo que me habló bien de GRAILS, me puse a buscar y llegue aquí.

Te animo a escribir un tutorial completo, porque desde mi pto de vista es una muy buena forma de aprender.

Enhorabuena.

Muchas gracias!!

Pepe

Yo también te animo a que escribas ese tutorial, sería muy interesante para un novato como yo.

Henry Sanchez

Ecxelente articulo, quisiera con ansias ese tutorial =).

Ps yo ya le he probado, realmente es una forma muy practica de desarrollar, son pocos los peros que le pongo a esta plataforma, llegue a ella el mes pasado por un proyecto que me toco terminar y pues se me hace una plataforma muy agil, es relativamente nueva pero creo que en unos cuantos años esta plataforma va a ser una de las mas utilizadas, solo es cuestión que se empiecen a extender, el desarrollo en grails pude lograr una velocidad casi parecida a la que logro con PHP, aun me falta conocer mucho mas de ella pero en conclusión pinta para bien y vale la pena que le hechen una miradilla creo que vale la pena la inversión.

David Huanca

excelente articulo!!, ya me anime a investigar y ver que tal este nuevo Framework, gracias a todos

Muy buen articulo!! felicidades!

Mire

Hola Enrique, yo tengo tiempo que programé en Java y la verdad es que estoy tratando de empezar nuevamente y me encontré con Grails.. que me parece muy práctico.. pero… no encuentro un tutorial que pase de las cosas básicas, conoces alguno que me pueda servir?
Gracias!

Enrique Medina Montenegro

Mire,

La documentación online en el propio sitio de Grails es estupenda, y si buscas en Google encontrarás multitud de pequeños tutoriales y todo tipo de artículos sobre el tema (eso sí, claro, todo en inglés).

Luego está el observatoriodegrails.com que gestiono yo donde también puedes encontrar tutoriales en castellano y todo tipo de recursos relacionados con Grails.

Un saludo.

Miriam

Interesante, voto por el tutorial de Grails :)