Desarrollo Web Con Grails 1.1.X

8/3/2019 Desarrollo Web Con Grails 1.1.X

1/208


2/208

Consigue la ltima versin de este manual enhttp://www.manual-de-grails.es

v1.1.0 16 de Diciembre de 2009

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


3/208



Pgina 3


4/208


5/208



LICENCIAManual de desarrollo web con Grails se distribuye bajo licenciaCreative 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 smbolo por claridad. No obstante, reconocemos todos los derechos legtimos de los propietarios de las marcas yno 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.

Copyright 2009 Nacho Brito

ISBN: 978-84-613-2651

Pgina 5
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/208



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 deaplicaciones, 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 sitio groovy.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
http://www.manual-de-grails.es/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/208



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.Cuando en 2006 comenz a probar las primerasversiones de Grails, enseguida reconoci elenorme impacto que una herramienta as podratener en la productividad de los equipos dedesarrollo Java. Incorpor la tecnologa al abanicode herramientas de ImaginaWorks y 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 Rocher y GillaumeLaforge. Tambin es responsable de otros

proyectos relacionados con Groovy, como el sitio web AllAboutGroovy.com.

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.En 2009 Nacho cofunda el proyecto Escuela de Groovy, una compaa dedicadaexclusivamente a prestar servicios de formacin, asesoramiento y desarrollo aempresas interesadas en adoptar Groovy y Grails como plataforma para desarrollo deaplicaciones JavaEE.Puedes contactar con Nacho en la [email protected]

Pgina 7
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.allaboutgroovy.com/http://www.allaboutgroovy.com/http://www.imaginaworks.com/http://www.imaginaworks.com/http://www.escueladegroovy.com/http://www.escueladegroovy.com/http://www.escueladegroovy.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.escueladegroovy.com/http://www.allaboutgroovy.com/http://www.manual-de-grails.es/


8/208



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 conGraeme Rocher a la cabeza.Pero si me dejasen ms tiempo para pensar mi respuesta, incluira ademsGuillaumeLafforge y 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, pormi 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.

PD. Esta segunda edicin del Manual existe gracias a todos los que creyeron quemereca la pena invertir su dinero en la versin 1.0. De no haber sido por el xito deaquella no hubiera tenido sentido seguir con la 1.1. Mi agradecimiento tambin paratodos aquellos pioneros :-)

Pgina 8


9/208



Pgina 9


10/208



Pgina 10


11/208



ndice de Contenidos

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

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

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

Agradecimientos.............................................................................................................. 8

1. Introduccin......................................................................................................................... 19

La bsqueda.................................................................................................................. 20

La solucin..................................................................................................................... 20

El libro............................................................................................................................ 21

2. Cmo usar este manual...................................................................................................... 24

Requisitos previos......................................................................................................... 26

3. Gua rpida......................................................................................................................... 28

Convencin mejor que configuracin........................................................................ 29

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

Instalar Grails................................................................................................................. 30

Estructura de una aplicacin Grails............................................................................... 30

Definicin del Modelo de Datos..................................................................................... 33

Scaffolding..................................................................................................................... 36

Cundo usar el Scaffolding.................................................................................. 39

Configuracin de acceso a datos.................................................................................. 40

Controladores................................................................................................................ 40

Vistas: Groovy Server Pages......................................................................................... 41

Pgina 11


12/208



Helpers para AJAX.................................................................................................... 42

Custom tags.............................................................................................................. 42

Servicios........................................................................................................................ 43

Desplegar nuestra aplicacin........................................................................................ 43

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

Metodologas................................................................................................................. 45

El patrn Model View Controller.................................................................................... 45Inversin de Control (IoC).............................................................................................. 47

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

Personalizar la generacin de cdigo............................................................................ 52

6. Configuracin...................................................................................................................... 54

El archivo Config.groovy................................................................................................ 55

Configuracin de log4j.............................................................................................. 56

Configuracin de GORM........................................................................................... 57

El archivo DataSource.groovy....................................................................................... 57

El archivo BuildConfig.groovy........................................................................................ 58

Configuracin de depencencias................................................................................ 59

7. El modelo de datos: GORM................................................................................................ 61Crear entidades............................................................................................................. 62

Validaciones.............................................................................................................. 63

Sobre los mensajes de error................................................................................ 65

Cmo mapear asociaciones...................................................................................... 66

Relaciones Uno-A-Uno......................................................................................... 66

Relaciones Tiene-Un............................................................................................ 67

Pgina 12


13/208



Relaciones Uno-A-Muchos................................................................................... 67

Relaciones Muchos-a-Muchos............................................................................. 69

Como mapear composiciones....................................................................................... 69

Cmo mapear herencia................................................................................................. 70

Utilizar esquemas de datos heredados......................................................................... 71

Operaciones sobre el modelo de datos......................................................................... 73

Actualizaciones......................................................................................................... 73Bloqueos de datos................................................................................................ 74

Consultas.................................................................................................................. 74

Dynamic Finders................................................................................................... 75

Criteria.................................................................................................................. 77

Named Queries.................................................................................................... 77

Hibernate HQL...................................................................................................... 78

Conceptos avanzados de GORM.................................................................................. 78

Eventos de persistencia............................................................................................ 78

Poltica de cach....................................................................................................... 79

Sobre las cachs de objetos................................................................................ 79

Configurando Hibernate....................................................................................... 80Definir la poltica de cach en cada clase............................................................ 81

Usar las cachs fuera de GORM......................................................................... 81

8. Controladores...................................................................................................................... 83

mbitos.......................................................................................................................... 86

El mtodo render, a fondo............................................................................................. 87

Encadenar acciones...................................................................................................... 89

Pgina 13


14/208



Interceptors.................................................................................................................... 90

Procesar datos de entrada............................................................................................ 91

Data Binding.............................................................................................................. 91

Recibir ficheros......................................................................................................... 92

Evitar el doble post.................................................................................................... 94

Objetos Command.................................................................................................... 95

9. Servicios.............................................................................................................................. 97Por qu deberan importarte los servicios..................................................................... 98

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

Poltica de creacin de instancias........................................................................... 100

Mtodos transaccionales........................................................................................ 101

10. Vistas: Groovy Server Pages.......................................................................................... 103

Etiquetas GSP............................................................................................................. 105

Etiquetas para manejo de variables........................................................................ 105

Etiquetas lgicas y de iteracin............................................................................... 106

Etiquetas para filtrar colecciones............................................................................ 106

Etiquetas para enlazar pginas y recursos............................................................. 107

Etiquetas para formularios...................................................................................... 107Etiquetas para AJAX............................................................................................... 108

Eventos Javascript............................................................................................. 109

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

Usar las etiquetas como mtodos........................................................................... 112

Crear TagLibs.............................................................................................................. 112

Utilizar libreras de etiquetas JSP................................................................................ 113

Pgina 14


15/208



Layouts: Sitemesh....................................................................................................... 114

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

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

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

Capturar cdigos de error............................................................................................ 120

Capturar mtodos HTTP.............................................................................................. 121

Patrones de URLs con nombre............................................................................... 12112. Web Flows...................................................................................................................... 123

13. Filtros.............................................................................................................................. 127

Ejemplo: filtro XSS....................................................................................................... 129

14. Bateras de pruebas........................................................................................................ 131

Tests unitarios............................................................................................................. 137

Los mtodos mock.................................................................................................. 139

Tests de integracin.................................................................................................... 140

Tests funcionales......................................................................................................... 144

15. Internacionalizacin........................................................................................................ 147

Cmo maneja Grails la i18n........................................................................................ 148

Cmo mostrar mensajes en el idioma correcto........................................................... 151Generar scaffolding internacionalizado....................................................................... 152

16. Seguridad........................................................................................................................ 155

Tipos de ataques......................................................................................................... 156

Inyeccin de SQL.................................................................................................... 156

Denegacin de servicio........................................................................................... 157

Inyeccin de HTML/Javascript................................................................................ 158

Pgina 15


16/208



Codecs......................................................................................................................... 159

17. Desarrollo de Plugins...................................................................................................... 160

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

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

Distribuir el plugin.................................................................................................... 166

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

Tu segundo plugin: aadir mtodos dinmicos a las clases de la aplicacin.............16818. Servicios web con Grails: SOAP vs REST .................................................................... 171

Usando SOAP............................................................................................................. 172

Usando XFire.......................................................................................................... 172

Usando REST.............................................................................................................. 173

Clientes REST para pruebas.................................................................................. 174

Usando Poster.................................................................................................... 175

Usando rest-client............................................................................................... 187

Implementando el servicio...................................................................................... 188

Procesar peticiones POST................................................................................. 188

Procesar peticiones GET.................................................................................... 190

Procesar peticiones PUT.................................................................................... 191Procesar peticiones DELETE............................................................................. 192

Servicios REST compatibles con JAX-RS.............................................................. 193

19. Entornos de desarrollo.................................................................................................... 196

Entornos Integrados.................................................................................................... 200

Netbeans (Gratuito)................................................................................................. 200

SpringSource Tool Suite (Basado en eclipse, Gratuito).........................................204

Pgina 16


17/208



IntelliJIDEA (205).................................................................................................. 209

Editores de Texto......................................................................................................... 210

UltraEdit (49,95).................................................................................................... 210

TextMate (48,75)................................................................................................... 211

E Text Editor (34,95)............................................................................................. 211

APNDICE A. Introduccin a Groovy .................................................................................. 213

El papel de Groovy en el ecosistema Java.................................................................. 214Descripcin rpida del lenguaje................................................................................... 214

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

Declaracin de clases............................................................................................. 216

Scripts..................................................................................................................... 216

GroovyBeans.......................................................................................................... 217

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

Listas, mapas y rangos........................................................................................... 218

Closures.................................................................................................................. 219

Estructuras de control............................................................................................. 220

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

Ejemplos de la vida real:.............................................................................................. 221Trabajar con XML.................................................................................................... 221

Trabajar con SQL.................................................................................................... 222

Trabajar con Ficheros............................................................................................. 223

Servicios web.......................................................................................................... 224

ImaginaWorks, miembro fundador de Escuela de Groovy...................................................226

Control de versiones............................................................................................................. 227

Pgina 17


18/208



Pgina 18


19/208



1. Introduccin

Pgina 19


20/208



Hola, bienvenido a manual de desarrollo web con Grails .El objetivo de este libro es presentarte los conceptos fundamentales que seencuentran detrs de esta plataforma para desarrollo de aplicaciones web con Groovyy Java, y darte algunas ideas sobre la mejor forma de aplicarlos.

La bsquedaNuestra 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 y mantener XML.Entonces se empezaba a hablar con fuerza de frameworks comoRuby on Rails oDjango, de las ventajas de usar Convention over Configuration (emplear convencionespara definir el tipo y las caractersticas de los artefactos, en lugar de hacerlo enarchivos de configuracin) y de las virtudes de loslenguajes dinmicos para crearaplicaciones con menos cdigo de fontanera.Los lenguajes dinmicos, entre otras cosas, evitan la necesidad de especificar el tipode dato de una variable en el momento de declararla en el cdigo fuente, sino que el

entorno de ejecucin es capaz de determinarloen tiempo de ejecucin a partir de losdatos 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? y

Quartz? y Compass/Lucene? e iText? y JPA/JDO? y JasperReports? y JUnit?Eran demasiadas herramientas a las que tenamos que renunciar para adoptar estosnuevos entornos, 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 solucinHabamos aprendido el valor de los lenguajes dinmicos, y sabamos que habaalgunos que podan usarse en la mquina virtual, como Ruby (Jruby), JavaScript

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

Pgina 20
http://www.manual-de-grails.es/http://www.manual-de-grails.es/http://groovy.codehaus.org/http://groovy.codehaus.org/http://www.manual-de-grails.es/


21/208



Lo que ms nos atrajo del lenguaje es que podamos empezar a escribir clases Groovy

como 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 (Groovyes Java), 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 desarrolloweb que se parece mucho a Rails por fuera (incluso en el nombre, que originalmenteera Groovy on Rails y tuvo que ser cambiado a peticin de la gente de RoR), pero quepor dentro est construido sobre una base slida formada por proyectos comoSpring

container , Hibernate, SiteMesh, Log4J y un largo etctera formado por plugins quepermiten incorporar 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 frameworks

asociados podan ofrecer en el espacio de las aplicaciones web. Grails se propona hacer lo siguiente:

Integrarse estrechamente con la plataforma Java.

Ser sencillo en la superficie, pero mantener la flexibilidad para acceder a los potentes 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 enorme ventaja inicial. El objetivo de Groovy era crear un lenguaje con que permitiese a programadores Java una fcil transicin al mundo de los lenguajes de script con tipado dinmico, proporcionando funcionalidades imposibles de implementar con lenguajes 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 forma

completamentetransparente 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 libroDesde entonces, en ImaginaWorks hemos trabajado con Groovy y Grailsprofundizando en las ideas que proponen y divulgando sus ventajas (fundamos elportalhttp://groovy.org.es) .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 por

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


22/208



plataformas 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 unlibro digital por dos razones: La primera,para no tener intermediarios . Al editar nosotros mismos el libro (bajo

la marca Ediciones giles) podemos elegir cundo lo publicamos, cmo y porcunto lo vendemos, y sobre todo, podemos publicar nuevas revisiones a cuandosea necesario para corregir erratas, adaptar el contenido a nuevas versiones deGrails o aadir captulos nuevos.

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 unlpiz 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 2009ImaginaWorks Software Factory

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


23/208



Pgina 23


24/208



2. Cmo usar este manual

Pgina 24


25/208



El 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 que puedes (y teanimo a hacerlo) compartir tus experiencias, comentarios, dudas y correcciones sobre

el 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 3 es 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 4 presenta 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 5 hace un recorrido por todos los scripts que forman parte de Grails, y quepodemos lanzar desde la lnea de comandos (o utilizando el IDE que prefieras, con elplugin correspondiente) paraactivar 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 10 recorren 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 11 te ensea todo lo necesario para definir el esquema de URLs de tuaplicacin, si no ests satisfecho con el usado por defecto.El captulo 12 describe el uso de Web Flows , una tcnica que permite definirconversaciones que se extienden ms all de una peticin HTTP, al estilo de losasistentes en las aplicaciones de escritorio.El captulo 13 introduce el concepto de Filtro, que puedes usar para implementar

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


26/208



cuestiones transversales de tu aplicacin, como la seguridad o la monitorizacin.

El captulo 14 te 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 15 explica cmo funciona la internacionalizacin de aplicaciones conGrails.El captulo 16 habla sobre seguridad, en trminos generales de web, y especficos deGrails.El captulo 17 te introduce en el desarrollo de plugins, y te explica los beneficios dedesarrollar aplicaciones modulares.El captulo 18 abarca todo lo relacionado con servicios web y Grails, y realiza unacomparacin entre los paradigmas ms utilizados hoy en da: REST y SOAP.El captulo 19 realiza un breve repaso por el soporte para Grails en los editores detexto y entornos de desarrollo ms populares.Al final del texto encontrars unapndice sobre Groovy que 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 previosAunque 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.2,x/ 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.

Pgina 26
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/


27/208



Pgina 27


28/208



3. Gua rpida.

Pgina 28


29/208



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

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

Spring para los flujos de trabajo e inyeccin de dependencias. Hibernate para la persistencia. SiteMesh para la composicin de la vista. Ant para la gestin del proceso de desarrollo.

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

Convencin mejor que configuracin

Aunque 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 debedefinirse una nica vez, hacindose visible a todos los dems de forma automtica.

Pgina 29

SiteMesh Spring Hibernate

AntJUnitlog4jJEE

GORM GSP

Plugins framework:Quartz, Acegi,Compass, Flex, ...

LibrerasJavaScript:Dojo, Prototype,YUI, ...

Grails

Groovy

Java


30/208



Instalar GrailsPara empezar a trabajar tenemos que instalar el entorno. Lo primero ser descargarGrails desde la web del proyecto:http://www.grails.org/Downloaddescomprimimos 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 GrailsGrails 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 unaaplicacin Grails nos colocamos en la carpeta donde deseemos tener el proyecto, yescribimos:

$ grails create-app testCuando 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+ i18n ---> message bundles+ services ---> Servicios+ taglib ---> Libreras de etiquetas

+ utils ---> Clases de utilidad+ views ---> Vistas

+ layouts ---> Layouts SiteMesh+ lib+ scripts+ src

+ groovy ---> Otras clases Groovy+ java ---> Otras clases Java

+ test ---> Casos de prueba+ web-app ---> Raz de mi aplicacin web.

Las carpetas donde pasaremos la mayor parte del tiempo songrails-app , quecontiene todos los artefactos que el entorno ir generando y que tendremos quemodificar para adaptar su funcionamiento a nuestra aplicacin, yweb-app, que

Pgina 30
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/


31/208



contiene la estructura de nuestra aplicacin web. En particular,web-app/css contiene

la/s hoja/s de estilo yweb-app/images el contenido grfico.Si trabajas con Netbeans, ten en cuenta que el IDE te mostrar distintas vistas de tuproyecto. En la pestaa Files vers la estructura real de la aplicacin, mientras queen la pestaa Projects vers los artefactos agrupados por familias lgicas:

Si ejecutamos el comandograils run-app podremos ver el aspecto de nuestraaplicacin (bastante vaco de momento):

Definicin del Modelo de DatosVamos 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 estiloJavaAlmanac .Empezamos por definir nuestro modelo: el sitio tratar con trucos publicados por los

Pgina 31


32/208



usuarios. Tambin ser posible publicar comentarios a un truco, as como valorar su

calidad 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:

Usuarionombre:Textofecha:Fechaemail:Textoperfil:Texto

Trucoautor:Usuariocomentarios:Listadenunciado:Booleantexto:Textotitulo:Textofecha:Fecha

Comentarioautor:Textotexto:Textofecha:Fecha

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

$ grails create-app GroovyAlmanacEntramos 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 Usuario {static hasMany = [trucos:Truco]String nombre

String emailDate fechaAlta }

grails-app/domain/Comentario.groovy:class Comentario {

static belongsTo = TrucoString autorString textoDate fecha

}grails-app/domain/Truco.groovy:

class Truco {

Pgina 32


33/208



static hasMany = [comentarios:Comentario]

static belongsTo = Usuario

List comentariosDate fechaString tituloString textoboolean denunciado

}Aparte de que no necesitamos definir getters ni setters (porque nuestras clases sonGroovyBeans, tienes ms informacin sobre esto en elAPNDICE A), estas entidadestienen otra particularidad: Comentario define una variable estticabelongsTo queindica la parte "N" de una relacin 1:N entre Truco y Comentario, mientras que estaltima define una propiedad esttica de nombrehasMany que representa el lado "1"(un Map, con cadenas de texto como claves y clases como valores). Con ellasestamos indicando a grails debe mapear esta relacin a la base de datos.Como ves hemos definido la propiedadcomentarios explcitamente, mientras queen Comentario no hay ninguna propiedadtruco . En realidad podramos haberomitidocomentarios , 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 mediantela palabra reservada constraints:class Usuario {

static hasMany = [trucos:Truco]String nombreDate fechaAltaString email

static constraints = {nombre(size:3..50)email(email:true)

}}

class Comentario {static belongsTo = TrucoString autorString textoDate fecha

static constraints = {autor(size:3..50)texto(maxSize:999999)

}}

Pgina 33


34/208



class Truco {static hasMany = [comentarios:Comentario]static belongsTo = Usuario

List comentariosDate fechaString tituloString textoboolean denunciado

static constraints = {titulo(size:10..1000)

texto(maxSize:999999)}}

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.

ScaffoldingUna 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 denominascaffolding , y generacontroladores y vistas a partir de un modelo de datos. Alejecutar este comando, Grails generar para cada entidad

las acciones list, show, edit, delete, create, save y update , alas que podremos acceder desde urls como estas:/[Aplicacin]/[Entidad]/[Accin ]

por ejemplo:http://localhost:8080/GroovyAlmanac/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 34

CRUDes un acrnimo para lasoperaciones bsicas deCreacin, Lectura (Read),Actualizacin (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/


35/208



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

Pgina 35


36/208



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, podemos

usarlo 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 a

generar los artefactos, puesto que se perderan nuestros cambios. Si la aplicacin no se parece a lo generado mediante scaffolding, an puede

resultar til como consola de administracin obackend , 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 datosComo seguro que habrs notado, no le hemos dicho a Grails dnde debe guardar losdatos, y sin embargo la aplicacin funciona correctamente.Grails incorporaHSQLDB(http://www.hsqldb.org), una base de datos empotradaescrita ntegramente en Java, para que podamos empezar a trabajar sin tener quecontar con un servidor. Sin embargo, en la mayora de los casos tendremos una basede datos y querremos usarla. Para ello editamos el siguiente archivo:

grails-app/conf/DataSource.groovydataSource {

pooled = truedbCreate = "update"driverClassName = "com.mysql.jdbc.Driver"username = "dataUser"password = "dataPass"

}environments {

production {dataSource {

url = "jdbc:mysql://servidor:3306/liveDb"}

}

test {dataSource {

Pgina 36
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/


37/208



url = "jdbc:mysql://servidor:3306/testDb"

}}development {

dataSource {url = "jdbc:mysql://servidor:3306/devDb"

}}

}Como ves, Grails permite tener entornos distintos (desarrollo, pruebas, produccin)configurados, de forma que por ejemplo:grails war - genera un war de mi aplicacin configurada para el entorno de desarrollo.

grails prod war - genera el war configurado para produccin.

ControladoresLos controladores son los responsables de recibir las solicitudes del usuario, aplicar lalgica de negocio sobre el modelo, y decidir la vista que se debe mostrar acontinuacin. Hemos visto que Grails puede generar controladores para gestionar elciclo de vida de nuestras entidades, pero lgicamente nosotros podemos generarcontroladores mediante el comandocreate-controller:

grails create-controller prueba

Al ejecutar el comando, Grails generar una clase en grails-app/controllers:grails-app/controllers/PruebaController.groovy:

class PruebaController {def accion = {

render "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 PagesLa 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.

Pgina 37


38/208



Por ejemplo:grails-app/views/otro/vista.gsp

...

Hoy es: ${new Date()}

Lo que tengo que decir es:${miVariable}

Para invocar esta vista desde un controlador usaramos el mtodo render:grails-app/controllers/OtroController.gsp

class OtroController {def mivista = {

render(view:'vista')}

}

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:

$('mydiv').onclick =

firstsecond

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 Groovy

Pgina 38


39/208



con el nombre XXXTagLib.groovy que se aloja en la carpeta grails-app/taglib. Por

ejemplo:grails-app/taglib/SimpleTagLib.groovy:

class SimpleTagLib{def mitag = {attrs, body ->

out


40/208



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

grails prod war

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 40


41/208



4. Lo que debes saber antes de empezar

Pgina 41


42/208



A estas alturas ya deberas tener una impresin de conjunto sobre Grails, y la forma

de 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.

MetodologasGrails es un entorno para desarrollo de aplicaciones web sobre la plataforma JavaEnterprise Edition nacido en un contexto muy particular: el de las metodologas gilesde desarrollo de software.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 completamenteuna etapa antes de comenzar la siguiente. Hay muchas metodologas giles, perotodas tienen en comn una clara orientacin agestionar 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 desarrollo

ms all de la reunin de arranque del proyecto.De esta manera, metodologas comoeXtreme Programming o Scrum incluyen 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 tambinsean giles, y aqu es donde nacen frameworks comoRuby on Rails, y en el mbitode Java, lenguajes como Groovy y frameworks comoGrails. 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 la

mayora del cdigo de infraestructura se genera de forma dinmica mientras laaplicacin se est ejecutando.

El patrn Model View ControllerRespecto al diseo, Grails sigue un patrn muy popular sobre todo en el desarrollo deaplicaciones web, denominado Model-View-Controller, o Modelo-Vista-Controlador.Este patrn establece que los componentes de un sistema de software debeorganizarse en 3 capas distintas segn su misin: Modelo, o capa de datos . Contiene los componentes que representan y gestionan

los datos manejados por la aplicacin. En el caso ms tpico, los objetos

Pgina 42


43/208



encargados de leer y escribir en la base de datos. Vista, o capa de presentacin . Los componentes de esta capa son responsables

de 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 la lgica 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 cuarta

capa: Capa de servicios . Contiene los componentes encargados de implementar la

lgica 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 enService y que se alojan en la carpetagrails-app/services :

class LoginService {Persona doLogin(userName, userPass){

def p = Persona.findByUserNameAndPassword(userName,userPass

)if(p){

p.lastLogin = new Date()p.save()

}}

}

Si queremos utilizar este servicio desde un Controlador, simplemente declaramos unavariable con el nombreloginService y Grails inyectar automticamente unainstancia del servicio:

class LoginController {def loginService

def login = {def p = loginService.doLogin(

params.n,params.p)

if(p){redirect(action:index)

}else{

redirect(action:loginForm)}

Pgina 43


44/208



}

}

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 mtododoLogin, 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 paraque 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 44


45/208



5. Anatoma de Grails: La lnea decomandos

Pgina 45


46/208



Grails no es un framework web al estilo de Struts, sino un entorno "full stack" que nos

proporciona componentes para todas las capas de nuestra arquitectura, as comoherramientas de generacin de cdigo y de testing entre otras. Por eso incluyeGant(un envoltorio sobreApache 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 [nombre del script]

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/scriptsSi 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 nuestroproyecto: clean elimina todas las clases compiladas compile realiza la compilacin de todos los fuentes Groovy y Java de nuestra

aplicacin. console lanza una consola Swing que podemos utilizar para ejecutar cdigo de

forma interactiva sobre nuestro proyecto:

Pgina 46
http://www.manual-de-grails.es/http://www.manual-de-grails.es/http://groovy.codehaus.org/Ganthttp://ant.apache.org/http://ant.apache.org/http://groovy.codehaus.org/Ganthttp://ant.apache.org/http://www.manual-de-grails.es/


47/208



create-app crea el esqueleto de una nueva aplicacin. create-controller crea el esqueleto para un controlador. create-domain-class - crea una nueva clase de Entidad. create-integration-test - crea el esqueleto para un caso de

prueba de integracin. create-plugin - crea el esqueleto para desarrollar un plugin. create-script - Crea el esqueleto para un nuevo script Gant. create-service - Crea el esqueleto para una nueva clase de la capa

de servicios. create-tag-lib - Crea el esqueleto para una nueva librera de

etiquetas. create-unit-test - Crea el esqueleto para un caso de pruebas

unitarias. doc genera la documentacin javaDoc y GroovyDoc de nuestro proyecto. generate-all - Lanza el scaffolding para la entidad

correspondiente.

Pgina 47


48/208



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

generate-views - Genera las vistas CRUD para la entidadcorrespondiente.

help Muestra la lista completa de comandos disponibles. install-plugin - Instala un plugin en nuestro proyecto. Si

proporcionamos 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 usar

nuestra copia local, de forma que podemos personalizar la generacin de cdigo. install-dependency (desde Grails 1.2) descarga una librera a la cach local,

por ejemplo:grails install-dependency mysql:mysql-connector-java:5.1.5

list-plugins Muestra la lista de plugins disponible en el repositorio oficial. run-app Ejecuta nuestra aplicacin en el contenedor Tomcat includo con Grails. run-war Genera un archivo WAR de nuestra aplicacin y lo despliega en el

contenedor Tomcat includo con Grails. A diferencia de run-app, en esta modalidadno se recargarn automticamente los archivos que modifiquemos.

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

set-version 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 48
http://www.manual-de-grails.es/http://www.manual-de-grails.es/http://grails.org/plugin/homehttp://grails.org/plugin/homehttp://grails.org/plugin/homehttp://www.manual-de-grails.es/


49/208



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 Elimina el plugin correspondiente de nuestraaplicacin.

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

war 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

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 deacceder a las profundidades si necesitamos un comportamientoespecfico. Siguiendo esa filosofa se ha incluido el comandoinstall-templates .Si instalamos las plantillas en una aplicacin, Grails copiar los archivos que utiliza

para generar cdigo en la carpetasrc/templates de nuestro proyecto, incluyendo:

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


50/208



src/templates/artifacts plantillas para generar los distintos tipos deartefacto:

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 tipo

de dato de cada propiedad) show.gsp

src/templates/war plantilla para generar la aplicacin JavaEE web.xml

En cada una de las plantillas vers que se utilizan variables para referirse en cadacaso al artefacto que se est generando as como otros datos relacionados. Porejemplo, la plantilla DomainClass.groovy tiene esta pinta:

@artifact.package@ class @artifact.name@ {

static constraints = {

}}

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 50


51/208



6. Configuracin

Pgina 51


52/208



Como hemos visto, Grails es un entorno en el que se prima la convencin sobre la

configuracin. 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/controllers ser 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 el

propsito 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.groovyEl archivograils-app/conf/Config.groovy contiene los parmetros deconfiguracin general de nuestra aplicacin. Se trata de un archivo deConfigSlurper(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 en

este archivo estar disponible desde cualquier artefacto de la aplicacin a travs delobjeto globalgrailsApplication.config . Por ejemplo, si definimos la siguientevariable:

com.imaginaworks.miParametro = "dato"podremos acceder desde cualquier controlador, vista, servicio, etc a su valor mediantela expresin

grailsApplication.config.com.imaginaworks.miParametro

Existe una serie de parmetros predefinidos que podemos utilizar para modificar elcomportamiento de Grails: grails.config.locations Ubicaciones en las que queremos guardar otros

archivos de configuracin para que se fundan con el principal. grails.enable.native2ascii Si el valor es true, Grails usar native2ascii

para convertir los archivos properties a unicode (el compilador y otras utilidadesJava slo puede manejar archivos que contengan caracteres Latin-1 y/o Unicode).

grails.views.default.codec El formato por defecto para nuestras GSPs.Puede valer 'none' (por defecto),'html' o 'base64'.

grails.views.gsp.encoding Codificacin por defecto de nuestros archivosGSP (por defecto es 'utf-8').

grails.mime.file.extensions Habilita el uso de la extensin en la url para

Pgina 52
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/


53/208



fijar el content type de la respuesta (por ejemplo, si aadimos '.xml' al final de

cualquier url Grails fijar automticamente el content type a 'text/xml', ignorando lacabecera Accept del navegador). grails.mime.types Un Map con los tipos mime soportados en nuestra

aplicacin. grails.serverURL La parte "fija" de nuestros enlaces cuando queramos que

Grails genere rutas absolutas. grails.war.destFile Ruta en la que grails war debera generar el archivo

WAR de nuestra aplicacin. grails.war.dependencies Permite personalizar la lista de libreras a incluir

en el archivo WAR. grails.war.java5.dependencies Permite personalizar la lista de libreras a

incluir en el archivo WAR para el JDK1.5 y superiores. grails.war.copyToWebApp Permite controlar qu archivos de la carpeta web-

app de nuestro proyecto se deben copiar al archivo WAR. grails.war.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 incluir en Config.groovy la configuracin de umbrales y appenders.Por ejemplo:

import org.apache.log4j.*log4j = {

root {error()

}appenders {

appender new RollingFileAppender(name:'archivoRotado',

maxFileSize:1024,fileName:'/var/log/grails/trazas.log')

}info'org.codehaus.groovy.grails.web.servlet',

'org.codehaus.groovy.grails.web.pages'warn 'org.mortbay.log'

}

Esta configuracin establece un umbral por defecto (root logger) de 'error', y de 'info'para los loggers de Controladores y GSPs, y de 'warn' para el de Jetty. Adems creaun appender de tipo RollingFileAppender que proporciona rotado automtico dearchivos (ms informacin sobre log4j enhttp://logging.apache.org/log4j).

Pgina 53
http://www.manual-de-grails.es/http://www.manual-de-grails.es/http://logging.apache.org/log4jhttp://logging.apache.org/log4jhttp://www.manual-de-grails.es/


54/208



Configuracin de GORMComo veremos en el captulo 7, GORM es el gestor de persistencia de Grails. Seencarga de mantener el estado de nuestras entidades en la base de datos. A

Desarrollo Web Con Grails 1.1.X

Documents

Transcript of Desarrollo Web Con Grails 1.1.X