Programacion de una tienda virtual en Grails
Upcoming SlideShare
Loading in...5
×
 

Like this? Share it with your network

Share

Programacion de una tienda virtual en Grails

on

  • 8,738 views

Proyecto de Final de Carrera en el que se diseña e implementa una Tienda Virtual mediante el framework Groovy on Grails

Proyecto de Final de Carrera en el que se diseña e implementa una Tienda Virtual mediante el framework Groovy on Grails

Statistics

Views

Total Views
8,738
Views on SlideShare
8,608
Embed Views
130

Actions

Likes
1
Downloads
414
Comments
0

4 Embeds 130

http://thegabview.wordpress.com 120
http://www.slashdocs.com 5
http://www.docshut.com 4
http://www.docseek.net 1

Accessibility

Categories

Upload Details

Uploaded via as Adobe PDF

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

Programacion de una tienda virtual en Grails Document Transcript

  • 1. Treball fi de carrera ENGINYERIA TÈCNICA EN INFORMÀTICA DE SISTEMES Facultat de Matemàtiques Universitat de BarcelonaPROGRAMACIÓ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
  • 2. Índice detallado1. 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.......................62. 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......................................213. 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...........264. 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................................385. 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
  • 3. 5.2.3.4 Imágenes..........................55 5.3 Pruebas.........................................566. Conclusiones y líneas de futuro.......................607. Bibliografía..........................................62 7.1 Libros..........................................62 7.2 Recursos electrónicos...........................628. 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 proyecto.64 8.4 Implantación....................................66
  • 4. Programación de una tienda virtual en Grails 1. Introducción1. Introducción1.1 Ámbito del proyectoEn la actualidad, Internet está viviendo una profundatransformación: ha pasado de ser un escaparate de informaciónestática a un conjunto de aplicaciones y portales que utilizanel conocimiento colectivo para facilitar servicios interactivosdonde los usuarios tienen el control de sus datos y de lainformación.Los entornos colaborativos son el conjunto de herramientas ytecnologías sobre los que se sustenta la Web 2.0: en una solapalabra "COLABORAR".Hay varios factores que son responsables de que seamos testigosde una convergencia entre tecnología y sociedad, donde latecnología facilita cambios sociales, y estos a su vez marcanlas tendencias de la tecnología. Uno de los factores másimportantes ha sido la facilidad de acceso y aparición detarifas planas de conexión, además de que la realidad de losconsumidores ha mutado y no se basa en una lealtad ciega haciacierta marca.El ámbito de los entornos colaborativos es tan amplio como lapropia WWW. Su aplicación se extiende a cualquier modelo denegocio, por lo que no es difícil imaginar el importante impactoeconómico y social que suponen en el entorno empresarial actual.La aparición de Blogs, Wikis, Redes sociales, ComercioElectrónico, etc ... ha impulsado la proliferación de estándarescon el fin de ayudar a la creación de aplicaciones web, losdenominados frameworks, con un único objetivo: simplificar lacomplejidad de la creación de aplicaciones web. Existen variosframeworks web, Struts / Tapestry / ASP.NET / Ruby on Rails /Groovy on Grails, pero casi todos basados en el mismo tipo deestructura: J2EE.Con el paso del tiempo cada vez es más sencillo utilizar estosframeworks, por lo que la creación de una aplicación web,actualmente, está al alcance de cualquier persona con nocionesbásicas de programación y, sobretodo, curiosidad.En algunas de las asignaturas de la carrera hemos estudiadodiversas metodologías de desarrollo de aplicaciones, incluyendosu análisis y diseño, y su aplicación en el panoramacolaborativo de Internet actual. En este proyecto se volverán autilizar estas metodologías para crear una aplicación web dee-commerce con el objetivo de demostrar la potencia delframework web estudiado.Gabriel Bermúdez Merino 4
  • 5. Programación de una tienda virtual en Grails 1. Introducción1.2 Objetivos generalesEl objetivo principal de nuestro proyecto es el estudio delnuevo framework web Grails basado en Groovy, para elloutilizamos dicho framework para crear una aplicación de e-commerce, en concreto una tienda virtual de mascotas basada enun ejemplo de Sun Microsystems. Gracias a esta aplicación dee-commerce se comparara la simplicidad de creación y laeficiencia entre dicha aplicación y el ejemplo de Sun, con elúnico objetivo de dar a conocer la potencia de este nuevoframework, que sin duda alguna en el futuro dará mucho quehablar en el panorama del diseño web.1.3 Objetivos específicosLos objetivos específicos que se quieren conseguir en elproyecto 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 entre 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 siguientes fases: o Introducción a la estructura de Grails y sus comandos 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 del de Sun Microsystems.Gabriel Bermúdez Merino 5
  • 6. Programación de una tienda virtual en Grails 1. Introducción1.4 Organización de la memoriaLa memoria esta organizada en diversos capítulos, cada uno consus 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 tecnologí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 explicaremos 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 proyecto y en el haremos la valoración final de la aplicación y del proyecto, así también evaluaremos las líneas de futuro de éste. • Bibliografía: En la bibliografía especificaremos los recursos de dónde se ha extraído la información necesaria para el desarrollo del proyecto. • Anexos: Los anexos contienen toda la documentación técnica e instalación de librerías necesarias, así como un análisis del tiempo de realización el proyecto.Gabriel Bermúdez Merino 6
  • 7. Programación de una tienda virtual en Grails 2. Antecedentes2. Antecedentes2.1 Exposición de problemáticasEn los últimos años Internet ha ido evolucionando poco a pocohacia un entorno colaborativo entre usuarios, hasta llegar a laactualidad y a la Web 2.0, donde el entorno colaborativo haculminado con la aparición de Blogs, Wikis, el e-commerce, …Esto último implica el estudio e investigación de nuevastecnologías que hagan más sencillo el desarrollo de nuevasaplicaciones web tanto para el desarrollador como para elusuario llano.El desarrollo de frameworks web ha ido evolucionandoconstantemente, desde los struts, framework que implementa elpatrón de arquitectura Modelo Vista-Controlador en Java, hasta,por ejemplo, “Groovy on Grails”, buscando siempre unasimplificación de código pero sin comprender una reducción de lacalidad del producto final.El problema abordado por este proyecto es la creación de unaaplicación web de e-commerce, concretamente una tienda virtualde mascotas, utilizando la nueva tecnología basada en Groovy,Grails. Para la implementación de esta aplicación han sidonecesarios varios estudios previos de cada una de lastecnologías que comprenden el mundo de “Groovy on Grails”, loscuales 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 dicha2.1.1 Groovy como lenguaje de programaciónEl 2 de Enero de 2007 aparecía laversión 1.0 de Groovy, un nuevo lenguajede programación orientado a objetosdesarrollado por Guillaume Laforge, Jefede 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 ySmalltalk. Gracias a la especificación JSR-241, se busca suestandarización para una futura inclusión como componenteoficial de la plataforma Java.Groovy utiliza una sintaxis muy parecida a Java, compartiendo elmismo modelo de objetos, de hilos y de seguridad. Medianteimportaciones, Groovy puede acceder a todas las API de Javaampliando la compilación, ya que el bytecode generado estotalmente compatible con el que Java genera para la JavaVirtual Machine.Gabriel Bermúdez Merino 7
  • 8. Programación de una tienda virtual en Grails 2. AntecedentesPara Groovy, Java no es un lenguaje incompatible con su código,todo lo contrario, todo el código escrito en Java es válido enGroovy. Este aspecto hace su aprendizaje mucho más sencillo aprogramadores Java que otros lenguajes que se ejecutan sobre laJava Virtual Machine, como Jython o Jruby.Java es totalmente compatible con Groovy, pero esto no hace queGroovy pierda todas las ventajas de un lenguaje de scripting, yaque también se puede ejecutar de forma dinámica. Por ejemplo, enJava la salida estándar de “Hello World” hace necesaria laescritura de una clase, un método main con una serie deargumentos, etc… Pero en Groovy, no es necesario escribir todoel código, te puedes ahorrar la declaración de la clase y elmétodo main, y sólo escribir una línea de código que muestre porpantalla “Hello World”.El contenido del archivo HelloWorld.groovy sería: println “Hello World”Como podemos observar, el dinamismo de un lenguaje de scriptingse encuentra presente en Groovy, pero, ¿y la compatibilidad conJava?Groovy da soporte a listas, mapas, etc… y aún podemos demostrarla simplicidad de Groovy y su capacidad para ejecutar código enJava: //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 podemos observar en el código, utilizamos directamentejava.util.Date y no importamos un soporte para colecciones paratrabajar con listas, mapas y rangos. Aunque no es necesario,Gabriel Bermúdez Merino 8
  • 9. Programación de una tienda virtual en Grails 2. Antecedentescomo en el ejemplo, podemos exportar librerías Java para que elproceso de desarrollo sea más cómodo.En el apartado de tecnologías asociadas, profundizaremos más enel mundo de Groovy mediante explicaciones y ejemplos.2.1.2 Grails como framework WebGrails es un framework paraaplicaciones Web de libredistribución, que tiene comobase el lenguaje deprogramación Groovy. Grailses un framework de alta productividad que viene distribuido bajoel paradigma del “código por convención” (MVC), el cuálproporciona un entorno de desarrollo independiente y unosdetalles de configuración escondidos para el desarrollador.Grails se llamó previamente “Groovy on Rails” (nombre que se lepuso en como homenaje a David Heinemeier Hansson, fundador deRuby on Rails, otro framework web). El trabajo de desarrollocomenzó en Julio de 2005 que dio como fruto la versión 0.1 el 29de Marzo de 2006 i la versión 1.0 el 18 de Febrero de 2008.En el momento de su implementación, se estudiaron variosconceptos 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, incluyendo un servidor web y un sistema de carga de ficheros automática.Gabriel Bermúdez Merino 9
  • 10. Programación de una tienda virtual en Grails 2. AntecedentesDichos objetivos se han conseguido en mayor o menor grado, entrelos 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 relevantes 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: $> groovy create-controller ---------------------------------------------------- def list = { if(!params.max) params.max = 10 [ petList: Pet.list( params ) ] } o Soporte a Ajax y uso de librerías dinámicas para poder implementar plugins con el fin de facilitar la 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-domain-class ---------------------------------------------------- class Cart { String status String payment String numberTarget Float total Map contentBuy=[1 : 1] }Gabriel Bermúdez Merino 10
  • 11. Programación de una tienda virtual en Grails 2. Antecedentes 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. Luego el compilador utiliza esa especificación para generar 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. class cartController { scaffold = true }Como podemos observar, Grails es un framework potente pero a lapar sencillo, ahora sólo hemos nombrado los aspectos másrelevantes por lo que a continuación, en el apartado detecnologías asociadas, profundizaremos más en el mundo de Grailsmediante explicaciones y ejemplos, posteriormente realizaremosuna implementación completa de una aplicación web de e-comerce.2.2 Tecnologías asociadas2.2.1 GroovyEn este apartado, se va a profundizar en los aspectos másrelevantes de Groovy mediante descripciones y ejemplos. No sepuede considerar este apartado como un manual de usuario deGroovy, 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 comparativa directa conJava con el objetivo de demostrar la disminución de código entreuno 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.Gabriel Bermúdez Merino 11
  • 12. Programación de una tienda virtual en Grails 2. Antecedentes public class HolaMundo{ public static void main(String[] args){ System.out.println(“Hola Mundo”); } } --------------------------------------------------------- println “Hola Mundo” La diferencia de cantidad de código es abrumadora, pero existen otras implementaciones con el mismo objetivo. class HolaMundo{ def hiWorld(name){ “Hola ${name}” } } def hW = new HolaMundo() println hW.hiWorld(“Mundo”) 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 tipos 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 ‘.’. <-- 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”]Gabriel Bermúdez Merino 12
  • 13. Programación de una tienda virtual en Grails 2. Antecedentes <-- Rangos --> def rg = (0..9) <-- Impresión de rangos --> rg.each{num -> print num} Como podemos observar, la definición de variables en 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 nuevo 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 donde 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ónima 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 closures es tan común, que si no se ha definido un parámetro específico de todos modos estará disponible una variable it que representa el valor del parámetro. def printOut = {item -> print item} (0..9).each(printout) --------------------------------------------------------- def printOut = {print it} (0..9).each(printout) La implementación de las closures implica un gran avance en el mundo de la programación, ya que no es necesario crear un nuevo método fuera del actual pudiendo utilizar las variables locales del actual. 4. Expresiones regulares Como muchos lenguajes de scripting, Groovy también ofrece la posibilidad de utilizar expresiones regulares, es decir, declarar y utilizar dichas expresiones sin necesidad de construcciones complexas o añadir sintaxis adicionales a las construcciones básicas del lenguaje.Gabriel Bermúdez Merino 13
  • 14. Programación de una tienda virtual en Grails 2. Antecedentes Basta con declarar la expresión de búsqueda entre barras diagonales y usar uno de los tres operadores disponibles: • =~ búsqueda de ocurrencias • ==~ coincidencias • ~ patrón 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/) 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 implementació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 acceso se generarán. Dichas propiedades se declaran con tipo y nombre, sin modificador de acceso, ya que de tenerlo 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 extendido debido a que Groovy anexa un constructor por omisión a los POGOs. En el momento del acceso a campos se puede realizar mediante el operador ‘.’ o ‘[]’ lo cuál hace que parezca que se ha roto la encapsulación del POGO, pero en realidad es todo lo contrario, ya que existe la posibilidad deGabriel Bermúdez Merino 14
  • 15. Programación de una tienda virtual en Grails 2. Antecedentes obtener y modificar el valor de un campo mediante el operador ‘.@’ que tampoco rompe la encapsulació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 } 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. class Person{ @BoundProperty String name @BoundProperty String firstName } 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 Groovy 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.Gabriel Bermúdez Merino 15
  • 16. Programación de una tienda virtual en Grails 2. Antecedentes 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 + 12.2.2 GrailsEn este apartado, se va a profundizar en los aspectos másrelevantes de Grails mediante descripciones y ejemplos. No sepuede considerar este apartado como un manual de usuario deGrails, más bien como un pequeño tutorial de introducción aéste potente framework web.En los siguientes apartados vamos a tratar varios aspectos deGrails, desde su estructura hasta llegar a su funcionalidadpasando 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 proyecto 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: $> grails create-app 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.Gabriel Bermúdez Merino 16
  • 17. Programación de una tienda virtual en Grails 2. Antecedentes Esta estructura de ficheros nos sitúa automáticamente 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áticamente durante la implementación del proyecto. Si se tiene experiencia utilizando Apache Ant, se puede crear manualmente este sistema de directorios modificando 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 tenga una permanencia (en el localhost), se modificará la siguiente línea en el fichero: …/grails-app/conf/ApplicationDataSource.groovy 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 en el código, modificando el valor de dbCreate por update, establecemos una base de datos permanente. Observamos también que por cada tipo de implementación, ya sea de desarrollo, testeo o producción podemos tener una base de datos diferente, lo que facilita la futura implantación del proyecto. Si por comodidad se quiere utilizar otro tipo de lenguaje de base de datos, tan sólo se ha de descargar el driver correspondiente y almacenarlo en el directorio lib delGabriel Bermúdez Merino 17
  • 18. Programación de una tienda virtual en Grails 2. Antecedentes 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 conocimiento 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, Read, 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/ , $> grails create-domain-class a dicha instrucción solamente le hemos de proporcionar 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 declaraciones de constraints para las propiedades y campos. Es posible establecer una relación de 1-1, 1-n o n-n entre clases directamente en la implementación de dichas clases, este y anteriores elementos los veremos en el siguiente ejemplo. 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 } }Gabriel Bermúdez Merino 18
  • 19. Programación de una tienda virtual en Grails 2. Antecedentes 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 directamente en código. • Restricciones directas en código Como podemos observar, utilizando una closure con el nombre “constraints”, podemos configurar las restricciones que queremos que tengan las propiedades 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 se 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: $> grails generate-all Gracias a este comando se crean los llamados controladores y las vistas básicas que necesitaremos para gestionar nuestra clase de dominio. Los controladores se almacenarán en el directorio grails- appcontrollers. Dichos controladores son los responsables de el manejo de las peticiones de nuestra aplicación Web. Los controladores son los sustitutos naturales de los Servlets de Java, con la ventaja de que su implementación es tan sencilla como crear una closure por cada tipo de petición que queramos que atienda. A continuación vamos a ver un ejemplo de controladores e introduciremos el concepto de Scaffolding en Grails.Gabriel Bermúdez Merino 19
  • 20. Programación de una tienda virtual en Grails 2. Antecedentes class CartController { def index = { redirect(action:list,params:params) } 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} deleted" 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} created" redirect(action:cartBuy,id:params.id) } else { render(view:create,model:[cart:cart]) } } }Gabriel Bermúdez Merino 20
  • 21. Programación de una tienda virtual en Grails 2. Antecedentes En este ejemplo, podemos ver los controladores básicos 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 posteriormente se pueden ir añadiendo funcionalidades como el logging 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, la 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: $> grails run-app 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: $> grails warDespués de esta breve introducción a Grails, realizaremos unaaplicación Web de ejemplo basada en una tienda virtual demascotas, donde profundizaremos más en los aspectos de Grailsademás de una comparación directa con la implementación de unaaplicación semblante en Java.2.3 ConclusiónDurante el desarrollo de este apartado hemos visto los problemasque tendremos que afrontar durante el desarrollo de proyecto,además de un pequeño estudio de las tecnologías que utilizaremospara el desarrollo de dicho proyecto. Los papeles de lasdiferentes tecnologías en nuestro proyecto son:Gabriel Bermúdez Merino 21
  • 22. Programación de una tienda virtual en Grails 2. Antecedentes • 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 realizar 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.Gabriel Bermúdez Merino 22
  • 23. Programación de una tienda virtual en Grails 3. Análisis3. Análisis3.1 Descripción del problemaTenemos la necesidad de crear un portal de una tienda virtual demascotas, donde los visitantes de dicha página pueden ver losanimales que hay en stock, así como sus descripciones yposteriormente comprarlos si satisfacen sus necesidades previoregistro en la base de datos de la página.Además de la visión externa del portal y las actividades quepodemos realizar en ella, necesitamos poder gestionar tanto lospedidos como el stock de animales y el registro de usuarios,mediante unas actividades especiales para el administrador de lapágina.3.2 Descripción del productoEl portal que desarrollaremos utilizará como apoyo el frameworkWeb Grails. En dicho portal, el cliente navegará por la lista demascotas a la venta y se autenticará en la página, previoregistro, para poder gestionar la compra de las mascotas quedesee, además de poder editar sus datos de registro y realizarun seguimiento del estado de las compras que ha realizadopreviamente.El administrador del portal administrará la lista de usuarios,mascotas y carritos de la compra. La creación de nuevas entradasen las listas de usuarios, además de su edición, actualización yeliminación; y la gestión de los carritos de la compra de losclientes,, actualizando el estado de éstos según vayaevolucionando el pedido.3.3 Requisitos funcionalesEn este apartado definiremos los requisitos funcionales y laestructura fija de nuestro portal. En la siguiente figurapodemos ver los elementos básicos que tendrá nuestro portal.Gabriel Bermúdez Merino 23
  • 24. Programación de una tienda virtual en Grails 3. Análisis3.3.1 BannerEl portal, como todo portal que se precie, tendrá un bannerestático en el que se mostrará su temática mediante una imagenfija con la que se pueda relacionar fácilmente con la rama decomercio a la que está dirigido el portal. Será una imagen fija,sin opciones ni funciones añadidas.3.3.2 Navigation BlocksTendremos dos bloques de navegación, el propio de navegación yel de contacto. • TOOLS NAVIGATION BLOCK En este bloque de navegación, se proporcionarán diferentes “atajos” a diferentes servicios del portal. Según el usuario que se encuentre activo en la sesión, las opciones del bloque de navegación variarán, ya que las opciones del administrador tienen que ser diferentes a la del usuario 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.Gabriel Bermúdez Merino 24
  • 25. Programación de una tienda virtual en Grails 3. Análisis 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 diferentes “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 RenderSección dinámica de nuestro portal donde se visualizarán lasdiferentes páginas de servicios de nuestra aplicación Web. Segúnel usuario que haya activo se podrá visualizar un tipo deservicios u otros, ya que un usuario externo no podrá visualizarel mismo contenido que el administrador, por lo que serestringirán los accesos a dichos servicios mediante unainstrucción propia de Grails insertada en cada uno de los archivosde controladores de las diferentes clases de dominio. //Closure para controlar los accesos de los usuarios def beforeInterceptor = [action:this.&auth, except:[login, logout, show, create, update, delete, save]]3.4 Requisitos no funcionales • FACILIDAD DE USO Los accesos a los diferentes servicios del portal son sencillos e intuitivos.Gabriel Bermúdez Merino 25
  • 26. Programación de una tienda virtual en Grails 3. Análisis • RENDIMIENTO El rendimiento de una aplicación Web depende en gran 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 objetivosEn la aplicación habrá tres actores diferentes, por lo que cadauno tendrá unos objetivos diferentes, pero también comparten unaserie de objetivos afines, dichos objetivos serán compartidos nopor todos los tipos de actores, sino por los más relevantes: elAdministrador 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 outGabriel Bermúdez Merino 26
  • 27. Programación de una tienda virtual en Grails 4. Diseño4. Diseño4.1 Casos de uso4.1.1 Objetivos afinesAcceso a la lista de mascotas a la ventaActor principal: Cualquier UsuarioPersonal 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 mascotas 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 vista con la lista de mascotas a la venta junto con una visualización del carrito de la compra.Acceso a la ficha de la macotaActor principal: Usuario Registrado y AdministradorPersonal involucrado e intereses: Usuario Registrado y Administrador: se quiere visualizar la ficha de una mascota en concreto.Escenario principal de éxito: 1. El usuario quiere visualizar la ficha de una mascota en concreto desde la página de mascotas a la venta. 2. El usuario clica sobre el identificador de la mascota. 3. Se carga la vista con la ficha de la mascota correspondiente.Extensiones: 1a. El usuario quiere visualizar la ficha de una mascota 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 compraActor principal: Usuario Registrado y AdministradorPersonal involucrado e intereses: Usuario Registrado y Administrador: se quiere visualizar la ficha de un carrito de la compra en concreto.Escenario principal de éxito:Gabriel Bermúdez Merino 27
  • 28. Programación de una tienda virtual en Grails 4. Diseño 1. El usuario quiere visualizar la ficha de un carrito 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 de 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 usuarioActor principal: Usuario Registrado y AdministradorPersonal involucrado e intereses: Usuario Registrado y Administrador: se quiere visualizar la ficha de un usuario en concreto.Escenario principal de éxito: 1. El usuario quiere visualizar la ficha del usuario 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 usuario actual.Extensiones: 3a. (Administrador) Se carga la vista de la lista de usuarios. 1. (Administrador) El usuario clica sobre el identificador del usuario. 2. (Administrador) Se carga la vista con la ficha del usuario.Edición de carritosActor principal: Usuario Registrado y AdministradorPersonal involucrado e intereses: Usuario Registrado y Administrador: se quiere editar la información de un carrito de la compra.Escenario principal de éxito: 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.Gabriel Bermúdez Merino 28
  • 29. Programación de una tienda virtual en Grails 4. Diseño 5. El usuario modifica los atributos que desee y salva los datos mediante el botón Save.Extensiones: 3a. (Administrador) Se carga la vista de la lista de carritos. 1. (Administrador) El usuario clica sobre el identificador del carrito. 2. (Administrador) Se carga la vista con la ficha del carrito. 3. (Administrador) Se continúa con el punto 4.Alta de usuariosActor principal: Usuario No Registrado y AdministradorPersonal involucrado e intereses: Usuario No Registrado y Administrador: se quiere dar de alta un nuevo usuario.Escenario principal de éxito: 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 registro. 4. El usuario rellena los campos necesarios y salva los datos mediante el botón Save.Extensiones: 3a. (Administrador) Se carga la vista de la lista de usuarios. 1. (Administrador) El usuario clica sobre el botón Create. 2. (Administrador) Se carga la vista con la ficha de registro. 3. (Administrador) Se continúa con el punto 4.Edición de usuariosActor principal: Usuario Registrado y AdministradorPersonal involucrado e intereses: Usuario Registrado y Administrador: se quiere editar la información de un usuario.Escenario principal de éxito: 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 usuario actual. 4. El usuario clica sobre el botón Edit.Gabriel Bermúdez Merino 29
  • 30. Programación de una tienda virtual en Grails 4. Diseño 5. El usuario modifica los atributos que desee y salva los datos mediante el botón Save.Extensiones: 3a. (Administrador) Se carga la vista de la lista de usuarios. 1. (Administrador) El usuario clica sobre el identificador del usuario. 2. (Administrador) Se carga la vista con la ficha del usuario. 3. (Administrador) Se continúa con el punto 4.Eliminación de carritosActor principal: Usuario Registrado y AdministradorPersonal involucrado e intereses: Usuario Registrado y Administrador: se quiere eliminar un carrito de la compra.Escenario principal de éxito: 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 de carritos. 1. (Administrador) El usuario clica sobre el identificador del carrito. 2. (Administrador) Se carga la vista con la ficha del carrito a eliminar. 3. (Administrador) Se continúa con el punto 4.Eliminación de usuariosActor principal: Usuario Registrado y AdministradorPersonal involucrado e intereses: Usuario Registrado y Administrador: se quiere eliminar un usuario.Escenario principal de éxito: 1. El usuario eliminará algún usuario.Gabriel Bermúdez Merino 30
  • 31. Programación de una tienda virtual en Grails 4. Diseño 2. El usuario clica en el botón de Profile/Users Administration 3. (Usuario) Se carga la vista con la ficha del usuario actual. 4. El usuario clica sobre el botón Delete y confirma la eliminación.Extensiones: 3a. (Administrador) Se carga la vista de la lista de usuarios. 1. (Administrador) El usuario clica sobre el identificador del usuario. 2. (Administrador) Se carga la vista con la ficha del usuario a eliminar. 3. (Administrador) Se continúa con el punto 4.BúsquedaActor principal: Cualquier UsuarioPersonal 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 alguna 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 realizar la búsqueda. 5. Se carga la vista con los resultados de la búsqueda.Log outActor principal: Usuario Registrado y AdministradorPersonal involucrado e intereses: Usuario Registrado y Administrador: se quiere cerrar la sesión actual.Escenario principal de éxito: 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 AdministradorAlta de mascotasActor principal: AdministradorPersonal involucrado e intereses:Gabriel Bermúdez Merino 31
  • 32. Programación de una tienda virtual en Grails 4. Diseño Administrador: se quiere dar de alta una nueva mascota en el sistema.Escenario principal de éxito: 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 guarda los cambios con el botón Save.Alta de carritos de la compraActor principal: AdministradorPersonal involucrado e intereses: Administrador: se quiere dar de alta un nuevo carrito en el sistema.Escenario principal de éxito: 1. El usuario quiere dar de alta un nuevo carrito en 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 guarda los cambios con el botón Save.Edición de mascotasActor principal: AdministradorPersonal involucrado e intereses: Administrador: se quiere editar la ficha de una mascota en concreto.Escenario principal de éxito: 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 mascota. 5. (Administrador) Se carga la vista con la ficha de la mascota. 6. El usuario clica sobre el botón Edit. 7. El usuario modifica los atributos que desee y salva los datos mediante el botón Save.Gabriel Bermúdez Merino 32
  • 33. Programación de una tienda virtual en Grails 4. DiseñoEliminación de mascotasActor principal: AdministradorPersonal 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 mascota. 5. Se carga la vista con la ficha de la mascota a eliminar. 6. El usuario clica sobre el botón Delete y confirma la eliminación.Acceso a la lista de usuariosActor principal: AdministradorPersonal 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 compraActor principal: AdministradorPersonal involucrado e intereses: Administrador: se quiere acceder a la lista de carritos de la compra.Escenario principal de éxito: 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 RegistradoCompra de mascotasActor principal: Usuario RegistradoPersonal involucrado e intereses: Usuario Registrado: se quiere realizar la compra de una mascota.Gabriel Bermúdez Merino 33
  • 34. Programación de una tienda virtual en Grails 4. DiseñoEscenario principal de éxito: 1. El usuario quiere realizar la compra de una mascota. 2. El usuario clica en el botón de Pets. 3. Se carga la vista de la lista de mascotas a la venta. 4. El usuario clica el botón Buy it!. 5. Se carga la vista con el carrito actual y la mascota añadida.Compra y finalización de carritosActor principal: Usuario RegistradoPersonal involucrado e intereses: Usuario Registrado: se quiere realizar la compra y finalización de un carrito.Escenario principal de éxito: 1. El usuario quiere realizar la compra y finalizació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 el 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 carritoActor principal: Usuario RegistradoPersonal involucrado e intereses: Usuario Registrado: se quiere eliminar una mascota añadida del carrito de la compra.Escenario principal de éxito: 1. El usuario quiere eliminar una mascota añadida del 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 pagoActor principal: Usuario RegistradoPersonal involucrado e intereses:Gabriel Bermúdez Merino 34
  • 35. Programación de una tienda virtual en Grails 4. Diseño 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 RegistradoLog inActor principal: Usuario No RegistradoPersonal 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 DiagramasSiguiendo el modelo Vista-Controlador en que está basado Grailsel cuál simplifica el desarrollo de aplicaciones Web mediante lareducción de archivos de configuración y generandoautomáticamente la mayoría de elementos necesarios por unaaplicación Web sobre una base de datosGabriel Bermúdez Merino 35
  • 36. Programación de una tienda virtual en Grails 4. Diseñorealizaremos el diseño del diagrama de clases de nuestraaplicación. El hecho de que se trate de una aplicación Web, parauna comprensión más sencilla, proporcionaremos un diagrama dedominio de las clases, el modelo Vista-Controlador mencionadoanteriormente y un mapa de portal el cuál nos informará sobre lanavegación dentro del portal.4.2.1 Diagrama de dominioEl diagrama de dominio de nuestra aplicación Web, nos ayudará ala comprensión de la configuración de la base de datos denuestra aplicación y nos dará una idea de la estructuración denuestro portal. PET N USER 1 N CART NComo podemos observar, tendremos 3 clases principalesrelacionadas entre sí, las cuáles serán la base de la estructurade la base de datos y de la aplicación Web.4.2.2 Modelo Vista-ControladorEn nuestra aplicación, el Controlador recoge las peticionesrealizadas por el servidor, posteriormente genera los datosnecesarios y la vista que se mostrará en el Render del navegadordel usuario. Realizaremos tres modelos de Vista-Controlador, unopor cada Clase de dominio.4.2.2.1 Vista-Controlador UserEl usuario realiza una acción en el VIEWportal, el cuál envía una petición alcontrolador, el cuál genera la vista dela respuesta a la petición del usuario. PETLos controladores que generan lasvistas para el usuario son los básicosdel CRUD a los cuáles añadimos losrealizados para la gestión de otraspeticiones. CONTROLLERGabriel Bermúdez Merino 36
  • 37. Programación de una tienda virtual en Grails 4. DiseñoLos controladores que generan las vistas para el usuario son losbásicos del CRUD a los cuáles añadimos los realizados para lagestión de otras peticiones. • Login: Controlador que comprueba que el usuario introducido y la contraseña corresponden a los almacenados en la base de datos, y si coincide, se almacena en la variable de sesión para la gestión de usuarios en los 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 por defecto.4.2.2.2 Vista-Controlador PetEl usuario realiza una petición en un VIEWelemento perteneciente a la clase dedominio de las mascotas que esgestionada por los controladores dedicha clase de dominio generando los USERelementos de la vista que serenderizará.Los controladores que generan las CONTROLLERvistas para la petición del usuario enel elemento de mascotas, son losbásicos del CRUD a los cuáles añadimos los realizados para lagestión de otras peticiones. • Upload_image: Controlador que gestiona el almacenamiento de la imagen correspondiente a la mascota que se crea 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 usuario.4.2.2.3 Vista-Controlador CartEl usuario realiza una petición en unelemento perteneciente a la clase de VIEWdominio del carrito que es gestionadapor los controladores de dicha clase dedominio generando los elementos de lavista que se renderizará. CARTLos controladores que generan lasvistas para la petición del usuario enel elemento del carrito, son los CONTROLLERbásicos del CRUD a los cuáles añadimosGabriel Bermúdez Merino 37
  • 38. Programación de una tienda virtual en Grails 4. Diseño 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 usuario. • 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 proporcionan información sobre la navegación entre las diferentes páginas Home Page Admin login Pets list Search Carts List Users LogoutDelete Update Show Pet Search Result Status Update Delete Show User Update Delete Gabriel Bermúdez Merino 38
  • 39. Programación de una tienda virtual en Grails 4. Diseño Home Page User login Profile Pets list sale Search Cart Logout Update Delete Buy Pet Show Pet Search Result Buy cart Update Delete Pay Mode ConfirmTodos los objetos mostrados en los Site Maps están representadospor controladores de las diferentes clases los cuáles seexplicarán en el apartado de Implementación.Gabriel Bermúdez Merino 39
  • 40. Programación de una tienda virtual en Grails 5. Implementación5. Implementación y pruebas5.1 Entorno de desarrolloAsí como en el apartado de análisis hemos realizado unavaloración inicial antes de implementar el código, en esteapartado realizaremos un balance de algunas herramientasutilizadas para la implementación del proyecto.5.1.1 GNU/LinuxEl sistema operativo escogido para programar la aplicación esGNU/Linux. Se ha escogido este sistema porque ofrece un entornode programación más amigable para el desarrollador además de serde libre distribución. Grails, como Java, ofrece unacompatibilidad con cualquier sistema operativo, lo que hace queel sistema operativo en que se haya desarrollado no searelevante.5.1.2 GEditEl editor de texto por defecto del entorno Gnome de GNU/Linux,que ofrece la posibilidad de inclusión de diferentes plugins quehacen más sencillo el desarrollo de aplicaciones en cualquierlenguaje de programación.5.1.3 Mozilla Firefox 2.14Firefox ha sido el navegador elegido para realizar las pruebasde nuestra aplicación Web, aunque como con el sistema operativo,la implementación final no establece un navegador por defecto,por lo que el navegador Web tampoco es relevante.5.1.4 GroovyComo ya he comentado varias veces durante la memoria, miconocimiento sobre este lenguaje de programación era nulo antesdel inicio de este proyecto, por este motivo y al ser una de laspartes fundamentales del proyecto, este lenguaje de Scriptingdispone de su propio apartado en esta memoria. La compatibilidaden los sistemas operativos es muy alta, ya que tanto Mac,Unix/Linux como Windows son compatibles con este lenguajeimportando sus librerías.5.1.5 GrailsAl igual que Groovy, el framework Web Grails tambien dispone deun apartado propio en la memoria debido a su relevancia en esteproyecto. La compatibilidad en los sistemas operativos es muyalta, ya que tanto Mac, Unix/Linux como Windows son compatiblescon este lenguaje importando sus librerías.Gabriel Bermúdez Merino 40
  • 41. Programación de una tienda virtual en Grails 5. Implementación5.2 Seguimiento y problemáticasEn este apartado realizaremos un seguimiento a la implementaciónde nuestra aplicación Web, durante el cuál también iremosdescubriendo las diferentes problemáticas con las que nos hemosencontrado durante dicha implementación.5.2.1 Estructura y persistenciaEl primer paso de una implementación en Grails es establecer laestructura de nuestro proyecto, para ello, Grails, aporta uncomando especial que nos asiste en la construcción de laestructura de nuestro proyecto.Creamos una carpeta en cualquier directorio de nuestro sistemaoperativo, e introducimos el siguiente comando de Grails: $> grails create-app projectNamecon este comando creamos la estructura de nuestro proyecto quequedará dividido en diferentes carpetas distribuidas según lafuncionalidad que tienen dentro del proyecto.Una vez ya hemos establecido la estructura del proyectoconfiguramos la persistencia de datos mediante la creación deuna base de datos (en nuestro caso MySQL) y posteriorconfiguración en nuestro proyecto de dicha BBDD. Para ellodescargamos el driver de la BBDD que queremos utilizar para lapersistencia de datos y lo almacenamos en la carpeta …/lib.Posteriormente configuramos el fichero …/grails-app/conf/ApplicationDataSource.groovy en el cuál estructuramosel fichero según las diferentes BBDD que se utilizaran para losdiferentes estados de creación de la aplicación Web. 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" } } }Gabriel Bermúdez Merino 41
  • 42. Programación de una tienda virtual en Grails 5. ImplementaciónComo podemos observar configuramos el fichero con el driver quehemos descargado, con su usuario y password, además del path decada BBDD que vamos a utilizar durante el desarrollo delproyecto.A continuación creamos las clases de dominio más relevantes denuestro proyecto utilizando un comando de Grails, las cualesposteriormente también se utilizará su estructura en la BBDD.Para la creación de estas clases seguiremos el diagrama dedominio del apartado de diseño. PET N USER 1 N CART NCreamos la clase de dominio mediante el comando de Grails yposteriormente rellenamos las clases con los atributos, lasconstraints y las relaciones entre las clases. $> grails create-domain-class pet import grails.util.GrailsUtil import org.springframework.web.multipart.MultipartFile import org.codehaus.groovy.grails.commons.ConfigurationHolder 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 } }Gabriel Bermúdez Merino 42
  • 43. Programación de una tienda virtual en Grails 5. Implementación $> 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, Completed]) 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) } }Para finalizar este punto, establecemos la estructura de la BBDDmediante otro comando de Grails, el cuál inicia la aplicaciónWeb a la vez que crea la estructura de la aplicación en la BBDD. $> grails run-appGabriel Bermúdez Merino 43
  • 44. Programación de una tienda virtual en Grails 5. Implementación5.2.2 Controladores y vistasUna vez configurada la estructura de la aplicación, sus clasesde dominio y la Base de Datos, necesitamos configurar loscontroladores de las clases y sus respectivas vistas mediantecomandos de Grails y la posterior personalización editando losficheros que se crearán. $> grails generate-all classNameMediante este comando de Grails se generan los controladores ylas vistas básicos para realizar tareas CRUD. Posteriormente loseditaremos para añadir funcionalidades a los controladores ycrearemos sus respectivas vistas.A continuación veremos las funcionalidades añadidas a loscontroladores y las ventajas que ha supuesto su implementaciónen Groovy y el uso de gsp’s para las vistas.5.2.2.1 ControladoresBase ControllerBase Controller es un pequeño controlador del cuál extiendentodos los Controladores que proporciona un chequeo continuo delos accesos a los controladote, comprobando que el usuario estaautentificado y compara los permisos con de acceso con losestablecidos en cada controlador. abstract class BaseController{ def auth(){ if(!session.userId){ redirect(controller:user, action:login) return false } } }PetsComo veremos a continuación, en el controlador de mascotas (Pet)añadiremos las funciones de Cargar imágenes y Búsqueda, ademásde los permisos de acceso a los controladores y la variable deScaffolding. Cargar imágenes nos proporciona la posibilidad desubir imágenes para añadirlas al perfil de las mascotas yBúsqueda nos proporciona el servicio de realizar búsquedas entrela lista de mascotas a la venta.Permisos de acceso y Scaffolding … def scaffold = Pet //Closure para controlar los accesos de los usuarios def beforeInterceptor = [action:this.&auth, except:[show, list]] …Gabriel Bermúdez Merino 44
  • 45. Programación de una tienda virtual en Grails 5. Implementación Como podemos observar, la restricción es para cualquier acción excepto para show y list.Cargar imágenes … def upload_image = { def pet = Pet.current(session) // Obtenemos el fichero de la imagen del request multi-parte def f = request.getFile(image) // Listado de las extensiones permitidas def okcontents = [image/png, image/jpeg, image/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(); } … Como podemos observar, la problemática más grande que ha tenido este servicio del controlador ha sido la configuración de los contenidos aceptados y el almacenaje de la imagen subida mediante la distribución de las referencias entre la base de datos y el objeto subido.Búsqueda … 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 + %)])Gabriel Bermúdez Merino 45
  • 46. Programación de una tienda virtual en Grails 5. Implementación }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.priceOperator}" } } } } render(view:list, model:[raceList:results]) } } … 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 utilizar mediante diferentes condicionales, y finalmente retornando el resultado de dicha búsqueda.CartComo veremos a continuación, en el controlador de carritos(Cart) añadiremos las funciones de Compras del carrito,Eliminación del carrito y Finalización del carrito, además delos permisos de acceso a los controladores y la variable deScaffolding. Compras del carrito nos proporciona una vista delcontenido del carrito así como la posibilidad de añadir oGabriel Bermúdez Merino 46
  • 47. Programación de una tienda virtual en Grails 5. Implementacióneliminar mascotas a dicho carrito, Eliminación del carrito nosproporciona la posibilidad de eliminar mascotas añadidas alcarrito y Finalización de carrito, como su propio nombre indica,nos da la posibilidad de finalizar la compra proporcionándonosuna “factura electrónica” del pedido.Permisos de acceso y Scaffolding … def scaffold = Cart //Closure para controlar los accesos de los usuarios def beforeInterceptor = [action:this.&auth] … Como podemos observar, la restricción es para cualquier acción.Compras del carrito … 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 ] } …Gabriel Bermúdez Merino 47
  • 48. Programación de una tienda virtual en Grails 5. Implementación Como podemos observar, este servicio nos proporciona 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 se le crea automáticamente uno. Si el usuario solo quiere ver el contenido del carrito se le carga la vista apropiada, sino el sistema busca el animal que se desea comprar y se le añade al carrito, posteriormente carga la vista de carrito actual. La problemática más relevante que me he encontrado a la hora de realizar este controlador era el uso de HashMaps para almacenar el contenido del carrito conjuntamente 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 … 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 ] } … Este servicio nos proporciona la posibilidad de eliminar del contenido del carrito una mascota que ya no queremos comprar, posteriormente actualiza la vista del carrito actual.Finalización del carrito … 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); } …Gabriel Bermúdez Merino 48
  • 49. Programación de una tienda virtual en Grails 5. Implementación Por último, este servicio nos da la posibilidad de finalizar la compra proporcionándonos una “factura electrónica” con el pedido realizado.UserComo veremos a continuación, en el controlador de usuarios(User) añadiremos las funciones de Log in y Log out, ya que elregistro se realiza con el método de creación por defecto,además de los permisos de acceso a los controladores y lavariable de Scaffolding. Log in nos proporciona la posibilidadde autenticarnos en el sistema y Log out todo lo contrario, nosproporciona la posibilidad de salir del sistema.Permisos de acceso y Scaffolding … def scaffold = Cart //Closure para controlar los accesos de los usuarios def beforeInterceptor = [action:this.&auth , except:[login, create, save]] … Como podemos observar, la restricción es para cualquier acción excepto para login, create y save.Log in … def login = { if(request.method == "GET"){ session.userId = null def user = new User() }else{ def user = User.findByUserIdAndPassword(params.userId, 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 } } } … Como podemos observar, el controlador comprueba que haya algún usuario registrado, sino se crea uno nuevo. Si existen usuario, el sistema comprueba que existe en el sistema y según que tipo de usuario es carga una vista u otra.Gabriel Bermúdez Merino 49
  • 50. Programación de una tienda virtual en Grails 5. ImplementaciónLog out … def logout = { session.userId = default session.password = default flash[message] = Successfully logged out redirect(uri:/) } … Como podemos observar, el controlador establece el usuario por defecto como usuario activo y redirecciona a la página principal.5.2.2.2 VistasUna vez configurados los controladores pasamos a la creación delas vistas necesarias para cada controlador. Grails utiliza unsistema de asignación, el cuál por cada controlador que se creanuevo tiene que haber una vista con el mismo nombre en formatogsp, aunque es posible realizar unos pequeños retoques que nohagan necesario este requisito previo. Para ello se ha utilizadoel editor de texto para implementar cada nueva vista según elestándar de Grails.A continuación se mostrarán los tags más relevantes de cadavista sin necesidad de entrar mucho en detalle.PetsLas nuevas vistas que se han tenido que implementar correspondena los nuevos controladores creados para la clase Pet, es decir,Cargar imágenes y Búsqueda.Cargar imágenes … <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 width- to-height ratio of 4:5. </div> </g:form> </fieldset> … 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.Gabriel Bermúdez Merino 50
  • 51. Programación de una tienda virtual en Grails 5. ImplementaciónBúsqueda … <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> … Este detalle de la implementación de la vista nos muestra el menú de búsqueda en el que podemos introducir el nombre, tipo y margen de precio mediante tags propios de html como de gsp’s.CartsLas nuevas vistas que se han tenido que implementar correspondena los nuevos controladores creados para la clase Cart, es decir,Compras del carrito y Finalización del carrito, ya queEliminación del carrito está implementada junto con Compras delcarrito mediante un sencillo tag que veremos a continuación.Compras del carrito y Eliminación del carrito … <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>Gabriel Bermúdez Merino 51
  • 52. Programación de una tienda virtual en Grails 5. Implementación <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="return confirm(Are you sure?);"><img src="${createLinkTo(dir:images/skin,file:database_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="Delete" /></span> <span class = "button"><g:link controller="cart" action="endCart" onclick="return confirm(Are you sure?);">Buy Cart</g:link></span> </g:form> </div> … Lo más relevante en el código de esta vista es el uso 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 controlador de eliminación vemos como mediante un bucle va mostrando 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 solamente muestra por pantalla una pequeña factura con el contenido del carrito y la información del comprador.UsersLas nuevas vistas que se han tenido que implementar correspondena los nuevos controladores creados para la clase User, es decir,Log in y Log out, ya que el registro de nuevos usuarios serealiza mediante el controlador de creación por defecto.Log in … <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>Gabriel Bermúdez Merino 52
  • 53. Programación de una tienda virtual en Grails 5. Implementación <input type="password" maxlength=8 name=password value=${user?.password}> </input> </td> </tr> … <div class="buttons"> <span class="button"> <g:actionSubmit value="Log in" /> </span> </div> Las secciones más relevantes del código de esta vista son la introducción de valores mediante cuadrados de texto 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 ExtrasEn este apartado veremos los extras añadidos a la aplicación Webque no tienen ningún controlador asociado.5.2.3.1 Tools Navigation BlockMediante una gsp creamos un bloque de navegación en el cuálmostramos enlaces a varios controladores. <g:if test="${default ==~ session.userId}"> <span class="menuButton"> <g:link controller="pet" action="listPetsSale">Pets</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">Register</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>Gabriel Bermúdez Merino 53
  • 54. Programación de una tienda virtual en Grails 5. Implementación <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">Profile</g:link> </span> <span class="menuButton"> <g:link controller="pet" action="listPetsSale">Pets</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> Como podemos observar, se mostrarán diferentes entradas para cada tipo de usuario que este activo en la sesión.5.2.3.2 Contact Navigation BlockMediante una gsp creamos un bloque de navegación en el cuálmostramos enlaces a páginas de información sobre el e-commerce. <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> 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”.ContactEn esta gsp damos información de contacto y gracias a un pluginimplementado por un usuario de Grails podemos visualizar lalocalización de la “tienda física” en Google Maps. <!-- GoogleMaps resources like JavaScript libraries --> <resource:googlemaps key="ABQIAAAAsjy-58pVi- 50ruUb53dLwhRpTILV1lFrmv4o7zMZQKLDsNraaxSe1UzeXnhvm8nsr6lstUQz6yzhyQ" /> <richui:googlemaps markers="[[latitude: 41.386903, longitude: 2.161517, draggable: true, route: true]]" />Gabriel Bermúdez Merino 54
  • 55. Programación de una tienda virtual en Grails 5. Implementación 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 de Grails el plugin implementado por el usuario. $> grails install-plugin richuiInformationEn esta gsp se da información sobre la funcionalidad de estaaplicación Web y el cometido que ha tenido, es decir, que estapágina pertenece a un proyecto de final de carrera de un alumnode ETIS.5.2.3.3 Gsp’s estructura por defectoMediante esta gsp se configura la estructura de las gsp’s conlas navigation blocks a mostrar así como el banner fijo que semuestra en la parte superior de las páginas. <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:logo.gif)}" type="image/x-icon" /> <g:layoutHead /> <g:javascript library="application" /> </head> <body> <div id="spinner" class="spinner" style="display:none;"> <img src="${createLinkTo(dir:images,file:spinner.gif)}" alt="Spinner" /> </div> <div class="logo"><img src="${createLinkTo(dir:images/petImages,file:bannerDef.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>5.2.3.4 ImagenesCualquier imagen fija que se quiera utilizar en la página, sealmacena en el path ...web-appimagespetImages, para realizarla llamada a la imagen que queremos mostrar se utiliza un tagbásico de html con una configuración especial de las gsp’s. <img src="${createLinkTo(dir:images,file:spinner.gif)}" alt="Spinner" />Gabriel Bermúdez Merino 55
  • 56. Programación de una tienda virtual en Grails 5. Implementación5.3 PruebasA continuación se mostrarán diferentes capturas de las vistasmás relevantes de la aplicación Web, desde la página de iniciohasta la gestión de carritos pasando por el perfil de usuario,etc.Página de inicioPerfil de usuarioGabriel Bermúdez Merino 56
  • 57. Programación de una tienda virtual en Grails 5. ImplementaciónLista de mascotas a la ventaBúsquedaGabriel Bermúdez Merino 57
  • 58. Programación de una tienda virtual en Grails 5. ImplementaciónPerfil de administradorContactoGabriel Bermúdez Merino 58
  • 59. Programación de una tienda virtual en Grails 5. ImplementaciónInformaciónEn estas capturas podemos comprobar la interficie tan amigableque proporciona Grails por defecto, y como mediante diferentestags de las gsp y otros servicios se pueden crear unas páginasde gestión de la información sencillas pero eficientes.Gabriel Bermúdez Merino 59
  • 60. Programación de una tienda virtual en Grails 6. Conclusiones6. Conclusiones y líneas de futuroLos objetivos de este proyecto eran llegar a crear unaaplicación Web de e-commerce basada en el nuevo framework WebGrails. En un principio, los conocimientos que se tenían sobreel framework Web Grails eran nulos, así como el conocimiento dellenguaje de programación en que está basado, Groovy, tambiéneran prácticamente nulos. Debido a estos inconvenientes,previamente al análisis, diseño e implementación de laaplicación, fue necesaria una documentación e investigaciónprofundas para poder desarrollar pequeñas aplicaciones en Groovyy realizar pequeñas aplicaciones con Grails. Viendo la evoluciónde la memoria se puede afirmar que se han cumplido los objetivosestablecidos, así como los objetivos establecidos en laimplementación de dicha aplicación Web.Como se ha comentado anteriormente, el aprendizaje de nuevastecnologías ha sido el eje central del proyecto. El aprendizajeha sido entorno a Groovy on Grails. Las aplicaciones que puedetener Groovy van mucho más allá de lo que se ha profundizado eneste proyecto, las ventajas y desventajas que ofrece respecto aJava se pueden ver en la siguiente tabla: Cuestiones intrínsecas Tecnología más potenteEscalabilidad: balanceo de carga, JAVAarquitectura distribuida, CPU, ficherosentrada/salida, BBDD y observabilidad.Velocidad de desarrollo: cantidad de GROOVYcódigo, compilación, despliegue y procesode configuración.Herramientas de desarrollo: IDEs, JAVAplantillas, mapeo objeto-relacional,documentación y rendimiento.Facilidad de mantenimiento posterior: GROOVYpatrón MVC (modelo-vista-controlador),tamaño del código, facilidad de lectura yorientación a objetos.Como podemos observar se podría determinar un “empate técnico”entre las dos tecnologías, pero nos decantaremos por Groovy yaque tiene menos código, fuerza la arquitectura MVC y el hecho deque las plantillas, el mapeo objeto-relacional, las pruebas y elcódigo de la aplicación están muy integrados.En cuanto a Grails al ser un framework Web todavía endesarrollo, las posibilidades de momento se encuentran bastantelimitadas, pero ya va dando señales de la potencia que llegará atener aunque dudo mucho que pueda desbancar a implementacionesen Java para aplicaciones Web.El desarrollo de este proyecto me ha ayudado a profundizar yaprender más temas que ya había estudiado en asignaturas propiasde la carrera. Un ejemplo sería Metodología y Tecnología de laProgramación donde había estudiado los pasos para desarrollaruna aplicación, otro sería Programación Para la Red donde habíaestudiado las diferentes aplicaciones de la programación en lared, o Lenguajes de Scripting que me introdujo en el mundo deGabriel Bermúdez Merino 60
  • 61. Programación de una tienda virtual en Grails 6. Conclusioneslos lenguajes de ejecución dinámica, todo esto y mucho más lo hevisto mientras realizaba este proyecto.Como he comentado anteriormente la problemática más relevanteera el nulo conocimiento tanto de Groovy como de Grails.Las posibles líneas de futuro del proyecto pasan por: • 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ónComo conclusión final, enunciaremos las posibles aplicacionesque puede tener Grails en el mundo real. Como ya he comentadoanteriormente, Grails a pesar de ser un potente framework Webtodavía se encuentra en desarrollo, lo que limita su radio deacción considerablemente.En la actualidad las aplicaciones que puede tener Grails son másbien de uso personal o local, nunca para un uso empresarial o enmasa, ya que la gestión de contenidos por su parte no es todo loeficiente que debería, así como su gestión de recursos. Estosdos puntos son los más relevantes en contra de Grails por lo quehacen imposible su inmediata implementación para aplicaciones enmasa, pero lo hacen perfecto para pequeñas aplicaciones graciasa su versatilidad y su usabilidad.A continuación, observaremos los puntos a favor y en contra quehemos 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 desconocidoGabriel Bermúdez Merino 61
  • 62. Programación de una tienda virtual en Grails 7. Bibliografía7. Bibliografía7.1 Libros[1] Dierk König, Andrew Glover, Paul King, Guillaume LaForge,Jon Skeet: “Groovy in Action”, 2007, New York, ManningPublications.[2] Kenneth Barclay, John Savage: “Groovy Programming anintroduction for Java developers”, 2007, San Francisco, ElsewierInc.[3] Graeme Keith Rocher: “The Definitive Guide to Grails”, 2006,New York, Springer-Verlag New York Inc.[4] Jason Rudolph, Venkat Subramaniam: “Getting Started withGrails”, 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.comGabriel Bermúdez Merino 62
  • 63. Programación de una tienda virtual en Grails 8. Anexos8. Anexos8.1 Manual instalación de libreríasEn este apartado se explicará la instalación de las libreríasnecesarias para el correcto funcionamiento de nuestraaplicación.8.1.1 GroovyLos pasos a seguir para una correcta instalación de laslibrerí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_HOME que apunte al directorio que escogiste en el paso anterior. • Asegúrate que JAVA_HOME también este definido y apunte 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 (la variable de ambiente PATH).8.1.2 GrailsLos pasos a seguir para una correcta instalación de laslibrerí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_HOME que apunte al directorio que escogiste en el paso anterior. • Asegúrate que JAVA_HOME también este definido y apunte a un directorio de instalación de JDK.Gabriel Bermúdez Merino 63
  • 64. Programación de una tienda virtual en Grails 8. Anexos • Asegúrate que tanto GRAILS_HOME/bin y JAVA_HOME/bin formen parte de la ruta de búsqueda de programas (la variable de ambiente PATH).NOTA: Es posible que tengamos que dar permisos de ejecucióna todo lo que esté en $GRAILS_HOME/bin y$GRAILS_HOME/ant/bin8.2 RiesgosLa solución descrita en este documento se ha probado ydesarrollado con las versiones de programas siguientes: • Groovy • Grails 1.0.2 • Ubuntu 8.04 • Java jdk1.6.0 • Mozilla Firefox 2.14El uso de esta herramienta con otras versiones de dichosprogramas no se ha probado, por lo que no se asegura el correctofuncionamiento de la misma con otras versiones que no sean lasdescritas anteriormente.8.3 Análisis del tiempo de realización delproyectoMediante diagramas de Gantt se darán a conocer una estimacióndel tiempo que se ha utilizado en cada apartado de larealización del proyecto, comenzando por un diagrama general yotro más detallado. En ellos se mostrarán las fechas aproximadasde inicio de cada apartado más relevante en la realización delproyecto, así como las fechas aproximadas de finalización.Diagrama generalGabriel Bermúdez Merino 64
  • 65. Programación de una tienda virtual en Grails 8. AnexosDiagrama detallado • Documentación y estudio avanzado • Estudio proyecto e implementación • DocumentaciónGracias a estos diagramas podemos calcular el coste económicodel 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 queañadir el coste del software, pero como es OpenSource no tienecoste alguno, por lo que el precio del proyecto sería el costepropio del estudio, implementación y documentación.El coste de implantación sería muy bajo, ya que cualquierordenador de medio rendimiento podría ejecutar las directricesdel proyecto, el coste de software es 0 como se ha mencionadoantes y la instalación/mantenimiento de la aplicación es muysencillo, una de las grandes ventajas de Grails respecto a otrosframeworks.Gabriel Bermúdez Merino 65
  • 66. Programación de una tienda virtual en Grails 8. Anexos8.4 ImplantaciónManagementPara la implantación de este proyecto de forma que unadministrador pueda modificar la configuración, se copiaría lacarpeta contiene el proyecto (en nuestro caso petStore que vieneincluída en el cd) en cualquier localización de nuestro sistemaLinuxque y posteriormente realizariamos la instalación de laslibrerías de Groovy y de Grails siguiendo los pasos del apartado8.1 de este anexo. A continuación exportaríamos la base de datoso configuraríamos el archivo …grails-appconfDataSource.groovycon una nueva base de datos creada previamente.Una vez realizados estos pasos ya se podría editar laconfiguración de nuestro proyecto y se podría ejecutarutilizando el comando de Grails: $> grails run-appDeliveryPara la implantación de este proyecto, ya preparado para supublicación, previamente tendríamos que aprovechar un comando deGrails que nos proporciona la posibilidad de crear un archivo.war de nuestra aplicación. $> grails warPosteriormente, antes de la instalación del archivo .warrealizariamos la instalación de las librerías de Groovy y deGrails siguiendo los pasos del apartado 8.1 de este anexo. Acontinuación instalaríamos el servidor de aplicaciones ApacheTomcat 5.5.Una vez instalado Tomcat se copia el fichero .war en eldirectorio TOMCAT_HOME/webapps y se configura la base de datosque se utilizará. Por defecto esta configuración se obtendrá viaJNDI, con lo que no será necesario modificar los ficheros war.Configuraremos la aplicación web usando JNDI creando un ficheroxml para el fichero war y con el mismo nombre en el directorioTOMCAT_HOME/conf/Catalina/localhost con el contenido: <Context path="/petStore" docBase="${catalina.home}/webapps/oness-party- webapp.war" debug="99" reloadable="true"> <!-- To use a global jndi datasource uncomment the <ResourceLink> tag and move the other entries to your server.xml under <GlobalNamingResources> --> <!-- <ResourceLink name="jdbc/oness" global="jdbc/oness" type="javax.sql.DataSource"/> -->Gabriel Bermúdez Merino 66
  • 67. Programación de una tienda virtual en Grails 8. Anexos <Environment description="Hibernate dialect" name="net.sf.oness.common.model.hibernateDialect" 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.BasicDataSourceFactory</val ue> </parameter> <!-- Maximum number of dB connections in pool. Make sure you configure your mysqld max_connections large enough to handle all of your db connections. Set to 0 for no limit. --> <parameter> <name>maxActive</name> <value>100</value> </parameter> <!-- Maximum number of idle dB connections to retain in pool. Set to 0 for no limit. --> <parameter> <name>maxIdle</name> <value>30</value> </parameter> <!-- Maximum time to wait for a dB connection to become available in ms, in this example 10 seconds. An Exception is thrown if this timeout is exceeded. Set to -1 to wait indefinitely. --> <parameter> <name>maxWait</name> <value>10000</value> </parameter> <!-- MySQL dB username and password for dB connections --> <parameter> <name>root</name> <value></value> </parameter> <parameter> <name> </name> <value></value> </parameter> <!-- Class name for JDBC driver --> <parameter> <name>driverClassName</name> <value>com.mysql.jdbc.Driver</value> </parameter> <!-- Autocommit setting. This setting is required to make Hibernate work. Or you can remove calls to commit(). --> <parameter> <name>defaultAutoCommit</name> <value>false</value> </parameter>Gabriel Bermúdez Merino 67
  • 68. Programación de una tienda virtual en Grails 8. Anexos <!-- The JDBC connection url for connecting to your MySQL dB. The autoReconnect=true argument to the url makes sure that the mm.mysql JDBC Driver will automatically reconnect if mysqld closed the connection. mysqld by default closes idle connections after 8 hours. --> <parameter> <name>url</name> <value>jdbc:mysql://localhost/petStore_dev</value> </parameter> <!-- Recover abandoned connections --> <parameter> <name>removeAbandoned</name> <value>true</value> </parameter> <!-- Set the number of seconds a dB connection has been idle before it is considered abandoned. --> <parameter> <name>removeAbandonedTimeout</name> <value>60</value> </parameter> <!-- Log a stack trace of the code which abandoned the dB connection resources. --> <parameter> <name>logAbandoned</name> <value>true</value> </parameter> </ResourceParams> </Context>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 datosUna vez realizados estos pasos ya tenemos lista nuestraaplicación implantada.Gabriel Bermúdez Merino 68
  • 69. ENGINYERIA TÈCNICA EN INFORMÀTICA DE SISTEMES UNIVERSITAT DE BARCELONATreball 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: