Como cualquier framework que utilice el Modelo Vista Controlador, la vista se utiliza para mostrar el contenido final que será visto por el usuario. Estos archivos de la vista utilizan plantillas y etiquetas para evitar la repetición de código y los fallos en la edición del mismo.
En Grails los archivos de la vista tienen extensión .gsp y están alojados en el directorio grails-app/views/. Las plantillas tienen por convenio que el nombre del archivo empieza con un subrayado bajo. La típica plantilla que nos podemos encontrar en cualquier aplicación web se refiere al pie de la misma. Podríamos tener algo así:
span style="color: #ff0000;">"copyright"
Una vez creada la plantilla, el siguiente paso será insertarla en aquellas páginas donde la queramos mostrar. Para eso Grails dispone de la etiqueta <g:render/> a la que debemos pasarle el parámetro template con la ubicación y el nombre de la plantilla que acabamos de generar, con lo que tendríamos algo asi: <g:render template="/common/piedepagina"/>. Como puedes comprobar, hemos obviado el subrayado bajo al inicio del nombre de la plantilla, puesto que aquello sólo era un convenio.
Si queremos modificar la apariencia de nuestro pie de página, debemos modificar el archivo css ubicado en web-app/css/main.css y añadir o modificar los descriptores necesarios.
Etiquetas en Grails
Posiblemente hayamos visto una de las etiquetas más utilizadas en Grails como es <g:render/>. Sin embargo, ésta no es la única y Grails cuenta con etiquetas para realizar operaciones lógicas, de iteración, de asignación, relativas a enlaces, AJAX, de formularios, de interfaz de usuario y renderización de contenido y de validación.
En la página oficial de Grails http://www.grails.org/GSP+Tag+Reference encontraréis un listado de completo de todas las etiquetas disponibles.
13 July 2009, 15:08
El scaffolding es un término utilizando en programación para designar la construcción automática de aplicaciones a partir del esquema de la base de datos. Está soportado por varios frameworks MVC y Grails no podía ser menos y también lo incluye entre sus características más importantes. La idea del scaffolding es, partiendo del esquema de la base de datos, generar el código necesario para implementar las cuatro operaciones básicas en cualquier aplicación, que son: creación, lectura, actualización y borrado. Este tipo de aplicaciones se las conoce como CRUD (create, read, update y delete).
Continue reading »
6 July 2009, 12:01
[2]
Grails es un framework para el desarrollo de aplicaciones web basado en el lenguaje de programación Groovy, que a su vez se basa en la Plataforma Java. Grails está basado en los paradigmas convención sobre configuración y DRY (don’t repite yourself) o no te repitas que permite al programador olvidarse en gran parte de los detalles de configuración.
Como la mayoría de los framework de desarrollo web, Grails está basado en el patrón Modelo Vista Controlador (MVC). En Grails los modelos son tratados como clases de dominio que permiten a la aplicación mostrar los datos en la vista. A diferencia de en otros frameworks, las clases de dominio de Grails son automáticamente persistidas y es incluso posible generar el esquema de la base de datos. Los controladores por su parte, permiten gestionar las peticiones a la aplicación y organizar los servicios proporcionados. Por último, la vista por defecto en Grails son las Groovy Server Pages (GSP) y habitualmente nos muestra el contenido en formato HTML.
Grails permite al programador olvidarse de gran parte de la configuración típico que incluyen los frameworks MVC. Además Grails se aprovecha de un lenguaje dinámico como Groovy para acortar los tiempos de desarrollo para simplemente dejarlos en escribir código, actualizar, testear y depuración de fallos. Esto hace que el desarrollo de la aplicación sea mucho más ágil que con otros frameworks MVC.
Además, Grails es una plataforma completa, puesto que incluye también un contenedor web, bases de datos, sistemas de empaquetado de la aplicación y un completo sistema para la realización de tests sobre nuestra aplicación. De esta forma, no debemos perder el tiempo buscando y descargando un servidor web para nuestra futura aplicación o un gestor de base de datos. Ni tan siquiera será necesario escribir complicados scripts de configuración para el empaquetado de la aplicación. Todo esto se convierte en una tarea tan sencilla como instalar Grails.
Características principales de Grails
- Convención sobre configuración
En lugar de tener que escribir interminables archivos de configuración en formato XML, Grails se basa en una serie de convenciones para que el desarrollo de la aplicación sea mucho más rápido y productivo. Además, gracias al uso de convenciones, se refuerza el otro principio del que hablábamos anteriormente, DRY (don’t repite yourself) o no te repitas.
Uno de las partes más importantes en el desarrollo de software se refiere a los tests implementados que garantizan un software de calidad y el fácil mantenimiento de una aplicación. Gracias a estos tests, es muy sencillo detectar y solucionar fallos provocados por cambios en el código. Cada vez que se genera en Grails una clase de dominio o un controlador, paralelamente se genera también un test para comprobar la nueva clase o controlador.
Grails distingue entre tests unitarios y tests de integración. Los tests unitarios son tests sin dependencias de ningún tipo, salvo algún que otro objeto mock. Por otro lado, los tests de integración tienen acceso completo al entorno de Grails, incluyendo la base de datos. Además, Grails permite también la creación de tests funcionales para comprobar la funcionalidad de nuestra aplicación web.
Grails permite también utilizar scaffolding en nuestras aplicaciones. El scaffolding es una característica de determinados frameworks que permite la generación automática de código para las cuatro operaciones básicas de cualquier aplicación, que son la creación, lectura, edición y borrado, lo que en inglés se conoce como CRUD (create, read, update and delete). El scaffolding en Grails se consigue escribiendo muy pocas líneas de código, con lo que podemos centrarnos en especificar las propiedades, comportamientos y restricciones de nuestras clases de dominio.
- Mapeado objeto-relacional
Grails incluye un potente framework para el mapeado objeto-relacional conocido como GORM (Grails Object Relational Mapping). Como cualquier framework de persistencia, GORM permite mapear objetos contra bases de datos relacionales y representar relaciones entre dichos objetos del tipo uno-a-uno o uno-a-muchos.
Sin embargo, Grails no siempre es la solución a cualquier problema que se nos pueda plantear en el desarrollo de aplicaciones web. Para ayudarnos, Grails dispone de una arquitectura de plugins con una comunidad de usuarios detrás (cada vez más grande) que ofrecen plugins para seguridad, AJAX, testeo, búsqueda, informes y servicios web. Este sistema de plugins hace que añadir complicadas funcionalidades a nuestra aplicación se convierte en algo muy sencillo.
30 June 2009, 16:08
Los Builders de Groovy se utilizan para realizar determinadas tareas que, por sencillas que parezcan, pueden llegar a convertirse en complejas, como por ejemplo la generación de archivos XML, la automatización de tareas con Ant se facilita o incluso el diseño de interfaces gráficas. Empecemos viendo como escribir archivos XML con el builder específico que Groovy pone a nuestra disposición. 
Los archivos XML son un tipo de archivo ampliamente extendido para el intercambio de información entre aplicaciones. Groovy quiere ayudarnos en la generación de estos archivos, tratando que escribamos el código para construir esos archivos XML de la forma más sencilla y clara posible y el builder encargado de esa labor es MarkupBuilder, el cual nos ayudará a escribir tanto archivos XML como HTML.
El ejemplo que vamos a ver consiste en crear un archivo XML referido a facturas de una empresa. Cada factura contendrá una serie de items, cada uno con un producto. El siguiente fragmento de código generaría el archivo XML de ejemplo:
span style="color: #ff0000;">'Teclado'"\r","")
Lo que produciría el siguiente archivo XML.
span style="color: #ff0000;">'Sun Jan 01 00:00:00 CET 2006'>
<item id=
'1'>
<producto nombre=
'Teclado' euros=
'876' />
</item>
</factura>
<factura fecha=
'Mon Jan 02 00:00:00 CET 2006'>
<item id=
'2'>
<producto nombre=
'Teclado' euros=
'876' />
</item>
</factura>
<factura fecha=
'Tue Jan 03 00:00:00 CET 2006'>
<item id=
'3'>
<producto nombre=
'Teclado' euros=
'876'Como puedes comprobar, la limpieza del código escrito para generar el archivo XML es increíble y prácticamente, el código sigue el mismo tabulado que el posterior archivo XML, con lo que la lectura del código por terceras personas se facilita muchísimo.
Otros buildes interesantes en Groovy son los que se refieren a la automatización de tareas con Ant o el diseño de interfaces gráficas.
24 June 2009, 14:19
Una de las características que se resaltan de Groovy es que es un lenguaje perfecto para escribir DSLs. Pero, ¿qué son los DSLs?
¿Qué son los DSLs?
Un DSL es un lenguaje de programación reducido que permite representar el conocimiento de un campo específico. Imaginemos que debemos desarrollar una aplicación que se encargue de la toma de decisiones en el entorno financiero. Para realizar la programación en Java o Groovy (o cualquier otro lenguaje), quien se encargue de la programación debería tener los conocimientos necesarios tanto del sistema financiero así como del lenguaje de programación utilizado.
Utilizando un DSL nos ahorraremos las reglas específicas del lenguaje de programación, centrando nuestros objetivos en la especificación de las reglas financieras necesarias para el correcto funcionamiento del sistema. De esta forma, vamos a poder encargar la parte relacionada con las reglas financieras a algún experto en la materia.
¿Por que Groovy?
Pues simplemente porque es un lenguaje dinámico que nos proporciona mucha libertad a la hora de crear estructuras necesarias en un contexto particular. Las características de Groovy que lo hacen idóneo para escribir DSLs son:
- Los Builders nos permiten crear estructuras en forma de árbol estructurado
- Se pueden añadir nuevos métodos y propiedades a través de categorías y metaclases. Incluso se puede hacer esto con los números para especificar cosas como 4.veces o 24.horas
- La mayoría de los operadores se pueden sobrecargar para poder hacer cosas como totalMinutos = 4.dias + 12.horas
- Podemos utilizar un mapa como parámetro en un método, lo cual es muy intuitivo. Por ejemplo mover(x:500.metros, y:2:kilometros)
- También podemos crear nuevas estructuras de control utilizando los closures, como por ejemplo siFaltaMenosDeUnDia{…}
Ejemplo de DSL
Un ejemplo de DSL puede ser GORM (Groovy Object Relational Mapping). GORM es el framework de persistencia utilizando en Grails. Basado en Hibernate, podemos utilizar GORM sin haber visto en nuestra vida nada sobre Hibernate, simplemente conociendo el modelo de datos. Imaginemos que tenemos una clase Persona mapeada contra una tabla de la base de datos. Gracias a GORM, podríamos acceder a los datos de la siguiente forma:
span style="color: #808080; font-style: italic;">//Para acceder a los datos de las Personas con GORM se haría así
"Manuel""Ma%""M%", "L%")
Aquí os dejo un enlace donde se crea un DSL para realizar el cálculo de distancias
18 June 2009, 10:53
Un closure es un trozo de código empaquetado como un objeto y definido entre llaves. Actúa como un método, al cual se le pueden pasar parámetros y pueden devolver valores. Es un objeto normal y corriente al cual se pasa una referencia de la misma forma que se le pasa a cualquier otro objeto.
Posiblemente estés pensando, que de momento los closures no te aportan nada que no puedas hacer nada con cualquier otro lenguaje de programación y posiblemente incluso sea cierto. Sin embargo, los closures nos aportan agilidad a la hora de programar, que es lo que en principio buscamos utilizando un lenguaje como Groovy.
Declarando closures
El siguiente fragmento de código representa la declaración y el uso de un closure muy básico en Groovy. En él, se imprime una frase a partir de un parámetro pasado al closure.
span style="color: #ff0000;">"Mi nombre es ${nombre}"}
imprimeNombre("Juan")
imprimeNombre "Yolanda"
Closures como objetos
Anteriormente comentábamos que los closures son objetos y que como tales, pueden ser pasados como parámetros a funciones. Un ejemplo de este caso es el método each de las listas, al cual se le puede pasar un closure para realizar una determinada operación sobre cada elemento de la lista.
span style="color: #ff0000;">"Calderón", "Navarro", "Jiménez", "Garbajosa", "Pau Gasol"]
salida = ""', ''Calderón, Navarro, Jiménez, Garbajosa, Pau Gasol, '
Como ves, el closure no ha recibido ningún parámetro, sin embargo, ha sido posible acceder al contenido de cada posición de la lista mediante la palabra reservada it.
« Entradas antiguas
Entradas recientes »
