Introducción A Groovy y Grails Con Maven - El Patrón CRUD - Adictosaltrabajo

12/7/2017 Introduccin a Groovy y Grails con Maven: el patrn CRUD | adictosaltrabajo
Introduccin a Groovy y Grails con Maven: el patrn

CRUD
ndice de contenidos
Resumen
1. Introduccin a Grails y Groovy
2. Requisitos iniciales
3. Generacin del proyecto base mediante el plugin Archetype de Maven
4. Generacin del proyecto base desde el arquetipo Maven
4.1. Inicializando la aplicacin
4.2. Instalando las plantillas utilizadas por defecto
5. Compilando y probando la aplicacin de ejemplo
6. El plugin de Grails para Maven
6.1. Aadir un plugin de Grails al proyecto
7. Introduccin al patrn MVC y al CRUD en Grails
7.1. Las plantillas de los formularios
7.2. Un ejemplo sencillo de plantilla modificada list.gsp
8. El plugin de Fields
8.1. Instalacin del plugin de Fields
9. Los controladores, la persistencia y el lenguaje Groovy
10. Conclusin
Resumen
En este artculo echaremos un primer vistazo a Grails, el servidor de aplicaciones para el lenguaje
Groovy. Adems haremos un pequeo ejemplo implementando el patn CRUD (consultas, altas, bajas y
modificaciones), que es la base de cualquier aplicacin de gestin.
Para hacer esto ms sencillo vamos a utilizar como plataforma de desarrollo Maven, ya que nos permite
poner en marcha el proyecto de ejemplo en poco tiempo.
1. Introduccin a Grails y Groovy

Groovy es un lenguaje interpretado basado en Java al estilo de Ruby y Grails es un servidor de
aplicaciones escritas en Groovy al estilo de Ruby on Rails o de PHP con Simphony. Tiene bastantes
caractersticas interesantes, como es su compatibilidad con Java (podemos usar libremente las clases
de java en nuestros proyectos), tipado fuerte y dbil y una sintaxis rpida y sencilla, que utiliza bastantes
convenios que a aquellos que venimos de Java al principio nos chocan.
https://www.adictosaltrabajo.com/tutoriales/groovy-grails-maven/ 1/32
Grails es un servidor de aplicaciones que permite ejecutar aplicaciones escritas en Groovy. Algunas de
sus caractersticas relevantes son:
Usa convencin frente a configuracin en para saber qu tiene que hacer. Por ejemplo si una clase
Book.grrovy est en grails-app/domain, ya sabe que esa clase declara una entidad del modelo de
datos.
Est preparado para ejecutar aplicaciones que siguen el patrn MVC modelo vista controlador.
El cdigo fuente es interpretado, basado en ficheros escritos en lenguaje Groovy y pginas web
generadas mediante plantillas GSP, que son bastante parecidas a los tradicionales JSPs de J2EE.
Arquitectura basada en plugins escritos en Groovy. Esto le permite extender su funcionalidad.
Acceso directo a todos los paquetes java estndar, con soporte para Maven
Gestor de ciclo de vida basado en Gradle, que es bastante compatible con Maven, aunque no sigue
su misma filosofa.
Soporte nativo para mapeo de bases de datos a Groovy mediante el GORM (basado en Hibernate),
con gestin automtica de la base de datos subyacente.
Sistema de generacin de modelo, vista y controladores para implementar un CRUD integrado en
Grails
Y por ltimo, las aplicaciones generadas en Grails se pueden empaquetar como WAR y desplegar
en un servidor de aplicaciones estndar o en un Tomcat.
2. Requisitos iniciales
El ejemplo lo voy a realizar sobre Ubuntu 14.04 Desktop, que podemos instalar en una mquina virtual
usando VirtualBox con mucha facilidad. Ya sabis, las pruebas con gaseosa y en casa.
3. Generacin del proyecto base mediante el plugin Archetype de

Maven
Desde Ubuntu, en principio instalamos Maven 3 con este comando:
1 $ sudo apt-get install openj

2 dk-7-jdk
3 $ sudo apt-get install maven
4 $ mvn --version
5 Warning: JAVA_HOME environme
6 nt variable is not set.
7
Apache Maven 3.0.5
8
Maven home: /usr/share/maven
9
Java version: 1.7.0_55, vend
10
or: Oracle Corporation
Java home:
/usr/lib/jvm/java-7-openjdk-
i386/jre
Default locale: es_ES, platf
orm encoding: UTF-8
OS name: "linux", version:
"3.13.0-29-generic", arch:
"i386", family: "unix"
Si no lo tenamos instalado nos instalar todo el JDK para Java y dejar todo listo para comenzar a crear
nuestra aplicacin Fcil. Limpio. Rpido. Pero tiene un problema: en Ubuntu 14.04 nos instala Apache
Maven 3.0.5, que no nos vale, ya que el plugin de Grails para Maven requiere Maven 3.1 o posterior. Por
ello vamos a instalar una ms reciente, por ejemplo Maven 3.2.1 sobre nuestro Ubuntu.
Para instalar una versin ms reciente hay que hacer varios pasos:
1
2 $ cd ~
3 $ wget http://apache.rediris.
4 es/maven/maven-3/3.2.1/binari
5 es/apache-maven-3.2.1-
6 bin.tar.gz
7 $ sudo mkdir -p /usr/local/ap
8 ache-maven
$ sudo mv apache-maven-3.2.1-
bin.tar.gz /usr/local/apache-
maven/
$ cd /usr/local/apache-maven/
$ sudo tar -xzvf apache-
maven-3.2.1-bin.tar.gz
$ cd ~
$ nano .profile
Ahora editamos el .profile y le aadimos estas lneas al final:
1 export M2_HOME=/usr/local/apa
2 che-maven/apache-maven-3.2.1
3 export M2=$M2_HOME/bin
4 export MAVEN_OPTS="-Xms256m -
Xmx512m"
export PATH=$M2:$PATH
Cerramos la sesin y volvemos a iniciarla, para coger los cambios del .profile. Y probamos el nuevo
Maven:
1 $ mvn --version
2 Apache Maven 3.2.1 (ea8b2b076
3 43dbb1b84b6d16e1f08391b666bc1
4 e9; 2014-02-
5 14T18:37:52+01:00)
6 Maven home:
7 /usr/local/apache-maven/apach
e-maven-3.2.1
Java version: 1.7.0_55, vendo
r: Oracle Corporation
Java home: /usr/lib/jvm/java-
7-openjdk-i386/jre
Default locale: es_ES, platfo
rm encoding: UTF-8
OS name: "linux", version:
"3.13.0-29-generic", arch: "i
386", family: "unix"
4. Creacin del proyecto base desde el arquetipo Maven

Para comenzar creamos un directorio para el proyecto:
1 $ mkdir -p ~/workspaces/works
2 paceGrailsdemo
$ cd ~/workspaces/workspaceGr
ailsdemo
NOTA: esta estructura de carpetas est especialmente diseada para trabajar con Eclipse y Netbeans.
Mi consejo es:
Meter todos vuestros desarrollos en la carpeta workspaces

Por cada proyecto o desarrollo crear dentro de ella una carpeta workspacenombreproyecto y dentro
de ella las carpetas de los proyectos
Esto ltimo facilita mucho abrir los proyectos en Eclipse y luego importarlos
Mediante el uso del arquetipo Grails para Maven podemos generar de manera sencilla el proyecto base.
El arquetipo es generado mediante un plugin de Maven que se descarga automticamente del
repositorio central de Maven. Yo voy a usar en este tutorial una versin concreta del arquetipo, pero se
pueden usar otras versiones, es cuestin de ir probando lo que nos funciona.
Nota importante: la versin elegida del plugin es muy importante, ya que no todas funcionan. Por
ejemplo yo he probado la versin 2.3.8 y con pruebas sencillas no he logrado levantar la aplicacin con
la configuracin por defecto. La versin 2.2.4 inicializa y ejecuta la aplicacin sin problemas, por lo que
para tomar contacto con Grails es la apropiada.
Podemos saber la lista de versiones disponibles consultando directamente el directorio del plugin en el
repositorio central de Maven. no sabes cmo buscarlo? La ruta para encontrar un artefacto o plugin en
el repositorio central de Maven es:
http://repo1.maven.org/maven/GROUP-ID/ARTIFACT-ID
Donde:
GROUP-ID es el groupId convirtiendo los puntos por barras d, por ejemplo si el gropuId es
org.grails, el GROUP-ID ser org/grails
El ARTIFACT-ID es el artifactId que tenemos que usar.
NOTA: esto vale para CUALQUIER dependencia Maven
Y el comando a ejecutar para este arquetipo es:
1 $ mvn archetype:generate -Da

rchetypeGroupId=org.grails -
2 DarchetypeArtifactId=grails-
3 maven-archetype -DarchetypeV
4 ersion=2.2.4 -DgroupId=es.co
5 m.gonzalezalmiron.grailsdemo
6
DartifactId=grailsdemo
7
[INFO] Scanning for
8
projects...
9
10 [INFO]
[INFO] ---------------------
----------------------------
-----------------------
[INFO] Building Maven Stub P
roject (No POM) 1
[INFO] ---------------------
----------------------------
-----------------------
[INFO]
[INFO] >>> maven-archetype-p
lugin:2.2:generate (default-
cli) @ standalone-pom >>>
[INFO]
[INFO]
Si no te has dado cuenta ya, la ruta del arquetipo en Maven es:
http://repo1.maven.org/maven2/org/grails/grails-maven-archetype/
Y veremos una carpeta por cada versin del plugin.
4.1. Inicializando la aplicacin

Tras la ejecucin del plugin de archetype lo nico que tenemos en grailsdemo es un pom.xml y una
carpeta src casi vaca, salvo el web.xml que hay en src/main/webapp/WEB-INF. Parece poco, pero como
siempre hay que terminar de trabajar en Maven. Inicializamos el proyecto.
1 ~/workspaces/workspaceGrailsdemo
2 mvn initialize
3 [INFO] Scanning for projects.
4
5 . Descarga un montn de paquetes
6 repositorio central..
7
8
9
10 [INFO]
11 [INFO] ------------------------
12 ------------------------------
13 [INFO] Building A custom grails
14 1.0-SNAPSHOT
15 [INFO] ------------------------
16 ------------------------------
17 [INFO]
18 [INFO] --- grails-maven-plugin
19 te (default-validate) @ grailsdemo
20 [INFO] No Grails application found
21 ng validation.
22
[INFO]
23
[INFO] --- grails-maven-plugin
24
(default-init) @ grailsdemo --
25
26 [INFO] Cannot read application
27 tialising new application.
28 [WARNING] Grails Start with out
29
30 |Loading Grails 2.2.4
31 |Configuring classpath
32 |Running pre-compiled script
33 .
34 |Environment set to development
..............................
|Created Eclipse project files
.
|Created Grails Application at
o/workspaces/workspaceGrailsdemo
[INFO] ------------------------
------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------
------------------------------
[INFO] Total time: 17.625s
[INFO] Finished at: Tue Jun 10
T 2014
[INFO] Final Memory: 21M/51M
[INFO] ------------------------
------------------------------
4.2. Instalando las plantillas utilizadas por defecto

Este paso es un poco curioso. Lo que hace es instalar las plantillas en la carpeta /src/templates que
luego se usan para generar los GSPs. Conviene hacerlo en este momento, pues luego cuando se instala
el plugin de Fields ya no se puede hacer (por lo menos a mi me ha dado problemas):
1 $ mvn grails:install-templates
2 [INFO] Scanning for
3 projects...
4 [WARNING]
[WARNING] Some problems were e
5 ncountered while building the
effective model for es.com.gon
6
zalezalmiron.grailsdemo:grails
7
demo:grails-app:1.0-SNAPSHOT
8 [WARNING] 'dependencies.depend
9 ency.(groupId:artifactId:type:
classifier)' must be unique: o
10 rg.grails.plugins:cache:zip ->
11 duplicate declaration of vers
ion 1.0.1 @ line 83, column 17
12 [WARNING] 'build.plugins.plugi
13 n.version' for org.apache.mave
14 n.plugins:maven-compiler-plugi
n is missing. @ line 143, colu
15 mn 15
16
[WARNING] 'build.plugins.plugi
17
n.version' for org.apache.mave
18
n.plugins:maven-surefire-plugi
19
20 n is missing. @ line 97, colum
21 n 17
22 [WARNING]
23 [WARNING] It is highly recomme
24 nded to fix these problems bec
25 ause they threaten the stabili
26 ty of your build.
27 [WARNING]
28 [WARNING] For this reason, fut
29 ure Maven versions might no lo
30 nger support building such mal
31
formed projects.
32
[WARNING]
33
[INFO]
34
35 [INFO] Using the builder org.a
36 pache.maven.lifecycle.internal
37 builder.singlethreaded.SingleT
38 hreadedBuilder with a thread c
39 ount of 1
40 [INFO]
41 [INFO] -----------------------
------------------------------
42 -------------------
43 [INFO] Building A custom grail
s project 1.0-SNAPSHOT
[INFO] -----------------------
------------------------------
-------------------
[INFO]
[INFO] --- grails-maven-
plugin:2.2.4:install-templates
(default-cli) @ grailsdemo --
-
[WARNING] Grails Start with ou
t fork
|Loading Grails 2.2.4

|Configuring classpath
|Running pre-compiled script
.
|Environment set to developmen
t
......
|Templates installed successfu
lly
[INFO] -----------------------
------------------------------
-------------------
[INFO] -----------------------
------------------------------
-------------------
[INFO] Total time: 8.722 s
[INFO] Finished at: 2014-06-11
T12:50:24+01:00
[INFO] -----------------------
------------------------------
-------------------
$ dir src/templates/
artifacts scaffolding testin
g wa
$ dir src/templates/artifacts/
Controller.groovy Filters.gr
oovy
ScaffoldingController.groovy
ervice.groovy Tests.groovy
DomainClass.groovy hibernate.
cfg.xml Script.groovy
TagLib.groovy WebTest.groov
y
$ dir src/templates/scaffoldin
g/
Controller.groovy create.gsp
dit.gsp _form.gsp list.gsp
enderEditor.template show.gsp
est.groovy
El uso de las plantillas lo veremos ms adelante.
5. Compilando y probando la aplicacin de ejemplo

Ejecutando la aplicacin:
1 $ mvn grails:run-app
2 [INFO] Scanning for projects..
3 [WARNING]
4 [WARNING] Some problems were enco
untered while building the effect
5 ive model for es.com.gonzalezalmi
ron.grailsdemo:grailsdemo:grails
6
app:1.0-SNAPSHOT
[WARNING] 'dependencies.dependenc
7
y.(groupId:artifactId:type:classi
8 fier)' must be unique:
9 org.grails.plugins:cache:zip ->
uplicate declaration of version
10 1.0.1 @ line 83, column 17
11 [WARNING] 'build.plugins.plugin.v
ersion' for org.apache.maven.plug
12 ins:maven-compiler-plugin is miss
13 ing. @ line 143, column 15
14 [WARNING] 'build.plugins.plugin.v
15 ersion' for org.apache.maven.plug
16 ins:maven-surefire-plugin is miss
17
ing. @ line 97, column 17
18
[WARNING]
19
20 [WARNING] It is highly recommende
21 d to fix these problems because
22 hey threaten the stability of
23 r build.
24 [WARNING]
25 [WARNING] For this reason, future
26 Maven versions might no longer
27 upport building such malformed
28 ojects.
29 [WARNING]
30 [INFO]
31
32 [INFO] ------------------------
33 ------------------------------
34 -------------
36 roject 1.0-SNAPSHOT
37 [INFO] ------------------------
38
------------------------------
39
-------------
40
[INFO]
41
42 [INFO] --- grails-maven-plugin
43 2.4:run-app (default-cli) @ grail
44 sdemo ---
46 ork
47
51 .
53
..............................
54
|Packaging Grails application
55
|Installing zip tomcat-2.2.4.zi
56
57 p...
58 ...
|Installed plugin tomcat-2.2.4
..............
|Installing zip hibernate-2.2.4.z
ip...
...
|Installed plugin hibernate-2.2.4
...
|Installing zip jquery-1.8.3.zi
p...
...
|Installed plugin jquery-1.8.3
...
|Installing zip cache-1.0.1.zi
p...
...
|Installed plugin cache-1.0.1
...
|Installing zip resources-1.2.zi
p...
...
|Installed plugin resources-1.2
...
|Installing zip database-migratio
n-1.3.2.zip...
...
|Installed plugin database-migrat
ion-1.3.2
......
|Compiling 119 source files
..
|Compiling 8 source files
.........
|Running Grails application
|Server running. Browse to
http://localhost:8080/grailsdemo
Podra ser que el Tomcat7 (puede ser otro servidor o aplicacin) ya estuviera ocupando el puerto, por lo
que debemos primero pararlo:
1 $ sudo lsof i
2
3 Buscamos el proceso que ocupa
4 pueto 8080. En mi caso era el
5 cat7
6
7 $ sudo service tomcat7 stop
8 $ mvn grails:run-app
9
10 . Grails hace su trabajo
11
12
13
|Configuring classpath
14
16 .
18 ..............................
19 |Packaging Grails application
.............
|Running Grails application
|Server running. Browse to
http://localhost:8080/grailsdemo
Y vemos el resultado:
6. El plugin de Grails para Maven

Si instalamos Grails como servidor de aplicaciones y entorno de generacin de aplicaciones, hay un
montn de acciones que se pueden ejecutar desde Grails. Estas acciones suelen tener un equivalente
Maven para ser ejecutadas desde el plugin de Maven.
En la documentacin de Grails est toda la documentacin del plugin de Grails para Maven pero ojo,
es bastante incompleta. Hay que averiguar muchas cosas mediante ensayo y error.
1 $ mvn grails:help
2 [INFO] --------------------
3 ---------------------------
4 -------------------------
5 [INFO] Building A custom gr
6 ails project 1.0-SNAPSHOT
7
[INFO] --------------------
8
---------------------------
9
10 -------------------------
11 [INFO]
12 [INFO] --- grails-maven-plu
13 gin:2.2.4:help (default-
14 cli) @ grailsdemo ---
15 [INFO] org.grails:grails-ma
16 ven-plugin:2.2.4
17
18 Maven plugin for GRAILS app
19 lications
20 This plugin allows you to
21 integrate GRAILS applicati
22
ons into maven 2 builds.
23
24
This plugin has 37 goals:
25
26
27 grails:clean
28 Cleans a Grails project.
29
30 grails:config-directories
31 Set sources/tests directo
32 ries to be compatible with
33 the directories layout
34 used by grails.
35
36 grails:console
37
Runs a Grails console ins
38
ide the current project.
39
40
41 grails:create-controller
42 Creates a new controller.
43
44 grails:create-domain-class
45 Creates a new domain clas
46 s.
47
48 grails:create-integration-t
49 est
50 Creates a new Grails inte
51 gration test which loads th
52
e whole Grails environment
53
when run.
54
55
56 grails:create-pom
57 Creates a creates a maven
58 2 POM for an existing Grai
59 ls project.
60
61 grails:create-script
62 Creates a Grails Gant Scr
63 ipt.
64
65 grails:create-service
66 Creates a new service cla
67
ss.
68
69
grails:create-tag-lib
70
71 Creates a new GSP tag lib
72 rary.
73
74 grails:create-unit-test
75 Creates a new Grails unit
76 test. A unit test requires
77
that you mock out access
78
to dynamic methods, but e
79
80 xecutes a lot quicker.
81
82 grails:exec
83 Executes an arbitrary Gra
84 ils command.
85
86 grails:generate-all
87 Generates a CRUD interfac
88 e (controller + views) for
89 a domain class.
90
91 grails:generate-controller
92
Generates a CRUD controll
93
er for a specified domain c
94
lass.
95
96
97 grails:generate-views
98 Generates the CRUD views
99 for a specified domain clas
100 s.
101
102 grails:help
103 Display help information
104 on grails-maven-plugin.
105 Call
106 mvn grails:help -Ddetai
107
l=true -Dgoal=
108
to display parameter deta
109
ils.
110
111
112 grails:init
113 Validate consistency betw
114 een Grails and Maven settin
115 gs.
116
117 grails:init-plugin
118 Validate consistency betw
119 een Grails and Maven settin
120 gs.
121
122 grails:install-templates
123
Installs the artifact and
124
scaffolding templates.
125
126
127 grails:list-plugins
128 Lists the available plugi
129 ns.
130
131 grails:maven-clean
132 Cleans a Grails project a
133 nd jars in lib directory.
134
135 grails:maven-compile
136 Compiles a Grails
137 project.
138
grails:maven-functional-tes
t
Runs a Grails
application's functional te
sts.
grails:maven-grails-app-war
Creates a WAR archive and
register it in maven. This
differs from the
MvnWarMojo in that it mak
es the WAR file the build a
rtifact for the
'grails-app' packaging. T
he standard 'maven-war' goa
l is designed for the
normal 'war' packaging.
So why have two versions?

Well, version 1.0 of the p
lugin was released with
the war packaging as the
default for Grails
projects. That hasn't worke
d out
so well, but we still nee
d to support it, so we need
one war target for the
war packaging type, and o
ne for the grails-app packa
ging type (which is now
preferred over war).
grails:maven-test
Runs a Grails application
s unit tests.
grails:maven-war
Creates a WAR archive for
the project and puts it in
the usual Maven place.
grails:package
Packages the Grails appli
cation into the web-app fol
der for running.
grails:package-plugin
Packages the Grails plugi
n.
grails:run-app
in Jetty.
grails:run-app-https
in Jetty with HTTPS listen
er.
grails:run-war
in Jetty from its WAR.
grails:set-version
Set the grails applicatio
n version from the Maven PO
M version.
grails:test-app
s unit tests and integratio
n tests.
grails:upgrade
Upgrades a Grails applica
tion to the version of this
plugin.
grails:validate
Validate consistency betw
een Grails and Maven settin
gs.
grails:validate-plugin
Validate consistency betw
een Grails and Maven settin
gs.
grails:war
Creates a WAR archive.
Para saber qu propiedades podemos definir antes de llamar a una de las tareas del plugin de Grails
usaremos este comando:
1 $ mvn help:describe -Ddetail

-DartifactId=grails-maven-plu
gin -DgroupId=org.grails
Si queremos la ayuda de un goal complete usamos el parmetro goal:
1 $ mvn grails:help -Dgoal= cre

ate-domain-class -Ddetail
Por ejemplo para grails:create-domain-class:
1 grails:create-domain-class
2 Description: Creates a new
3 domain class.
4 Implementation:
5 org.grails.maven.plugin.Grai
6 lsCreateDomainClassMojo
7 Language: java
8
9
10 Available parameters:
11
12 activateAgent
13 User property: activat
14 eAgent
15 Whether to activate th
16 e reloading agent (forked mo
17 de only) for this
18 command
19
20 basedir (Default: ${base
21 dir})
22
Required: true
23
The directory where is
24
25 launched the mvn command.
26
27 domainClassName
28 User property: domainC
29 lassName
30 The name for the domai
31 n class to create.
32
33 env
34 User property: grails.
35 env
36 The Grails environment
37
to use.
38
39 extraClasspathEntries
40 Extra classpath entrie
41 s as a comma separated list
42 of file names. For
43 entries with a comma i
44 n their name, use backslash
45
to escape. INTERNAL
46
This parameter is not
47
meant to be used externally.
48
49 It is used by IDEs
50 that require extra cla
51 sspath entries to execute gr
52 ails commands.
53
54 fork (Default: false)
55 User property: fork
56 Whether the JVM is for
57 ked for executing Grails com
58 mands
59
60 forkDebug (Default: fals
61
e)
62
User property: forkDeb
63
64 ug
67 mands
68
69 forkedVmArgs
70 List of arguments pass
71 ed to the forked VM
72
73 forkMaxMemory (Default:
74 1024)
75
User property: forkMax
76
Memory
77
80 mands
81
82 forkMinMemory (Default:
83 512)
User property: forkMin
Memory
Whether the JVM is for
ked for executing Grails com
mands
forkPermGen (Default: 25
6)
User property: forkPer
mGen
Whether the JVM is for
ked for executing Grails com
mands
grailsBuildListener
Fully qualified classn
ame of a grails build listen
er to attach to the
Grails command
grailsEnv
User property: environ
ment
The Grails environment
to use.
grailsHome
User property: grailsH
ome
The path to the Grails
installation.
grailsWorkDir (Default:
${project.build.directory}/w
ork)
User property: grails.
grailsWorkDir
The Grails work direct
ory to use.
nonInteractive (Default:
false)
Required: true
User property: nonInte
ractive
Whether to run Grails
in non-interactive mode or n
ot. The default is to
run interactively, jus
t like the Grails command-li
ne.
pluginsDir (Default: ${b

asedir}/plugins)
Required: true
User property: plugins
Directory
The directory where pl
ugins are stored.
showStacktrace (Default:
false)
User property: showSta
cktrace
Turns on/off stacktrac
es in the console output for
Grails commands.
Error importante: si al ejecutar un commando de Grails Maven retorna un error de este estilo:
1 [INFO] BUILD FAILURE

2 [INFO] ----------------------
3 -----------------------------
4 ---------------------
5 [INFO] Total time: 15.058s
6 [INFO] Finished at: Mon Jun 0
7
9 14:20:22 CEST 2014
[INFO] ----------------------
-----------------------------
---------------------
[ERROR] Failed to execute goa
l org.grails:grails-maven-plu
gin:2.2.4:create-domain-class
(default-cli) on project gra
ilsdemo: Unable to start Grai
ls: java.lang.reflect.Invocat
ionTargetException:
java.lang.IllegalStateExcepti
on: User input is not
enabled, cannot obtain input
stream -> [Help 1]
Es muy probable que nos falte definir parmetros para el comando de Grails. En Grails, se pediran por
pantalla dichos parmetros. Pero dado que la versin evaluada tiene algunos parmetros con el modo
interactivo desactivado, hay que definirlos antes de ejecutar el goal del plugin de Grails.
6.1. Aadir un plugin de Grails al proyecto

En Grails hay muchos plugins disponibles para realizar un montn de tareas. La lista completa de plugins
disponibles la podemos generar con:
1 $ mvn grails:list-plugins
Para aadir el plugin de Grails, simplemente se mete en el pom.xml la dependencia del plugin, por
ejemplo:
1 org.grails.plugins
2 authentication
3 2.0.1
4 zip
5 runtime
6
7
8
9
11 file-uploader
12 1.2.1
13 zip
runtime
Al intentar ejecutar la aplciacin, se descargar e instalar el plugin de Grails.
7. Introduccin al patrn MVC y al CRUD en Grails

Grails est preparado para crear aplicaciones que siguen el patrn MVC de manera sencilla. El Proceso
es el siguiente:
1. Creamos el modelo. Para ello vamos a definir las entidades mediante clases Groovy que definirn
los datos que se van a persistir en la base de datos
2. Luego generamos los controladores asociados a dichas entidades. Se generarn automticamente
las acciones necesarias para implementar el patrn CRUD (Consltas, altas, bajas y modificaciones)
3. Luego generamos las vistas que podrn mostrar la informacin de dicha entidad
Generemos una entidad simple: Book:
1 $ mvn grails:create-domain-c
2 lass -DdomainClassName=Book
3 ..
4
8
.
9
10 |Environment set to developm
11 ent
12 ................
13 |Created file grails-app/dom
14 ain/grailsdemo/Book.groovy
15 ..
16 |Compiling 1 source files
17 ......
18 |Created file test/unit/grai
19 lsdemo/BookTests.groovy
20 [INFO] ---------------------
21 ----------------------------
-----------------------
[INFO] ---------------------
----------------------------
-----------------------
[INFO] Finished at: Mon Jun
09 13:41:30 CEST 2014
[INFO] ---------------------
----------------------------
-----------------------
Y ahora veremos que se ha creado una clase groovy en la carpeta de clases del dominio grails-
app/domain/grailsdemo
1 $ dir grails-app/domain/grai
2 lsdemo/
3 Book.groovy
4 $ nano grails-app/domain/gra
5 ilsdemo/Book.groovy
6
7
package grailsdemo
8
9
class Book {
10
11
static constraints = {
}
}
Vamos a generar el controlador (ojo con el nombre de la entidad, ya que las genera dentro del paquete
grailsdemo)
1 $ mvn grails:generate-controller
2 -DdomainClassName=grailsdemo.Bo
3 ok
5
6
7
8
[INFO]
9
[INFO] ------------------------
10
11 -------------------------------
12 ---------------
14 project 1.0-SNAPSHOT
15 [INFO] ------------------------
16 -------------------------------
17 ---------------
18 [INFO]
19 [INFO] --- grails-maven-
20 plugin:2.2.4:generate-controller
21 (default-cli) @ grailsdemo --
23
fork
24
25
29 .
..............................
.......................
|Generating controller for domai
n class grailsdemo.Book
|Finished generation for domain
class grailsdemo.Book
[INFO] ------------------------
-------------------------------
---------------
[INFO] ------------------------
-------------------------------
---------------
2:25:30 CEST 2014
[INFO] ------------------------
-------------------------------
---------------
Y ahora generamos la vista:
1 $ mvn grails:generate-views -Ddo

2 mainClass=grailsdemo.Book
4
5
6
7
[INFO]
8
[INFO] ------------------------
9
10 -------------------------------
11 ---------------
13 project 1.0-SNAPSHOT
14 [INFO] ------------------------
15 -------------------------------
16 ---------------
17 [INFO]
18 [INFO] --- grails-maven-
19 plugin:2.2.4:generate-views (def
20 ault-cli) @ grailsdemo ---
22
fork
23
24
25
28 .
30 ..............................
31 |Packaging Grails application
32 ....
33 |Compiling 1 source files
34 .........
..........
|Generating views for domain cla
ss grailsdemo.Book
|Finished generation for domain
class grailsdemo.Book
[INFO] ------------------------
-------------------------------
---------------
[INFO] ------------------------
-------------------------------
---------------
2:28:23 CEST 2014
[INFO] ------------------------
-------------------------------
---------------
Los ficheros generados son:

en grails-app/views/book/
create.gsp
edit.gsp
_form.gsp
list.gsp
show.gsp
En grails-app/controllers/grailsdemo/
BookController.groovy
En grails-app/domain/grailsdemo/
Book.groovy
Las vistas generadas son GSPs, que son parecidos a los JSPs estndares, pero incluyen etiquetas
Groovy para generar los elementos de la vista.
El controlador est escrito en Groovy, por lo que hay que entender algunos de los conveniso del lenguaje
Grroovy para ver cmo funciona.
Ahora ejecutamos de nuevo la aplicacin con $ mvn grails:run-app y al abrir el navegador ya

aparece el nuevo controlador.
Pinchamos en el controlador:
Y si pinchamos en Crear Book:
Ahora vamos a aadir nuevos campos a la entidad. Modificamos el fichero Book.groovy
1 class Book {
2
3 static constraints = {
4 }
5
6 String titulo;
7 String autor;
8
Date fechaPublicaon;
9
}
Y regeneramos las vistas con:
1 $ mvn grails:generate-views -
DdomainClass=grailsdemo.Book
Al ir a crear un nuevo libro aparecen ya los campos.
7.1. Las plantillas de los formularios

Cmo genera Grails los ficheros GSPs cuando usamos grails:generate-views? El misterio est en los
ficheros de plantillas. Pero la plantilla es a su vez un GSP, luego el motor de Grails genera un GSP a
partir de un GSP de plantilla. El proceso exacto es bastante curioso. Para explicarlo mejor vamos a ver
una plantilla y un GSP generado a partir de ella:
1 <% import grails.persistence.Event

2 <%=packageName%>
3 <html>
4 <head>
5 <meta name="layout"
6 <g:set var="entityName"
'${domainClass.propertyName}.label', default: '{className}')}"
7 />
8 <title><g:message
9 args="[entityName]" /></title>
10
</head>
<body>
11
12 <a href="#list-${domainClass.propertyName}"
13 class="skip" tabindex="-1"><g:
el" default="Skip to content"
14 <div class="nav"
<ul>
15
16 eLink(uri: '/')}"><g:message code
17
action="create"><g:message code
18 Name]" /></g:link></li>
19 </ul>
20 </div>
21
<div id="list-${domainClass.propertyName}"
22
23 class="content scaffold-list"
24 <h1><g
25 args="[entityName]" /></h1>
<g:if
26 <div class
sh.message}</div>
27 </g:if
<table
28
29 Event.allEvents.toList() << 'id'

30
31 mainClass.persistentProperties
32
ated'
33
34 ss.properties.findAll { allowedNames
edProps.contains(it.name) && it
35 ignableFrom(it.type) }
36
37 rops, comparator.constructors[
38 ect[]))
39
ex { p, i ->
40
41 6) {
42
43 f (p.isAssociation()) { %>
44
de="${domainClass.propertyName}.${p.name}.label"
45
uralName}" /></th>
46
47 property="${p.name}" title="\${message(code: '${domainClass.prop

ertyName}.${p.name}.label', default: '${p.naturalName}')}"
48
49
50
51 t}" status="i" var="${propertyName}"

52
53
0 ? 'even' : 'odd'}">
54
55
56 p, i ->
57
58 0) { %>
59
60 n="show" id="\${${propertyName}.id}"
61 tyName}, field: "${p.name}")}<
f (p.type == Boolean || p.type
ean boolean="\${${propertyName}.${p.name}}"
(p.type == Date || p.type == java

java.sql.Time || p.type == Calendar
date="\${${propertyName}.${p.name}}"
ean: ${propertyName}, field: "${p.name}"
</table
<div class
ame}Total}" />
</div>
</div>
</body>
</html>
Ahora vemos el fichero generado:
1 <html>
2 <head>
4 <g:set var="entityName"
5 (code: 'book.label', default: 'Book')}"
6 <title><g:message
7
l" args="[entityName]" /></title
8
</head>
9 <body>
10 <a href="#list-book"
11 x="-1"><g:message code="default.link.skip.label"
default="Skip to content"/></
12 <div class="nav"
<ul>
13
14 href="{createLink(uri: '/')}">
15 me.label"/></a></li>
16
17 e" action="create"><g:message
18 gs="[entityName]" /></g:link><
19 </ul>
20
</div>
21
22 <div id="list-book"
23 ld-list" role="main">
24 <h1><g
t.label" args="[entityName]" /
25 <g:if
26 <div class
s">${flash.message}</div>
27 </g:if
28 <table
29
30
31
32
leColumn property="autor" title
33
tor.label', default: 'Autor')}"
34
35
36 leColumn property="fechaPublicaon"
'book.fechaPublicaon.label', default: 'Fecha Publicao
37 n')}" />
38
39
leColumn property="titulo" title
40
itulo.label', default: 'Titulo')}"
41
42
43
44
45
46 eList}" status="i" var="bookInstance"
47
48 2) == 0 ? 'even' : 'odd'}">
49
50
51 nk action="show" id="${bookInstance.id}"
n: bookInstance, field: "autor"
rmatDate date="${bookInstance.fechaPublicaon}"
ldValue(bean: bookInstance, field
</table
<div class
InstanceTotal}" />
</div>
</div>
</body>
</html>
Observar que entre otras cosas:
Los \$ se cambian por $ en el fichero GSP generado

Los ${variable} se sustituyen por su valor en el GSP generado
Se usan sentencias de control g:if y g:each para generar elementos en el GSP generado.
Este ltimo punto es muy importante, ya que si queremos personalizar un GSP generado hay que
modificar las plantillas y aadir las exclusiones o cdigo a medida que necesitemos en la propia
plantilla.
Una pregunta curiosa. Por defecto cuntas columnas tiene como mximo un listado estndar en Grails?
Por cierto, cul es el orden de las columnas en los listados?
7.2. Un ejemplo sencillo de plantilla modificada list.gsp

Os voy a mostrar una plantilla list.gsp que incluye elementos a medida:
1 <!DOCTYPE html>
2 <html>
3 <head>
5 content="main">
6 <g:set var="entityNa
7 me" value="\${message(code:
8 '${domainClass.propertyNam
9 e}.label', default: '{classN
10 ame}')}" />
11 <title><g:message co
12 de="default.list.label"
args="[entityName]" /></titl
13 e>
14 <resource:dateChoose
15
r />
16
17 <resource:autoComple
18 te skin="default" />
19 <export:resource />
20 </head>
21 <body>
<a href="#list-${dom
ainClass.propertyName}" clas
22 s="skip" tabindex="-1"><g:me
23 ssage code="default.link.ski
24 p.label" default="Skip to co
25 ntent"/></a>
26
27
28 <g:if test="\${'${pr
29
opertyName}' == 'autorInstan
30
ce'}">
31
32 <g:form
33 action="searchBy"
controller="autor">
<div id="aut
34 ocom">
35 <g:messa
36 ge code="default.search.labe
l" args="['cliente', 'comerc
ial']" />
<richui:a
utoComplete name="dato" acti
on="completeFilter" class="r
equired" />
<g:actio
nSubmitImage
value="Buscar" action="sear
chBy" src="/wp-content/uploa
ds/tutorial-data/\{resource
(dir: 'images/skin', file:
'lupa.png')}" align="cente
r" style="border:0px;backgro
und:transparent"/>
</div>
</g:form>
</g:if>
<g:else>
<g:form
action="filterLike" controll
er="${domainClass.propertyNa
me}">
<div id="aut
ocom">
<g:messa
ge code="default.filter.labe
l" args="['${domainClass.pro
pertyName}']" />
<richui:a
utoComplete name="dato" acti
on="completeFilter" class="r
equired" />
<g:actio
nSubmitImage
value="Buscar" action="filt
erLike" src="/wp-content/upl
oads/tutorial-data/\{resourc
e(dir: 'images/skin', file:
'lupa.png')}" align="cente
r" style="border:0px;backgro
und:transparent"/>
</div>
</g:form>
</td>
8. El plugin de Fields
En Grails, al mecanismo utilizado para generar el patrn CRUD se le llama scaffolding (andamiaje). Este
mecanismo utiliza un sistema de plantillas para gerarlas vistas.
Estas plantillas analizan la clase entidad del dominio y generan la vista durante la etapa grails:generate-
views.
Pero el sistema de plantillas utilizado por defecto es muy bsico. Es recomendable utilizar el plugin Fieds
de Grails para tener ms flexibilidad a la hora de generar las vistas.
8.1. Instalacin del plugin de Fields

Se mete la dependencia en el pom.xml y se vuelve a compilar:
2 fields
3 1.3
4 zip
5 runtime
Luego hacemos $ mvn grails:run-app para que se instale el plugin de fields.
Si volvemos a intentar regenerar la vista veremos cmo se descarga e instala el plugin automticamente.
Para instalar las plantillas del plugin hay que hacer:
1 $ mvn grails:exec -
2 Dcommand="install-form-field
3 s-templates"
4
5
6
7
8
9
11 .
12 |Environment set to developm
13 ent
14 ....
15 |Copying templates from /hom
16 e/usuario/workspaces/workspa
17 ceGrailsdemo/grailsdemo/plug
18 ins/fields-1.3
19 .......
20 |Template installation compl
ete
[INFO] ---------------------
----------------------------
-----------------------
[INFO] ---------------------
----------------------------
-----------------------
[INFO] Finished at: Tue Jun
10 13:35:58 CEST 2014
[INFO] ---------------------
----------------------------
-----------------------
Las plantillas se generan en /src/templates/scaffolding
El plugin de fields nos permite modificar el comportamiento de cada campo, pudindole asignar a un
campo un trozo de cdigo simplemente ubicando el cdigo de plantilla en el lugar adecuado. Por ejemplo
podemos modificar el campo fechaPublicacion de la entidad Book. Para ello creamos el fichero de
plantilla de dicho campo en el lugar adecuado:
1 $ mkdir grails-
2 app/views/book/fechaPublicaci
3 on
$ nano grails-
4 app/views/book/fechaPublicaci
5 on/_field.gsp
6 <div class="fieldcontain ${ha
7
sErrors(bean: bookInstance, f
8
ield: 'fechaPublicacion', 'er
9 ror')} required">
<label for="fechaInic
io">
<g:message co
de="book.fechaPublicacion.lab
el" />
<span
class="required-indicator">*
</span>
</label>
<richui:dateChooser n
ame="fechaInicio" format="dd/
MM/yyyy" firstDayOfWeek="Mo"
value="${bookInstance?.fechaP
ublicacion}" />
</div>
Os dejo como tarea:
Instalar el plugin richui

Aadir la etiqueda al principio del fichero src/templates/scaffolding/create.gsp
Regenerar la vista
Ver que se genera un nuevo campo fecha de publicacin
Ayuda: Esta es la dependencia que yo he usado:
1 org.grails.plugin
2 s
3 richui
4 0.8
5 zip
runtime
9. Los controladores, la persistencia y el lenguaje Groovy

Para el patrn MVC necesitamos un modelo, que es nuestra entidad Book, un conjunto de vistas, que
son los GSP generados por Grails y nos queda nada ms analizar el contolador, que es una clase
Groovy.
Ya que hemos generado el controlador, listemos su contenido:
1 $ cat grails-app/controllers/
2 ailsdemo/BookController.groovy
3 package grailsdemo
4
5 import org.springframework.dao
6 DataIntegrityViolationException
7
8
class BookController {
9
10
11 static allowedMethods = [
12 ve: "POST", update: "POST", del
13 ete: "POST"]
14
15 def index() {
16 redirect(action:
17 "list", params: params)
18 }
19
20 def list(Integer max) {
21
params.max = Math.min
22
23 ax ?: 10, 100)
24 [bookInstanceList:
25 Book.list(params), bookInstance
26 Total: Book.count()]
27 }
28
29 def create() {
30 [bookInstance: new
Book(params)]
31 }
32
33 def save() {
34
def bookInstance = new
35
Book(params)
36
37 if
(!bookInstance.save(flush:
38 true)) {
39 render(view: "creat
40 e", model: [bookInstance: bookI
41 nstance])
42 return
43 }
44
45 flash.message =
46 message(code: 'default.created.
47 message', args: [message(code
48 'book.label', default: 'Book'
bookInstance.id])
49
50 redirect(action:
51 "show", id: bookInstance.id)
52 }
53
54 def show(Long id) {
55 def bookInstance =
56 Book.get(id)
57 if (!bookInstance) {
58 flash.message = mes
59 sage(code: 'default.not.found.m
essage', args: [message(code:
61 id])
62
redirect(action:
63
64 ist")
65 return
66 }
67
68 [bookInstance: bookInst
69 ance]
70 }
71
72 def edit(Long id) {
74 Book.get(id)
77
sage(code: 'default.not.found.m
78
79
81 id])
redirect(action:
82 ist")
83 return
84 }
85
86 [bookInstance: bookInst
87 ance]
88 }
89
def update(Long id, Long
90
91 rsion) {
93 Book.get(id)
96 essage', args: [message(code:
98 id])
99 redirect(action:
ist")
100 return
101 }
102
103
if (version != null)
if (bookInstance.ve
rsion > version) {
bookInstance.er
rors.rejectValue("version", "de
fault.optimistic.locking.failur
e",
[mess
age(code: 'book.label',
default: 'Book')] as Object[]
"Anot
her user has updated this Book
while you were editing")
render(view:
dit", model: [bookInstance: boo
kInstance])
return
}
}
bookInstance.properties
= params
if
(!bookInstance.save(flush:
true)) {
render(view:
"edit", model: [bookInstance:
ookInstance])
return
}
flash.message =
message(code: 'default.updated.
message', args: [message(code
'book.label', default: 'Book'
bookInstance.id])
redirect(action:
"show", id: bookInstance.id)
}
def delete(Long id) {

def bookInstance =
Book.get(id)
if (!bookInstance) {
flash.message = mes
'book.label', default: 'Book'
id])
redirect(action:
ist")
return
}
try {
bookInstance.delete
lush: true)
flash.message = mes
sage(code: 'default.deleted.mes
sage', args: [message(code: 'bo
ok.label', default: 'Book'),
id])
redirect(action:
ist")
}
catch (DataIntegrityVio
lationException e) {
flash.message = mes
sage(code: 'default.not.delete
d.message', args:
[message(code: 'book.label',
fault: 'Book'), id])
redirect(action:
how", id: id)
}
}
}
Cmo funciona el controlador? Es como en otros frameworks MVC. La ruta solicitada por el navegador
comienza por el nombre del controlador y la accin solicitada, y los parmetros aadidos a la ruta
estarn disponibles dentro del controlador. Dentro del controlador se debe invocar a un mtodo. As
http://localhost:8080/grailsdemo/book/ invoca a la accin por defecto, que es index() y sta a su vez
redirige al list(), y http://localhost:8080/grailsdemo/book/create invoca a la accin crate del controlador
BookController.groovy
Si observamos las acciones encontraremos detalles importantes al estar usando Groovy, que hay que
tener en cuenta si venimos de Java:
El estilo de escritura es muy simple, no hay muchos ;

Groovy tiene ms operadores que Java, como ?. y otros.
Las variables en Groovy pueden ser dbil o fuertemente tipadas.
Al estilo de javascript, las variables no tipadas se definen con def
A una variable se le puede asignar un valor o un trozo de cdigo. Esto ltimo es lo que se
denominan closures en Groovy.
Adems es muy normal definir la closure e invocarla a la vez, como por ejemplo en estre
fragmento de cdigo:
1 def results = book.list (max:

2 params.max, offset: params.o
3 ffset) {
4 eq("user",paramTarea2)
5 if (params.order) {
6 order(params.sort, pa
7 rams.order)
8
} else {
order("description",
"asc")
}
}
Todos los mtodos devuelven siempre un valor, que el valor de la ltima sentencia o expresin
ejecutada
Cuando se ejecuta un mtodo del controlador, la variable params contiene los parmetros de la
peticin.
Una lista se crea simplemente encerrando un conjunto de valores entre corchetes cuadrados: [
cadena1, cadena2, cadena3]
Un mapa se crea simplemente encerrando un conjunto de pares clave:valor entre corchetes
cuadrados: [nombre: Diego, apellido:Rojo ]
Si el mtodo del controlador devuelve un mapa, ste se aadir al conjunto de variables disponibles
por la vista, como en el mtodo edit() del controlador de Book
Ojo con las vistas, ya que los GSPs se parecen a los JSPs estndares de java, pero son ms
potentes, ya que las expresiones ${ } admiten cualquier expresin Groovy, incluso llamadas a
mtodos.
Todo el acceso a la base de datos lo haremos a travs de GORM, que es el mapeador de Grails,
basado en Hibernate. Adems GORM utiliza un avanzado sistema de
proxis dinmicos que simplifica la ejecucin de consultas sencillas, como los tpicos findByAutor()
Nota: todo el sistema de persistencia por defecto trabaja en memoria, pero se puede guardar en una
base de datos simplemente cambiando el DataSource.groovy
10. Conclusin
En este tutorial hemos realizado una presentacin de Grails, usando como herramienta de desarrollo
simplemente Maven. Hemos visto entre otros:
Como se crea una aplicacin en Grails

Como se crea un patrn CRUD en Grails
Una ligera introduccin al patrn MVC y su implementacin en Grails
Algunas tcnicas de Grails y Groovy
Y ahora llega la pregunta del milln cundo debo usar Grails en vez de Java con JSF y los frameworks
estndares?
Para un desarrollo corto, con un modelo de datos sencillo y un flujo de pantallas basado en CRUDs,
Grails nos da la oportunidad de desarrollar la aplicacin en poco tiempo, si lo dominamos.
Realmente desarrollar en Groovy tambin tiene su propia curva de aprendizaje. Se pueden hacer
cosas bastante interesantes en poco tiempo, pero adaptar el estilo visual de la aplicacin a lo que a
nosotros nos gusta lleva su tiempo.
Si el desarrollo es largo, los frameworks de Java suelen facilitar los desarrollos (por ejemplo usando
Primefaces o similares) y es algo a lo que la mayor parte de desarrolladores Java estn ya
acostumbrados.

Introducción A Groovy y Grails Con Maven - El Patrón CRUD - Adictosaltrabajo

Încărcat de

Informații document

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Introducción A Groovy y Grails Con Maven - El Patrón CRUD - Adictosaltrabajo

Încărcat de

Drepturi de autor:

Formate disponibile

12/7/2017 Introduccin a Groovy y Grails con Maven: el patrn CRUD | adictosaltrabajo

Introduccin a Groovy y Grails con Maven: el patrn

1. Introduccin a Grails y Groovy

3. Generacin del proyecto base mediante el plugin Archetype de

1 $ sudo apt-get install openj

Ahora editamos el .profile y le aadimos estas lneas al final:

4. Creacin del proyecto base desde el arquetipo Maven

Meter todos vuestros desarrollos en la carpeta workspaces

Y el comando a ejecutar para este arquetipo es:

1 $ mvn archetype:generate -Da

Si no te has dado cuenta ya, la ruta del arquetipo en Maven es:

Y veremos una carpeta por cada versin del plugin.

4.1. Inicializando la aplicacin

siempre hay que terminar de trabajar en Maven. Inicializamos el proyecto.

4.2. Instalando las plantillas utilizadas por defecto

|Loading Grails 2.2.4

El uso de las plantillas lo veremos ms adelante.

5. Compilando y probando la aplicacin de ejemplo

6. El plugin de Grails para Maven

So why have two versions?

1 $ mvn help:describe -Ddetail

Si queremos la ayuda de un goal complete usamos el parmetro goal:

1 $ mvn grails:help -Dgoal= cre

Por ejemplo para grails:create-domain-class:

pluginsDir (Default: ${b

1 [INFO] BUILD FAILURE

6.1. Aadir un plugin de Grails al proyecto

Al intentar ejecutar la aplciacin, se descargar e instalar el plugin de Grails.

7. Introduccin al patrn MVC y al CRUD en Grails

Generemos una entidad simple: Book:

Y ahora generamos la vista:

1 $ mvn grails:generate-views -Ddo

Los ficheros generados son:

Ahora ejecutamos de nuevo la aplicacin con $ mvn grails:run-app y al abrir el navegador ya

Y si pinchamos en Crear Book:

Ahora vamos a aadir nuevos campos a la entidad. Modificamos el fichero Book.groovy

Y regeneramos las vistas con:

Al ir a crear un nuevo libro aparecen ya los campos.

7.1. Las plantillas de los formularios

1 <% import grails.persistence.Event

29 Event.allEvents.toList() << 'id'

47 property="${p.name}" title="\${message(code: '${domainClass.prop

51 t}" status="i" var="${propertyName}"

f (p.type == Boolean || p.type

(p.type == Date || p.type == java

ean: ${propertyName}, field: "${p.name}"

Ahora vemos el fichero generado:

ldValue(bean: bookInstance, field

Observar que entre otras cosas:

Los \$ se cambian por $ en el fichero GSP generado

Por cierto, cul es el orden de las columnas en los listados?

7.2. Un ejemplo sencillo de plantilla modificada list.gsp

8.1. Instalacin del plugin de Fields

Luego hacemos $ mvn grails:run-app para que se instale el plugin de fields.

Para instalar las plantillas del plugin hay que hacer:

Las plantillas se generan en /src/templates/scaffolding

Os dejo como tarea:

Instalar el plugin richui

Ayuda: Esta es la dependencia que yo he usado:

9. Los controladores, la persistencia y el lenguaje Groovy

Ya que hemos generado el controlador, listemos su contenido:

def delete(Long id) {

El estilo de escritura es muy simple, no hay muchos ;