Grails Grails ofrece las siguientes ventajas -

Una manera facil de utilizar ORM en Hibernate Una tecnologa expresiva llamada Groovy Server Pages (GSP) Un control de capas basado en Spring Un ambiente de script construido en Groovy-powered
Un contenedlo tomcat embebido el cual es configurado para recargar al aire (no debes de deployar) Injeccion de dependencias con el contenedlo de Spring

Todo esto es hecho fcilmente a travez de un lenguaje poderosos llamado Groovy y un extensivo uso de Domain Spacific Language (DSL). Insalacion El primer paso de empezar con Grails es intalar la distribucin. Para hacer esto sigue los siguientes pasos: - Descargar la version binaria en la siguiente pagina http://grails.org/Download - Colocar la variable de ambiente GRAILS_HOME con la locacion donde descomprimiste el zip anterior - Ya saves como meter la variable de ambiente MiPC(Clic derecho)Seleccionas variables de ambienteAvanzados - Ahora tu necesitas agregar el directorio bin a tu variable path Si todo trabaja correctamente podras escribir grails en una Terminal de Windows Valores de retorno Tag y Body Los Tags ya no regresan instancias de java.lang.String en lugar de eso ocupan StreamCharBuffer. La clase StreamCharBuffer implementa los mismo metodos de String. Creando una aplicacin Para crear una aplicacin primero necesita familizarse con el uso de de los comandos de grails; los cuales se usan de la siguiente manera
grails [command name] En el siguiente caso el comando que tu necesitas ejecutar es create-app, como se muestra en el siguiente ejemplo: grails create-app helloworld Esto creara un nuevo directorio dentro del actual. Ahora tu puedes navegar sobre este directorio desde una Terminal: cd helloworld

Hello World Example Para implementar un tipico ejemplo de hello word corre el comando create-controller
grails create-controller hello

Esto creara un nuevo controller (Un controller maneja las peticiones y crear o prepara la respuesta y su scope de request), en el directorio grails-

app/controllers llamdo HelloController.groovy. Los controller son capaces de manejar las peticiones request y realizar el hello Word, nuestra implementacion necesita verse como se muestra a continuacin:
class HelloController { def world = { render "Hello World!" } } El trabajo esta hecho. Ahora necesitamos iniciar el container con otro comando llamado run-app. grails run-app Esto iniciara el servidor en el puerto 8080 y ahora podemos acceder a la aplicacin con la URL:

http://localhost:8080/helloworld
Instalando en un IDE Eclipse: Se recomienda que se utilise la suite SpringSource Tool(http://www.springsource.com/downloads/sts?sid=662621) Suite, el cual ofrece soporte en la construccion para Grails incluyendo el manejo automatico del classpath; un editor GSP y aceso a comandos de grails

Estructura A continuacin se muestra el desglose y los links de las secciones relevantes:

Corriendo una aplicacin Las aplicaciones en Grails pueden correr en el built de tomcat usando el comando run-app grails run-app

Probando la aplicacin El comando create-*

Deployando una aplicacin La aplicacin grail es deplorada como un Web Application Archives (WAR files), grails puede correr en los siguientes servidores: Tomcat 5.5 Tomcat 6.0 SpringSource tc Server SpringSource dm Server 1.0 GlassFish v1 (Sun AS 9.0) GlassFish v2 (Sun AS 9.1) GlassFish v3 Prelude Sun App Server 8.2 Websphere 6.1 Websphere 5.1 Resin 3.2 Oracle AS JBoss 4.2 Jetty 6.1 Jetty 5 Weblogic 7/8/9/10
Crear clases domain Una clase domain es un artefacto de persistencia y todas las propiedades son por default persistidas Mi configuracin Bajas el siguiente archivo springsource-tool-suite-2.3.3.M2-e3.6-win32installer.exe (STS), el cual es un ejecutable que te instala eclipse con parte del ambiente. Desgarga y descomprime el grails, aqu descargue el grais 1.3.4 Colocar la variable de ambiente GRAILS_HOME con la locacion donde descomprimiste el zip anterior - Ya saves como meter la variable de ambiente MiPC(Clic derecho)Seleccionas variables de ambienteAvanzados Ahora tu necesitas agregar el directorio bin a tu variable path Tambien debes poner la variable JAVA_HOME que apunte a tu jdk como se ve a continuacin: C:\Archivos de programa\Java\jdk1.6.0_21 Si todo trabaja correctamente podras escribir grails en una Terminal(DOS) de Windows y te aparecera la siguiente imagen

Te va a hacer un men en Windows

Lo abres y realizas los siguientes pasos:

Abres el DashBoard, con el siguiente boton: superior del eclipse.

que se encuentra en la parte

En la parte inferior del dashboard hay un tab de extensin lo presionas y te saldra la siguiente pantalla Insalas lo siguiente:

Seleccionas el checkbox y presionas install Ahora debemos instalar el Grails lo bajas de la siguiente pagina http://www.grails.org/Download el que diga Binary ZIP Creas un proyecto

La primera vez que lo instales te va a decir que no tienes una configuracin de Grails instalada, presionas el link de Configure Grails Installations y agrega la ruta del Grail que bajaste Te va a generar un main:

El STS tiene un servidor interno entonces solo le tienes que dar clic derecho al archivo

LIBRO BEGINNING GROOVY AND GRAILS

Las clases java y groovy son muy compatibles al punto que para que un archivo java funcione como groovy solo debes de cambiarle la extencion. Para correr una aplicacin en groovy desde linea de comandos se hace con la siguiente sentencia: groovy com\apress\bgg\Todo.groovy

Si tu bienes de java, estaras sorprendido que tu no necesitas primero compilar el codigo. Aqu esta el equivalente en java > javac com\apress\bgg\Todo.java > java com.apress.bgg.Todo Esto es por que groovy compila el bytecode en tiempo de ejecucin Pag 33 Groovy tambien maneja sus pojos, pero el los maneja como pogo que son GroovyBean, Veaamos los ejemplos de pojos: Java 01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 package com.apress.bgg; import java.util.List; import java.util.ArrayList; import java.util.Iterator; public class Todo { private String name; private String note; public Todo() {} public Todo(String name, String note) { this.name = name; this.note = note; } public String getName() { return name; } public void setName(String name) { this.name = name; } public String getNote() { return note; } public void setNote(String note) { this.note = note; } public static void main(String[] args) { List todos = new ArrayList(); todos.add(new Todo("1", "one")); todos.add(new Todo("2", "two")); todos.add(new Todo("3","three"));

39 40 41 42 43 44 45

for(Iterator iter = todos.iterator();iter.hasNext();) { Todo todo = (Todo)iter.next(); System.out.println(todo.getName() + " " + todo.getNote()); } } }

Ahora el de Groovy 01 package com.apress.bgg; 02 03 import java.util.List; 04 import java.util.ArrayList; 05 import java.util.Iterator; 06 07 public class Todo { 08 09 String name; 10 String note; 11 12 public static void main(String[] args) { 13 List todos = new ArrayList(); 14 todos.add(new Todo(name:"1", note:"one")); 15 todos.add(new Todo(name:"2", note:"two")); 16 todos.add(new Todo(name:"3", note:"three")); 17 18 for(Iterator iter = todos.iterator();iter.hasNext();) { 19 Todo todo = (Todo)iter.next(); 20 System.out.println(todo.name + " " + todo.note); 21 } 22 } 23 } Como veras el codigo de groovy es mucho mas sencillo, debido a que groovy tiene el concepto de propiedades nativas, lo que significa que los setter y setter no deben de ser declarados. Por default, todos los atributos de las clases como nombre y notas son propiedades publicas y automticamente generan los correspondientes getters y setters en bytecode. Estas propiedades tienen un modelo mucho mas intuitivo. Ellos pueden ser usados directamente, como se muestra en la linea 20. Otros interesantes avances que tiene groovy para simplificar el codigo es incluir implcitamente el import de los paquetes java.util.*; java.lang.*, java.net.*, java.io.*, groovy.lang.*, y groovy.util.*., y mas flexibles cadenas Como vera a continuacin nosotros podemos poner opcionalmente los parntesis, pero no es el unico cambio, el metodo println a sido modificado para usuar el formato de Groovys

GString, para concatenar 2 Strings

println "${todo.name} ${todo.note}" Tambien como vera a continuacin ya no es definida como tipo lista def todos = new ArrayList() Usando la notacion de colecciones de Groovy

Listing 1-4. Example with the Groovy Collection Notation and Closure
01 package com.apress.bgg; 02 03 public class Todo {

04 05 String name 06 String note 07 08 public static void main(String[] args) { 09 def todos = [ 10 new Todo(name:"1", note:"one"), 11 new Todo(name:"2", note:"two"), 12 new Todo(name:"3", note:"three") 13 ] 14 15 todos.each { 16 println "${it.name} ${it.note}" 17 } 18 } Note como el ArrayList es remplazado con [ ] y para simplificar la iteracin solo ocupamos todos.each, note que la variable de iteracin es it. En grails podemos remover el metodo main como se muestra a continuacin: package com.apress.bgg; public class Todo { String name String note } def todos = [ new Todo(name:"1", note:"one"), new Todo(name:"2", note:"two"), new Todo(name:"3", note:"three") ] todos.each { println PAg 39 Capitulo 2 Tu puedes usar el lenguaje Groovy para contruir: objetos domain,controller y services, pero esta no es la unica forma de usar Groovy, tu puedes usar Groovy como un lenguaje de script

Listing 2-1. A Simple Groovy Script,Hello.groovy

println "Hello ${args[0]}, may Groovy be with you." La version de java seria la siguiente: package com.apress.beginninggrails.cli.scripts; public class HelloJava { public static void main(String[] args) { System.out.println( "Hello "+ args[0], may Java be with you.); } } Los Scripts de Groovy pueden organizarse dentro de bloques de codigo reusables es decir en funciones

Listing 2-3. A Script Function, PrintFullName.groovy

def printFullName(firstName, lastName) { println "${firstName} ${lastName}" } printFullName('Luke', 'SkyWalker') printFullName('Darth', 'Vader') Cadenas

En groovy las cadenas se pueden definir en 3 diferentes maneras

Listing 2-12. Groovy String Definition

01 02 03 04 05 06 07 08 09 10 11 // Quote def helloChris = "Hello, Chris" println helloChris.class.name // java.lang.String // Single quote def helloJoseph = 'Hello, Joseph' println helloJoseph.class.name // java.lang.String // Slashy string def helloJim = /Hello, Jim/ println helloJim.class.name // java.lang.String

Groovy tambien soporta GString es como una cadena normal

Listing 2-13. GString and Embedded Expressions

01 02 03 04 05 06 07 08 09 10 11 12 def name = "Jim" def helloName = "Hello, ${name}" println helloName // Hello, Jim println helloName.class.name // org.codehaus.groovy.runtime.GStringImpl def helloNoName = 'Hello, ${name}' println helloNoName // Hello, ${name} println helloNoName.class.name // java.lang.String def helloSlashyName = /Hello, ${name}/ println helloSlashyName // Hello, Jim println helloSlashyName.class.name // org.codehaus.groovy.runtime.GStringImpl

La salida es la siguiente:

Hello, Jim org.codehaus.groovy.runtime.GStringImpl Hello, ${name} java.lang.String Hello Jim org.codehaus.groovy.runtime.GStringImpl

La linea 4 imprimimos el nombre de la clase para probar que es un GString La linea 6 definimos una cadena con comillas simples, el resultado en la linea 8 es una cadena de Java y la expresin no es evaluada. Con la linea 10 a 12 pasa o mismo que de la 1 a la 4 La evaluacion de la exprecion dentro de un String se le denomina interpolacion Interpolacion La interpolacion de cadenas es la habilidad de substituir una expresin o variable dentro de un String , como se vio en el ejemplo anterior Multiples lineas Se puede manejar varias lineas en la cadena como usando tres comillas dobles para abrir y otras para cerrar Cadenas con diagonales La cadena con diagonales, puede manejar mejor las cadenas de escape, como se muestra a continuacin:

def winpathQuoted='C:\\windows\\system32' def winpathSlashy=/C:\windows\system32/ println winpathSlashy // C:\windows\system32 Como ve en el caso de las comillas simples se requiere poner doble diagonal invertida y en el de las diagonales no. Metodos y Closures Tu puedes definir bloques de codigo reusables en 2 maneras: como metodos como lo haces en java y como closures, veamos los metodos comparandolos con java:

Methods
Listing 2-17 illustrates defining a method in Groovy the Java way . Listing 2-17. Defining aMethod the Java Way
public String hello(String name) { return "Hello, " + name; }

Listing 2-18 illustrates defining the method using the Groovy idiom. Listing 2-18. Defining aMethod Using the Groovy Idiom
def hello(name) { "Hello, ${name}" } El tipo de retorno y la sentencia de retorno no se incluye en el cuerpo de los metodos. Groovy solo regresa el resultado de la ultima expresin En este caso, el GString Hello, El modificador de acceso no es definido. Por default a menos que lo especifiques de otro modo, Groovy pone por default el acceso a a publico en todas las clases, propiedades, y metodos. Closures Un closure es un bloque de codigo reusable dentro de llaves { }, los cuales pueden ser asignados a una vairable o pasado como parmetro a un metodo. El codigo dentro de las llaves es ejecutado el closure es invocado. La diferencia entre metodos y closures es que closures son objetos y los metodos no. El siguiente ejemplo muestra la invocacin de closure y la definicin def name = "Chris" def printClosure = { println "Hello, ${name}" } printClosure() name = "Joseph" printClosure() ///////////////////////////Salida

Hello, Chris Hello, Joseph

Y como los metodos se pueden pasar parmetros a los metodos, veamos el siguiente ejemplo: def printClosure = {name -> println "Hello, ${name}" } printClosure("Chris") printClosure("Joseph")

printClosure "Jim" La salida seria la siguiente:

Hello, Chris Hello, Joseph Hello, Jim Ahora veamos un ejemplo con muchos parmetros:
def printClosure = {name1, name2, name3 -> println "Hello, ${name1}, ${name2}, ${name3}" } printClosure "Chris", "Joseph", "and Jim" La salida es la siguiente:

Hello, Chris, Joseph, and Jim Veamos otro ejemplo

01 def startTimer() { 02 def initialDate = new java.util.Date() 03 return { println "${initialDate} - ${new java.util.Date()} : Elapsed time ${System.currentTimeMillis() - initialDate.time}" } 04 } 05 06 def timer = startTimer() 07 // Simulate some work Como se ve el metodo startTimer() devuelve un closure Un closure se puede pasar como parmetro, como se muestra a continuacin: def list = ["Chris", "Joseph", "Jim"] def sayHello = { println it } list.each(sayHello) Collections Groovy soporta diferentes tipos de colecciones incluyendo list,ranges,set,arrays y map List Veamos unos ejemplos: 01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 17 def emptyList = [] println emptyList.class.name // java.util.ArrayList println emptyList.size // 0 def list = ["Chris"] // List with one item in it // Add items to the list list.add "Joseph" // Notice the optional () missing list << "Jim" // Notice the overloaded left-shift operator println list.size // 3 // Iterate over the list list.each { println it } // Chris Joseph Jim // Access items in the list println list[1] // Joseph // Indexed access list[0] = "Christopher" println list.get(0) // Christopher

18 19 20 21 22 23 24 25 26 27 28 29

list.set(0, "Chris") // Set the 0 item to Chris println list.get(0) // Chris list.remove 2 list-= "Joseph" // Overloaded - operator list.each { println it } // Chris list.add "Joseph" list+="Jim" // Overloaded + operator list.each { println it } // Chris Joseph Jim println list[-1] // Jim

Ranges Un range es una lista de valores sequenciales. Lgicamente puedes pensar en el como 1 hacia 10 o de la a hacia z. De hecho la declaracion es exactamente esa 1..10 o a..z Un range es una lista de cualquier objeto que implementa java.lang.Comparable. Los objetos tienen los metodos next() y previous() para facilitar la navegacin. Veamos un ejemplo: 01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 17 18 def numRange = 0..9 println numRange.size() // 10 numRange.each {print it} // 0123456789 println "" println numRange.contains(5) // true def alphaRange = 'a'..'z' println alphaRange.size() // 26 println alphaRange[1] // b def exclusiveRange = 1..<10 println exclusiveRange.size() // 9 exclusiveRange.each {print it} // 123456789 println "" println exclusiveRange.contains(10) // false def reverseRange = 9..0 reverseRange.each {print it} // 9876543210

Set En groovy los son elementos que no se duplican como en java. De hecho es una implementacion de java.util.Set. Por default, al menos que tu lo especifiques, un set de Groovy es un java.util.HashSet. Si tu necesitas setear de otro tipo simplemente debes hacer los siguiente: def aTreeSet = new TreeSet(). Veamo unos usos comunes: 01 def emptySet = [] as Set 02 println emptySet.class.name // java.util.HashSet 03 println emptySet.size() // 0 04 05 def list = ["Chris", "Chris" ] 06 def set = ["Chris", "Chris" ] as Set 07 println "List Size: ${list.size()} Set Size: ${set.size()}" // List Size: 2 Set Size: 1 08 set.add "Joseph" 09 set << "Jim" 10 println set.size() // 3 11 println set // ["Chris", "Jim", "Joseph"] 12 13 // Iterate over the set 14 set.each { println it } 15 S 16 set.remove 2

17 18 19 20 21 22 23 24 25 26 27

set-= "Joseph" // Overloaded - operator set.each { println it } // Chris set+= "Joseph" set+= "Jim" set.each { println it } // Chris Joseph Jim // Convert a set to a list List = set as List println list.class.name // java.util.ArrayList println set.asList().class.name // java.util.ArrayList println set.toList().class.name // java.util.ArrayList

Crear un set vacio es similar a crear una lista vacia. La diferencia es la adicion de la clausula as Set Arrays Los arrays de Groovy tiene ciertas limitaciones igual que los arrays de java, pero con grooby hace el trabajo un poco mas sencillo como se mostrara a continuacin: 01 02 03 04 05 06 07 08 09 10 def stringArray = new String[3] println stringArray.size() stringArray[0] = "Chris" println stringArray // {"Chris", null, null} stringArray[1] = "Joseph" stringArray[2] = "Jim" println stringArray // {"Chris", "Joseph", "Jim"} println stringArray[1] // Joseph stringArray.each { println it} // Chris, Joseph, Jim println stringArray[-1..-3] // ["Jim", "Joseph", "Chris"]

Maps Los mapas en groovy es una implementacion de java.util.Map .Pero por default, a menos que tu establescas lo contrario, los map en groovy son java.util.LinkedHashMap. Si requieres otro tipo de map, se debera hacer como se muestra a continuacin: def aTreeMap = new TreeMap(). En general lo deberas usar como usas un map normal, como se muestra en el siguiente ejemplo: 01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 def emptyMap = [:] // map.class returns null, use getClass() println emptyMap.getClass().name //java.util.LinkedHashMap println emptyMap.size() // 0 def todos = ['a':'Write the map section', 'b':'Write the set section'] println todos.size() // 2 println todos["a"] // Write the map section println todos."a" // Write the map section println todos.a // Write the map section println todos.getAt("b") // Write the set section println todos.get("b") // Write the set section println todos.get("c", "unknown") // unknown, Notice "c" wasn't defined // and now it is println todos // ["a":"Write the map section", "b":"Write the set section", // "c":"unknown"] todos.d = "Write the ranges section" println todos.d // Write the ranges section todos.put('e', 'Write the strings section') println todos.e // Write the strings section todos.putAt 'f', 'Write the closure section' // Notice () are optional println todos.f // Write the closure section todos[null] = 'Nothing Set' // Using null as a key println todos[null] // Nothing set

27 28 29 30 31 32 33 34

// Print each key/value pair on a separate line // Note: it is an implicit iterator todos.each { println "Key: ${it.key}, Value: ${it.value}" } // Print each key/value pair on a separate line with index todos.eachWithIndex { it, i -> println "${i} Key: ${it.key}, Value: ${it.value}" } // Print the value set todos.values().each { println it }

PAg 61 En la linea 1, creamos un mapa vacio. Una lista vacia es creada usando el valor [ ] , un mapa [:]. La linea 6 ilustra un mapa con varias entradas, la linea 6 es [ key1:value1,key2:value2] Expresiones regulare Ya las conoces te pongo una tabla de los que usa groovy: Table 2-1. Summary of Regular-Expression Constructs Construct Matches Characters x The character x \\ The backslash character \t The tab character (\u0009) \n The newline (line feed) character (\u000A) \r The carriage-return character (\u000D) \f The form-feed character (\u000C) \e The escape character (\u001B) Character Classes [abc] a, b, or c (simple class) [^abc] Any character except a, b, or c (negation) [a-zA-Z] a through z or A through Z, inclusive (range) [a-d[m-p]] a through d, or m through p: [a-dm-p] (union) [a-z&&[def]] d, e, or f (intersection) [a-z&&[^bc]] a through z, except for b and c: [ad-z] (subtraction) [a-z&&[^m-p]] a through z, and not m through p: [a-lq-z] (subtraction) Predefined Character Classes . Any character (may or may not match line terminators) \d A digit: [09] \D A nondigit: [^09] \s A whitespace character: [\t\n\x0B\f\r] \S A non-whitespace character: [^\s] \w A word character: [a-zA-Z_0-9] \W A nonword character: [^\w] Boundary Matchers ^ The beginning of a line $ The end of a line \b A word boundary \B A nonword boundary \A The beginning of the input \G The end of the previous match \Z The end of the input but for the final terminator, if any \z The end of the input Greedy Quantifiers X? X, once or not at all X* X, zero or more times X+ X, one or more times X{n} X, exactly n times X{n,} X, at least n times X{n,m} X, at least n but not more than m times Reluctant Quantifiers X?? X, once or not at all X*? X, zero or more times

X+? X, one or more times X{n}? X, exactly n times X{n,}? X, at least n times X{n,m}? X, at least n but not more than m times Possessive Quantifiers X?+ X, once or not at all X*+ X, zero or more times X++ X, one or more times X{n}+ X, exactly n times X{n,}+ X, at least n times X{n,m}+ X, at least n but not more than m times Logical Operators XY X followed by Y X|Y Either X or Y (X) X, as a capturing group Si quiere conocer mas de expresiones regulares revisa la pagina 64 CAPITULO 3 (MORE ADVANCE GROOVY) Capitulo pendiente CAPITULO 4 (INTRODUCCION A GRAILS) Grails no solo es un framework de web open source, tambien es una plataforma de desarrollo, Grails es un framework MVC. Grails controller tienen scope de request, que significa que una instancia es creada por cada request. La vista por default de Grails son los Groovy Server Page (GSP) y tipicamente rendereado en HTML Grails es tambien una plataforma de desarrollo, incluyendo un contenedlo web,base de datos y testeador Grails evita los archivos de configuracin. Las clases domain de grails son automticamente persistentes. Como otros frameworks MVC, grails controla las peticiones y orquesta los servicios y otros comportamientos. Otras ventajas de grails incluyen minimas configuraciones y mas ageles procesos de deploy. Grails es una completa plataforma de desarrollo, incluye un contenedor web,base de datos, sistemas de construccion Grails contiene las siguientes ventajas: ORM Grails contiene su propio ORM llamado GORM, pero que aparta GORM de otros ORM es el hecho de que esta contruido en Groovy PlugIn Grails no se propone ser la respuesta para todos los problemas de desarrollo. En lugar de eso provee una arquitectura de plug-in y una comunidad donde tu puedes encontrar pllugin para seguridad,Ajax,testing,bsqueda, reporteo y webservice Pag 94 Hibernate Hibernate provee los fundamentos para GORM Ajax Grails incluye 3 populares frameworks de ajax por default en cada aplicacin web: script.aculo.us,6 Rico,7 and Prototype . Algunas de los tags de grails integran el comportamiento Ajax

HSQLDB Grails invluye una base de datos 100% java llamada HSQLDB. Tu puedes usar esta base como una base de datos normal o como una base de datos embebida. Por default Grails usa el embebido, entonces cada vez que corres la aplicacin, la base de datos es reconstruida y los datos perdidos. JUnit Grails usa Junit Arquitectura de Grails

Encima de los lenguajes tu encuentras los frameworks de grails, que como tu viste anteriormente, esta hecho con varios de los proyectos open source de la industria, como Spring,SiteMesh y GORM/Hibernate, por mencionar algunos, sin embargo Grails no se limita a esto. Tus aplicaciones pueden usar casi cualquier librera java Pag 97 Veamos el siguiente diagrama de Grails en tiempo de ejecucin:

En la figura 4-2 tu ves el broswer haciendo una peticin al contenedor web jetty (el cual al parecer esta integrado en Grails), el contenedor web renvia la peticin hacia el controller, de la misma forma que lo hace el patron de diseo MVC, el controller setea o usa los datos de las clases domain(model). Como lo mencionamos anteriormente, todos las clases domain grails son persistentes a traves del framework GROM. Tu no necesitas usar el patron DAO o escribir SQL para persisitir. Grails ocupa usa una base de datos embebida (HSQLDB), lo cual significa que la base de datos corre en la misma maquina virtual que tu aplicacin y en el contenedor web jetty. Cuando el controlador a terminado, manda la peticin hacia el GSP, la cual es una tecnologa de vista que senderea un HTML el cual lo devuelve al browser. Generar Projecto con GRails Puedes generar proyectos en Grail por linea de comandos, como se muestra a continuacin: grails create-app collab-todo Para ver el detalle ver pagina 103:

CONSTRULLENDO LA INTERFAZ DE USUARIOS PAG 134 Vamos algunos componentes de la vista enfocados al frame, este es un ejemplo de una aplicacion:

Como la gran mayoria de las tecnologas de vista. Grails utiliza plantillas para ensamblar la vista. Una plantilla es un pequeo fragmento que reside en el directorio grails-app/views y empieza con _ . El _ en grails lo utiliza para saber que ese GSP es una plantilla. Tu puedes poner plantillas que son mas genericas y compartirlas a travez de la vista en lugares comunes como grails-app/views/common. A continuacin mencionaremos los archivos de configuracin estandar de Grails: Pag 107 BootStrap.groovy: Maneja la configuracin del ciclo de vida para inicializar y destruir la aplicacin

Config.groovy: Toma todas los archivos de configuracin, como el loggin, Multipurpose Internet Mail Extensions (MIME) y otras configuraciones. DataSource.groovy: Maneja las configuraciones JDBC o JNDI UrlMappings.groovy: Archivos de mapeo URL persaonalizables Implementando una clase Domain Vamos a implementar una clase Domain con el siguiente E.R:

Ahora veamos la clase Domain: 1 class Todo { 2 3 String name 4 String note 5 Date createdDate 6 Date dueDate 7 Date completedDate 8 String priority 9 String status 10 11 static constraints = { 12 name(blank:false) 13 createdDate() 14 priority() 15 status() 16 note(maxSize:1000, nullable:true) 17 completedDate(nullable:true) 18 dueDate(nullable:true) 19 } 20 21 String toString() { 22 name 23 } 24 }

Como ves se encuentran las propiedades requeridas para la clase TODO. Pero existen otras propiedades que tu no vez que son implicitas para Grails. Estas incluyen las propiedades id y versin. La propiedad id, como tu esperas representa un identificador unico autoincrmentable y es null hasta que el objeto es salvado inicialmente. La propiedad versin es el mecanismo de Hibernate. Cada vez que un objeto es salvado, su numero de versin es incrementado y como el id es inicializado en nulo. Antes que Hibernate salve cualquier objeto, primero checa el numero de versin en la base de datos, y si la versin no machea Significa que ha sido modificado desde la ultima vez que se leyo- Hibernate lanzara una org.hibernate.StaleObjectStateException. Las lineas 11-19 demuestra la contruccion del constrain, como ve la linea 12 establece que el name no debe ser null. En cambio note,completedDate, y dueDate pueden ser nulos. En adicion el constrain dicta el orden de los campos en la pagina de edicion asi como en los tipos de campos del formulario de HTML son senderados. El orden de los constrain representan el orden de los campos de la pagina. Mientras un String es usualmente representado como un campo input en HTML con type text, una propiedad String con un maxSize es usualemente sendereado como un textarea, para soportar la cantidad de caracteres. Las clases Domain pueden tener comportamiento implementados como metodos. Por defautl el comportamiento de toString() en las clases domain imprime el nombre de la clase, seguido de un punto y el id del objeto Para hacer tu primera aplicacin ve el manual desde la pagina 103, tips: Crea el projecto con STS un grails Project Las clases las puedes hacer a mano o meter los comandos en el sts de la siguiente forma

Te aparecera la siguiente pantalla: El termino Scaffolding , es que tu solo creas tu domaim (Clase de entidad) y tu controller (Clase de logica) con una propiedad apuntando al domain y te crea automticamente la vista, veamos un ejemplo:

Clase Domain:

package mifirstgrails class Todo { Date completedDate String priority String status String name String note Date createdDate Date dueDate String prueba;

static constraints = { name(blank:false) createdDate() priority() status() note(maxSize:1000, nullable:true) completedDate(nullable:true) dueDate(nullable:true) prueba(); } String toString() { name } } Cheque el bloque constraints, es donde vas a poner los constrains de tus campos, por ejemplo blank:false indica que este campo no puede estar vacio. El campo note le pusimos un contrain de maxSize, este te transforma en la vista una caja de texto Clase Controller package mifirstgrails class TodoController { def scaffold = Todo } Ya con esto te crea la vista, vea la variable debe ser declarada como: scaffold para que grails la pueda transformar,las pantallas creadas son las siguientes:

y al presionar New Todo

CHAPTER 5 BUILDING THE USER INTERFACE El guion bajo en Grails es una convencion que significa que ese GSP es una plantilla (template) Footer Para agregar una plantilla a tu layout, se debe ocupar la siguiente etiqueta:

<g:render template="/common/footer" />

Veamos un ejemplo con un footer: Primero hacemos el footer con la convencion del guin bajo (_footer.gsp), como se muestra a continuacin:

<span class="copyright">&copy; Copyright del rorro<br /> Rodrigo Davalos </span>

Despus lo incluimos e nuestro main.gsp:

<html> <head> <title><g:layoutTitle default="Grails" /></title> <link rel="stylesheet" href="$ {resource(dir:'css',file:'main.css')}" /> <link rel="shortcut icon" href="$ {resource(dir:'images',file:'favicon.ico')}" type="image/x-icon" /> <g:layoutHead />

<g:javascript library="application" /> </head> <body> <div id="spinner" class="spinner" style="display:none;"> <img src="${resource(dir:'images',file:'spinner.gif')}" alt="${message(code:'spinner.alt',default:'Loading...')}" /> </div> <div id="grailsLogo"><a href="http://grails.org"><img src="$ {resource(dir:'images',file:'grails_logo.png')}" alt="Grails" border="0" /></a></div> <g:layoutBody /> <g:render template="/common/footer" /> </body> </html>
La salida seria la siguiente:

Pero se ve medio feo vamos a ponerle unas hojas de estilo. Tu necesitas agregar un tag <div> con el atributo id como footer, ademas necesitas agregar el estilo footer en el main.css, primero veamos agregar la etiqueta div en el main .gsp:

<g:layoutBody /> <div id="footer"> <g:render template="/common/footer" /> </div> </body> </html>
Ahora hacemos la clase para darle estilo en el main css:

#footer { clear:both; text-align: center; padding: 3px; border-top: 1px solid #333; color: red; }

La salida sera la siguiente:

En la vista de grails del STS,los archivos se verias como se muestra a continuacin:

TopBar Para el topbar se hace el mismo proceso, veamos el _topbar.gsp:

<div id="menu"> <nobr> <g:if test="${session.user}"> <b>${session.user?.firstName}&nbsp;${session.user?.lastName}</b> | <g:link controller="user" action="logout">Logout</g:link> </g:if> <g:else> <g:link controller="user" action="login">Login</g:link> </g:else> </nobr> </div>
Note las etiquetas de grails g:if, g:else; g:link, en el main seria : <div id="topbar"> <g:render template="/common/topbar" />

</div> y crear la clase css En general se ocupa el div para meter el ordenamiento de los componentes, ponemos despus del body un div con id page como se muestra acontinuacion:

<body> <div id="page">

y su css:

#page { width: 778px; margin: 0px auto; padding: 4px 0; text-align:left; }

Ademas con hojas de estilo podemos agregar imgenes como se muestra a continuacin:

#header { width: 778px; background: #FFFFFF url(../images/MiDibujo.JPG) repeat-x; height: 70px; margin: 0px auto; } Ademas le decimos que las repita en el eje de las x, ya en el main.gsp se maneja como siempre: <div id="header"> <h1>Mi grails</h1> </div> La salida seria como se muestra a continuacin:

Grails siempre busca el index.gsp,para usar las plantillas dentro de este archivo se pone lo siguiente: <meta name="layout" content="main" /> el cual main es el main.gsp Ahora veamos como le hace grails para iterar la lista de los controles: <body> <div class="dialog" style="margin-left:20px;width:60%;">

<ul> <g:each var="c" in="${grailsApplication.controllerClasses}"> <li class="controller"> <a href="${c.logicalPropertyName}"> ${c.fullName} </a> </li> </g:each> </ul> </div> </body> De esta forma se usa la etiqueta g:each, y asi Grails obtiene todos los controlers y los itera, para que quede como se muestra a continuacin:

mifirstgrails.TodoController es la unica aplicacin en escalafon que tengo, por tal motivo es la unica que te pinta. Tags de Grails Los tags de grails son similares a JSTL y a Struts. Es decir tiene tags para todas las condiciones logicas para senderear y plantillas. Tags logicos:

PAG 146 Tags de iteracin:

Variables de asignacin: Tu ocupas estas etiquetas para crear y asignar valores a una variable

Linking tags Son ocupadas para usar URLS

Tags Ajax

Tags Form

Tags UI Estos tags se ocupan para mejorar la interface. El unico oficial de Grails es el rich text editor, pero bastantes UI tags son contruidos por la comunidad como plug ins. A continuacin se muestra un brevario de estas etiquetas:

Tag render y layout Estas etiquetas son usadas para crear plantillas y senderearlas

Tags de validacin Estas tag son usadas para desplegar errores y mensajes. A continuacin un resumen:

Flujo Basico Grails A continuacin voy a mostrar un flujo basico que yo hice: Primero puse un link: <g:link controller="cosas" action="doThing">MiFlujo4</g:link> Ahora cree un controller llamado : CosasController despues cree un closure (como metodo en grails visto anteriormente) llamado doThing, como se muestra a continuacin: class CosasController { def doThing = { println("Dentro del doThing ahora"); System.out.println("Dentro del doThing"); } }

Grails lo maneja de la siguiente forma empesemos con el g:link , el atributo controller es el que te indica a que controlador va a ir, se poner solamente el sufijo (sin el controller) es decir solamente cosas, el atributo action manda llamar al closure (doThing). Ahora del lado del Controller cuando termine por default Grails busca un .gsp que tengal el mismo nombre del closure(doThing), en la carpeta con nombre de la clase (cosas), como se muestra a continuacin:

Ya en el .gsp puedes poner solo un texto como se muestra a continuacin: <html> <body> Mi verdadero primer grails </body> </html>

Externar Strings Grail soporta el concepto de mensajes bundle. Utiliza el tag de <g:message> para buscar un archivo de propiedades para el texto que va a ser desplegado. Grails tambien utiliza este metodo para desplegar errores. Para esto utiliza el archivo messages.properties localizazdo en el directorio grails-app/i18n, veamos un ejemplo de messages.properties:

Ahora vamos hacer un ejemplo: En nuestro gsp de _topbar.gsp, ponemos lo siguiente:

<g:link controller="user" action="login"> <g:message code="topbar.login" /> </g:link> ahora en nuestro messages.properties, agregamos la propiedad: topbar.login=Login desde properties Este archivo se encuentra en la siguiente ruta en la vista de Grails de nuestro STS:

Uso de varios proporties, para usar varios properties se debe primero crear tu propertie(recuerda que grails por default utiliza el messages.properties):

Ya creado el archivo messages_mio.propertie, pones un mensaje: topbar.login=Login desde properties mio Ahora se modifica un archivo de configuracin en tu vista de grails abre el siguiente archivo(resources.groovy):

lo modificas como s muestra a continuacin: // Place your Spring DSL code here beans = { messageSource(org.springframework.context.support.ReloadableResourceBu ndleMessageSource) { basenames = ["classpath:grails-app/i18n/messages_mio", "classpath:grails-app/i18n/messages"] } } Como se ve creamos una lista en el atributo basenames, con los nombres de los properties y su ruta. ERRORES Y VALIDACIONES PAG 169 Creamos la vista y los controller por medio de comandos (Vea seccion de comandos) y por medio del domain Al hacer el controller por medio de comandos nos crea un closure save, como se muestra a continuacin: def save = { println("Entrando al save"); def userInstance = new User(params) 04 if (userInstance.save(flush: true)) { flash.message = "${message(code: 'default.created.message', args: [message(code: 'user.label', default: 'User'), userInstance.id])}" redirect(action: "show", id: userInstance.id) } else { println("Entrando al else"); render(view: "create", model: [userInstance: userInstance]) } } Cuando grails ejecuta la linea 04 valida los contrains de User(Domain) antes de intentar persistir el usuario en la base de datos Componentes: g:select: <g:select name='userName' from="${mifirstgrails.User.list()}" optionKey="userName" optionValue="userName"> </g:select>

El componente g:select es un componente que nos transforma a un combo de seleccion:

Atributos: from: Con este atributo le dices de donde va a obtener los valores para iterar en este caso de un domain(user) y utilizamos el metodo list para iterar los objeto. Nota: Se debe poner el paquete donde se encuentra el domain name: Con el name le decimos que propiedad del domain vamos a ocupar optionKey e optionValue: Con estos atributos le indicas que va a pintar en el combo y que valor va tener cuando lo envies. Pongo el domain user: package mifirstgrails class User { String userName String firstName String lastName static hasMany = [todos: Todo, categories: Category] static constraints = { userName(blank:false,unique:true) firstName(blank:false) lastName(blank:false) } String toString () { "$lastName, $firstName" } } Comandos Tu puedes usar el scalafon para poder crear tus vistas pero tambien las puedes crear fisicamente con el siguiente comando:
Grails generate-views mifirstgrails.User

Este comando es utilizado para hacer plantillas en Grails toma la clase domain (User) ademas debes de ponerle el paquete donde se encuentra (mifirstgrails)y generara 4 nuevas paginas GSP en el directorio grails-app/views/user: create.gsp, edit.gsp, list.gsp, y show.gsp. Ahora tu necesitas crear el controlles por scalafon. Tu puedes crear el controller por medio del domain User ejecutando el comando:
grails generate-controller mifirstgrails.User

Si ya tienes un controller Grails detectara que tu ya tienes una implementacion del controller y te pedira los permisos para sobrescribirlos