programacion de una tienda virtual en grails

Treball fi de carrera

ENGINYERIA TÈCNICA EN

INFORMÀTICA DE SISTEMES

Facultat de Matemàtiques

Universitat de Barcelona

PROGRAMACIÓN DE UNA TIENDA VIRTUAL EN GRAILS

Gabriel Bermúdez Merino

Director: Jesús Cerquides Bueno Realitzat a: Departament de Matemàtica

Aplicada i Anàlisi. UB

Barcelona, 3 de julio de 2008

Índice detallado 1. Introducción.................................... .......4 1.1 Ámbito del proyecto........................... ...4 1.2 Objetivos generales........................... ...5 1.3 Objetivos específicos......................... ...5 1.4 Organización de la memoria.................... ...6 2. Antecedentes.................................... .......7 2.1 Exposición de problemáticas................... ...7 2.1.1 Groovy como lenguaje de programación......7 2.1.2 Grails como framework Web.................9 2.2 Tecnologías asociadas......................... ..11 2.2.1 Groovy...................................11 2.2.2 Grails...................................16 2.3 Conclusión.................................... ..21 3. Análisis........................................ ......23 3.1 Descripción del problema...................... ..23 3.2 Descripción del producto...................... ..23 3.3 Requisitos funcionales........................ ..23 3.3.1 Banner...................................24 3.3.2 Navigation Blocks........................24 3.3.3 Render...................................25 3.4 Requisitos no funcionales..................... ..25 3.5 Identificación de actores y objetivos......... ..26 4. Diseño.......................................... ......27 4.1 Casos de uso.................................. ..27 4.1.1 Objetivos afines.........................27 4.1.2 Objetivos administrador..................31 4.1.3 Objetivos Usuario Registrado.............33 4.1.4 Objetivos Usuario No Registrado..........35 4.2 Diagramas..................................... ..35 4.2.1 Diagrama de dominio......................36 4.2.2 Modelo Vista-Controlador.................36 4.2.2.1 Vista-Controlador User............36 4.2.2.2 Vista-Controlador Pet.............37 4.2.2.3 Vista-Controlador Cart............37 4.2.3 Site Maps................................38 5. Implementación y pruebas........................ ......40 5.1 Entorno de desarrollo......................... ..40 5.1.1 GNU/Linux................................40 5.1.2 Gedit....................................40 5.1.3 Mozilla Firefox 2.14.....................40 5.1.4 Groovy...................................40 5.1.5 Grails...................................40 5.2 Seguimiento y problemáticas................... ..41 5.2.1 Estructura y persistencia................41 5.2.2 Controladores y vistas...................44 5.2.2.1 Controladores.....................44 5.2.2.2 Vistas............................50 5.2.3 Extras...................................53 5.2.3.1 Tools Navigation Block............53 5.2.3.2 Contact Navigation Block..........54 5.2.3.3 Gsp’s estructura por defecto......55

5.2.3.4 Imágenes..........................55 5.3 Pruebas....................................... ..56 6. Conclusiones y líneas de futuro................. ......60 7. Bibliografía.................................... ......62 7.1 Libros........................................ ..62 7.2 Recursos electrónicos......................... ..62 8. Anexos.......................................... ......63 8.1 Manual instalación de librerías............... ..63 8.1.1 Groovy...................................63 8.1.2 Grails...................................63 8.2 Riesgos....................................... ..64 8.3 Análisis del tiempo de realización del proyect o.64 8.4 Implantación.................................. ..66

Programación de una tienda virtual en Grails 1. Int roducción

Gabriel Bermúdez Merino 4

1. Introducción

1.1 Ámbito del proyecto En la actualidad, Internet está viviendo una profun da transformación: ha pasado de ser un escaparate de i nformación estática a un conjunto de aplicaciones y portales q ue utilizan el conocimiento colectivo para facilitar servicios interactivos donde los usuarios tienen el control de sus datos y de la información. Los entornos colaborativos son el conjunto de herra mientas y tecnologías sobre los que se sustenta la Web 2.0: e n una sola palabra "COLABORAR". Hay varios factores que son responsables de que sea mos testigos de una convergencia entre tecnología y sociedad, do nde la tecnología facilita cambios sociales, y estos a su vez marcan las tendencias de la tecnología. Uno de los factore s más importantes ha sido la facilidad de acceso y aparic ión de tarifas planas de conexión, además de que la realid ad de los consumidores ha mutado y no se basa en una lealtad ciega hacia cierta marca. El ámbito de los entornos colaborativos es tan ampl io como la propia WWW. Su aplicación se extiende a cualquier m odelo de negocio, por lo que no es difícil imaginar el impor tante impacto económico y social que suponen en el entorno empres arial actual. La aparición de Blogs, Wikis, Redes sociales, Comer cio Electrónico, etc ... ha impulsado la proliferación de estándares con el fin de ayudar a la creación de aplicaciones web, los denominados frameworks, con un único objetivo: simp lificar la complejidad de la creación de aplicaciones web. Exi sten varios frameworks web, Struts / Tapestry / ASP.NET / Ruby on Rails / Groovy on Grails, pero casi todos basados en el mis mo tipo de estructura: J2EE. Con el paso del tiempo cada vez es más sencillo uti lizar estos frameworks, por lo que la creación de una aplicació n web, actualmente, está al alcance de cualquier persona c on nociones básicas de programación y, sobretodo, curiosidad. En algunas de las asignaturas de la carrera hemos e studiado diversas metodologías de desarrollo de aplicaciones , incluyendo su análisis y diseño, y su aplicación en el panoram a colaborativo de Internet actual. En este proyecto s e volverán a utilizar estas metodologías para crear una aplicaci ón web de e-commerce con el objetivo de demostrar la potencia del framework web estudiado.



1.2 Objetivos generales El objetivo principal de nuestro proyecto es el est udio del nuevo framework web Grails basado en Groovy, para e llo utilizamos dicho framework para crear una aplicació n de e-commerce, en concreto una tienda virtual de mascota s basada en un ejemplo de Sun Microsystems. Gracias a esta apli cación de e-commerce se comparara la simplicidad de creación y la eficiencia entre dicha aplicación y el ejemplo de S un, con el único objetivo de dar a conocer la potencia de este nuevo framework, que sin duda alguna en el futuro dará mu cho que hablar en el panorama del diseño web. 1.3 Objetivos específicos Los objetivos específicos que se quieren conseguir en el proyecto son descritos a continuación:

• Estudio de Groovy , el lenguaje de programación base de Grails. Para este estudio seguiremos las siguientes fases:

o Estudio base de las diferencias más relevantes entr e

Groovy y Java.

o Introducción a los comandos básicos de Groovy.

o Realización de ejemplos para profundizar en su estructura.

• Estudio de Grails , tanto su estructura como sus posibles aplicaciones. Para este estudio seguiremos las sigu ientes fases:

o Introducción a la estructura de Grails y sus comand os

más relevantes.

o Realización de ejemplos simples para profundizar en su estructura.

o Realizar un ejemplo que estudia en profundidad la

gran mayoría de su estructura y comandos.

o Comparación entre este framework y la estructura de l de Sun Microsystems.



1.4 Organización de la memoria La memoria esta organizada en diversos capítulos, c ada uno con sus funcionalidades, las cuáles están explicadas a continuación:

• Introducción : Apartado en el que se hace una aproximación a los términos que acatará el proyecto.

• Antecedentes : Se expondrá el problema que se quiere abordar con el proyecto y se estudiarán las tecnolo gías para llevarlo a cabo.

• Análisis : En este apartado analizaremos el problema, la aplicación que queremos desarrollar, sus requisitos y demás objetivos que se quieren abordar.

• Diseño : En este apartado se diseñara el sistema según las especificaciones analizadas en el apartado anterior .

• Implementación y pruebas : Este apartado será escrito durante la implementación del código y en él explic aremos el entorno con el que desarrollaremos la aplicación , las simulaciones y problemáticas.

• Conclusiones y Líneas de Futuro : El apartado de conclusiones será escrito antes de finalizar el pro yecto y en el haremos la valoración final de la aplicación y del proyecto, así también evaluaremos las líneas de fut uro de éste.

• Bibliografía : En la bibliografía especificaremos los recursos de dónde se ha extraído la información nec esaria para el desarrollo del proyecto.

• Anexos : Los anexos contienen toda la documentación técnic a e instalación de librerías necesarias, así como un análisis del tiempo de realización el proyecto.

Programación de una tienda virtual en Grails 2. Ant ecedentes


2. Antecedentes 2.1 Exposición de problemáticas En los últimos años Internet ha ido evolucionando p oco a poco hacia un entorno colaborativo entre usuarios, hasta llegar a la actualidad y a la Web 2.0, donde el entorno colabor ativo ha culminado con la aparición de Blogs, Wikis, el e-co mmerce, … Esto último implica el estudio e investigación de n uevas tecnologías que hagan más sencillo el desarrollo de nuevas aplicaciones web tanto para el desarrollador como p ara el usuario llano. El desarrollo de frameworks web ha ido evolucionand o constantemente, desde los struts, framework que imp lementa el patrón de arquitectura Modelo Vista-Controlador en Java , hasta, por ejemplo, “ Groovy on Grails” , buscando siempre una simplificación de código pero sin comprender una re ducción de la calidad del producto final. El problema abordado por este proyecto es la creaci ón de una aplicación web de e-commerce, concretamente una tie nda virtual de mascotas, utilizando la nueva tecnología basada en Groovy , Grails . Para la implementación de esta aplicación han sid o necesarios varios estudios previos de cada una de l as tecnologías que comprenden el mundo de “ Groovy on Grails ”, los cuales podriamos dividir en:

• Estudio del lenguaje de programación Groovy • Estudio del framework basado en Groovy , Grails

• Análisis, diseño e implementación de la aplicación web propiamente dicha

2.1.1 Groovy como lenguaje de programación El 2 de Enero de 2007 aparecía la versión 1.0 de Groovy , un nuevo lenguaje de programación orientado a objetos desarrollado por Guillaume Laforge , Jefe de Proyecto y JSR-241 Spec Lead. La implementación de Groovy se realiza sobre la plataforma Java, además, tiene características similares a Python , Ruby, Perl y Smalltalk . Gracias a la especificación JSR-241, se busca su estandarización para una futura inclusión como comp onente oficial de la plataforma Java . Groovy utiliza una sintaxis muy parecida a Java , compartiendo el mismo modelo de objetos, de hilos y de seguridad. M ediante importaciones, Groovy puede acceder a todas las API de Java ampliando la compilación, ya que el bytecode genera do es totalmente compatible con el que Java genera para la Java Virtual Machine.



Para Groovy , Java no es un lenguaje incompatible con su código, todo lo contrario, todo el código escrito en Java es válido en Groovy . Este aspecto hace su aprendizaje mucho más sencil lo a programadores Java que otros lenguajes que se ejecu tan sobre la Java Virtual Machine, como Jython o Jruby . Java es totalmente compatible con Groovy , pero esto no hace que Groovy pierda todas las ventajas de un lenguaje de script ing, ya que también se puede ejecutar de forma dinámica. Po r ejemplo, en Java la salida estándar de “Hello World” hace necesaria la escritura de una clase, un método main con una seri e de argumentos, etc… Pero en Groovy , no es necesario escribir todo el código, te puedes ahorrar la declaración de la c lase y el método main, y sólo escribir una línea de código qu e muestre por pantalla “Hello World”. El contenido del archivo HelloWorld.groovy sería:

println “Hello World”

Como podemos observar, el dinamismo de un lenguaje de scripting se encuentra presente en Groovy , pero, ¿y la compatibilidad con Java? Groovy da soporte a listas, mapas, etc… y aún podemos dem ostrar la simplicidad de Groovy y su capacidad para ejecutar código en Java:

Como podemos observar en el código, utilizamos dire ctamente java.util.Date y no importamos un soporte para colecciones para trabajar con listas, mapas y rangos. Aunque no es n ecesario,

//Printamos una fecha utilizando codigo Java def mydate = new java.util.Date() println mydate //Iteración sobre un hash map def numbersMAP = ['1':'ONE', '2':'TWO'] for (entry in numbersMAP) { println "${entry.key} = ${entry.value}" } //Introducimos un rango def range = 'a'..'d' //Listas def numberlist = [1, 2, 3, 4, 5, 6, 7, 8] println numberlist; println "Maximum value: ${numberlist.max()}"



como en el ejemplo, podemos exportar librerías Java para que el proceso de desarrollo sea más cómodo.

En el apartado de tecnologías asociadas, profundiza remos más en el mundo de Groovy mediante explicaciones y ejemplos.

2.1.2 Grails como framework Web Grails es un framework para aplicaciones Web de libre distribución, que tiene como base el lenguaje de programación Groovy . Grails es un framework de alta productividad que viene dis tribuido bajo el paradigma del “código por convención” (MVC), el cuál proporciona un entorno de desarrollo independiente y unos detalles de configuración escondidos para el desarr ollador. Grails se llamó previamente “ Groovy on Rails” (nombre que se le puso en como homenaje a David Heinemeier Hansson, f undador de Ruby on Rails , otro framework web). El trabajo de desarrollo comenzó en Julio de 2005 que dio como fruto la vers ión 0.1 el 29 de Marzo de 2006 i la versión 1.0 el 18 de Febrero de 2008. En el momento de su implementación, se estudiaron v arios conceptos a favor de Grails entre los que destacaban:

• Proporcionar una alta productividad basándose en la plataforma de Java .

• Utilizar de manera más simple tecnologías de Java como Hibernate y Spring , mediante una interface consistente.

• Un framework sencillo y fácil de aprender. • Documentación con participación de los usuarios. • Proporcionar simplicidad en áreas donde antes solo podían

adentrarse usuarios expertos: o Framework persistente potente y consistente. o Uso sencillo pero potente de las templates de vista

utilizando GSP (Páginas de Servidor Groovy). o Librerías de tags dinámicas para una creación de

componentes web sencilla. o Buen soporte a Ajax pero simple de ampliar y

personalizar. • Proporcionar ejemplos de aplicaciones con los que

demostrar la potencia de este nuevo framework. • Proporcionar un modo de desarrollo completo, incluy endo un

servidor web y un sistema de carga de ficheros auto mática.



Dichos objetivos se han conseguido en mayor o menor grado, entre los logros más relevante, cabe destacar:

• Framework sencillo y simple

Gracias a la implementación de Grails basandose en el paradigma del “código por convención” (MVC), se han conseguido realizar nuevas implementaciones, ya sea en la mejora del código o en su funcionalidad. Las más re levantes son:

o Controllers

Los controllers son los sustitutos naturales de los Servlets tal y como los conocemos, ya que siguiendo la convención de Grails crearemos una Closure de Groovy cada vez que queramos realizar una acción sobre una clase de la aplicación web.

La creación de un controlador vendría dado por:

o Soporte a Ajax y uso de librerías dinámicas para poder implementar plugins con el fin de facilitar l a implementación de la nueva aplicación web.

• Persistencia y alta productividad

o La alta productividad viene dada por el uso del

lenguaje de scripting Groovy como base de programación, ya que sobre este lenguaje se podría aplicar un famoso dicho, “Nunca tan poco a dado tanto” , ya que con poca cantidad de código se puede realizar una pequeña aplicación en Grails.

o La persistencia en Grails viene dada por la

simplicidad de creación de sus clases de dominio:

$> groovy create-controller --------------------------------------------------- -def list = { if(!params.max) params.max = 10

[ petList: Pet.list( params ) ] }

$> groovy create-domain-class --------------------------------------------------- - class Cart { String status String payment String numberTarget Float total Map contentBuy=[1 : 1] }



seguida por la implementación del soporte más importante para las operaciones CRUD (Create, Read, Update, Delete), el Scaffolding. Scaffolding es un método para construir aplicaciones basadas en bases de datos, esta técnica está soportada por algunos frameworks del tipo MVC en el cuál el programador escribe una especificación que describe cómo debe ser usada la base de datos. Lueg o el compilador utiliza esa especificación para gener ar el código que la aplicación usará para crear, leer, actualizar y eliminar registros de la base de datos . En Grails la activación del Scaffolding es tan sencilla como la mayoría de implementaciones en Grails .

Como podemos observar, Grails es un framework potente pero a la par sencillo, ahora sólo hemos nombrado los aspecto s más relevantes por lo que a continuación, en el apartad o de tecnologías asociadas, profundizaremos más en el mu ndo de Grails mediante explicaciones y ejemplos, posteriormente r ealizaremos una implementación completa de una aplicación web d e e-comerce.

2.2 Tecnologías asociadas 2.2.1 Groovy En este apartado, se va a profundizar en los aspect os más relevantes de Groovy mediante descripciones y ejemplos. No se puede considerar este apartado como un manual de us uario de Groovy , más bien como un pequeño tutorial de introducció n a éste potente lenguaje de scripting. En algunos de estos ejemplos se hará una comparativ a directa con Java con el objetivo de demostrar la disminución de cód igo entre uno y otro.

1. Primeros pasos: “Hola Mundo”

Queremos que Groovy imprima por pantalla una cadena de caracteres con la información “Hola Mundo”. Gracias a la compatibilidad de Groovy con el lenguaje Java se podría implementar este problema de la misma manera que lo haríamos en Java , pero al ser un lenguaje de Scripting no sería necesaria la creación de una clase, con solo introducir la instrucción de imprimir por pantalla sería suficiente.

class cartController { scaffold = true }



La diferencia de cantidad de código es abrumadora, pero existen otras implementaciones con el mismo objetiv o.

Con esta implementación podemos observar algunas de las características de Groovy :

• El valor de retorno no es específico, por lo que usamos la palabra reservada def (muy parecida a la palabra var de JavaScript )

• No es necesario utilizar la palabra reservada return , la última sentencia ejecutada determina el valor de retorno.

• La cadena de caracteres no es un java.lang.string, se trata de un GString. Los GStrings permiten la evaluación de expresiones, al igual que con Perl .

2. Tipos de datos

Groovy soporta todos los tipos de datos de Java , sin primitivos, y además define listas y mapas como tip os básicos, así como los arrays y hashs de Perl y PHP. En realidad las listas son en el fondo java.util.ArrayList y los mapas java.util.HashMap , por lo que se podrán utilizar todos los métodos ya conocidos en Java relacionados con listas y mapas. Además, Groovy permite que los índices y llaves sean manipulados a través del operador ‘[]’, y en el caso de los mapas también mediante ‘.’.

public class HolaMundo{ public static void main(String[] args){ System.out.println(“Hola Mundo”); } } --------------------------------------------------- ------ println “Hola Mundo”

class HolaMundo{ def hiWorld(name){ “Hola ${name}” } } def hW = new HolaMundo() println hW.hiWorld(“Mundo”)

<-- Números --> def x = 12 def y = 10.0e4 <-- Caracteres y Strings --> def c = “a” def s = “hi World!” <-- Listas y Mapas --> def list = [1,2,3,4] def map= [“Jon”:”Matthers”, “1”:”Mark”]



Como podemos observar, la definición de variables e n Groovy no implica una definición primitiva, el contenido de la variable especifica el tipo de dicha variable . En la última descripción, podemos observar el método de recorrido de los rangos, el cuál puede ser aplicado en más tipos de variables, además nos introduce en un nuev o concepto de Groovy , que ha sido adoptado por la nueva implementación de Java 7 , las closures .

3. Closures

Una closure se podría describir como un bloque de c ódigo reutilizable, que retiene la información entorno do nde fueron definidos. Esta forma de trabajo es muy parecida a JavaScript , ya que es muy parecido a la definición de una función anón ima en un script. Las closures pueden recibir parámetros, puesto que los tipos de Groovy son opcionales, sólo es necesario escribir el nombre del parámetro. El uso de closure s es tan común, que si no se ha definido un parámetro específico de todos modos estará disponible una var iable it que representa el valor del parámetro.

La implementación de las closures implica un gran a vance en el mundo de la programación, ya que no es necesa rio crear un nuevo método fuera del actual pudiendo uti lizar las variables locales del actual.

4. Expresiones regulares

Como muchos lenguajes de scripting, Groovy también ofrece la posibilidad de utilizar expresiones regulares, e s decir, declarar y utilizar dichas expresiones sin necesidad de construcciones complexas o añadir sint axis adicionales a las construcciones básicas del lengua je.

<-- Rangos --> def rg = (0..9) <-- Impresión de rangos --> rg.each{num -> print num}

def printOut = {item -> print item} (0..9).each(printout) --------------------------------------------------- ------ def printOut = {print it} (0..9).each(printout)



Basta con declarar la expresión de búsqueda entre b arras diagonales y usar uno de los tres operadores dispon ibles:

• =~ búsqueda de ocurrencias • ==~ coincidencias • ~ patrón

5. POJOs to POGOs

En los últimos años Sun a dominado el sector de JavaBeans gracias al resurgimiento de los POJOs (Plain Old Java Objects), es decir, un subconjunto de la convención JavaBeans . Los POJOs son un subconjunto puesto que los JavaBeans deben notificar cualquier cambio que se realice en alguna de sus propiedades, mientras que los POJOs no lo hacen. Spring y Hibernate no dudaron sobre las ventajas de uso, y no tardaron en incorporarlo en su implementa ción. El único pero que tenían los POJOs era su complicada implementación, este apartado fue resuelto gracias a que algunos Ambientes de Desarrollo Integrados (IDE) comenzaron a proporcionar herramientas para generar este tipo de código. Pero los POGOs van más allá, simplemente con declarar las propiedades según la convención, los métodos de acc eso se generarán. Dichas propiedades se declaran con tipo y nombre, sin modificador de acceso, ya que de tenerl o dejan de ser una propiedad para pasar a ser un campo. La creación de POGOs implica una definición de un POGO propiamente dicho, la definición de cómo mínimo 1 propiedad y campos. En el momento de la creación descubrimos otra de las ventajas de Groovy , en el momento de la llamada al constructor mediante un mapa exten dido debido a que Groovy anexa un constructor por omisión a los POGOs. En el momento del acceso a campos se puede realiz ar mediante el operador ‘.’ o ‘[]’ lo cuál hace que pa rezca que se ha roto la encapsulación del POGO, pero en realidad es todo lo contrario, ya que existe la posibilidad de

def text = “At school, Harry had no one. Everybody know that Dudley’s gang hated that odd Harry Potter” + “ in his baggy old clothes and broken glasses, and nobody liked to disagree with Dudley’s gang.”

matcher = (text =~ /Harry Potter/) --------------------------------------------------- ------ matcher = (text ==~ /Harry/) --------------------------------------------------- ------ matcher = (text ~ /H.*y/)



obtener y modificar el valor de un campo mediante e l operador ‘.@’ que tampoco rompe la encapsulación.

Gracias a los POGOs podemos descubrir otra de las peculiaridades de Groovy, es el segundo lenguaje, después de Java , que soporta anotaciones, aunque el soporte para tipos genéricos aún está en desarrollo.

6. Desarrollo web con Groovy

Como pequeña introducción en el desarrollo web con Groovy antes de las definiciones y ejemplos de Grails , introduciremos el sustituto de los Servlets de Java por los Groovlets . La simplicidad de código y la posible inclusión de tags de html en el mismo código en Gro ovy representa grandes ventajas que los Servlets no disponen. A continuación introducimos un ejemplo de un Groovlet ya que es la forma más sencilla de entender este tipo de implementación.

class Person{ String name #Property String firstName #Property private int id #Field String toString() {“${name} ${firstName}”} } Person person = new Person(name:’Matthew’, firstName:’McMag’) assert “Matthew McMag” == person.toString() person.firstName = “McGam” assert “Matthew McGam” == person.toString() person[‘firstName’] = “McMag” assert “Matthew McMag” == person.toString() assert person.name == “Matthew” assert person.@name == “Matthew” assert person.completName == “Matthew McMag” try{ assert person.completName == “Matthew McMag” }match(MissingFieldException e){ println “Error, completName isn’t a field }

class Person{ @BoundProperty String name @BoundProperty String firstName }



2.2.2 Grails En este apartado, se va a profundizar en los aspect os más relevantes de Grails mediante descripciones y ejemplos. No se puede considerar este apartado como un manual de us uario de Grails , más bien como un pequeño tutorial de introducció n a éste potente framework web. En los siguientes apartados vamos a tratar varios a spectos de Grails , desde su estructura hasta llegar a su funcionalid ad pasando por la implementación de controladores, gsp ’s, etc …

1. Estructura de la aplicación

El primer paso en la implementación de un nuevo pro yecto en Grails , es la creación de la estructura de directorios

del proyecto. Para realizar este paso, Grails nos proporciona un comando que nos crea automáticamente la estructura de directorios: seguidamente a esta instrucción introducimos el nombre de la aplicación y a continuación Grails nos crea la estructura necesaria para administrar nuestro proyecto. Una de las ideas principales de Grails es la aplicación de convenciones de desarrollo de aplicaciones Web, siguiendo esta convención se crean los archivos y directorios que se usarán en la mayoría de aplicaciones Web. Aunque esta estructura de directorios no es estática, ya que la podemos configurar según nuestras necesidades.

import java.util.Date if (session == null) { session = request.getSession(true); } if (session.counter == null) { session.counter = 1 } println """ <html> <head> <title>Groovy Servlet</title> </head> <body> Hello, ${request.remoteHost}: ${session.counter}! $ {new Date()} </body> </html> """ session.counter = session.counter + 1

$> grails create - app



Esta estructura de ficheros nos sitúa automáticamen te los Paths donde van a ir almacenados las vistas, controladores, librerías,… donde Grails va a ir colocando los nuevos elementos que se vayan creando automátic amente durante la implementación del proyecto. Si se tiene experiencia utilizando Apache Ant, se p uede crear manualmente este sistema de directorios modif icando el archivo de /src/grails/build.xml que encontramos en el directorio GRAILS_HOME.

2. Base de datos

La base de datos que viene configurada por defecto cuando creamos un nuevo proyecto en Grails es volátil y utiliza el lenguaje de base de datos HSQL. Si queremos que nuestra base de datos deje de ser volátil y queremos que te nga una permanencia (en el localhost), se modificará la sig uiente línea en el fichero:

…/grails-app/conf/ApplicationDataSource.groovy

Como podemos observar en el código, modificando el valor de dbCreate por update, establecemos una base de da tos permanente. Observamos también que por cada tipo de implementación, ya sea de desarrollo, testeo o prod ucción podemos tener una base de datos diferente, lo que f acilita la futura implantación del proyecto. Si por comodidad se quiere utilizar otro tipo de le nguaje de base de datos, tan sólo se ha de descargar el dr iver correspondiente y almacenarlo en el directorio lib del

dataSource { pooled = false driverClassName = "com.mysql.jdbc.Driver" username = "root" password = "" } … environments { development { dataSource { dbCreate = "update" // one of 'create', 'create-drop','update' url = "jdbc:mysql://localhost/petStore_dev" } } test { dataSource { dbCreate = "update" url = "jdbc:mysql://localhost/petStore_test" } } production { dataSource { dbCreate = "update" url = "jdbc:mysql://localhost/petStore_prod;shutdown=true " } } }



proyecto. Seguidamente se ha de modificar el nombre del driver en el anterior código, así como la situación de las bases de datos que se utilizaran.

3. Clases de dominio

El Mapeo de Objetos Relacionales de Grails (GORM) utiliza internamente Hibernate 3 , pero para poder implementar la aplicación Web no es necesario tener ningún conocim iento sobre Hibernate. Para realizar este mapeo Grails utiliza las llamadas clases de dominio , que determina los objetos mapeados en la base de datos. Se pueden linkar clases de dominio utilizando relaciones proporcionando metodos dinámicos para realizar operaciones CRUD (Create, R ead, Update, Delete), sobretodo mediante Scaffolding . Grails dispone de una instrucción para la creación automática de clases, que nos almacenará las nuevas clases en el directorio …/grails-app/domain/ , a dicha instrucción solamente le hemos de proporcio nar el nombre de la clase y ya tendremos una nueva clase disponible para configurar. Estas clases de dominio pueden disponer, además de sus propiedades y campos, de métodos propios y declarac iones de constraints para las propiedades y campos. Es posible establecer una relación de 1-1, 1-n o n-n entre cla ses directamente en la implementación de dichas clases, este y anteriores elementos los veremos en el siguiente ej emplo.

class Pet { String name String type String description Float price byte[] image static hasMany = [carts:Cart] static belongsTo = Cart static constraints = { name(maxLength:50, blank:false) type(inList:['Bird','Cat', 'Dog', 'Fish', 'Ferret ', 'Rodent'], blank:false) description() price(min:0f) image(nullable:true, maxSize:65536) /* 64K */ } static mapping = { description type: 'text' } }

$> grails create - domain - class



En el anterior ejemplo descubrimos las ventajas de las clases de dominio de Grails, las restricciones directas en código y la relación entre diferentes clases direct amente en código.

• Restricciones directas en código

Como podemos observar, utilizando una closure con e l nombre “constraints”, podemos configurar las restricciones que queremos que tengan las propiedad es y los campos de la clase, lo que nos facilitará la implementación posteriormente cuando se creen las vistas y los controladores.

• Relación entre clases directamente en código

Para realizar una relación entre clases, tan sólo s e ha de establecer una variable relacional:

o Sección 1 de la relación: Utilizaremos la variable belongsTo con valor igual a la clase con la que estamos relacionando.

o Sección n de la relación: Utilizaremos la variable anterior belongsTo, además de la variable hasMany con valor igual a la clase con la que estamos relacionando mediante un mapa extendido, especificando el nombre de la variable que almacenará la colección de valores.

4. Controladores y vistas

Una vez que las clases de dominio ya se han creado, es el momento de utilizar un nuevo comando de Grails que nos auto genera los CRUD básicos para nuestra aplicació n Web: Gracias a este comando se crean los llamados contro ladores y las vistas básicas que necesitaremos para gestion ar nuestra clase de dominio. Los controladores se almacenarán en el directorio grails-app\controllers . Dichos controladores son los responsables de el manejo de las peticiones de nuestra aplicació n Web. Los controladores son los sustitutos naturales de l os Servlets de Java , con la ventaja de que su implementación es tan sencilla como crear una closure por cada tip o de petición que queramos que atienda. A continuación v amos a ver un ejemplo de controladores e introduciremos el concepto de Scaffolding en Grails .

$> grails generate - all



class CartController { def index = { redirect(action:list,params:param s) } def scaffold = Cart def list = { if(!params.max) params.max = 10 [ cartList: Cart.list( params ) ] } def show = { def cart = Cart.get( params.id ) if(!cart) { flash.message = "Cart not found with id ${params.id}" redirect(action:list) } else { return [ cart : cart ] } } def delete = { def cart = Cart.get( params.id ) if(cart) { cart.delete() flash.message = "Cart ${params.id} dele ted" redirect(action:list) } else { flash.message = "Cart not found with id ${params.id}" redirect(action:list) } } def edit = { def cart = Cart.get( params.id ) if(!cart) { flash.message = "Cart not found with id ${params.id}" redirect(action:list) } else { return [ cart : cart ] } } def update = { def cart = Cart.get( params.id ) if(cart) { cart.properties = params if(!cart.hasErrors() && cart.save()) { flash.message = "Cart ${params.id} updated" redirect(action:show,id:cart.id) } else { render(view:'edit',model:[cart:cart ]) } } else { flash.message = "Cart not found with id ${params.id}" redirect(action:edit,id:params.id) } } def create = { def cart = new Cart() cart.properties = params return ['cart':cart] } def save = { def cart = new Cart(params) if(!cart.hasErrors() && cart.save()) { flash.message = "Cart ${cart.id} create d" redirect(action:cartBuy,id:params.id) } else { render(view:'create',model:[cart:cart]) } } }



En este ejemplo, podemos ver los controladores bási cos que se crean con el comando anterior, añadiendo además la opción de Scaffolding con la variable “scaffold”. Los controladores básicos son los de Creación, Actualización, Edición y Modificación, pero posteri ormente se pueden ir añadiendo funcionalidades como el logg ing de usuarios, etc... Una vez el controlador ha procesado la petición, la delega a la vista apropiada. Para realizarlo Grails utiliza un mecanismo de convención, en el cuál el controlador delega la petición a la vista que tiene su mismo nombre, l a cuál se encuentra almacenada en grails-app/views/name/ donde name es el nombre de la clase dominio. En dicha carpeta podemos encontrar la vista en formato JSP o GSP, ya que Grails admite ambos formatos.

5. Funcionalidad

Grails incorpora un servidor de management con el que se puede ejecutar nuestra aplicación de Grails antes de importarla. Utilizando el comando especifico: de compilación y ejecución con nuestra aplicación, el servidor inicia nuestra aplicación en la dirección http://localhost:8080/nameApp , donde “nameApp” es el nombre de nuestra aplicación Web.

Posteriormente podemos exportar nuestra aplicación en un fichero war para importarlo en un Tomcat utilizando el comando:

Después de esta breve introducción a Grails , realizaremos una aplicación Web de ejemplo basada en una tienda virt ual de mascotas, donde profundizaremos más en los aspectos de Grails además de una comparación directa con la implementa ción de una aplicación semblante en Java .

2.3 Conclusión Durante el desarrollo de este apartado hemos visto los problemas que tendremos que afrontar durante el desarrollo de proyecto, además de un pequeño estudio de las tecnologías que utilizaremos para el desarrollo de dicho proyecto. Los papeles d e las diferentes tecnologías en nuestro proyecto son:

$> grails r un- app

$> grails war



• Groovy: Lenguaje de programación base de Grails , con el que sin una pequeña práctica anterior al desarrollo del proyecto, no se habría podido realiz ar con soltura.

• Grails: Framework Web que nos asiste en la creación de nuestra aplicación Web y además nos hace dicha tarea más amena y sencilla.

Programación de una tienda virtual en Grails 3. Aná lisis


3. Análisis 3.1 Descripción del problema Tenemos la necesidad de crear un portal de una tien da virtual de mascotas, donde los visitantes de dicha página pued en ver los animales que hay en stock, así como sus descripcion es y posteriormente comprarlos si satisfacen sus necesid ades previo registro en la base de datos de la página. Además de la visión externa del portal y las activi dades que podemos realizar en ella, necesitamos poder gestion ar tanto los pedidos como el stock de animales y el registro de usuarios, mediante unas actividades especiales para el admini strador de la página.

3.2 Descripción del producto

El portal que desarrollaremos utilizará como apoyo el framework Web Grails . En dicho portal, el cliente navegará por la lista de mascotas a la venta y se autenticará en la página, previo registro, para poder gestionar la compra de las mas cotas que desee, además de poder editar sus datos de registro y realizar un seguimiento del estado de las compras que ha rea lizado previamente. El administrador del portal administrará la lista d e usuarios, mascotas y carritos de la compra. La creación de nu evas entradas en las listas de usuarios, además de su edición, ac tualización y eliminación; y la gestión de los carritos de la com pra de los clientes,, actualizando el estado de éstos según va ya evolucionando el pedido.

3.3 Requisitos funcionales En este apartado definiremos los requisitos funcion ales y la estructura fija de nuestro portal. En la siguiente figura podemos ver los elementos básicos que tendrá nuestr o portal.



3.3.1 Banner El portal, como todo portal que se precie, tendrá u n banner estático en el que se mostrará su temática mediante una imagen fija con la que se pueda relacionar fácilmente con la rama de comercio a la que está dirigido el portal. Será una imagen fija, sin opciones ni funciones añadidas. 3.3.2 Navigation Blocks Tendremos dos bloques de navegación, el propio de n avegación y el de contacto.

• TOOLS NAVIGATION BLOCK En este bloque de navegación, se proporcionarán dif erentes “atajos” a diferentes servicios del portal. Según e l usuario que se encuentre activo en la sesión, las o pciones del bloque de navegación variarán, ya que las opcio nes del administrador tienen que ser diferentes a la del us uario externo ya registrado o sin registrar. Las opciones que tendrá cada usuario serán:

o ADMINISTRADOR

� Pets administration : Acceso a la lista de mascotas dadas de alta en la página, donde además se podrán dar de alta nuevas mascotas, editar o eliminar mascotas ya registradas.

� Carts administration : Acceso a la lista de carritos de la compra tanto activos como pendientes o finalizados. En dicha lista se podrán modificar los carritos o eliminarlos.

� Users administration : Acceso a la lista de usuarios dados de alta en la página, donde además se podrán dar de alta nuevos usuarios, editar o eliminar usuarios ya registrados.

� Search : Acceso a la búsqueda de mascotas. � Log out : Salir de la sesión.

o USUARIO NO REGISTRADO

� Pets : Acceso a la lista de mascotas en venta,

donde se podrán comprar dichas mascotas previo registro/autenticación en el portal.

� Search : Acceso a la búsqueda de mascotas. � Register : Acceso a la página de registro de

usuarios. � Log in : Acceso a la página de autenticación de

usuarios ya registrados.



o USUARIO REGISTRADO

� Pets : Acceso a la lista de mascotas en venta, donde se podrán comprar dichas mascotas siguiendo unos pasos bien definidos.

� Profile : Acceso al perfil del usuario actual donde el usuario podrá modificar su información o eliminarse de la base de datos de la página.

� Cart : Acceso al carrito de compra activo, donde el usuario podrá eliminar las mascotas añadidas si no satisfacen sus necesidades, así como comprar dicho carrito.

� Search : Acceso a la búsqueda de mascotas. � Log out : Salir de la sesión.

• CONTACT NAVIGATION BLOCK

En este bloque de navegación, se proporcionarán dif erentes “atajos” a diferentes servicios del portal que se mantendrán estáticos para todos los usuarios. Los servicios a los que se proporcionan acceso son:

o Contact : Proporciona una dirección de contacto física con la tienda, así como un plug-in de Google Maps con la situación de la tienda.

o Information : Proporciona información sobre el portal. 3.3.3 Render Sección dinámica de nuestro portal donde se visuali zarán las diferentes páginas de servicios de nuestra aplicaci ón Web. Según el usuario que haya activo se podrá visualizar un t ipo de servicios u otros, ya que un usuario externo no pod rá visualizar el mismo contenido que el administrador, por lo que se restringirán los accesos a dichos servicios mediant e una instrucción propia de Grails insertada en cada uno de los archivos de controladores de las diferentes clases de domini o.

3.4 Requisitos no funcionales

• FACILIDAD DE USO Los accesos a los diferentes servicios del portal s on sencillos e intuitivos.

//Closure para controlar los accesos de los usuarios def beforeInterceptor = [action:this.&auth, except:['login', 'logout', 'show', 'create', 'update', 'delete', 'save']]



• RENDIMIENTO

El rendimiento de una aplicación Web depende en gra n medida de la capacidad de la red del usuario, pero intentaremos disminuir la carga reduciendo el peso de los atributos a cargar de la aplicación Web.

• INTERFICIE

La interficie debe ser lo más amigable e intuitiva posible.

3.5 Identificación de actores y objetivos En la aplicación habrá tres actores diferentes, por lo que cada uno tendrá unos objetivos diferentes, pero también comparten una serie de objetivos afines, dichos objetivos serán c ompartidos no por todos los tipos de actores, sino por los más re levantes: el Administrador y el Usuario Registrado.

• OBJETIVOS ADMINISTRADOR o Alta de mascotas. o Alta de carritos. o Edición de mascotas. o Eliminación de mascotas. o Acceso a la lista de usuarios. o Acceso a la lista de carritos de la compra.

• OBJETIVOS USUARIO REGISTRADO o Compra de mascotas. o Compra y finalización de carritos. o Eliminar mascotas del carrito. o Modificar el método de pago

• OBJETIVOS USUARIO NO REGISTRADO

o Log in

• OBJETIVOS AFINES

o Acceso a la lista de mascotas a la venta. o Acceso a la ficha de la mascota. o Acceso a la ficha del carrito de la compra. o Acceso a la ficha del usuario. o Alta de usuarios. o Edición de carritos. o Edición de usuarios. o Eliminación de carritos. o Eliminación de usuarios. o Búsqueda o Log out

Programación de una tienda virtual en Grails 4. Dis eño


4. Diseño 4.1 Casos de uso 4.1.1 Objetivos afines Acceso a la lista de mascotas a la venta Actor principal : Cualquier Usuario Personal involucrado e intereses :

Usuario : se quiere visualizar el contenido de la lista de mascotas a la venta.

Escenario principal de éxito :

1. El usuario quiere visualizar la lista de mascota s a la venta desde cualquier página . 2. El usuario clica en el botón de Pets/Pets Administration 3. Se carga la vista con la lista de mascotas a la venta.

Extensiones :

3a. Si el usuario está autenticado, se carga la vis ta con la lista de mascotas a la venta junto con una visua lización del carrito de la compra.

Acceso a la ficha de la macota Actor principal : Usuario Registrado y Administrador Personal involucrado e intereses :

Usuario Registrado y Administrador : se quiere visualizar la ficha de una mascota en concreto.


1. El usuario quiere visualizar la ficha de una mas cota en concreto desde la página de mascotas a la venta . 2. El usuario clica sobre el identificador de la ma scota. 3. Se carga la vista con la ficha de la mascota correspondiente.

Extensiones :

1a. El usuario quiere visualizar la ficha de una ma scota en concreto desde el carrito de la compra . 2a. El usuario clica sobre el nombre de la mascota.

Acceso a la ficha del carrito de la compra Actor principal : Usuario Registrado y Administrador Personal involucrado e intereses :

Usuario Registrado y Administrador : se quiere visualizar la ficha de un carrito de la compra en concreto.




1. El usuario quiere visualizar la ficha de un carr ito de la compra desde cualquier página . 2. El usuario clica en el botón de Cart/Carts Administration 3. (Usuario) Se carga la vista con el carrito de la compra activo para ese usuario.

Extensiones :

3a. (Administrador) Se carga la vista de la lista d e carritos de la compra.

1. (Administrador) El usuario clica sobre el identificador del carrito. 2. (Administrador) Se carga la vista con el carrito de la compra activo para ese usuario.

Acceso a la ficha del usuario Actor principal : Usuario Registrado y Administrador Personal involucrado e intereses :

Usuario Registrado y Administrador : se quiere visualizar la ficha de un usuario en concreto.


1. El usuario quiere visualizar la ficha del usuari o desde cualquier página . 2. El usuario clica en el botón de Profile/Users Administration 3. (Usuario) Se carga la vista con la ficha del usu ario actual.

Extensiones :

3a. (Administrador) Se carga la vista de la lista d e usuarios.

1. (Administrador) El usuario clica sobre el identificador del usuario. 2. (Administrador) Se carga la vista con la ficha d el usuario.

Edición de carritos Actor principal : Usuario Registrado y Administrador Personal involucrado e intereses :

Usuario Registrado y Administrador : se quiere editar la información de un carrito de la compra.


1. El usuario modificará algún campo perteneciente al carrito de la compra . 2. El usuario clica en el botón de Cart/Carts Administration 3. (Usuario) Se carga la vista con la ficha carrito actual. 4. El usuario clica sobre el botón Edit .



5. El usuario modifica los atributos que desee y sa lva los datos mediante el botón Save .

Extensiones :

3a. (Administrador) Se carga la vista de la lista d e carritos.

1. (Administrador) El usuario clica sobre el identificador del carrito. 2. (Administrador) Se carga la vista con la ficha d el carrito. 3. (Administrador) Se continúa con el punto 4.

Alta de usuarios Actor principal : Usuario No Registrado y Administrador Personal involucrado e intereses :

Usuario No Registrado y Administrador : se quiere dar de alta un nuevo usuario.


1. El usuario dará de alta un nuevo usuario . 2. El usuario clica en el botón de Register/Users Administration 3. (Usuario) Se carga la vista con la ficha de regi stro. 4. El usuario rellena los campos necesarios y salva los datos mediante el botón Save .

Extensiones :


1. (Administrador) El usuario clica sobre el botón Create . 2. (Administrador) Se carga la vista con la ficha d e registro. 3. (Administrador) Se continúa con el punto 4.

Edición de usuarios Actor principal : Usuario Registrado y Administrador Personal involucrado e intereses :

Usuario Registrado y Administrador : se quiere editar la información de un usuario.


1. El usuario modificará algún campo perteneciente al usuario . 2. El usuario clica en el botón de Profile/Users Administration 3. (Usuario) Se carga la vista con la ficha del usu ario actual. 4. El usuario clica sobre el botón Edit .



5. El usuario modifica los atributos que desee y sa lva los datos mediante el botón Save .

Extensiones :


1. (Administrador) El usuario clica sobre el identificador del usuario. 2. (Administrador) Se carga la vista con la ficha d el usuario. 3. (Administrador) Se continúa con el punto 4.

Eliminación de carritos Actor principal : Usuario Registrado y Administrador Personal involucrado e intereses :

Usuario Registrado y Administrador : se quiere eliminar un carrito de la compra.


1. El usuario eliminará algún carrito de la compra . 2. El usuario clica en el botón de Cart/Carts Administration 3. (Usuario) Se carga la vista con la ficha carrito actual. 4. El usuario clica sobre el botón Delete y confirma la eliminación.

Extensiones :

2a. (Usuario) El usuario clica en el botón Profile. 1. (Usuario) Clica en el identificador de carrito que

quiere eliminar. 2. (Usuario) Se carga la vista con la ficha del

carrito a eliminar. 3. (Usuario) Se continúa con el punto 4.

3a. (Administrador) Se carga la vista de la lista d e carritos.

1. (Administrador) El usuario clica sobre el identificador del carrito. 2. (Administrador) Se carga la vista con la ficha d el carrito a eliminar. 3. (Administrador) Se continúa con el punto 4.

Eliminación de usuarios Actor principal : Usuario Registrado y Administrador Personal involucrado e intereses :

Usuario Registrado y Administrador : se quiere eliminar un usuario.


1. El usuario eliminará algún usuario .



2. El usuario clica en el botón de Profile/Users Administration 3. (Usuario) Se carga la vista con la ficha del usu ario actual. 4. El usuario clica sobre el botón Delete y confirma la eliminación.

Extensiones :


1. (Administrador) El usuario clica sobre el identificador del usuario. 2. (Administrador) Se carga la vista con la ficha d el usuario a eliminar. 3. (Administrador) Se continúa con el punto 4.

Búsqueda Actor principal : Cualquier Usuario Personal involucrado e intereses :

Usuario : se quiere realizar una búsqueda de alguna mascota . Escenario principal de éxito :

1. El usuario eliminará realizará una búsqueda de a lguna mascota . 2. El usuario clica en el botón de Search 3. Se carga la vista con la ficha de búsqueda. 4. El usuario rellena los campos necesarios para re alizar la búsqueda. 5. Se carga la vista con los resultados de la búsqu eda.

Log out Actor principal : Usuario Registrado y Administrador Personal involucrado e intereses :

Usuario Registrado y Administrador : se quiere cerrar la sesión actual.


1. El usuario cerrará la sesión actual . 2. El usuario clica en el botón de Log out 3. Se cierra la sesión y se carga la vista de la pá gina de inicio.

4.1.2 Objetivos Administrador Alta de mascotas Actor principal : Administrador Personal involucrado e intereses :



Administrador : se quiere dar de alta una nueva mascota en el sistema.


1. El usuario quiere dar de alta una nueva mascota en el sistema . 2. El usuario clica en el botón de Pets Administration 3. Se carga la vista de la lista de mascotas. 4. El usuario clica el botón Create . 5. Se carga la vista con la plantilla de mascotas. 6. El usuario rellena los campos necesarios y guard a los cambios con el botón Save.

Alta de carritos de la compra Actor principal : Administrador Personal involucrado e intereses :

Administrador : se quiere dar de alta un nuevo carrito en el sistema.


1. El usuario quiere dar de alta un nuevo carrito e n el sistema . 2. El usuario clica en el botón de Carts Administration 3. Se carga la vista de la lista de carritos. 4. El usuario clica el botón Create . 5. Se carga la vista con la plantilla de carritos. 6. El usuario rellena los campos necesarios y guard a los cambios con el botón Save.

Edición de mascotas Actor principal : Administrador Personal involucrado e intereses :

Administrador : se quiere editar la ficha de una mascota en concreto.


1. El usuario quiere editar la ficha de una mascota en concreto . 2. El usuario clica en el botón de Pets Administration 3. Se carga la vista de la lista de mascotas. 4. El usuario clica sobre el identificador de la ma scota. 5. (Administrador) Se carga la vista con la ficha d e la mascota. 6. El usuario clica sobre el botón Edit . 7. El usuario modifica los atributos que desee y sa lva los datos mediante el botón Save .



Eliminación de mascotas Actor principal : Administrador Personal involucrado e intereses :

Administrador : se quiere eliminar una mascota. Escenario principal de éxito :

1. El usuario eliminará alguna mascota . 2. El usuario clica en el botón de Pets Administration 3. Se carga la vista de la lista de mascotas. 4. El usuario clica sobre el identificador de la ma scota. 5. Se carga la vista con la ficha de la mascota a e liminar. 6. El usuario clica sobre el botón Delete y confirma la eliminación.

Acceso a la lista de usuarios Actor principal : Administrador Personal involucrado e intereses :

Administrador : se quiere acceder a la lista de usuarios. Escenario principal de éxito :

1. El usuario accederá a la lista de usuarios . 2. El usuario clica en el botón de Users Administration 3. Se carga la vista de la lista de usuarios.

Acceso a la lista de carritos de la compra Actor principal : Administrador Personal involucrado e intereses :

Administrador : se quiere acceder a la lista de carritos de la compra.


1. El usuario accederá a la lista de carritos de la compra . 2. El usuario clica en el botón de Carts Administration 3. Se carga la vista de la lista de carritos de la compra.

4.1.3 Objetivos Usuario Registrado Compra de mascotas Actor principal : Usuario Registrado Personal involucrado e intereses :

Usuario Registrado : se quiere realizar la compra de una mascota.



Escenario principal de éxito : 1. El usuario quiere realizar la compra de una masc ota . 2. El usuario clica en el botón de Pets. 3. Se carga la vista de la lista de mascotas a la v enta. 4. El usuario clica el botón Buy it! . 5. Se carga la vista con el carrito actual y la mas cota añadida.

Compra y finalización de carritos Actor principal : Usuario Registrado Personal involucrado e intereses :

Usuario Registrado : se quiere realizar la compra y finalización de un carrito.


1. El usuario quiere realizar la compra y finalizac ión de un carrito . 2. El usuario clica en el botón de Cart. 3. Se carga la vista con el carrito actual. 4. El usuario clica el botón Buy Cart. 5. Se carga la vista con la factura de la compra.

Extensiones :

6a. El usuario clica el botón Edit para modificar e l método de pago.

1. El usuario modifica el método de pago. 2. El usuario salva los datos con el botón Save . 3. Se continúa con el punto 5.

Eliminar mascotas del carrito Actor principal : Usuario Registrado Personal involucrado e intereses :

Usuario Registrado : se quiere eliminar una mascota añadida del carrito de la compra.


1. El usuario quiere eliminar una mascota añadida d el carrito de la compra . 2. El usuario clica en el botón de Cart. 3. Se carga la vista con el carrito actual. 4. El usuario clica el botón de eliminación que hay al lado de cada mascota añadida . 5. Se vuelve al paso 3.

Modificar el método de pago Actor principal : Usuario Registrado Personal involucrado e intereses :



Usuario Registrado : se quiere modificar el método de pago. Escenario principal de éxito :

1. El usuario quiere modificar el método de pago . 2. El usuario clica en el botón de Cart. 3. Se carga la vista con el carrito actual. 4. El usuario clica el botón Edit para modificar el método de pago. 5. El usuario modifica el método de pago. 6. El usuario salva los datos con el botón Save .

4.1.4 Objetivos Usuario No Registrado Log in Actor principal : Usuario No Registrado Personal involucrado e intereses :

Usuario No Registrado : se quiere iniciar una nueva sesión. Escenario principal de éxito :

1. El usuario quiere iniciar una nueva sesión . 2. El usuario clica en el botón de Log in. 3. Se carga la vista de autenticación. 4. El usuario rellena los campos e inicia la sesión .

4.2 Diagramas Siguiendo el modelo Vista-Controlador en que está b asado Grails el cuál simplifica el desarrollo de aplicaciones We b mediante la reducción de archivos de configuración y generando automáticamente la mayoría de elementos necesarios por una aplicación Web sobre una base de datos



VIEW

PET

CONTROLLER

realizaremos el diseño del diagrama de clases de nu estra aplicación. El hecho de que se trate de una aplicac ión Web, para una comprensión más sencilla, proporcionaremos un d iagrama de dominio de las clases, el modelo Vista-Controlador mencionado anteriormente y un mapa de portal el cuál nos infor mará sobre la navegación dentro del portal. 4.2.1 Diagrama de dominio El diagrama de dominio de nuestra aplicación Web, n os ayudará a la comprensión de la configuración de la base de da tos de nuestra aplicación y nos dará una idea de la estruc turación de nuestro portal. Como podemos observar, tendremos 3 clases principal es relacionadas entre sí, las cuáles serán la base de la estructura de la base de datos y de la aplicación Web. 4.2.2 Modelo Vista-Controlador En nuestra aplicación, el Controlador recoge las pe ticiones realizadas por el servidor, posteriormente genera l os datos necesarios y la vista que se mostrará en el Render del navegador del usuario. Realizaremos tres modelos de Vista-Con trolador, uno por cada Clase de dominio. 4.2.2.1 Vista-Controlador User El usuario realiza una acción en el portal, el cuál envía una petición al controlador, el cuál genera la vista de la respuesta a la petición del usuario. Los controladores que generan las vistas para el usuario son los básicos del CRUD a los cuáles añadimos los realizados para la gestión de otras peticiones.

PET

USER

CART

1

N

N

N



Los controladores que generan las vistas para el us uario son los básicos del CRUD a los cuáles añadimos los realizad os para la gestión de otras peticiones.

• Login : Controlador que comprueba que el usuario introducido y la contraseña corresponden a los alma cenados en la base de datos, y si coincide, se almacena en la variable de sesión para la gestión de usuarios en l os demás servicios de los portales.

• Logout : Controlador que cierra la sesión del usuario activo y redirige el portal a la página de inicio p or defecto.

4.2.2.2 Vista-Controlador Pet El usuario realiza una petición en un elemento perteneciente a la clase de dominio de las mascotas que es gestionada por los controladores de dicha clase de dominio generando los elementos de la vista que se renderizará. Los controladores que generan las vistas para la petición del usuario en el elemento de mascotas, son los básicos del CRUD a los cuáles añadimos los realizad os para la gestión de otras peticiones.

• Upload_image : Controlador que gestiona el almacenamiento de la imagen correspondiente a la mascota que se cr ea o edita.

• Image_link : Controlador que crea el link con la imagen correspondiente a la mascota actual.

• Search : Controlador que gestiona la búsqueda de mascotas siguiendo un tipo de búsqueda establecido por el us uario.

4.2.2.3 Vista-Controlador Cart El usuario realiza una petición en un elemento perteneciente a la clase de dominio del carrito que es gestionada por los controladores de dicha clase de dominio generando los elementos de la vista que se renderizará. Los controladores que generan las vistas para la petición del usuario en el elemento del carrito, son los básicos del CRUD a los cuáles añadimos

VIEW

USER

CONTROLLER

VIEW

CART

CONTROLLER



los realizados para la gestión de otras peticiones.

• CartBuy : Controlador que gestiona la compra de las mascotas añadiéndolas al carrito activo.

• EndCart : Controlador que gestiona la compra del carrito estableciendo el método de pago que utilizará el us uario.

• DelOfCart : Controlador que muestra el estado final del carrito una vez confirmada la compra del mismo.

4.2.3 Site Maps Los Site Maps de nuestra aplicación Web, nos propor cionan información sobre la navegación entre las diferente s páginas

Admin login

Home Page

Pets list Search Carts List Logout

Search ResultShow PetDelete UpdateStatusUpdate

Users

Update DeleteDelete Show User



Todos los objetos mostrados en los Site Maps están representados por controladores de las diferentes clases los cuál es se explicarán en el apartado de Implementación .

User login

Home Page

Pets list sale Search Cart Logout

Show Pet Search ResultBuy Pet

Profile

Update Delete Buy cart Update Delete

Pay Mode

Confirm

Programación de una tienda virtual en Grails 5. Imp lementación


5. Implementación y pruebas 5.1 Entorno de desarrollo Así como en el apartado de análisis hemos realizado una valoración inicial antes de implementar el código, en este apartado realizaremos un balance de algunas herrami entas utilizadas para la implementación del proyecto. 5.1.1 GNU/Linux El sistema operativo escogido para programar la apl icación es GNU/Linux. Se ha escogido este sistema porque ofrec e un entorno de programación más amigable para el desarrollador además de ser de libre distribución. Grails , como Java , ofrece una compatibilidad con cualquier sistema operativo, lo que hace que el sistema operativo en que se haya desarrollado no sea relevante. 5.1.2 GEdit El editor de texto por defecto del entorno Gnome de GNU/Linux , que ofrece la posibilidad de inclusión de diferente s plugins que hacen más sencillo el desarrollo de aplicaciones en cualquier lenguaje de programación. 5.1.3 Mozilla Firefox 2.14 Firefox ha sido el navegador elegido para realizar las pruebas de nuestra aplicación Web, aunque como con el siste ma operativo, la implementación final no establece un navegador p or defecto, por lo que el navegador Web tampoco es relevante. 5.1.4 Groovy Como ya he comentado varias veces durante la memori a, mi conocimiento sobre este lenguaje de programación er a nulo antes del inicio de este proyecto, por este motivo y al s er una de las partes fundamentales del proyecto, este lenguaje de Scripting dispone de su propio apartado en esta memoria. La c ompatibilidad en los sistemas operativos es muy alta, ya que tant o Mac, Unix/Linux como Windows son compatibles con este lenguaje importando sus librerías. 5.1.5 Grails Al igual que Groovy, el framework Web Grails tambien dispone de un apartado propio en la memoria debido a su releva ncia en este proyecto. La compatibilidad en los sistemas operati vos es muy alta, ya que tanto Mac, Unix/Linux como Windows son compatibles con este lenguaje importando sus librerías.



5.2 Seguimiento y problemáticas En este apartado realizaremos un seguimiento a la i mplementación de nuestra aplicación Web, durante el cuál también iremos descubriendo las diferentes problemáticas con las q ue nos hemos encontrado durante dicha implementación.

5.2.1 Estructura y persistencia El primer paso de una implementación en Grails es establecer la estructura de nuestro proyecto, para ello, Grails , aporta un comando especial que nos asiste en la construcción de la estructura de nuestro proyecto. Creamos una carpeta en cualquier directorio de nues tro sistema operativo, e introducimos el siguiente comando de Grails : con este comando creamos la estructura de nuestro p royecto que quedará dividido en diferentes carpetas distribuida s según la funcionalidad que tienen dentro del proyecto. Una vez ya hemos establecido la estructura del proy ecto configuramos la persistencia de datos mediante la c reación de una base de datos (en nuestro caso MySQL) y posteri or configuración en nuestro proyecto de dicha BBDD. Pa ra ello descargamos el driver de la BBDD que queremos utili zar para la persistencia de datos y lo almacenamos en la carpet a …/lib . Posteriormente configuramos el fichero …/grails-app/conf/ApplicationDataSource.groovy en el cuál estructuramos el fichero según las diferentes BBDD que se utiliza ran para los diferentes estados de creación de la aplicación Web .

$> grails create-app projectName

dataSource { pooled = false driverClassName = "com.mysql.jdbc.Driver" username = "root" password = "" } … environments { development { dataSource { dbCreate = "update" // one of 'create', 'create-drop','update' url = "jdbc:mysql://localhost/petStore_dev" } } test { dataSource { dbCreate = "update" url = "jdbc:mysql://localhost/petStore_test" } } production { dataSource { dbCreate = "update" url = "jdbc:mysql://localhost/petStore_prod;shutdown=true " } } }



Como podemos observar configuramos el fichero con e l driver que hemos descargado, con su usuario y password, además del path de cada BBDD que vamos a utilizar durante el desarroll o del proyecto. A continuación creamos las clases de dominio más re levantes de nuestro proyecto utilizando un comando de Grails , las cuales posteriormente también se utilizará su estructura e n la BBDD. Para la creación de estas clases seguiremos el diag rama de dominio del apartado de diseño. Creamos la clase de dominio mediante el comando de Grails y posteriormente rellenamos las clases con los atribu tos, las constraints y las relaciones entre las clases.

PET

USER

CART

1

N

N

N

$> grails create - domain - class pet

import grails.util.GrailsUtil import org.springframework.web.multipart.MultipartF ile import org.codehaus.groovy.grails.commons.Configura tionHolder class Pet { String name String type String description Float price byte[] image static hasMany = [carts:Cart] static belongsTo = Cart static constraints = { name(maxLength:50, blank:false) type(inList:['Bird','Cat', 'Dog', 'Fish', 'Ferret ', 'Rodent'], blank:false) description() price(min:0f) image(nullable:true, maxSize:65536) /* 64K */ } static mapping = { description type: 'text' } }



Para finalizar este punto, establecemos la estructu ra de la BBDD mediante otro comando de Grails, el cuál inicia la aplicación Web a la vez que crea la estructura de la aplicació n en la BBDD.

$> grails run - app

$> grails create - domain - class cart

class Cart { String status String payment String numberTarget Float total Map contentBuy=[1 : 1] static hasMany = [pets:Pet] static belongsTo = [user:User] static constraints = { payment(inList:['Card','Against reimbursement']) status(inList:['In process', 'Pending', 'Complete d']) total(min:0f) } }

$> grails create - domain - class user

class User { String name String firstName String lastName String NIF String postalAddress String emailAddress String userId String password static hasMany = [carts:Cart] static constraints = { userId(length:5..8, unique:true) password(length:6..8) name(blank:false) firstName(blank:false) lastName(blank:false) NIF(length:9,unique:true) postalAddress(maxLength:255,blank:true) emailAddress(maxLength:50,blank:false,email:true) } }



5.2.2 Controladores y vistas Una vez configurada la estructura de la aplicación, sus clases de dominio y la Base de Datos, necesitamos configur ar los controladores de las clases y sus respectivas vista s mediante comandos de Grails y la posterior personalización editando los ficheros que se crearán. Mediante este comando de Grails se generan los controladores y las vistas básicos para realizar tareas CRUD. Posteriormente los editaremos para añadir funcionalidades a los contro ladores y crearemos sus respectivas vistas. A continuación veremos las funcionalidades añadidas a los controladores y las ventajas que ha supuesto su imp lementación en Groovy y el uso de gsp’s para las vistas. 5.2.2.1 Controladores Base Controller Base Controller es un pequeño controlador del cuál extienden todos los Controladores que proporciona un chequeo continuo de los accesos a los controladote, comprobando que el usuario esta autentificado y compara los permisos con de acceso con los establecidos en cada controlador. Pets Como veremos a continuación, en el controlador de m ascotas ( Pet ) añadiremos las funciones de Cargar imágenes y Búsqueda , además de los permisos de acceso a los controladores y la variable de Scaffolding . Cargar imágenes nos proporciona la posibilidad de subir imágenes para añadirlas al perfil de las masc otas y Búsqueda nos proporciona el servicio de realizar búsquedas entre la lista de mascotas a la venta. Permisos de acceso y Scaffolding

$> grails generate-all className

abstract class BaseController{ def auth(){ if(!session.userId){ redirect(controller:'user', action:'login') return false } } }

… def scaffold = Pet //Closure para controlar los accesos de los usu arios def beforeInterceptor = [action:this.&auth, exc ept:['show', 'list']] …



Como podemos observar, la restricción es para cualq uier acción excepto para show y list .

Cargar imágenes

Como podemos observar, la problemática más grande q ue ha tenido este servicio del controlador ha sido la configuración de los contenidos aceptados y el alma cenaje de la imagen subida mediante la distribución de las re ferencias entre la base de datos y el objeto subido.

Búsqueda

… def upload_image = {

def pet = Pet.current(session)

// Obtenemos el fichero de la imagen del request mu lti-parte def f = request.getFile('image')

// Listado de las extensiones permitidas def okcontents = ['image/png', 'image/jpeg', 'imag e/gif'] if(! okcontents.contains(f.getContentType())){ flash.message = "La imagen debe tener la extensió n: ${okcontents}" render(view:'create', model:[pet:pet]) return; } // Guardamos la imagen y su extension pet.image = f.getBytes() log.info("Imagen subida") // Validamos el trabajo, comprobamos que la imagen no sea muy grande if(!pet.save()){ render(view:'create', model:[pet:pet]) return; }

flash.message = "Imagen subida correctamente." // redirect(action:'show') } def image_link = { def imagePet = Pet.get(params.id) if(!imagePet || !imagePet.image){ response.sendError(404) return; } OutputStream out = response.getOutputStream(); out.write(imagePet.image); out.close(); } …

… def search = {

if(request.method == 'POST'){ def auxName = params.name def auxType = params.type params.name = null params.type = null PetQuery query = new PetQuery() bindData(query, params) /*if(auxName != null){ if(auxType != null){ render(view:'list', model:[petList:Pet.findAllByNameLikeAndTypeLike('%' + auxName + '%', '%' + auxType + '%')])



Para la implementación de este controlador, se han realizado dos pasos previos:

• Creación de una clase Java llamada PetQuery , que únicamente está formada por la definición de los atributos que se van a utilizar en las consultas y sus respectivos métodos getter y setter.

• Uso de una clase propia de Grails , criteria , que nos proporciona un sistema de búsqueda más sencillo y eficaz.

Una vez realizados estos dos pasos previos, se han configurado las llamadas a dicha clase Java y a criteria , y los parámetros de búsqueda que se quieran utiliza r mediante diferentes condicionales, y finalmente ret ornando el resultado de dicha búsqueda.

Cart Como veremos a continuación, en el controlador de c arritos (Cart) añadiremos las funciones de Compras del carrito , Eliminación del carrito y Finalización del carrito , además de los permisos de acceso a los controladores y la var iable de Scaffolding . Compras del carrito nos proporciona una vista del contenido del carrito así como la posibilidad de añ adir o

}else{ render(view:'list', model:[petList: Pet.findAllByNameLike('%' + auxName + '%')]) } }else{ render(view:'list', model:[petList: Pet.findAllByTypeLike('%' + params.type + '%')]) }*/ def criteria = Pet.createCriteria() def results = criteria { and { like('name', '%' + auxName + '%') like('type', '%' + auxType + '%') if(query.price) { switch (query.priceOperator) { case PetQuery.PriceOperator.AT_LEAST: ge('price', query.price) break case PetQuery.PriceOperator.EXACTLY: eq('price', query.price) break case PetQuery.PriceOperator.AT_MOST: le('price', query.price) break default: log.error "Found unexpected value for price" + "operator - ${query.priceOperato r}" } } } } render(view:'list', model:[raceList:results]) } } …



eliminar mascotas a dicho carrito, Eliminación del carrito nos proporciona la posibilidad de eliminar mascotas aña didas al carrito y Finalización de carrito , como su propio nombre indica, nos da la posibilidad de finalizar la compra propor cionándonos una “factura electrónica” del pedido. Permisos de acceso y Scaffolding

Como podemos observar, la restricción es para cualq uier acción.

Compras del carrito

… def scaffold = Cart //Closure para controlar los accesos de los usu arios def beforeInterceptor = [action:this.&auth] …

… def cartBuy = { def user = User.findByUserId(session.userId); params.petId = params.id def cart = null; def value = null if(user.name == 'default'){ redirect(controller:'user', action:'login') } def findCart = { if(it.status ==~ 'In process'){ cart = it } } user.carts.each(findCart); if(cart == null){ //redirect(action:create) params.status='In process' params.payment='Against reimbursement' params.numberTarget='' params.total=0.0 params.user=user save() if(params.petId == null) redirect(controller:'pet ', action:'listPetsSale') } if(params.id != null){ def pet = Pet.findById(params.petId) if(pet != null){ if(cart.contentBuy.containsKey(pet.id)){ value = cart.contentBuy.get(pet.id) cart.contentBuy.put(pet.id, value+1) }else{ cart.pets.add(pet) cart.contentBuy.put(pet.id, 1) } cart.total += pet.price } } params.petId = null return [ 'cart' : cart ] } …



Como podemos observar, este servicio nos proporcion a tanto la compra de mascotas como la visión del contenido del carrito. Si el usuario compra una mascota o quiere ver el contenido de su carrito y no tiene ninguno activo s e le crea automáticamente uno. Si el usuario solo quiere ver el contenido del carrito se le carga la vista apropiad a, sino el sistema busca el animal que se desea comprar y s e le añade al carrito, posteriormente carga la vista de carrito actual. La problemática más relevante que me he enc ontrado a la hora de realizar este controlador era el uso de HashMaps para almacenar el contenido del carrito conjuntamen te con la cantidad de animales del mismo tipo añadidos, el cu ál se solvento con un tipo de declaración mixta de Java y Groovy en la clase Cart .

Eliminación del carrito

Este servicio nos proporciona la posibilidad de eli minar del contenido del carrito una mascota que ya no que remos comprar, posteriormente actualiza la vista del carr ito actual.

Finalización del carrito

… def endCart ={ def user = User.findByUserId(session.userId); def cart = null; def findCart = { if(!it.status ==~ 'In process'){ cart = it } } user.carts.each(findCart); cart.setStatus('Pending'); return[ 'user' : user, 'cart' : cart ] } …

… def delOfCart = { def user = User.findByUserId(session.userId); def pet = Pet.findById(params.id); def value = null def findCart = { if(it.status ==~ 'In process'){ if(cart.contentBuy.get(pet.id)>1){ value = cart.contentBuy.get(pet.id) cart.contentBuy.put(pet.id, value - 1) }else{ it.contentBuy.remove(pet.id) it.pets.remove(pet) } it.total = it.total - pet.price redirect(action:cartBuy) } } user.carts.each(findCart); } …



Por último, este servicio nos da la posibilidad de finalizar la compra proporcionándonos una “factura electrónica” con el pedido realizado.

User Como veremos a continuación, en el controlador de u suarios (User) añadiremos las funciones de Log in y Log out, ya que el registro se realiza con el método de creación por d efecto, además de los permisos de acceso a los controladore s y la variable de Scaffolding . Log in nos proporciona la posibilidad de autenticarnos en el sistema y Log out todo lo contrario, nos proporciona la posibilidad de salir del sistema. Permisos de acceso y Scaffolding

Como podemos observar, la restricción es para cualq uier acción excepto para login, create y save .

Log in

Como podemos observar, el controlador comprueba que haya algún usuario registrado, sino se crea uno nuevo. S i existen usuario, el sistema comprueba que existe en el sist ema y según que tipo de usuario es carga una vista u otra .

… def scaffold = Cart //Closure para controlar los accesos de los usu arios

def beforeInterceptor = [action:this.&auth , except:['login', 'create', 'save']] …

… def login = { if(request.method == "GET"){ session.userId = null def user = new User() }else{ def user = User.findByUserIdAndPassword(params.us erId, params.password) if(user){ session.userId = user.userId session.password = user.password if(user.userId == 'admin'){ redirect(uri:'/cart/list') }else{ redirect(uri:'/user/profile') } }else{ flash['message'] = 'Please enter a valid user ID and password' } } } …



Log out

Como podemos observar, el controlador establece el usuario por defecto como usuario activo y redirecciona a la página principal.

5.2.2.2 Vistas Una vez configurados los controladores pasamos a la creación de las vistas necesarias para cada controlador. Grails utiliza un sistema de asignación, el cuál por cada controlador que se crea nuevo tiene que haber una vista con el mismo nombre en formato gsp, aunque es posible realizar unos pequeños retoq ues que no hagan necesario este requisito previo. Para ello se ha utilizado el editor de texto para implementar cada nueva vist a según el estándar de Grails . A continuación se mostrarán los tags más relevantes de cada vista sin necesidad de entrar mucho en detalle. Pets Las nuevas vistas que se han tenido que implementar corresponden a los nuevos controladores creados para la clase Pe t, es decir, Cargar imágenes y Búsqueda . Cargar imágenes

Como podemos observar, para cargar la nueva imagen se utiliza un tag propio de las gsp que proporciona la posibilidad de subir diferentes tipos de archivos, además de otras utilidades.

… def logout = { session.userId = 'default' session.password = 'default' flash['message'] = 'Successfully logged out' redirect(uri:'/') } …

… <fieldset>

<legend>Pet Image Upload</legend> <g:form action="upload_image" method="post" enctype ="multipart/form-

data"> <label for="image">Image (64K)</label>

<input type="file" name="image" id="image"/> <div style="font-size:0.8em; margin: 1.0em;"> Ok, for best results, your image should have a w idth-to-height ratio of 4:5. </div> </g:form> </fieldset> …



Búsqueda

Este detalle de la implementación de la vista nos m uestra el menú de búsqueda en el que podemos introducir el no mbre, tipo y margen de precio mediante tags propios de ht ml como de gsp’s.

Carts Las nuevas vistas que se han tenido que implementar corresponden a los nuevos controladores creados para la clase Ca rt, es decir, Compras del carrito y Finalización del carrito , ya que Eliminación del carrito está implementada junto con Compras del carrito mediante un sencillo tag que veremos a continuació n. Compras del carrito y Eliminación del carrito

… <table> <tr class='prop'> <td valign='top' class='name'> <label for='type'>Name:</label> </td> <td valign='top' class='name'> <input type:="text" maxlengt='30' name='name'> </input> </td> </tr> <tr class='prop'> <td valign='top' class='name'> <label for='type'>Type:</label> </td> <td valign='top' class='value'> <g:select name='type' from='${[""] + new Pet().constraints.type.inList}'> </g:select> </td> </tr> <tr class='prop'> <td valign='top' class='name'> <label for='price'>Price:</label> </td> <td valign='top' class='value'> <select name='priceOperator' > <option value='AT_LEAST' >At least</option> <option value='EXACTLY' >Exactly</option> <option value='AT_MOST' >At most</option> </select> <input type='text' name='price' size='5'> </input> € </td> </tr> </table> …

… <g:if test="${cart.payment==~'Card'}">

<tr class="prop"> <td valign="top" class="name">Number Target:</td> <td valign="top"

class="value">${cart.numberTarget}</td> </tr> </g:if>



Lo más relevante en el código de esta vista es el u so del tag de condición if propio de gsp’s, además de las llamadas a los diferentes controladores mediante botones que tienen asignada un tipo de acción a realizar. Para el cont rolador de eliminación vemos como mediante un bucle va most rando todas las mascotas que hay en el carrito y gracias a un tag link própio de gsp’s da la posibilidad de eliminar la mascota seleccionada.

Finalización del carrito

La vista asignada a este controlador no dio ninguna complicación al momento de implementarla, ya que so lamente muestra por pantalla una pequeña factura con el con tenido del carrito y la información del comprador.

Users Las nuevas vistas que se han tenido que implementar corresponden a los nuevos controladores creados para la clase Us er, es decir, Log in y Log out , ya que el registro de nuevos usuarios se realiza mediante el controlador de creación por def ecto.

Log in

<tr class="prop"> <td valign="top" class="name">Pets:</td> <td valign="top" class="value"> <g:each in="${cart.pets}" status="i" var="pet">

<g:link controller="pet" action="show" id="${pet.id}">${pet.name}</g:link>

<p> ${pet.price} €</p> <p>Quantity: <g:link controller="cart"

action="delOfCart" params="[id:pet.id]" onclick="re turn confirm('Are you sure?');"><img src="${createLinkTo(dir:'images/skin',file:'databas e_delete.png')}" alt="Delete" /></g:link>

<br> </g:each> </td> </tr> … <div class="buttons">

<g:form> <input type="hidden" name="id" value="${cart ?.id}" /> <span class="button"><g:actionSubmit class= "edit"

value="Edit" /></span> <span class="button"><g:actionSubmit class= "delete"

onclick="return confirm('Are you sure?');" value="D elete" /></span> <span class = "button"><g:link controller="cart"

action="endCart" onclick="return confirm('Are you s ure?');">Buy Cart</g:link></span> </g:form>

</div> …

… <td valign='top' class='value'>

<input type="text" maxlength='8' name='userId' value='${user?.userId}'>

</input> </td>

</tr> <tr class='prop'> <td valign='top' class='name'> <label for='password'>Password:</label> </td> <td valign='top' class='value'>



Las secciones más relevantes del código de esta vis ta son la introducción de valores mediante cuadrados de te xto y el botón de autenticación mediante un tag propio de las gsp’s.

Log out

Este controlador, al igual que paso con Eliminación del carrito de la clase Cart no tiene ninguna vista asociada, ya que una vez se sale de la sesión se redirecciona a la vista de la página inicial. Para realizar el cierre de sesión se realiza la llamada mediante un botón que se encuentra en la barra de navegación de la aplicació n, la cuál explicaremos a continuación en el apartado de extras.

5.2.3 Extras En este apartado veremos los extras añadidos a la a plicación Web que no tienen ningún controlador asociado. 5.2.3.1 Tools Navigation Block Mediante una gsp creamos un bloque de navegación en el cuál mostramos enlaces a varios controladores.

<input type="password" maxlength='8' name='passw ord' value='${user?.password}'> </input>

</td> </tr> … <div class="buttons"> <span class="button"> <g:actionSubmit value="Log in" /> </span> </ div>

<g:if test="${'default' ==~ session.userId}"> <span class="menuButton"> <g:link controller="pet" action="listPetsSale">Pe ts</g:link> </span> <span class="menuButton"> <g:link controller="pet" action="search">Search</ g:link> </span> <span class="menuButton"> <g:link controller="user" action="create">Registe r</g:link> </span> <span class="menuButton"> <g:link controller="user" action="login">Log in</ g:link> </span> </g:if> <g:elseif test="${'admin' ==~ session.userId}"> <span class="menuButton"> <g:link controller="pet" action="list">Pets administration</g:link> </span> <span class="menuButton"> <g:link controller="pet" action="search">Search</ g:link> </span> <span class="menuButton"> <g:link controller="cart" action="list">Carts administration</g:link> </span> <span class="menuButton"> <g:link controller="user" action="list">Users administration</g:link> </span>

Como podemos observar, se mostrarán diferentes entr adas para cada tipo de usuario que este activo en la ses ión.

5.2.3.2 Contact Navigation Block Mediante una gsp creamos un bloque de navegación en el cuál mostramos enlaces a páginas de información sobre el e-commerce.

Proporcionamos enlaces a las diferentes páginas de información sobre la aplicación Web y la forma de contactar con la “tienda física”.

Contact En esta gsp damos información de contacto y gracias a un plugin implementado por un usuario de Grails podemos visualizar la localización de la “tienda física” en Google Maps .

<span class="menuButton"> <g:link controller="user" action="logout">Log out </g:link> </span> </g:elseif> <g:else> <span class="menuButton"> <g:link controller="user" action="profile">Profil e</g:link> </span> <span class="menuButton"> <g:link controller="pet" action="listPetsSale">Pe ts</g:link> </span> <span class="menuButton"> Accessories </span> <span class="menuButton"> Services </span> <span class="menuButton"> <g:link controller="pet" action="search">Search</ g:link> </span> <span class="menuButton"> <g:link controller="cart" action="cartBuy">Cart</ g:link> </span> <span class="menuButton"> <g:link controller="user" action="logout">Log out </g:link> </span> </g:else>

<center> <span class="menuButton"> <a href="/petStore/contact.gsp">Contact Us</a> </span> <span class="menuButton"> <a href="/petStore/information.gsp">Information</a > </span> <br> <br> Powered by: <br> <span class="menuButton"> <g:link url="http://grails.codehaus.org"><img src="${createLinkTo(dir:'images',file:'grails_logo. jpg')}" alt="Powered" height='30' width='100' /></g:link> </span>

</center>

 <resource:googlemaps key="ABQIAAAAsjy-58pVi-50ruUb53dLwhRpTILV1lFrmv4o7zMZQKLDsNraaxSe1UzeXnhvm 8nsr6lstUQz6yzhyQ" /> <richui:googlemaps markers="[[latitude: 41.386903, longitude: 2.161517, draggable: true, route: true]]" />



Estos tags nos dan acceso al plugin que nos muestra la situación de la tienda mediante Google Maps , pero anteriormente se ha instalado mediante un comando d e Grails el plugin implementado por el usuario.

Information En esta gsp se da información sobre la funcionalida d de esta aplicación Web y el cometido que ha tenido, es deci r, que esta página pertenece a un proyecto de final de carrera de un alumno de ETIS. 5.2.3.3 Gsp’s estructura por defecto Mediante esta gsp se configura la estructura de las gsp’s con las navigation blocks a mostrar así como el banner fijo que se muestra en la parte superior de las páginas. 5.2.3.4 Imagenes Cualquier imagen fija que se quiera utilizar en la página, se almacena en el path ...\web-app\images\petImages , para realizar la llamada a la imagen que queremos mostrar se util iza un tag básico de html con una configuración especial de la s gsp’s.

$> grails install-plugin richui

<html> <head> <title><g:layoutTitle default="Littlest Pet Shop" /></title> <link rel="stylesheet" href="${createLinkTo(dir:'css',file:'main.css')}" / > <link rel="shortcut icon" href="${createLinkTo(dir:'images/petImages',file:'l ogo.gif')}" type="image/x-icon" /> <g:layoutHead /> <g:javascript library="application" /> </head> <body> <div id="spinner" class="spinner" style="di splay:none;"> <img src="${createLinkTo(dir:'images',f ile:'spinner.gif')}" alt="Spinner" /> </div> <div class="logo"><img src="${createLinkTo(dir:'images/petImages',file:'ba nnerDef.jpg')}" alt="Littlest Pet Shop" / width="1300" height="220" ></div> <div class="nav"> <g:render template="/adminmenubar" /> </div> <div class="pageContent"> <g:layoutBody /> </div> <div class="nav"> <g:render template="/contatmenubar" /> </div> </body> </html>

<img src="${createLinkTo(dir:'images',file:'spinner .gif')}" alt="Spinner" />



5.3 Pruebas A continuación se mostrarán diferentes capturas de las vistas más relevantes de la aplicación Web, desde la págin a de inicio hasta la gestión de carritos pasando por el perfil de usuario, etc. Página de inicio

Perfil de usuario



Lista de mascotas a la venta

Búsqueda



Perfil de administrador

Contacto



Información

En estas capturas podemos comprobar la interficie t an amigable que proporciona Grails por defecto, y como mediante diferentes tags de las gsp y otros servicios se pueden crear u nas páginas de gestión de la información sencillas pero eficien tes.

Programación de una tienda virtual en Grails 6. Con clusiones


6. Conclusiones y líneas de futuro Los objetivos de este proyecto eran llegar a crear una aplicación Web de e-commerce basada en el nuevo fra mework Web Grails . En un principio, los conocimientos que se tenían sobre el framework Web Grails eran nulos, así como el conocimiento del lenguaje de programación en que está basado, Groovy , también eran prácticamente nulos. Debido a estos inconvenie ntes, previamente al análisis, diseño e implementación de la aplicación, fue necesaria una documentación e inves tigación profundas para poder desarrollar pequeñas aplicacio nes en Groovy y realizar pequeñas aplicaciones con Grails . Viendo la evolución de la memoria se puede afirmar que se han cumplido los objetivos establecidos, así como los objetivos establecidos e n la implementación de dicha aplicación Web. Como se ha comentado anteriormente, el aprendizaje de nuevas tecnologías ha sido el eje central del proyecto. El aprendizaje ha sido entorno a Groovy on Grails . Las aplicaciones que puede tener Groovy van mucho más allá de lo que se ha profundizado en este proyecto, las ventajas y desventajas que ofrec e respecto a Java se pueden ver en la siguiente tabla:

Cuestiones intrínsecas Tecnología más potente Escalabilidad : balanceo de carga, arquitectura distribuida, CPU, ficheros entrada/salida, BBDD y observabilidad.

JAVA

Velocidad de desarrollo : cantidad de código, compilación, despliegue y proceso de configuración.

GROOVY

Herramientas de desarrollo : IDEs, plantillas, mapeo objeto-relacional, documentación y rendimiento.

JAVA

Facilidad de mantenimiento posterior : patrón MVC (modelo-vista-controlador), tamaño del código, facilidad de lectura y orientación a objetos.

GROOVY

Como podemos observar se podría determinar un “empa te técnico” entre las dos tecnologías, pero nos decantaremos po r Groovy ya que tiene menos código, fuerza la arquitectura MVC y el hecho de que las plantillas, el mapeo objeto-relacional, las pruebas y el código de la aplicación están muy integrados. En cuanto a Grails al ser un framework Web todavía en desarrollo, las posibilidades de momento se encuent ran bastante limitadas, pero ya va dando señales de la potencia que llegará a tener aunque dudo mucho que pueda desbancar a imple mentaciones en Java para aplicaciones Web. El desarrollo de este proyecto me ha ayudado a prof undizar y aprender más temas que ya había estudiado en asigna turas propias de la carrera. Un ejemplo sería Metodología y Tecnología de la Programación donde había estudiado los pasos para desarrollar una aplicación, otro sería Programación Para la Red donde había estudiado las diferentes aplicaciones de la program ación en la red, o Lenguajes de Scripting que me introdujo en el mundo de

Programación de una tienda virtual en Grails 6. Con clusiones


los lenguajes de ejecución dinámica, todo esto y mu cho más lo he visto mientras realizaba este proyecto. Como he comentado anteriormente la problemática más relevante era el nulo conocimiento tanto de Groovy como de Grails . Las posibles líneas de futuro del proyecto pasan po r:

• Estructura del sistema de gestión más amigable para el administrador, con una gestión más sencilla y una interficie de gestión de tareas.

• Añadir plugins ya implementados para Grails que aporten nuevos servicios a nuestra aplicación haciéndola má s llamativa e amigable.

• Perfeccionar la depuración del código en Groovy mediante investigaciones más profundas sobre dicho lenguaje de programación

Como conclusión final, enunciaremos las posibles ap licaciones que puede tener Grails en el mundo real. Como ya he comentado anteriormente, Grails a pesar de ser un potente framework Web todavía se encuentra en desarrollo, lo que limita s u radio de acción considerablemente. En la actualidad las aplicaciones que puede tener Grails son más bien de uso personal o local, nunca para un uso emp resarial o en masa, ya que la gestión de contenidos por su parte no es todo lo eficiente que debería, así como su gestión de recur sos. Estos dos puntos son los más relevantes en contra de Grails por lo que hacen imposible su inmediata implementación para ap licaciones en masa, pero lo hacen perfecto para pequeñas aplicaci ones gracias a su versatilidad y su usabilidad. A continuación, observaremos los puntos a favor y e n contra que hemos encontrado respecto a otros frameworks.

• Ventajas o Menor curva de aprendizaje -> gran productividad o Groovy fácil de aprender para desarrolladores Java o Uso de Spring e Hibernate como base

• Desventajas o Rendimiento menor que otros frameworks o Baja potencia respecto a Java o Framework desconocido

Programación de una tienda virtual en Grails 7. Bib liografía


7. Bibliografía 7.1 Libros [1] Dierk König, Andrew Glover, Paul King, Guillaum e LaForge, Jon Skeet: “Groovy in Action”, 2007, New York, Manning Publications. [2] Kenneth Barclay, John Savage: “Groovy Programmi ng an introduction for Java developers”, 2007, San Francisco, Elsewier Inc. [3] Graeme Keith Rocher: “The Definitive Guide to G rails”, 2006, New York, Springer-Verlag New York Inc. [4] Jason Rudolph, Venkat Subramaniam: “Getting Sta rted with Grails”, 2006, C4Media Inc.

7.2 Recursos electronicos [5] Página principal de Grails: http://grails.codehaus.org [6] Weblogs de Java: http://weblogs.java.net [7] Wikipedia: http://en.wikipedia.org [8] Foro oficial de Groovy en Español: http://groovy.org.es [9] Introducción a Groovy y Grails: http://dev2dev.bea.com

Programación de una tienda virtual en Grails 8. Ane xos


8. Anexos 8.1 Manual instalación de librerías En este apartado se explicará la instalación de las librerías necesarias para el correcto funcionamiento de nuest ra aplicación.

8.1.1 Groovy Los pasos a seguir para una correcta instalación de las librerías de Groovy :

• Dirígete a http://groovy.codehaus.org/Download • Descarga la última versión estable disponible. • Si deseas instalar en Windows, existe un instalador

disponible en esa misma página ( http://groovy.codehaus.org/Windows+NSIS-Installer ), encontrarás una breve descripción sobre él. El instalador cuenta con traducciones en Inglés, Castellano, Francés y Alemán.

• Si escogiste la ruta "manual" (paso 2), descomprime el archivo en un directorio de tu elección, como por ejemplo C:\groovy (en Windows) o /usr/local/groovy en Unix.

• Declara una variable de ambiente llamada GROOVY_HOM E que apunte al directorio que escogiste en el paso anter ior.

• Asegúrate que JAVA_HOME también este definido y apu nte a un directorio de instalación de JDK.

• Aseguráte que tanto GROOVY_HOME/bin y JAVA_HOME/bin formen parte de la ruta de búsqueda de programas (l a variable de ambiente PATH).

8.1.2 Grails Los pasos a seguir para una correcta instalación de las librerías de Grails :

• Dirígete a http://docs.codehaus.org/display/GRAILS/Download • Descarga la última versión estable disponible. • Si escogiste la ruta "manual" (paso 2), descomprime el

archivo en un directorio de tu elección, como por ejemplo C:\grails (en Windows) o /usr/local/grails en Unix.

• Declara una variable de ambiente llamada GRAILS_HOM E que apunte al directorio que escogiste en el paso anter ior.

• Asegúrate que JAVA_HOME también este definido y apu nte a un directorio de instalación de JDK.



• Asegúrate que tanto GRAILS_HOME/bin y JAVA_HOME/bin formen parte de la ruta de búsqueda de programas (l a variable de ambiente PATH).

NOTA: Es posible que tengamos que dar permisos de ejecuci ón a todo lo que esté en $GRAILS_HOME/bin y $GRAILS_HOME/ant/bin

8.2 Riesgos La solución descrita en este documento se ha probad o y desarrollado con las versiones de programas siguien tes:

• Groovy • Grails 1.0.2 • Ubuntu 8.04 • Java jdk1.6.0 • Mozilla Firefox 2.14

El uso de esta herramienta con otras versiones de d ichos programas no se ha probado, por lo que no se asegur a el correcto funcionamiento de la misma con otras versiones que no sean las descritas anteriormente.

8.3 Análisis del tiempo de realización del proyecto Mediante diagramas de Gantt se darán a conocer una estimación del tiempo que se ha utilizado en cada apartado de la realización del proyecto, comenzando por un diagram a general y otro más detallado. En ellos se mostrarán las fecha s aproximadas de inicio de cada apartado más relevante en la real ización del proyecto, así como las fechas aproximadas de finali zación. Diagrama general



Diagrama detallado

• Documentación y estudio avanzado

• Estudio proyecto e implementación

• Documentación

Gracias a estos diagramas podemos calcular el coste económico del proyecto, que quedaría dividido en:

• Coste de análisis = 28 horas * 60 €/hora = 1680 € • Coste de programación = 70 horas * 45 €/hora = 3150 € • Coste de documentación = 24 horas * 45 €/hora = 1080 €

El coste total ascendería a 5910 €, a los que se tendría que añadir el coste del software, pero como es OpenSour ce no tiene coste alguno, por lo que el precio del proyecto ser ía el coste propio del estudio, implementación y documentación. El coste de implantación sería muy bajo, ya que cua lquier ordenador de medio rendimiento podría ejecutar las directrices del proyecto, el coste de software es 0 como se ha mencionado antes y la instalación/mantenimiento de la aplicaci ón es muy sencillo, una de las grandes ventajas de Grails respecto a otros frameworks.

8.4 Implantación Management Para la implantación de este proyecto de forma que un administrador pueda modificar la configuración, se copiaría la carpeta contiene el proyecto (en nuestro caso petSt ore que viene incluída en el cd) en cualquier localización de nue stro sistema Linuxque y posteriormente realizariamos la instalac ión de las librerías de Groovy y de Grails siguiendo los pasos del apartado 8.1 de este anexo. A continuación exportaríamos la base de datos o configuraríamos el archivo …\grails-app\conf\Data Source.groovy con una nueva base de datos creada previamente. Una vez realizados estos pasos ya se podría editar la configuración de nuestro proyecto y se podría ejecu tar utilizando el comando de Grails : Delivery Para la implantación de este proyecto, ya preparado para su publicación, previamente tendríamos que aprovechar un comando de Grails que nos proporciona la posibilidad de crear un arc hivo .war de nuestra aplicación. Posteriormente, antes de la instalación del archivo .war realizariamos la instalación de las librerías de Groovy y de Grails siguiendo los pasos del apartado 8.1 de este anexo . A continuación instalaríamos el servidor de aplicacio nes Apache Tomcat 5.5 . Una vez instalado Tomcat se copia el fichero .war en el directorio TOMCAT_HOME/webapps y se configura la ba se de datos que se utilizará. Por defecto esta configuración se obtendrá via JNDI, con lo que no será necesario modificar los fi cheros war. Configuraremos la aplicación web usando JNDI creand o un fichero xml para el fichero war y con el mismo nombre en el directorio TOMCAT_HOME/conf/Catalina/localhost con el contenid o:

$> grails war

$> grails run - app

<Context path="/ petStore " docBase="${catalina.home}/webapps/ oness-party-webapp .war" debug="99" reloadable="true">

<Environment description="Hibernate dialect" name="net.sf.oness.common.model.hibernateDi alect" value=" net.sf.hibernate.dialect.MySQLDialect " type="java.lang.String"/> <Resource name="jdbc/oness" auth="Container" type="javax.sql.DataSource"/> <ResourceParams name="jdbc/oness"> <parameter> <name>factory</name> <value>org.apache.commons.dbcp.BasicDataSourceFacto ry</value> </parameter>  <parameter> <name>maxActive</name> <value>100</value> </parameter>  <parameter> <name>maxIdle</name> <value>30</value> </parameter>  <parameter> <name>maxWait</name> <value>10000</value> </parameter>  <parameter> <name> root </name> <value></value> </parameter> <parameter>

<name> </name> <value></value> </parameter>  <parameter> <name> driverClassName </name>

<value> com.mysql.jdbc.Driver </value> </parameter>  <parameter> <name>defaultAutoCommit</name> <value>false</value> </parameter>

Donde:

Url en la que estará disponible la aplicación dentro del servidor Ubicación del fichero war Dialecto de Hibernate para el gestor de base de datos utilizado Usuario de la base de datos Contraseña de la base de datos Clase del driver JDBC para el gestor de base de datos Url de la base de datos

Una vez realizados estos pasos ya tenemos lista nue stra aplicación implantada.

 <parameter> <name> url </name> <value> jdbc:mysql://localhost/petStore_dev </value> </parameter>  <parameter> <name>removeAbandoned</name> <value>true</value> </parameter>  <parameter> <name>removeAbandonedTimeout</name> <value>60</value> </parameter>  <parameter> <name>logAbandoned</name> <value>true</value> </parameter> </ResourceParams> </Context>

ENGINYERIA TÈCNICA EN INFORMÀTICA DE SISTEMES

UNIVERSITAT DE BARCELONA

Treball fi de carrera presentat el dia de de 200 a la Facultat de Matemàtiques de la Universitat de Barcelona,

amb el següent tribunal: Dr. President Dr. Vocal 1 Dr. Secretari Amb la qualificació de:

programacion de una tienda virtual en grails

Technology