FRAMEWORK WEB GRAILS Capacitación Empresarial a medida.

Fecha: Febrero del año 2012

Capacitador: Ing. Santiago Tapia Y.

Tema: Desarrollo Rápido para Java Empresarial con el framework Grails v2.0

Modalidad: Video Conferencia Horas: 32 horas

MANUAL PRÁCTICO - CAPACITACIÓN SOBRE EL FRAMEWORK GRAILS:

El presente manual está ideado para que se compagine con la teoría expuesta en las dispositivas del curso, brindando el conjunto de pasos que se deben seguir para generar las aplicaciones de la vida real que se desarrollaron a lo largo de la presente capacitación.

NOTA: La versión del Grails con la que se trabajará el presente manual es la versión 1.3.7.

INDICE

Creación de un proyecto Grais (2)

Ejecutando el Proyecto en Tomcat (2)

Creando Domain Clases (3)

Validación: Constratints (5)

Creando Controllers (5)

Scaffolding (6)

Estadísticas (stats) (7)

i18n (7)

Custom Validators (8)

Test Unitarios y de Integración (8)

Relaciones (9)

One to Many (10)

One To One (10)

Many To Many (11)

Bootstrapping (12)

Migrar a otra Base de Datos (13)

Generate-all (14)

URL y Controllers (14)

Views, Templates (14)

Partial Templates (15)

CSS (15)

Tag Libs (16)

Install-templates (17)

Seguridad (18)

Spring Security Core (21)

Partabilidad, Exportación y Deploying del Proyecto (25)

−−−− Empleando la consola de comandos ingresamos el comando grails create-app curso

−−−− La ejecución de dicho comando generará mucha “acción” en la consola y con ésto el esqueleto del proyecto, que debe aclararse todo proviene de la convención que lleva Grails por atrás. NOTA: La explicación detallada de cada una de las carpetas generadas se puede hallar en las diapositivas del curso.

−−−− Al tener ya nuestra aplicación creada (y en un estado funcional), corremos la aplicación para verificarlo mediante el comando grails run-app

−−−− Habrá mucho movimiento en la consola y finalmente se nos notificará que la aplicación está corriendo en el servidor. NOTA: se indica la url incluido el puerto con el que podemos acceder a la aplicación

−−−− En un browser apuntamos a la dirección que se nos indica y el resultado será el siguiente:

−−−− NOTA: En caso de querer modificar la vista que se muestra por default al correr la aplicación podemos hacerlo accediendo al archivo index.gsp en el path siguiente >/curso/grails-app/views/index.gsp

−−−− Partiendo del hecho que Grails entre sus postulados primarios está permitir que el desarrollador centre sus esfuerzos en crear la lógica de negocio en lugar de esfuerzo en tareas de carpintería como creación desde cero de vistas, para lograr esto Grails sugiere que en primera instancia nos centremos en el desarrollo de las Clases de Dominio (Domain classes) pues a partir de ellas podremos generar muchas más funcionalidades y código, precisamente por su visión de Convención sobre configuración como parte básica de su gestión de Desarrollo Rápido.

Para crear las Domain Classes debemos digitar en consola el siguiente comando: grails create-domain-class com.capacitacion.Persona

−−−− Por convención Grails nos ha creado ya un archivo que represente a la Domain Class Persona en la ubicación >/curso/grails-app/domain/com/capacitacion/Persona.groovy

−−−− NOTA: Por Convención Grails creará también archivos para testing en >/curso/test/unit/com/capacitacion/PersonaTests.groovy. Este tema los analizaremos en la sección de pruebas.

−−−− Persona.groovy por default se creará sin contenido:

−−−− Para nuestro ejemplo, el resultado final de Persona.groovy será:

−−−− NOTA: Como es notorio, una clase de dominio está conformada por atributos como nombre, password, bio, etc. Y dentro del bloque constraints mostramos dichos atributos en el orden que queremos que aparezcan en pantalla, así como las validaciones necesarias. En las diapositivas pueden hallarse los Constraints disponibles que ofrece Grails.

−−−− Ya que posteriormente haremos relacionamientos entre Domain Clases, lo cual fin de cuentas se verá reflejado como relaciones entre tablas en la base de datos, necesitamos crear las siguientes clases: Curso y Facultad.

−−−− Para obtener los datos desde las Domain clases y presentar dicha información en la vista requerimos los controladores, los cuales se generan con el comando: grails create-controller com.capacitacion.Persona

−−−− Por convención Grails creará éste controlador en: >/curso/grails-app/controllers/com/capacitacion/PersonaController.groovy

−−−− Al igual que lo ocurrido al momento de crear las Domain Clases, al crear los Controllers se generarán automáticamente archivos de testing. Revísese la ruta: >/curso/test/unit/com/capacitacion

−−−− Con el procedimiento antes indicado creamos los controladores restantes para Curso y Facultad. El controlador de Persona lucirá así:

−−−− El código de la izquierda define la acción index del controlador Persona. Modificamos el código para que luzca como el de la derecha y al Ejecutar la aplicación apuntando en el browser a localhost:8080/curso/persona. renderiza la frase “Capacitación Grails” al invocar la acción index del controlador Persona.

−−−− Ahora vamos a hacer uso de la característica scaffolding de los controladores, añadiendo el siguiente código al controlador Persona:

−−−− Esta característica añade funcionalidad a la aplicación casi como por “arte de magia” pues simplemente con esta única línea de código que se ha añadido al controlador, la aplicación está teniendo ya funcionalidad CRUD. En la imagen siguiente puede verse el formulario de ingreso de una nueva Persona, así como la opción “show” que permite edición y borrado ( generado automáticamente con scaffolding):

−−−− En éste punto vamos a verificar las estadísticas de código de nuestra aplicación. Para conseguirlo debemos digitar el comando: grails stats

−−−− Como es notorio, este comando nos permite ver las estadísticas a nivel de líneas de código por archivos que pertenecen al proyecto.

−−−− Para gestionar e internacionalizar los mensajes que presenta la aplicación, debemos acceder al archivo en la siguiente ruta: >/curso/grails-app/i18n/message_es.properties (asumiendo que la configuración regional tenga al español como idioma nativo). En dicho archivo se podrán modificar todos los mensajes que aparecen en las vistas.

−−−− Para generar Validadores personalizados, dentro del bloque de constraints debemos añadir la instrucción validator, teniendo siempre en mente que el valor que retorne un validador será booleano (true o false)

−−−− Para realizar Tests Unitarios, en el archivo PersonaTests.groovy (>curso/test/nit/com/capacitacion/PersonaTests.groovy) añadimos el siguiente código

−−−− Y en la Domain Class Persona.groovy, añadimos lo siguiente.

−−−− Generamos las pruebas con el comando grails test-app Persona y en la consola se presentará la salida de dicho test, es decir indicando si pasó el test o no. Para éste caso la aplicación pasó el test (Mírese la palabra “PASSED”).

−−−− Adicionalmente Grails presentará reportes en formato HTML de dichos tests; para acceder a los mismos tenemos que seguir la siguiente ruta: >\curso\target\test-reports\html:

−−−− Para crear Test de Integración nos vamos a >/curso/test/integration y creamos el archivo PersonaIntegrationTests.groovy:

−−−− Verificamos el Test de Integración digitando grails test-app -integration. La consola mostrará la salida, y al igual que en el caso de los Tests Unitarios también habrá un reporta HTML.

−−−− Hasta este punto ya hemos creado nuestras Domian Classes, pero si queremos forzarlas a trabajar conjuntamente, compartiendo información entre ellas, tenemos que relacionarlas, y para lograrlo, están los relacionamientos, que como se mencionó anteriormente a fin de cuentas dicho relacionamientos también actúan a nivel de Base de datos.

−−−− Para lograr el relacionamiento bidireccional OneToMany entre Curso y Persona (un curso está formado por varias personas) debemos añadir el siguiente código:

−−−− Ejecutamos la aplicación en el servidor y vemos que ya hay un relacionamiento entre curso y persona. En la imagen se muestra la vista para crear una persona. Como es notorio, debe tener asignado un curso.

−−−− Nótese que la manera en que se exhibe el nombre del curso en la pantala de Creación de Persona proviene del método toString de Curso:

−−−− Ahora vamos a generar un relacionamiento One To One entre Persona y Perfil (Una persona tiene uno y solo un perfil). Para lograrlo creamos inicialmente una Domain Class para Perfil con su respectivo Controller (con scaffolding).

−−−− No hace falta añadir código en Persona. Al ejecutar la aplicación vemos que Perfil ya está relacionado a Persona.

−−−− Vamos ahora a crear el reracionamiento Many To Many entre Curso y Facultad (Muchos cursos pueden estar en muchas facultades), para lo cual creamos una Domain Class y el respectivo Controller para Facultad:

−−−− Para lograr el reracionamiento Many To Many necesitamos crear una Domain Class intermediaria: Estudio.

−−−− Ejecutamos la aplicación y vemos que al añadir un nuevo Estudio, ya están vinculados Curso y Facultad.

−−−− Si bien Grails al trabajar en entorno de Desarrollo tiene una “memoria frágil” y cada vez que se reinicia el servidor la información se pierde, para remediar esto hay la característica Bootstraping para que los datos no se pierdan con cada reiniciada del servidor. Para lograr esto nos abrimos el archivo >/curso/grails-app/conf/BootStrap.groovy y lo editamos de la siguiente manera:

−−−− NOTA: Desde Éste momento cuando arranquemos el servidor ,la aplicación ya tendrá la información que suministramos en BootStrap.groovy

−−−− Ya que hemos trabajado con HSQLDB como gestor de pruebas ahora vamos a migrar a un gestor de base de datos más robusto, para este caso MySQL. Para conseguir esta migración debemos: Conseguir el driver JDBC para MySQL y copiarlo en: >/curso/lib

−−−− Crear en MySQL una base de datos llamada curso, así como un usuario con password para acceder a la misma.

−−−− Ajustar el archivo DataSource.groovy para que trabaje ahora con MySQL: >/curso/grails-app/conf

−−−− Para sus posterior uso en el tema de seguridad y análisis de generación de código con Grails crearemos una nueva Domain Class llamada User.

−−−− Necesitamos crear un controlador para User. En condiciones normales se habría usado el comando create-controller, pero para ver nuevas posibilidades que brinda Grails emplearemos grails generate-all que básicamente genera el Controller así como Vistas pero implementadas. A continuación una porción del código del controlador generado:

−−−− Así mismo los archivos para la Vista de User generados automáticamente con el comando generate-all.

−−−− No se debe olvidar que el Url de la aplicación tiene una convención:

−−−− Ahora vamos a trabajar en las vistas para modificar el archivo index que por default nos brinda grails. Para empezar vamos a quitar el logo de Grails de la página principal. Para hacer esto, debemos tomar en cuenta que Grails emplea templating (con SiteMesh) en la vista, así que nos dirigimos a: >/curso/grails-app/views/layouts/ y en el archivo main.gsp comentamos la siguiente línea:

−−−− Y de la página principal ha desaparecido el logo:

−−−−

−−−− Ahora vamos a crear un header personalizado, para lo cual emplearemos los “Partial Templates”. Creamos un archivo _header.gsp en >/curso/grails-app/views/layouts, con el código siguiente:

−−−−

−−−− En el archivo main.gsp hacemos la llamada a dicha Partial Template (sin incluir el guión bajo de _header):

−−−− Ya que el Partial Template, está llamandose. Vamos a darle estilos. Para esto, editamos el archivo >/curso/web-app/css/main.css añadiendo el siguiente código:

−−−− Adicionalmente añadiremos un Partial Template para el footer de la página. Creamos un archivo _footer.gsp con el siguiente código.

−−−− En el archivo main.gsp hacemos la llamada a dicha Partial Template (sin incluir el guión bajo de _footer):

−−−− Editamos el archivo main.css añadiendo el siguiente código.

−−−− Ejecutamos la aplicación en el servidor y obtendremos una vista como la siguiente.

−−−− Hago notar que en el footer el año 2012 esta quemado en el código y para sanear el problema que puede aparecer al editar esta fecha emplearemos un Tag Lib que presente el año actual en la aplicación. Para esto, ejecutamos el comando grails create-tag-lib Footer y obtenemos el archivo vacío FooterTagLib.groovy en >/curso/grails-app/taglib/curso/FooterTagLib.groovy:

−−−− Editamos el archivo _footer.gsp, y la aplicación ya tiene una etiqueta que muestra el año actual en el footer.

−−−− Aparentemente es imposible customizar las vistas que se generan con la línea def scaffold = true en los controladores, pero para lograrlo debemos editar directamente los templates que Grails usa para la generación de código. Para esto ejecutamos en la consola el comando: grails install-templates. Este comando le “dice” a Grails que genere el código template para todas las vistas, controllers, domain classes, TagLibs, etc. Y con ellos tenerlo disponible para editarlo a nuestro favor. Los templates por default se generan en >/curso/src/templates

−−−− La carpeta “artifacts” contiene los templates para el código formado por los comandos create-*. La carpeta “sacaffolding” como es notorio contiene los templates que generan las vistas basadas en scaffolding, así como el código formado por los comandos genrate-*, La carpeta war contiene el template para la generacion del deployment descriptor web.xml.

−−−− Ya que tenemos acceso a los templates de generación de código, si quisiéramos por ejemplo que los controladores al generarlos con el comando create-controller por default usen scaffolding deberíamos en >/curso/src/templates/artifacts/Controller.groovy tener el siguiente código:

−−−− Así mismo, si quisieramos que las Domain clases por default tengan el método toString al crearlas con el comando create-domain-class, deberíamos en >/curso/src/templates/artifacts/DomainClass.groovy tener el siguiente código:

−−−− Si quisiéramos por ejemplo que los archivos de la vista que se generan automáticamente con scaffolding mostraran una lista de atributos mayor a los 6 que trae por default Grail podriamos editar >/curso/src/templates/scaffolding/list.gsp de la siguiente manera para tener 8 atributos:

−−−− Como introducción al tema de seguridad, y de la mano con el usos de templates vamos a dejar o no visible la barra de menús dependiendo del rol del usuario, siendo visible en su totalidad para un usuario administrador y lo contrario para un usuario user. Para lograrlo nos vamos a >/curso/src/templates/scaffolding/list.gsp y añadimos la siguiente línea de código:

−−−− En cuanto al tema de seguridad, vamos a implementar autenticación y autorización de usuarios a partir de: su username, password y rol. Para conseguirlo, añadimos el siguiente código en la Domain Class User:

−−−− NOTA: El password está encriptándose antes de ser persistido en la base de datos.

−−−− Adicionalmente en el Controlador de User debemos añadir lo siguiente:

−−−− Para completar el proceso de encriptación del password del usuario, necesitamos hacer uso de un Codec de encriptación, que básicamente gestionará cadenas de caracteres (que es lo que es a fin de cuentas un password). Para esto necesitamos crear un archivo SHACodec.groovy en:

−−−− Ejecutamos la aplicación en el servidor y veremos que la lista de usuarios tiene los passwords encriptados perfectamente.

−−−− Vamos a crear ahora un TagLib de autorización en la página, con las opciones de Login y Logout del sistema. Para esto en la consola de comandos ejecutamos el comando grails create-tag-lib Login y dicha clase debe tener el siguiente código:

−−−− Hacemos referencia al TagLib creado loginControl en el archivo _header.gsp:

−−−− Añadimos estilos al archivo main.css:

−−−− Ejecutamos la aplicación y verificamos la funcionalidad de Login y Logout. Indico a continuación el código que contiene el archivo login.gsp, así como la ubicación del mismo:

−−−− Añadiremos ahora, la restricción de que solamente un usuario administrador sea quien pueda acceder a tareas como la creación de usuarios. Para lograrlo, debemos hacer uso de los Interceptors e interceptar todas las acciones del controlador User para dependiendo del rol del usuario ejecutarlas o no. En UserController añadimos:

−−−− Hemos aplicado el Interceptor a un solo controlador, pero si quisiéramos aplicarlo a todos los controladores, debemos hacer uso del concepto de Filters (filtros). Para lo cual ejecutamos el comando grails create-filters admin. Y un nuevo Filtro se creara en:

>/curso/grails-app/conf/curso/AdminFilters.groovy

−−−− NOTA: El resultado final será similar al obtenido con Interceptors solo que a mayor escala, ahora todos los controladores tiene la restricción de que solamente el usuario administrador podrá ejecutar la lógica descrita en el Filtro.

−−−− Hasta este punto, hemos desarrollado la funcionalidad de seguridad “a mano”, pero vamos un escalón más allá y hagamos uso de los plugins que ofrece Grails, específicamente nos referimos al plugin Sprin Security Core que abstrae de una manera mucho más transparente los aspectos de

Seguridad que acabamos de hacer “reinventando la rueda”. Para tener acceso a información y código nos vamos a la dirección http://grails.org a

la sección “Plugins” y escogemos a Spring Security Core en el link “All”.

−−−− En dicha opción, tendremos acceso a información, código, manuales referentes a este Plugin.

−−−− Para realizar ésta práctica, creamos un proyecto nuevo llamado seguridades con el comando grails create-app seguridad en la consola.

−−−− El paso siguiente es verificar la lista de plugins disponibles en el repositorio de Grails. Para ellos digitamos el comando grails list-plugins y ubicamos el plugin que buscamos:

−−−− El siguiente paso es instalar el plugin de Spring Security Core co el comando grails install-plugin spring-security-core. En la imagen siguiente se puede observar una instalación exitosa del plugin.

−−−− El primer paso para usar el plugin, es digitar el comando grails s2-quickstar com.sguridad User Role con el objetivo de crear las Domain Clases y Vistas que gestionarán Usuarios con sus Roles:

−−−− A continuación puede verse una porción del código de User generado en totalidad por el plugin Spring Security Core.

−−−− NOTA: Se sugiere como parte de la práctica analizar el código restante de las Domain Clases Role, UserRole, así como las vistas generadas por el plugin.

−−−− Vamos a crear ahora un controlador llamado SecureController y verificamos en el browser el libre acceso que este action brinda a cualquier usuario que haga Lgin al Sistema:

−−−− Ahora vamos a agregar políticas de acceso a dicho action de la siguiente manera. Y verificamos que ya aparece una ventana de Login:

−−−− Para poder verificar de mejor manera, debemos modificar el archivo BootStrap.groovy y añadir usuarios con roles:

−−−− Ejecutamos la aplicación en el Servidor y verificamos el Login de un usuario tipo user:

−−−− Como parte de la práctica se sugiere revisar el nivel de acceso que tienen los diversos usuarios a los actions de SecureController, adicionalmente revísese la característica “Remember Me” y el manejo de cookies que Spring Security Core hace en ello.

−−−− Configuraciones adicionales puede hacerse en el archivo Config.groovy como lo muestra la siguiente imagen, en donde se puede trabajar conjuntamente con roles y tipos de autenticación.

−−−− Las diversas opciones de autenticación que ofrece Spring security Core son:

−−−− Adicionalmente si se requiere bloqueo de las direcciones IP desde las cuales se accede a la aplicación podría hacerse de la siguiente configuración:

−−−− Y finalmente si se quisiera internacionalizar los mensajes gestionados por Spring Security Core, tómese en cuenta los iguiente:

−−−− Otro aspecto importante es la portabilidad de los proyectos en Grails, lo cual no supone ningún inconveniente pues simplemente debe copiarse el proyecto (con la estructura de archivos tal cual se ha generado en una maquina local) y llevarlo a la máquina destino (obviamente que tenga instalados debidamente Java y Grails), y de ser el caso configurar la base de datos (si es que se decide trabajar con otro gestor que no sea el default HSQLD).

−−−− Finalmente, como todo proyecto web en java, Grails nos permite exportar nuestro proyecto como archivo web (.war) que se pueda deployar en cualquier servidor web Java como JBoss, GlassFish, Tomcat, Jerónimo etc. Para lograrlo necesitamos en consola ejecutar el siguiente comando grails war:

−−−− Y en la ruta >/curso/target ya tenemos un archivo con extensión war listo para ser deplorado en cualquier servidor web Java.

Responsable: Ing. Santiago Tapia Y.

Contacto:

Dirección: Urbanización Ushimana Lote 28 (Valle de los Chillos) Quito – Ecuador Email: santiago_tapiasr@hotmail.com Mobile: (593) 92 738 561 Sitio Web: http://santiagotapiay.blogspot.com