1) Manual Grails

5/20/2018 1) Manual Grails

1/167


2/167

Nacho Brito: Manual de desarrollo web con GRAILS - http://www.manual-de-grails.es

v1.0.4 9 de Junio de 2009

Pgina 2 de 167
http://www.manual-de-grails.es/http://www.manual-de-grails.es/


3/167



Pgina 3 de 167
http://www.manual-de-grails.es/http://www.manual-de-grails.es/http://www.manual-de-grails.es/


4/167



MANUAL DE DESARROLLOWEB CONGRAILS

JavaEE, como siempre debi haber sido.

Nacho Brito Calahorro

Pgina 4 de 167


5/167



LICENCIAManual de desarrollo web con Grailsse distribuye bajo licencia Creative CommonsReconocimiento-No comercial-Sin obras derivadas 3.0 Espaa. Por tanto, si adquieresuna copia del libro tienes derecho a utilizarla bajo las siguientes condiciones:

Debes mantener el reconocimiento al autor original y mantener todas lasreferencias existentes tanto a l como a ImaginaWorks Software Factory.

No puedes distribuir la obra comercialmente. Esto significa que no puedesvenderla sin consentimiento por escrito del autor original, ni tampoco distribuirlacomo valor aadido a un servicio de ningn tipo, por ejemplo, si eres formadory utilizas este manual como apoyo a tu curso. Para usos comerciales del librodebes ponerte en contacto con ImaginaWorks en la [email protected] en el telfono 902 546 336.

No puedes distribuir versiones alteradas de la obra. Puesto que el autorasume totalmente la autora de la obra, y es el nico responsable por suscontenidos, l es el nico autorizado a realizar modificaciones o, en su caso,autorizar por escrito a terceros para realizarlas en su nombre.

Salvando estos puntos, que esperamos consideres razonables, la licencia dedistribucin de la obra mantiene el resto de tus libertades como propietario de la copiaque has adquirido para reproducirla (imprimir todas las copias que necesites, copiar elPDF tantas veces como te haga falta, etc), ensearla o regalrsela a compaeros oamigos, utilizarla en grupos de desarrollo, etc.

EL CONTENIDO DE ESTE LIBRO SE PROPORCIONA SIN NINGUNA GARANTA.AUNQUE EL AUTOR HA PUESTO EL MXIMO DE SU PARTE PARA ASEGURARLA VERACIDAD Y CORRECCIN DE LOS MATERIALES EXPUESTOS, NI L NIIMAGINAWORKS SOFTWARE FACTORY S.L.U. ASUMEN NINGUNARESPONSABILIDAD POR DAOS O PERJUICIOS CAUSADOS DIRECTA OINDIRECTAMENTE POR LA INFORMACIN CONTENIDA EN ESTE LIBRO.A lo largo del texto se usarn marcas comerciales pertenecientes a personas y organizaciones, y puede que se omitael smbolopor claridad. No obstante, reconocemos todos los derechos legtimos de los propietarios de las marcas y

no tenemos intencin de infringirlos.Java y todas las marcas derivadas son propiedad de Sun Microsistems Inc. Tanto en Estados Unidos como en otrospases. ImaginaWorks Software Factory no mantiene ninguna relacin de afiliacin con Sun Microsistems, ni hasolicitado su aprobacin para la publicacin de este libro.

Copyright2009 Nacho Brito

ISBN: 978-84-613-2651

Pgina 5 de 167
http://www.manual-de-grails.es/http://www.manual-de-grails.es/http://creativecommons.org/licenses/by-nc-nd/3.0/es/http://creativecommons.org/licenses/by-nc-nd/3.0/es/mailto:[email protected]://creativecommons.org/licenses/by-nc-nd/3.0/es/http://creativecommons.org/licenses/by-nc-nd/3.0/es/mailto:[email protected]://www.manual-de-grails.es/


6/167



PRLOGO

El paisaje de la industria de Java est cambiando. La competitividad de los mercadosest impulsando la necesidad de que el desarrollo de software sea ms rpido y gil.Surgen metodologas que promueven estos principios y se producen cambios en losframeworks. Ya no se considera aceptable pasar aos desarrollando un proyecto desoftware. Los clientes necesitan soluciones y las necesitan ahora.

Grails es un nuevo framework web para la plataforma Java que se basa en el lenguajedinmico Groovy. Mediante el uso de Lenguajes de Dominio Especfico (DSLs)potentes pero a la vez sencillos, la versatilidad de Groovy, y un ecosistema de PlugInsque mejora la productividad en un conjunto cada vez ms amplio de escenarios, Grailsse ha hecho inmensamente popular, y un motor de cambio en el espacio Java.

Grails permite crear aplicaciones en das, en lugar de semanas. En comparacin conel tpico framework de Java, con Grails se necesita menos cdigo para obtener elmismo resultado. Menos cdigo significa menos errores y menos lneas de cdigo demantener.

Gracias a la estrecha integracin con Java, Grails ofrece un camino de migracindesde entornos Java menos productivos. Grails se puede desplegar en tu servidor de

aplicaciones, monitorizar y depurar con tus herramientas y construir con lasherramientas de construccin con las que ya ests familiarizado, como Ant y Maven.

Participar en el desarrollo de Grails desde el principio me ha dado el privilegio depresenciar el crecimiento de la comunidad. Desde muy al principio, hay un fuerteinters de la comunidad internacional y gracias al soporte de internacionalizacin(i18n) de Grails , hay una forma sencilla de desarrollar aplicaciones multi-idioma.

Nacho y sus colegas en ImaginaWorks han sido uno de los motores de lapopularizacin de Grails en la comunidad de habla hispana y su dedicacin amantener el muy popular sitiogroovy.org.esha dado lugar a una gran riqueza decontenidos en espaol. El hecho de que mi mujer tenga origen espaol hace quesignifique mucho para m a nivel personal ver cmo Grails florece en esta comunidaden particular.

Nacho ha creado un fantstico recurso para los que buscan iniciarse con Grails yobtener resultados productivos rpidamente. Bienvenidos a una nueva era dedesarrollo Web en la plataforma Java. Happy coding!

Graeme Rocher

Grails Project Lead

Jefe de Desarrollo Grails en SpringSource

Pgina 6 de 167
http://www.manual-de-grails.es/http://groovy.org.es/http://groovy.org.es/http://groovy.org.es/http://www.manual-de-grails.es/


7/167



Sobre el autorNacho Brito (Madrid, 1977)-perfil en LinkedIn -lleva ms de 10 aos desarrollando

software y formando desarrolladores. Seespecializ en la plataforma Java a principios de2000 y desde entonces ha trabajado en proyectosde todos los tamaos para organismos pblicos yprivados.

Su experiencia con Grails comienza a finales de2006, con las primeras versiones del framework, yenseguida fue consciente del cambio que podasuponer en la forma de desarrollar aplicacionesJavaEE. Incorpor la tecnologa al abanico deherramientas de ImaginaWorksy fundgroovy.org.es,el primer portal sobre Groovy yGrails en espaol, para el que tuvo la oportunidadde entrevistar a los principales impulsores deambos proyecto: Graeme Rochery GillaumeLaforge.

Actualmente desarrolla su carrera profesional enImaginaWorks Software Factory,

compaa que fund en Junio de 2006 y que presta servicios de desarrollo de softwarea medida, formacin y asesoramiento tecnolgico.

Puedes contactar con Nacho en la direccin [email protected].

Pgina 7 de 167
http://www.manual-de-grails.es/http://www.manual-de-grails.es/http://www.linkedin.com/in/nachobritohttp://www.linkedin.com/in/nachobritohttp://groovy.org.es/http://groovy.org.es/http://groovy.org.es/home/story/14http://groovy.org.es/home/story/14http://groovy.org.es/home/story/13http://groovy.org.es/home/story/13http://www.imaginaworks.com/http://www.imaginaworks.com/mailto:[email protected]://www.linkedin.com/in/nachobritohttp://groovy.org.es/http://groovy.org.es/home/story/14http://groovy.org.es/home/story/13http://groovy.org.es/home/story/13http://groovy.org.es/home/story/13http://www.imaginaworks.com/mailto:[email protected]://www.manual-de-grails.es/


8/167



AgradecimientosSi tuviera que dar una respuesta rpida a por qu existe este libro, lgicamente diraque este libro existe porque existe Grails. Por eso el primer agradecimiento debe irpara todo el equipo de desarrollo del framework con Graeme Rochera la cabeza.

Pero si me dejasen ms tiempo para pensar mi respuesta, incluira adems GuillaumeLafforgey todo el equipo de desarrollo de Groovy, que estn haciendo una inmensalabor por abrirnos la mente a todos los desarrolladores que vivimos en la mquinavirtual Java.

Luego tendra que decir que este libro existe porque existe el software libre, porquesomos muchos los que pensamos que se llega ms lejos con modelos cooperativosque competitivos, y que para vivir del software no es necesario vendar los ojos denuestros clientes y encerrarnos para que nadie vea cmo trabajamos.

Este libro existe tambin gracias a javaHispano, asociacin con la que colaboro desdehace muchos aos y que siempre ha estado dispuesta a hacer ms accesible elconocimiento. La idea de escribir este manual surgi durante una serie de seminariosgratuitos de introduccin a Groovy y Grails que ImaginaWorks y javaHispano hanorganizado a lo largo de 2009.

Y dejo para el final lo ms importante. Este libro existe porque he tenido la ilusin, lafuerza y las ganas de escribirlo, y no tendra nada de eso si no fuera por mi familia, por

mi mujer, Ana, por mis hijas Clara y Emma a las que tantas horas robo al da parateclear y teclear.

Este libro existe porque mis padres me educaron y sirvieron de ejemplo en laconstancia, el trabajo duro y el compromiso con uno mismo.

Va por todos ellos.

Pgina 8 de 167


9/167



Pgina 9 de 167


10/167



Pgina 10 de 167


11/167



ndice de Contenidos

LICENCIA.................................................................................................................................. 5

PRLOGO................................................................................................................................ 6

Sobre el autor............................................................................................................................ 7

Agradecimientos....................................................................................................................... 81. Introduccin......................................................................................................................... 19

La bsqueda.................................................................................................................. 19

La solucin..................................................................................................................... 19

El libro............................................................................................................................ 20

2. Cmo usar este manual...................................................................................................... 22

Requisitos previos......................................................................................................... 23

3. Gua rpida......................................................................................................................... 24

Convencin mejor que configuracin........................................................................ 24

DRY: Don't repeat yourself! ("'No te repitas!")......................................................... 24

Instalar Grails................................................................................................................. 25

Estructura de una aplicacin Grails............................................................................... 25

Definicin del Modelo de Datos..................................................................................... 26

Scaffolding..................................................................................................................... 29

Cundo usar el Scaffolding.................................................................................. 31

Configuracin de acceso a datos.................................................................................. 31

Controladores................................................................................................................ 32

Vistas: Groovy Server Pages......................................................................................... 33

Pgina 11 de 167


12/167



Helpers para AJAX.................................................................................................... 34

Custom tags.............................................................................................................. 34

Servicios........................................................................................................................ 35

Desplegar nuestra aplicacin........................................................................................ 35

4. Lo que debes saber antes de empezar.............................................................................. 36

Metodologas................................................................................................................. 36

El patrn Model View Controller.................................................................................... 36

Inversin de Control (IoC).............................................................................................. 38

5. Anatoma de Grails: La lnea de comandos........................................................................ 39

Personalizar la generacin de cdigo............................................................................ 43

6. Configuracin...................................................................................................................... 45

El archivo Config.groovy................................................................................................ 45

Configuracin de log4j.............................................................................................. 46

DataSource.groovy........................................................................................................ 47

7. El modelo de datos: GORM................................................................................................ 48

Crear entidades............................................................................................................. 48

Validaciones.............................................................................................................. 49

Sobre los mensajes de error................................................................................ 51

Cmo mapear asociaciones...................................................................................... 51

Relaciones Uno-A-Uno......................................................................................... 51

Relaciones Uno-A-Muchos................................................................................... 52

Relaciones Muchos-a-Muchos............................................................................. 54

Como mapear composiciones....................................................................................... 55

Cmo mapear herencia................................................................................................. 55

Pgina 12 de 167


13/167



Utilizar esquemas de datos heredados......................................................................... 57

Operaciones sobre el modelo de datos......................................................................... 58

Actualizaciones......................................................................................................... 58

Bloqueos de datos................................................................................................ 59

Consultas.................................................................................................................. 60

Dynamic Finders................................................................................................... 60

Criteria.................................................................................................................. 62

Hibernate HQL...................................................................................................... 62

Conceptos avanzados de GORM.................................................................................. 63

Eventos de persistencia............................................................................................ 63

Poltica de cach....................................................................................................... 64

Sobre las cachs de objetos................................................................................ 64

Configurando Hibernate....................................................................................... 65

Definir la poltica de cach en cada clase............................................................ 66

Usar las cachs fuera de GORM......................................................................... 66

8. Controladores...................................................................................................................... 68

mbitos.......................................................................................................................... 70

El mtodo render, a fondo............................................................................................. 71

Encadenar acciones...................................................................................................... 73

Interceptors.................................................................................................................... 74

Procesar datos de entrada............................................................................................ 75

Data Binding.............................................................................................................. 75

Recibir ficheros......................................................................................................... 76

Evitar el doble post.................................................................................................... 78

Pgina 13 de 167


14/167



Objetos Command.................................................................................................... 79

9. Servicios.............................................................................................................................. 81

Por qu deberan importarte los servicios..................................................................... 81

Ok, pero qu es un Servicio en GRAILS?................................................................... 82

Poltica de creacin de instancias............................................................................. 83

10. Vistas: Groovy Server Pages............................................................................................ 85

Etiquetas GSP............................................................................................................... 86

Etiquetas para manejo de variables.......................................................................... 86

Etiquetas lgicas y de iteracin................................................................................. 87

Etiquetas para filtrar colecciones.............................................................................. 87

Etiquetas para enlazar pginas y recursos............................................................... 88

Etiquetas para formularios........................................................................................ 88

Etiquetas para AJAX................................................................................................. 89

Eventos Javascript............................................................................................... 90

Generar XML o JSON en el servidor.................................................................... 92

Usar las etiquetas como mtodos............................................................................. 93

Crear TagLibs................................................................................................................ 93

Utilizar libreras de etiquetas JSP.................................................................................. 94

Layouts: Sitemesh......................................................................................................... 95

Cmo seleccionar el layout para una vista............................................................... 96

11. Definiendo la estructura de URLs de nuestra aplicacin.................................................. 98

Cmo afecta UrlMappings a la etiqueta link............................................................ 100

Capturar cdigos de error............................................................................................ 100

Capturar mtodos HTTP.............................................................................................. 101

Pgina 14 de 167


15/167



12. Web Flows...................................................................................................................... 102

13. Filtros.............................................................................................................................. 105

Ejemplo: filtro XSS....................................................................................................... 106

14. Bateras de pruebas........................................................................................................ 108

Tests unitarios............................................................................................................. 111

Los mtodos mock.................................................................................................. 112

Tests de integracin.................................................................................................... 113

Tests funcionales......................................................................................................... 117

15. Internacionalizacin........................................................................................................ 121

Cmo maneja Grails la i18n........................................................................................ 121

Cmo mostrar mensajes en el idioma correcto........................................................... 122

Generar scaffolding internacionalizado....................................................................... 123

16. Seguridad........................................................................................................................ 126

Tipos de ataques......................................................................................................... 126

Inyeccin de SQL.................................................................................................... 126

Denegacin de servicio........................................................................................... 127

Inyeccin de HTML/Javascript................................................................................ 128

Codecs......................................................................................................................... 129

17. Desarrollo de Plugins...................................................................................................... 131

Qu podemos hacer en un plugin?........................................................................... 133

Tu primer plugin: aadir artefactos a la aplicacin...................................................... 133

Distribuir el plugin.................................................................................................... 137

Qu ocurre cuando instalamos un plugin en una aplicacin?..............................138

Tu segundo plugin: aadir mtodos dinmicos a las clases de la aplicacin.............138

Pgina 15 de 167


16/167



18. Servicios web con Grails: SOAP vs REST .................................................................... 142

Usando SOAP............................................................................................................. 143

Usando XFire.......................................................................................................... 143

Usando REST.............................................................................................................. 143

Clientes REST para pruebas.................................................................................. 144

Usando Poster.................................................................................................... 145

Usando rest-client............................................................................................... 146

Implementando el servicio...................................................................................... 147

Procesar peticiones POST................................................................................. 147

Procesar peticiones GET.................................................................................... 149

Procesar peticiones PUT.................................................................................... 151

Procesar peticiones DELETE............................................................................. 152

APNDICE A. Introduccin a Groovy .................................................................................. 154

El papel de Groovy en el ecosistema Java.................................................................. 154

Descripcin rpida del lenguaje................................................................................... 154

Qu pinta tiene el cdigo Groovy? ......................................................................... 155

Declaracin de clases............................................................................................. 156

Scripts..................................................................................................................... 156

GroovyBeans.......................................................................................................... 157

Cadenas de texto, expresiones regulares y nmeros............................................. 157

Listas, mapas y rangos........................................................................................... 158

Closures.................................................................................................................. 159

Estructuras de control............................................................................................. 160

Posibilidades de integracin con libreras Java existentes ........................................160

Pgina 16 de 167


17/167



Ejemplos de la vida real:.............................................................................................. 161

Trabajar con XML.................................................................................................... 161

Trabajar con SQL.................................................................................................... 161

Trabajar con Ficheros............................................................................................. 163

Servicios web.......................................................................................................... 163

Servicios especializados....................................................................................................... 165

Control de versiones............................................................................................................. 166

Pgina 17 de 167


18/167



Pgina 18 de 167


19/167



1. IntroduccinHola, bienvenido a manual de desarrollo web con Grails.

El objetivo de este libro es presentarte los conceptos fundamentales que seencuentran detrs de este framework para desarrollo de aplicaciones web con Groovyy Java, y darte algunas ideas sobre la mejor forma de aplicarlos.

La bsqueda

Nuestra experiencia con Grails comienza a finales de 2006, cuando buscbamosherramientas que optimizaran nuestro proceso de desarrollo con JavaEE. Somos unequipo pequeo de desarrolladores, y no podamos permitirnos el tiempo que habaque perder cada vez que comenzbamos un nuevo proyecto en configurar el entornode desarrollo, pruebas y preproduccin, por no hablar de la cantidad de horasdedicadas a escribir XML.

Entonces se empezaba a hablar con fuerza de frameworks como Ruby on Rails oDjango,de las ventajas de usar Convention over Configuration(convenciones mejorque archivos de configuracin) y de las virtudes de los lenguajes dinmicos para crearaplicaciones con menos cdigo de fontanera.

Haciendo un breve parntesis, por lenguajes dinmicos nos referimos, en principio, aaquellos que presentan tipado dinmico, de forma que no necesitamos especificar eltipo de dato de una variable en el momento de declararla en el cdigo fuente, sino queel entorno de ejecucin es capaz de determinarlo en tiempo de ejecucina partir delos datos que almacenemos en ella.

Esta idea, simple inicialmente, alcanza su mxima expresin cuando hablamos delenguajes dinmicos orientados a objetos, ya que nos permiten, por ejemplo, definirclases en tiempo de ejecucin para que los objetos se ajusten a un esquema que nopuede conocerse de antemano, o aadir propiedades y mtodos a un objeto para quehaga ms cosas de aquellas para las que fue inicialmente concebido.

Sonaba muy bien, pero cuando le dedicbamos a estos frameworks nuestra prueba

de los 20 minutos terminbamos echando de menos la plataforma Java. La sensacinera que, efectivamente, podamos hacer un prototipo de nuestra aplicacin en unosminutos, pero... con qu reemplazbamos las libreras de Jakarta Commons? yQuartz? y Compass/Lucene? e iText? y JPA/JDO? y JasperReports? y JUnit?Eran demasiadas herramientas a las que tenamos que renunciar para adoptar estosnuevos frameworks, y eso haca que no mereciese la pena el cambio.

An as estbamos en la senda que nos llevara a encontrar lo que estbamosbuscando.

La solucin

Habamos aprendido el valor de los lenguajes dinmicos, y sabamos que haba

Pgina 19 de 167


20/167



algunos que podan usarse en la mquina virtual, como Ruby (Jruby), JavaScript

(Rhino), Python (Jython), Y as llegamos a Groovy (http://groovy.codehaus.org/),un lenguaje dinmico desarrollado desde y para Java.

Lo que ms nos atrajo del lenguaje es que podamos empezar a escribir clases Groovycomo si fueran Java, ya que la sintaxis es altamente compatible, y poco a poco iraprovechando las maravillas sintcticas a medida que lo descubrisemos. Adems, lacompatibilidad con todo nuestro cdigo heredado y las libreras que conocamos eratotal (Groovy esJava), de forma que podamos reutilizar lo que ya tenamos y aadir anuestro cajn de herramientas cosas como sobrecarga de operadores, programacindinmica, closures, y mucho ms.

El salto de Groovy a Grails fue inmediato. Grails es, con toda seguridad, el proyectoms emblemtico construido con Groovy. Se trata de un framework para desarrollo

web que se parece mucho a Rails por fuera (incluso en el nombre, que originalmenteera Groovy on Railsy tuvo que ser cambiado a peticin de la gente de RoR), pero quepor dentro est construido sobre una base slida formada por proyectos como Springcontainer, Hibernate, SiteMesh, Log4Jy un largo etctera formado por plugins quepermiten encorporar Quartz, Compass/Lucene, JasperReports, ...

Segn cuenta Graeme Rocher en The definitive guide to Grails (Apress, ISBN 1-59059-758-3):

El objetivo de Grails era ir ms all de lo que otros lenguajes y sus frameworksasociados podan ofrecer en el espacio de las aplicaciones web. Grails se proponahacer lo siguiente:

Integrarse estrechamente con la plataforma Java.

Ser sencillo en la superficie, pero mantener la flexibilidad para acceder a lospotentes frameworks Java sobre los que se construa.

Aprender de los errores cometidos en la ya madura plataforma Java.

El uso de Groovy como punto de partida para el framework le proporcion una enormeventaja inicial. El objetivo de Groovy era crear un lenguaje con que permitiese aprogramadores Java una fcil transicin al mundo de los lenguajes de script contipado dinmico, proporcionando funcionalidades imposibles de implementar conlenguajes de tipado esttico.

Enseguida nos dimos cuenta del potencial de la tecnologa, y de cmo poda suponeruna revolucin en la manera de desarrollar aplicaciones para la plataforma JavaEE, noslo porque inclua las palabras mgicas "convention over configuration", "Scaffolding"y "Don't repeat yourself", sino porque traa esos conceptos a la JVM de una formacompletamente transparente y compatible con todo el cdigo Java existente. Por finexista una tecnologa que encajaba con las metodologas giles y que no nosobligaba a abandonar la plataforma Java ni nuestro Know-How acumulado.

El libro

Desde entonces, en ImaginaWorkshemos trabajado con Groovy y Grails

profundizando en las ideas que proponen y divulgando sus ventajas (fundamos elportal http://groovy.org.es) .

Pgina 20 de 167
http://www.manual-de-grails.es/http://groovy.codehaus.org/http://docs.codehaus.org/display/GRAILS/2006/03/30/Grails+Name+Changehttp://groovy.org.es/http://groovy.codehaus.org/http://docs.codehaus.org/display/GRAILS/2006/03/30/Grails+Name+Changehttp://groovy.org.es/http://www.manual-de-grails.es/


21/167



Hemos desarrollado sitios web con Grails de todos los tamaos, sitios que a da de

hoy estn en produccin y que realizan labores desde el ms bsico gestor decontenidos, hasta los sitios MiddleWare con servicios web SOAP y REST, pasando porplataformas B2B y sitios WAP.

Tambin impartimos formacin a instituciones pblicas y privadas, y prestamosservicios de consultora y direccin de proyectos a empresas de desarrollo que seinician en el uso de Groovy y Grails.

Este manual incluye todo lo que hemos aprendido durante el tiempo que hemostrabajado con Grails. Incluye una referencia (no exhaustiva) de las funcionalidadesprincipales del framework, pero lo ms valioso es que incluye las lecciones que noshan aportado estos tres aos de experiencia y que te ahorrarn mucho tiempo yquebraderos de cabeza.

Respecto al formato, hemos querido que este sea un libro digitalpor dos razones:

La primera, para no tener intermediarios. Al editar nosotros mismos el libropodemos elegir cundo lo publicamos, cmo y por cunto lo vendemos, y sobretodo, podemos publicar nuevas revisiones a cuando sea necesario para corregirerratas, adaptar el contenido a nuevas versiones de Grails o aadir captulosnuevos.

La segunda, para respetar tu libertad. Ya que t has comprado esta copia dellibro, te corresponden ciertas libertades que queremos respetar. Puedes decidir si lolees en la pantalla o en papel, imprimir tantas copias como necesites, enviar elarchivo PDF por email a tus amigos o compaeros, puedes llevarla al trabajo en un

lpiz de memoria usb... Tienes ms detalles sobre los trminos de uso en elAPNDICE B.

Esperamos que compartas nuestra visin de este proyecto, y que el manual te gue enel aprendizaje de Grails y te permita sacar lo mejor de ti mismo en tus proyectos.

Madrid, Mayo de 2009

ImaginaWorks Software Factory

Pgina 21 de 167


22/167



!. Cmo usar este manualEl objetivo de este libro es orientar a quienes empiezan en el desarrollo con Grails,aportando datos suficientes sobre la tecnologa y consejos para aplicarla de la mejorforma segn el caso.

Pero para cumplir con esa tarea es necesario que este libro sea una obra gil, en elsentido en que usamos esa palabra en desarrollo de software. Necesitamos que laobra evolucione a la par que las tecnologas que trata, y que las aportaciones de loslectores se reflejen con la mayor frecuencia que sea posible, para no quedar obsoletay perder su utilidad.

Por eso se trata de un libro vivo, que coexiste con un sitio web en el puedes (y teanimo a hacerlo) compartir tus experiencias, comentarios, dudas y correcciones sobreel texto:

http://www.manual-de-grails.es

Con todas las aportaciones y correcciones intentar publicar revisiones del texto confrecuencia, y recoger los cambios y novedades que aporten futuras versiones deGrails.

El libro est dividido en 18 captulos y un Anexo:El captulo 3es una gua rpida que puedes usar para tener una impresin general avista de pjaro acerca de Grails. Te permitir realizar un primer proyecto yfamiliarizarte con la estructura de una aplicacin web MVC. En los captulos siguientesiremos recorriendo cada uno de los aspectos fundamentales del entorno con mayordetenimiento.

El captulo 4presenta los principios tericos en los que se basa Grails, patrones yconvenciones que te ser muy til comprender antes de empezar a profundizar en losaspectos tcnicos.

El captulo 5hace un recorrido por todos los scripts que forman parte de Grails, y que

podemos lanzar desde la lnea de comandos (o utilizando el IDE que prefieras, con elplugin correspondiente) para activar la magia.

A partir de este punto comienza el repaso por todas las tcnicas que necesitasconocer para desarrollar aplicaciones

El captulo 6 te ensea a configurar tu aplicacin Grails para personalizar aspectoscomo las trazas, el acceso a bases de datos, el negociado de tipos mime con elnavegador, etc.

Los captulos 7, 8, 9 y 10recorren el ncleo duro de cualquier aplicacin MVC: elmodelo de datos, la capa de control, la capa de servicios y la capa de presentacin.

El captulo 11te ensea todo lo necesario para definir el esquema de URLs de tu

aplicacin, si no ests satisfecho con el usado por defecto.

Pgina 22 de 167
http://www.manual-de-grails.es/http://www.manual-de-grails.es/http://www.manual-de-grails.es/http://www.manual-de-grails.es/


23/167



El captulo 12describe el uso de Web Flows, una tcnica que permite definir

conversaciones que se extienden ms all de una peticin HTTP, al estilo de losasistentes en las aplicaciones de escritorio.

El captulo 13introduce el concepto de Filtro, que puedes usar para implementarcuestiones transversales de tu aplicacin, como la seguridad o la monitorizacin.

El captulo 14te sumerge de lleno en las facilidades de Grails para realizar pruebasunitarias, de integracin y funcionales sobre tus proyectos, y explica por qu deberasprestar atencin a este aspecto.

El captulo 15explica cmo funciona la internacionalizacin de aplicaciones conGrails.

El captulo 16habla sobre seguridad, en trminos generales de web, y especficos de

Grails.El captulo 17te introduce en el desarrollo de plugins, y te explica los beneficios dedesarrollar aplicaciones modulares.

El captulo 18abarca todo lo relacionado con servicios web y Grails, y realiza unacomparacin entre los paradigmas ms utilizados hoy en da: REST y SOAP.

Al final del texto encontrars un apndice sobre Groovyque te recomiendo leasdetenidamente para familiarizarte con el lenguaje. A fin de cuentas, la mayor parte delcdigo que escribas en Grails ser Groovy y es muy importante que conozcas susintaxis y herramientas bsicas.

Requisitos previos

Aunque no es necesario, aprovechars mejor el contenido de este libro si tienesalguna experiencia desarrollando aplicaciones web con JavaEE. Todos losconocimientos que poseas sobre Servlets y JSPs, servidores de aplicaciones y basesde datos te sern de gran utilidad para asimilar mejor los conceptos de Grails.

Adems, si ests familiarizado con Spring (http://www.springsource.org/about) eHibernate (https://www.hibernate.org/) podrs sacar ms provecho a lasfuncionalidades avanzadas de ambos.

Para una documentacin exhaustiva de todas las funcionalidades de Grails terecomiendo la gua oficial:

http://grails.org/doc/1.1/

Si no tienes experiencia en JavaEE no te preocupes, an as podrs aprender adesarrollar aplicaciones web con Grails de forma sencilla con este manual, e investigarms tarde las ventajas de incorporar mdulos y libreras escritas en Java a tusproyectos.

Los ejemplos de este libro se han escrito sobre la versin 1.1 de Grails.

Pgina 23 de 167
http://www.manual-de-grails.es/http://www.manual-de-grails.es/http://www.springsource.org/abouthttps://www.hibernate.org/http://grails.org/doc/1.1/http://www.springsource.org/abouthttps://www.hibernate.org/http://grails.org/doc/1.1/http://www.manual-de-grails.es/


24/167



". Gu#a r$%ida.

Grails es un framework para desarrollo de aplicaciones web construido sobre cincofuertes pilares:

Groovypara la creacin de propiedades y mtodos dinmicos en los objetosde la aplicacin.

Springpara los flujos de trabajo e inyeccin de dependencias.

Hibernatepara la persistencia.

SiteMeshpara la composicin de la vista.

Antpara la gestin del proceso de desarrollo.

Desde el punto de vista del diseo, Grails se basa en dos principios fundamentales:

Convencin mejor que configuracinAunque en una aplicacin Grails existen archivos de configuracin, es muy pocoprobable que tengas que editarlos manualmente ya que el sistema se basa enconvenciones. Por ejemplo, todas las clases de la carpeta grails-app/controllers serntratados como Controladores, y se mapearn convenientemente a las urls de tuaplicacin.

DRY: Don't repeat yourself! ("'No te repitas!")La participacin de Spring Container en Grails permite inyeccin de dependenciasmediante IoC (Inversion of Control), de forma que cada actor en la aplicacin debe

Pgina 24 de 167

SiteMesh Spring Hibernate

AntJUnitlog4jJEE

GORM GSP

Plugins framework:uart!" A#egi"$ompass" %le&" '''

(i)rer*asJa+aS#ript:,ojo" Protot-pe".U/" '''

Grails

Groo+-

Ja+a


25/167



definirse una nica vez, hacindose visible a todos los dems de forma automtica.

Instalar Grails

Para empezar a trabajar tenemos que instalar el entorno. Lo primero ser descargarGrails desde la web del proyecto:

http://www.grails.org/Download

descomprimimos el archivo en la carpeta que elijamos y fijamos la variable$GRAILS_HOMEpara que apunte a esa carpeta. Si estamos en linux, tambintendremos que dar permisos de ejecucin a todo lo que est en $GRAILS_HOME/biny $GRAILS_HOME/ant/bin.

Para comprobar si todo ha ido bien, podemos escribir en una consola el comandograils help, que nos mostrar un mensaje con la versin del entorno que estamosejecutando y los scripts que podemos invocar.

Estructura de una aplicacin Grails

Grails contiene todo lo necesario para desarrollar desde el primer momento, nonecesitamos servidor adicional ni base de datos (aunque lgicamente podemos usarlos que tengamos instalados, sobre todo en produccin). Para comenzar una

aplicacin Grails nos colocamos en la carpeta donde deseemos tener el proyecto, yescribimos:

$ grails create-app test

Cuando el proceso termina, tenemos una carpeta de nombre "test" (o el nombre que lehayamos dado a nuestra aplicacin), con la siguiente estructura:

+ grails-app + conf ---> Archivos de configuracin + hibernate ---> Config. hibernate (opcional) + spring ---> Config. spring + controllers ---> Controladores + domain ---> Entidades

+ i!n ---> message bundles + services ---> "ervicios + taglib ---> #ibreras de eti%uetas + util ---> Clases de utilidad + vie&s ---> 'istas + laouts ---> #aouts "iteesh + lib + scripts + src + groov ---> *tras clases roov + ,ava ---> *tras clases ava + test ---> Casos de prueba

+ &eb-app ---> a/ de mi aplicacin &eb.Las carpetas donde pasaremos la mayor parte del tiempo son grails-app, que

Pgina 25 de 167
http://www.manual-de-grails.es/http://www.manual-de-grails.es/http://www.grails.org/Downloadhttp://www.grails.org/Downloadhttp://www.manual-de-grails.es/


26/167



contiene todos los artefactos que el entorno ir generando y que tendremos que

modificar para adaptar su funcionamiento a nuestra aplicacin, y web-app, quecontiene la estructura de nuestra aplicacin web. En particular, web-app/csscontienela/s hoja/s de estilo y web-app/imagesel contenido grfico.

Si ejecutamos el comando grails run-apppodremos ver el aspecto de nuestraaplicacin (bastante vaco de momento):

Definicin del Modelo de Datos

Vamos a tratar ahora las cuestiones relacionadas con el modelo de datos y lasrelaciones. Para ello vamos a construir un pequeo sitio web que permita a losusuarios compartir trucos y fragmentos de cdigo Groovy, al estilo JavaAlmanac.

Empezamos por definir nuestro modelo: el sitio tratar con trucos publicados por los

usuarios. Tambin ser posible publicar comentarios a un truco, as como valorar sucalidad para controlar la utilidad de la informacin. Si un truco es denunciado por otrousuario, se retirar provisionalmente y se avisar a su autor para que lo revise. Asque una primera aproximacin podra ser esta:

0suario nombre12e3to fecha14echa email12e3to perfil12e3to2ruco autor10suario comentarios1#ista

denunciado15oolean

Pgina 26 de 167


27/167



te3to12e3to

titulo12e3to fecha14echa

Comentario autor12e3to te3to12e3to fecha14echa

Para empezar, como ya hemos hecho antes, seleccionamos la carpeta donde vamos atrabajar y ejecutamos el comando

$ grails create-app roovAlmanac

Entramos en el directorio GroovyAlmanac, y creamos nuestras clases del dominio:

$grails create-domain-class usuario$grails create-domain-class truco$grails create-domain-class comentario

Una vez creados los archivos, los editamos para completar las entidades:

grails-app/domain/Usuario.groovy:

class 0suario 6 static hasan 7 8trucos12ruco9 "tring nombre "tring email :ate fechaAlta

;

grails-app/domain/Comentario.groovy:

class Comentario 6 static belongs2o 7 2ruco "tring autor "tring te3to :ate fecha;

grails-app/domain/Truco.groovy:

class 2ruco 6

static hasan 7 8comentarios1Comentario9 static belongs2o 7 0suario

#ist comentarios :ate fecha "tring titulo "tring te3to boolean denunciado;

Aparte de que no necesitamos definir getters ni setters (porque nuestras clases sonGroovyBeans), estas entidades tienen otra particularidad: Comentario define unavariable esttica belongs2oque indica la parte "N" de una relacin 1:N entre Truco yComentario, mientras que esta ltima define una propiedad esttica de nombre

Pgina 27 de 167


28/167



hasanque representa el lado "1" (un Map, con cadenas de texto como claves y

clases como valores). Con ellas estamos indicando a grails debe mapear esta relacina la base de datos.

Como ves hemos definido la propiedad comentariosexplcitamente, mientras queen Comentariono hay ninguna propiedad truco. En realidad podramos haberomitido comentarios, pero entonces grails usara la coleccin por defecto, que esSet, y queremos que los comentarios guarden el orden en que son aadidos a lacoleccin, as que forzamos el uso de un List.

Igualmente, hay una relacin 1:N entre los trucos y los usuarios (un usuario puedepublicar varios trucos, cada truco pertenece a un usuario).

Para controlar la validacin de las propiedades podemos definir restricciones mediante

la palabra reservada constraints:

class 0suario 6 static hasan 7 8trucos12ruco9 "tring nombre :ate fechaAlta "tring email

static constraints 7 6 nombre(si/e1


29/167



te3to(ma3"i/e1??????)

;;

Probablemente no hace falta explicar mucho lo que significa cada restriccin, es lobueno de Groovy: el cdigo lo dice casi todo. En las propiedades de tipo texto estamosrestringiendo las longitudes mnima y mxima, y en la propiedad que representa unemail utilizamos una restriccin incorporada que valida que la cadena de texto cumplacon las restricciones de una direccin de correo electrnico.

Scaffolding

Una vez creado el modelo de datos, podemos solicitar a Grails que genere elcontrolador y las vistas necesarias para realizar operaciones CRUD con estasentidades:

$ grails generate-all comentario$ grails generate-all truco$ grails generate-all usuario

Esta tcnica se denomina scaffolding, y generacontroladores y vistas a partir de un modelo de datos. Alejecutar este comando, Grails generar para cadaentidad las acciones list, show, edit, delete, create, save y

update, a las que podremos acceder desde urls comoestas:

@8Aplicacin9@8Entidad9@8Accin9

por ejemplo:

http1@@localhost1!!@roovAlmanac@truco@list

Si vuelves a ejecutar la aplicacin vers que la pgina principal es diferente. Ahoramuestra enlaces a los tres controladores principales, y al pulsar sobre cada unopodrs navegar por las acciones de gestin de entidades.

Pgina 29 de 167

CRUDes un acrnimo para lasoperaciones bsicas de Creacin,Lectura (Read), A ctualizacin(Update) y Borrado (Delete).
http://www.manual-de-grails.es/http://www.manual-de-grails.es/http://localhost:8080/%5BAplicacion%5D/%5BEntidad%5D/%5BAccionhttp://localhost:8080/%5BAplicacion%5D/%5BEntidad%5D/%5BAccionhttp://www.manual-de-grails.es/


30/167



El scaffolding crea un esqueleto completo para empezar a trabajar en nuestraaplicacin:

Pgina 30 de 167


31/167



Cundo usar el ScaffoldingComo ves, el scaffolding es una tcnica muy potente que nos evita construir unaporcin importante de nuestra aplicacin. Sin embargo, como todo, tiene suslimitaciones y no es una herramienta fundamental. A la hora de decidir si laempleamos o no, debemos considerar dos escenarios posibles:

Si nuestra aplicacin se va a parecer mucho a lo generado por Grails, podemosusarlo como punto de partida para una primera versin del cdigo, y a partir de esemomento, asumir el control sobre l introduciendo los cambios que seannecesarios. Es importante tener en cuenta que entonces no debemos volver agenerar los artefactos, puesto que se perderan nuestros cambios.

Si la aplicacin no se parece a lo generado mediante scaffolding, an puederesultar til como consola de administracin o backend, aunque para implementar lalgica de nuestra aplicacin tendremos que partir de cero.

Por tanto, antes de generar artefactos de forma automtica es recomendable pararsea pensar en qu tipo de uso vamos a darles despus, ya que si no planificamosnuestra aplicacin podemos vernos en un callejn sin salida intentando que elscaffolding haga cosas para las que nunca fue diseado.

Configuracin de acceso a datos

Grails incorpora HSQLDB(http://www.hsqldb.org), una base de datos empotradaescrita ntegramente en Java, para que podamos empezar a trabajar sin tener que

Pgina 31 de 167
http://www.manual-de-grails.es/http://www.manual-de-grails.es/http://www.hsqldb.org/http://www.hsqldb.org/http://www.manual-de-grails.es/


32/167



contar con un servidor. Sin embargo, en la mayora de los casos tendremos una base

de datos y querremos usarla. Para ello editamos el siguiente archivo:

grails-app/conf/DataSource.groovy

data"ource 6pooled 7 truedbCreate 7 updatedriverClassBame 7 com.ms%l.,dbc.:riverusername 7 data0serpass&ord 7 dataass

;environments 6

production 6 data"ource 6 url 7 ,dbc1ms%l1@@servidor1


33/167



class ruebaController 6

def accion 7 6render Controlador de pruebas...

;;

Gracias al empleo de convenciones, todas las clases de la carpeta grails-app/controllers que se llamen XXXController.groovy respondern a la urlcorrespondiente, en este caso, /Aplicacin/prueba/accion.

Vistas: Groovy Server Pages

La vista en una aplicacin MVC es la responsable de mostrar al usuario el estado delsistema y las acciones que tiene a su disposicin. En Grails desarrollamos las vistasmediante Groovy Server Pages, una versin simplificada de JSP que permiteintercalar expresiones en el cdigo HTML y emplear una serie de etiquetas al estiloJSTL.

Por ejemplo:

grails-app/views/otro/vista.gsp

html>

head>...@head>bod>

g1set var7mi'ariable>Fo es1 $6ne& :ate();

@g1set>p>#o %ue tengo %ue decir es1strong>$6mi'ariable;@strong>@p>

@bod>@html>

Para invocar esta vista de sun controlador usaramos el mtodo render:

grails-app/controllers/OtroController.gsp

class *troController 6def mivista 7 6

render(vie&1GvistaG);

;

Pgina 33 de 167


34/167



Helpers para AJAXEntre las libreras de etiquetas GSP encontramos varias que nos permiten generarcdigo Javascript en nuestras pginas y realizar llamadas AJAX al servidor. Porejemplo:

script tpe7te3t@,avascript>$(GmdivG).onclicH 7 g1remote4unction action7sho&id7 @>@script>

selectonchange7$remote4unction(

action1GbooHbnameGIupdate18success1GgreatGI failure1GohnoG9Iparams1GGbooHBame7G + this.valueG );>

option>first@option> option>second@option>@select>

Custom tags

Al igual que JSP, GSP soporta el concepto de librera de etiquetas, solo que muchoms simplificado y elegante. En Grails una librera de etiquetas es una clase Groovycon el nombre XXXTagLib.groovy que se aloja en la carpeta grails-app/taglib. Porejemplo:

grails-app/taglib/SimpleTagLib.groovy:

class "imple2ag#ib6def mitag 7 6attrsI bod ->

out div class7G$6attrs.estilo;G>out bod()out @div>

;

;

Podramos usar este fragmento en cualquier vista para utilizar nuestro TagLib:

bod> g1mitag estilo7ro,o>

p>Cual%uier cosa...

@p> @g1mitag>@bod>

Pgina 34 de 167


35/167



ServiciosEl equipo de desarrollo de Grails desaconseja (y yo tambin) la inclusin de lgica denegocio en la capa de Control, y recomienda hacerlo mediante servicios. Un servicioes una clase cuyo nombre sigue el patrn XXXService.groovy y que se aloja en lacarpeta grails-app/services. Por ejemplo:

grails-app/services/UserService.groovy:

class 0ser"ervice 6void activar0suario(0suario u)6

@@lgica del servicio;

;Para usar el servicio, cualquier controlador, librera de etiquetas, etc puede declararuna variable userService, lo que activar la inyeccin automtica por parte de Springde la dependencia:

grails-app/controllers/UserController.groovy:

class 0serController6def user"ervicedef activar 7 6

def u 7 0ser.get(params.id)user"ervice.activar0suario(u)

;

;

Desplegar nuestra aplicacin

Una vez completado el desarrollo de nuestra aplicacin, podemos desplegarla encualquier contenedor JavaEE. Para ello necesitaremos generar el archivo WARmediante el comando:

grails prod &ar

Este comando compilar todo nuestro cdigo Groovy y Java, y generar un archivo apartir del esqueleto contenido en la carpeta web-app de nuestro proyecto. El nombredel archivo incluir la versin de nuestra aplicacin, de forma que podamos mantenerun histrico de versiones.

Con esto completamos el breve repaso a Grails. En los siguientes captulos nosadentraremos con una mayor profundidad en los temas que hemos tratado.

Pgina 35 de 167


36/167



&. Lo 'ue debes saber antes de em%e(arA estas alturas ya deberas tener una impresin de conjunto sobre Grails, y la formade trabajar para crear aplicaciones web JavaEE con este entorno. En este captulovamos a profundizar en los principios que hay detrs del framework, explicando el porqu de cada cosa y tratando de guiarte a la hora de disear tus aplicaciones.

Metodologas

Grails es un entorno para desarrollo de aplicaciones web sobre la plataforma JavaEnterprise Edition nacida en un contexto muy particular: el de las metodologas dedesarrollo de software giles.

La idea detrs de estos procesos es que los requisitos de una aplicacin no siemprepueden definirse completamente antes de comenzar la implementacin, y es necesarioun ciclo basado en iteraciones cortas y una comunicacin muy fluida con el clientepara que el proyecto vaya bien encaminado desde el principio y no se desve en fechay/o coste.

Se trata de aliviar el desarrollo de software de procesos burocrticos y rgidos queobligan a definir por completo los requisitos, luego disear una solucin, luegoimplementarla, y luego probarla, siempre por ese orden y terminando completamente

una etapa antes de comenzar la siguiente. Hay muchas metodologas giles, perotodas tienen en comn una clara orientacin a gestionar el cambio. Es posible (yfrecuente) que el cliente no tenga completamente definidos los requisitos antes decomenzar el desarrollo, y que necesite estar involucrado en el proceso de desarrolloms all de la reunin de arranque del proyecto.

De esta manera, metodologas como eXtreme Programmingo Scrumincluyen alcliente en las reuniones de seguimiento, y establecen una forma de trabajo en la quela comunicacin fluida garantiza que si se produce un cambio total o parcial en losrequisitos el equipo de desarrollo ser capaz de adaptar la aplicacin en un tiemporazonable.

Pero para que esto sea posible es necesario contar con herramientas que tambin

sean giles, y aqu es donde nacen frameworks como Ruby on Rails, y en el mbitode Java, lenguajes como Groovyy frameworks como Grails. Son herramientas en lasque el programador gasta el mnimo tiempo necesario en tareas repetitivas, y en lasque un cambio de requisitos no obliga a reescribir toda la aplicacin, porque lamayora del cdigo de infraestructura se genera de forma dinmica mientras laaplicacin se est ejecutando.

El patrn Model View Controller

Respecto al diseo, Grails sigue un patrn muy popular sobre todo en el desarrollo de

aplicaciones web, denominado Model-View-Controller, o Modelo-Vista-Controlador.Este patrn establece que los componentes de un sistema de software debe

Pgina 36 de 167


37/167



organizarse en 3 capas distintas segn su misin:

Modelo, o capa de datos. Contiene los componentes que representan y gestionanlos datos manejados por la aplicacin. En el caso ms tpico, los objetosencargados de leer y escribir en la base de datos.

Vista, o capa de presentacin. Los componentes de esta capa son responsablesde mostrar al usuario el estado actual del modelo de datos, y presentarle lasdistintas acciones disponibles.

Capa de control. Contendr los componentes que reciben las rdenes del usuario,gestionan la aplicacin de la lgica de negocio sobre el modelo de datos, ydeterminan qu vista debe mostrarse a continuacin.

Cuando digo que los componentes de la capa de control "gestionan la aplicacin de lalgica de negocio" me refiero a que son responsables de que sta se aplique, lo cualno quiere decir que debamos implementar la lgica de nuestros casos de uso enlos controladores. Normalmente esta lgica estar implementada en una cuartacapa:

Capa de servicios. Contiene los componentes encargados de implementar lalgica de negocio de nuestra aplicacin.

Cuando trabajamos en Grails, generamos componentes en cada una de las capas y esel entorno el que se encarga de conectar unos con otros y garantizar su buenfuncionamiento. Por ejemplo, los componentes de la capa de servicios son clases cuyonombre termina en "ervicey que se alojan en la carpeta grails-app@services:

class #ogin"ervice 6ersona do#ogin(userBameI userass)6

def p 7 ersona.find50serBameAndass&ord(userBameIuserass

)if(p)6

p.last#ogin 7 ne& :ate()p.save()

;;

;

Si queremos utilizar este servicio desde un Controlador, simplemente declaramos unavariable con el nombre login"ervicey Grails inyectar automticamente unainstancia del servicio:

class #oginController 6def login"ervice

def login 7 6def p 7 login"ervice.do#ogin(

params.nIparams.p)

if(p)6redirect(action1inde3)

Pgina 37 de 167


38/167



;

else6redirect(action1login4orm)

;;

;

El resultado de implementar la lgica de negocio en un servicio es que el controladornicamente tiene que decidir qu vista se muestra en funcin del resultado devueltopor el mtodo do#oginI con lo que nuestros componentes quedan sencillos y fcilesde leer y diagnosticar en caso de incidencias.

Inversin de Control (IoC)La inversin de control es otro patrn utilizado en Grails, segn el cual lasdependencias de un componente no deben gestionarse desde el propio componentepara que ste slo contenga la lgica necesaria para hacer su trabajo.

En el ejemplo anterior hemos visto cmo el Controlador defina una variable con elnombre del servicio que necesitaba emplear, pero no se ocupaba de instanciar elservicio ni de configurarlo de ningn modo antes de poder usarlo. En su lugar, Grailsutiliza el contenedor Spring para ese tipo de tareas.

Cuando creamos un componente en nuestra aplicacin, Grails configura Spring para

que gestione su ciclo de vida (cundo se crea, cuntas instancias se mantienen vivasa la vez, cmo se destruyen, etc.) y sus dependencias (qu otros componentesnecesita para realizar su trabajo y cmo conseguirlos).

El objetivo de esta tcnica es mantener nuestros componentes lo ms sencillos quesea posible, incluyendo nicamente cdigo que tenga relacin con la lgica denegocio, y dejar fuera todo el cdigo de fontanera. As, nuestra aplicacin ser msfcil de comprender y mantener.

Pgina 38 de 167


39/167



). Anatom#a de Grails* La l#nea decomandos

Grails no es un framework web al estilo de Struts, sino un entorno "full stack" que nosproporciona componentes para todas las capas de nuestra arquitectura, as comoherramientas de generacin de cdigo y de testing entre otras. Por eso incluye Gant(un envoltorio sobre Apache Ant escrito en Groovy) para coordinar el trabajo de todo elentorno.

Con Grails una gran parte del tiempo lo pasaremos en la consola, invocandocomandos desde la carpeta de nuestro proyecto. Estos comandos son los queutilizaremos para, por ejemplo, generar el esqueleto de nuestros artefactos, o ejecutartodas las pruebas unitarias y de integracin, o ejecutar la aplicacin en mododesarrollo.

Cada vez que ejecutemos el comando:

grails 8nombre del script9

Grails buscar un script de Gant con el nombre que hayamos introducido en lassiguientes ubicaciones:

USER_HOME/.grails/scripts

PROJECT_HOME/scripts

PROJECT_HOME/plugins/*/scripts

GRAILS_HOME/scripts

Si encuentra ms de un script con el nombre que hayamos escrito, nos dejar elegircual queremos ejecutar.

Veamos algunos de los comandos principales que podemos invocar sobre nuestro

Pgina 39 de 167


40/167



proyecto:

clean elimina todas las clases compiladas

compile realiza la compilacin de todos los fuentes Groovy y Java de nuestraaplicacin.

console lanza una consola Swing que podemos utilizar para ejecutar cdigo deforma interactiva sobre nuestro proyecto:

create-app nombre> crea el esqueleto de una nueva aplicacin.

create-controller nombre> crea el esqueleto para un controlador.

create-domain-class nombre>- crea una nueva clase de Entidad.

create-integration-test nombre>- crea el esqueleto para un caso deprueba de integracin.

create-plugin nombre>- crea el esqueleto para desarrollar un plugin.

create-script nombre>- Crea el esqueleto para un nuevo script Gant.

create-service nombre>- Crea el esqueleto para una nueva clase de la capade servicios.

create-tag-lib nombre>- Crea el esqueleto para una nueva librera de

Pgina 40 de 167


41/167



etiquetas.

create-unit-test nombre>- Crea el esqueleto para un caso de pruebasunitarias.

doc genera la documentacin javaDoc y GroovyDoc de nuestro proyecto.

generate-all entidad>- Lanza el scaffolding para la entidadcorrespondiente.

generate-controller entidad> - Genera el controlador CRUD para laentidad correspondiente.

generate-vie&s entidad>- Genera las vistas CRUD para la entidadcorrespondiente.

help Muestra la lista completa de comandos disponibles.

install-plugin nombre o ruta>- Instala un plugin en nuestro proyecto. Siproporcionamos un nombre en vez de una ruta, buscar el plugin en el repositoriooficial (ver http://grails.org/plugin/home).

install-templates Instala en nuestro proyecto las plantillas usadas porGrails para la generacin de artefactos. Una vez instaladas, Grails siempre usarnuestra copia local, de forma que podemos personalizar la generacin de cdigo.

list-plugins Muestra la lista de plugins disponible en el repositorio oficial.

run-app Ejecuta nuestra aplicacin en el contenedor Jetty includo con Grails. run-&ar Genera un archivo WAR de nuestra aplicacin y lo despliega en el

contenedor Jetty includo con Grails. A diferencia de run-app, en esta modalidad nose recargarn automticamente los archivos que modifiquemos.

schema-e3port Utiliza la herramienta SchemaExport de Hibernate para generarel cdigo DLL de nuestro esquema.

set-version numero> Modifica la versin actual de nuestro proyecto. Elnmero de versin se refleja entre otros sitios en el nombre del archivo WARgenerado cuando empaquetamos nuestra aplicacin.

shell Ejecuta una terminal Groovy que podemos usar para lanzar comandos deforma interactiva en nuestra aplicacin:

Pgina 41 de 167
http://www.manual-de-grails.es/http://www.manual-de-grails.es/http://grails.org/plugin/homehttp://grails.org/plugin/homehttp://www.manual-de-grails.es/


42/167



stats Muestra una estadstica sobre nuestro proyecto mostrando nmero dearchivos segn tipo y el total de lneas de cdigo:

test-app Ejecuta todos los casos de prueba definidos en nuestro proyecto,generando un informe con el resultado del proceso.

uninstall-plugin nombre> Elimina el plugin correspondiente de nuestraaplicacin.

upgrade actualiza nuestra aplicacin para adaptarla a una versin superior deGrails.

&ar genera el archivo WAR (Web Application aRchive) de nuestra aplicacin, quepodemos desplegar en cualquier servidor de aplicaciones JavaEE.

A lo largo de los siguientes captulos iremos mostrando con ms profundidad elfuncionamiento de la mayora de estos comandos, a medida que los utilicemos en losdistintos ejemplos. Para una lista completa y actualizada te recomiendo ladocumentacin oficial del proyecto: http://grails.org/Documentation

Pgina 42 de 167
http://www.manual-de-grails.es/http://grails.org/Documentationhttp://grails.org/Documentationhttp://www.manual-de-grails.es/


43/167



Personalizar la generacin de cdigoComo has visto, la mayora de los scripts de Grails sirven para generar cdigo de unau otra manera, ya sea creando artefactos o construyendo controladores y vistasmediante scaffolding para manipular nuestro modelo de datos.

El cdigo generado es til en la mayora de las situaciones, pero existen otras en lasque necesitamos tener ms control sobre el proceso. Como vimos en el primercaptulo, el objetivo de Grails es ser sencillo en la superficie, pero manteniendo laposibilidad de acceder a las profundidadessi necesitamos un comportamientoespecfico. Siguiendo esa filosofa se ha incluido el comando install-templates.

Si instalamos las plantillas en una aplicacin, Grails copiar los archivos que utiliza

para generar cdigo en la carpeta src@templatesde nuestro proyecto, incluyendo: src@templates@artifacts plantillas para generar los distintos tipos de

artefacto:

Controller.groovy

DomainClass.groovy

Filters.groovy

Script.groovy

Service.groovy

TagLib.groovy

Tests.groovy

WebTest.groovy

src@templates@scaffolding plantillas para el scaffolding de una clase delmodelo de datos:

Controller.groovy

create.gsp

edit.gsp

list.gsp

renderEditor.template (crea el campo del formulario HTML en funcin del tipode dato de cada propiedad)

show.gsp

src@templates@&ar plantilla para generar la aplicacin JavaEE

web.xml

En cada una de las plantillas vers que se utilizan variables para referirse en cada

caso al artefacto que se est generando as como otros datos relacionados. Porejemplo, la plantilla DomainClass.groovy tiene esta pinta:

Pgina 43 de 167


44/167



Jartifact.pacHageJ class Jartifact.nameJ 6

static constraints 7 6

;;

Lo importante a tener en cuenta es que una vez que hemos instalado las plantillas ennuestra aplicacin, Grails usar siempre la copia local para generar cdigo, de formaque podemos modificarlas para controlar el proceso de generacin alterando, porejemplo, el aspecto que tienen las vistas por defecto, o el editor utilizado para un tipode dato particular.

Pgina 44 de 167


45/167



+. Con,iguracinComo hemos visto, Grails es un entorno en el que se prima la convencin sobre laconfiguracin. Gracias a este principio, para definir, por ejemplo, los Controladores denuestra aplicacin, no necesitamos declararlos en ningn archivo XML o de ningntipo. En lugar de eso, cualquier clase que se llame [LoQueSea]Controller y est en lacarpeta grails-app@controllersser tratada como un controlador y estarasociado con un conjunto de URLs particular. Tampoco es necesario especificar quvista hay que mostrar para una accin particular, ya que Grails buscarautomticamente aquella que se llame igual que la accin y est en una carpeta con elmismo nombre que el controlador (ms sobre esto en el captulo 9)

A pesar de esto, en Grails s existen archivos de configuracin que podemosmanipular para modificar el comportamiento del entorno. Estos archivos se almacenanen la carpeta grails-app@conf, y a continuacin repasamos el contenido y elpropsito de los ms importantes.

Grails contempla el uso de entornos de ejecucin, de forma que podamos establecervalores de configuracin diferentes para desarrollo, pruebas y produccin.

El archivo Config.groovy

El archivo grails-app@[email protected] los parmetros deconfiguracin general de nuestra aplicacin. Se trata de un archivo de ConfigSlurper(http://groovy.codehaus.org/ConfigSlurper), lo cual permite la declaracin de variablesy el uso de tipos de datos en la configuracin. Cualquier parmetro que definamos eneste archivo estar disponible desde cualquier artefacto de la aplicacin a travs delobjeto global grailsApplication.config. Por ejemplo, si definimos la siguientevariable:

com.imagina&orHs.miarametro 7 dato

podremos acceder desde cualquier controlador, vista, servicio, etc a su valor mediantela expresin

grailsApplication.config.com.imagina&orHs.miarametro

Existe una serie de parmetros predefinidos que podemos utilizar para modificar elcomportamiento de Grails:

grails.config.locations Ubicaciones en las que queremos guardar otrosarchivos de configuracin para que se fundan con el principal.

grails.enable.nativeKascii Si el valor es true, Grails usar native2asciipara convertir los archivos properties a unicode (el compilador y otras utilidadesJava slo puede manejar archivos que contengan caracteres Latin-1 y/o Unicode).

grails.vie&s.default.codec El formato por defecto para nuestras GSPs.

Puede valer 'none' (por defecto),'html' o 'base64'.

Pgina 45 de 167
http://www.manual-de-grails.es/http://www.manual-de-grails.es/http://groovy.codehaus.org/ConfigSlurperhttp://groovy.codehaus.org/ConfigSlurperhttp://www.manual-de-grails.es/


46/167



grails.vie&s.gsp.encoding Codificacin por defecto de nuestros archivos

GSP (por defecto es 'utf-8'). grails.mime.file.e3tensions Habilita el uso de la extensin en la url para

fijar el content type de la respuesta (por ejemplo, si aadimos '.xml' al final decualquier url Grails fijar automticamente el content type a 'text/xml', ignorando lacabecera Accept del navegador).

grails.mime.tpes Un Map con los tipos mime soportados en nuestraaplicacin.

grails.server0# La parte "fija" de nuestros enlaces cuando queramos queGrails genere rutas absolutas.

grails.&ar.dest4ile Ruta en la que grails war debera generar el archivoWAR de nuestra aplicacin.

grails.&ar.dependencies Permite personalizar la lista de libreras a incluiren el archivo WAR.

grails.&ar.,ava=.dependencies Permite personalizar la lista de libreras aincluir en el archivo WAR para el JDK1.5 y superiores.

grails.&ar.cop2oLebApp Permite controlar qu archivos de la carpeta web-app de nuestro proyecto se deben copiar al archivo WAR.

grails.&ar.resources Permite personalizar el proceso de generacin del

WAR, especificando tareas previas en una closure mediante cdigo Ant builder.

Configuracin de log4jGrails emplea log4j para la generacin de trazas, y proporciona (a partir de la versin1.1) un DSL para configurar los umbrales y appenders. Por ejemplo:

import org.apache.logM,.NlogM, 7 6

root 6error()

;

appenders 6appender ne& olling4ileAppender(name1GarchivootadoGIma34ile"i/e1KMIfileBame1G@var@log@grails@tra/as.logG

);infoGorg.codehaus.groov.grails.&eb.servletGI

Gorg.codehaus.groov.grails.&eb.pagesG&arn Gorg.mortba.logG

;

Esta configuracin establece un umbral por defecto (root logger) de 'error', y de 'info'

Pgina 46 de 167


47/167



para los loggers de Controladores y GSPs, y de 'warn' para el de Jetty. Adems crea

un appender de tipo RollingFileAppender que proporciona rotado automtico dearchivos (ms informacin sobre log4j en http://logging.apache.org/log4j).

DataSource.groovy

Grails es Java, y por tanto la configuracin de acceso a datos recae en ltima instanciaen JDBC. El archivo :ata"ource.groovcontiene los parmetros de conexin conla base de datos que vayamos a utilizar en cada entorno:

data"ource 6 driverClassBame 7 Gcom.ms%l.,dbc.:riverG

pooled 7 true dbCreate 7 GupdateG;environments 6 development 6

url 7 ,dbc1ms%l1@@localhost1


48/167



-. El modelo de datos* GOR

El modelo de datos en una aplicacin Grails est compuesto por las clases delDominio (yo prefiero el trmino Entidades), que se ubican en la carpeta grails-app@domain. Grails utiliza GORM (Grails Object Relational Mapping), un gestor depersistencia escrito en Groovy, para controlar el ciclo de vida de las entidades yproporcionar una serie de mtodos dinmicos (se crean en tiempo de ejecucin paracada entidad) que facilitan enormemente las bsquedas.

GORM est construido sobre Hibernate, una herramienta de mapeo objeto-relacional,que se encarga de relacionar las entidades de tu clase con tablas de una base dedatos, y las propiedades de tus entidades con campos en las tablas. Cada operacinque realices sobre los objetos de tu modelo de datos ser traducida por Hibernate enlas sentencias SQL necesarias para quedar reflejado en la base de datos.

En Hibernate se maneja el concepto de sesin de usuario, que representa unaunidad de trabajo a realizar. Cuando se inicia una sesin se reserva un espacioespecfico de memoria para almacenar los objetos que se estn manipulando, y lasecuencia de instrucciones SQL que se deben ejecutar, y cuando termina la sesin selanzan todas las consultas contra la base de datos para hacer permanentes los datosrealizados.

Es importante que conozcas la forma de trabajar de Hibernate, pero no te preocupesms por l, porque Grails crea automticamente una sesin de Hibernate para cadapeticin atendida por nuestra aplicacin, y la cierra cuando la peticin ha terminado deatenderse, justo antes de enviar la respuesta al navegador. No es necesario manipularHibernate directamente.

Si no te gusta Hibernate o necesitas incluir tu aplicacin clases de entidad definidascon JPA puedes utilizar el soporte para esta tecnologa de persistencia mediante unplugin especfico. Tienes ms informacin en http://www.grails.org/JPA+Plugin

Crear entidades

Todas las clases groovy que se encuentren en la carpeta grails-app@domainserntratadas por GORM como entidades, por tanto podemos generarlas directamentecreando el archivo fuente correspondiente o mediante el comando:

grails create-domain-class 8nombre9

Utilizar el comando tiene la ventaja de que Grails generar el esqueleto para nuestraclase, que tendr ste aspecto:

class 8nombre9 6static constraints 7 6

;

Pgina 48 de 167
http://www.manual-de-grails.es/http://www.grails.org/JPA+Pluginhttp://www.grails.org/JPA+Pluginhttp://www.manual-de-grails.es/


49/167



;

Lo que tendremos que hacer a continuacin es definir las propiedades de la clase, yGORM se encargar del resto:

generar la tabla correspondiente en la base de datos con los campos necesariospara almacenar cada propiedad y

proporcionar los mtodos de bsqueda y modificacin que nos permitan manipularnuestra entidad.

Por ejemplo, si definimos una entidad como esta:

class 0suario 6

"tring nombre"tring apellidosOnteger edad:ate fechaBacimiento

;

GORM crear automticamente una tabla usuarioen la base de datos con loscampos correspondientes. Adems, aadir un campo ida nuestra clase (no tenemosque hacerlo nosotros) y se encargar de generar un valor nico secuencial para cadainstancia de esta clase. As, podremos recuperar un Usuario mediante:

def u 7 0suario.get(


50/167



"tring userBame

"tring userass"tring emailOnteger edad

static constraints 7 6nombre(blanH1falseIsi/e1=..=)apellidos(blanH1falseIsi/e1=..=)userBame(blanH1falseIsi/e1D..K)userass(blanH1falseIsi/e1D..K)email(email1true)edad(min1!)

;

;

Para aplicar las restricciones Grails utiliza Apache Commons Validator(http://commons.apache.org/validator). Las reglas que podemos definir son:

blanH tendremos que poner bank:false si el campo no admite cadenas de textovacas.

creditCard obliga a que un campo String contenga valores de nmero detarjeta de crdito vlidos.

email obliga a que un campo de texto tenga una direccin de correo electrnico

vlida. in#ist obliga a que el valor del campo est entre los de una lista cerrada. Por

ejemplo:

departamento(in#ist18G"istemasGIG:esarrolloG9)

matches obliga a que el valor del campo satisfaga una determinada expresinregular:

telefonoovil(matches1D8-?96!;)

ma3 garantiza que el valor de este campo no ser mayor que el lmite propuesto.

ma3"i/e obliga a que el valor tenga un tamao menor que el indicado.

min garantiza que el valor del campo no ser menor que el lmite propuesto. min"i/e obliga a que el valor tenga un tamao mayor que el indicado.

notE%ual El valor de la propiedad no podr ser igual al indicado.

nullable Por d

1) Manual Grails

Documents

Transcript of 1) Manual Grails