27 September 2009, 16:15
Hoy en día, cualquier aplicación web que se precie necesita de una interfaz lo suficientemente atractiva, cómoda y usable para que el usuario no la abandone tras los primeros intentos. En este punto es donde aparece AJAX para ayudarnos en esta tarea. 
Grails soporta por defecto una serie de frameworks AJAX como Prototype, Yahoo User Interface, Script.aculo.us y Dojo y básicamente lo que Grails hace es poner una capa por encima de todos estos frameworks para que independientemente del que utilicemos, la sintaxis sea siempre la misma.
Gracias a estos frameworks, vamos a poder utilizar en nuestras aplicaciones una serie de características de la web 2.0 como pueden ser los editores de texto enriquecido, buscadores de contenido con el plugin Searchable o incluso la posibilidad de exportar a varios formatos sin apenas esfuerzo y tiempo gracias al plugin Export.
De igual forma, con los frameworks AJAX podremos conseguir los típicos editInPlace, autocompletados o un sistema de votación de contenidos con estrellas.
24 September 2009, 16:46
En cualquier proyecto desarrollado en Grails, toda la configuración del mismo la podéis encontrar en el directorio grails-app/conf. Básicamente, en este directorio hay cuatro archivos para configurar diferentes aspectos de una aplicación típica: Config.groovy, DataSource.groovy, BootStrap.groovy y UrlMappings.groovy.
Config.groovy
Contiene los parámetros de configuración general de nuestra aplicación e incluso podemos crear variables globales que estarán disponibles en todos los artefactos de la aplicación.
DataSource.groovy
Este archivo nos servirá para configurar el acceso a la base de datos utilizada por la aplicación. Grails puede trabajar en tres entornos: desarrollo, test y producción. Pues para cada uno de esos entornos, es posibles indicarle una base de datos diferente.
BootStrap.groovy
Este archivo contiene una clase llamada en la que a su vez se definen los métodos init() y destroy(). Estos métodos se ejecutarán al arrancar y al parar nuestra aplicación respectivamente. Habitualmente, el método se init() se utiliza para insertar una serie de datos en la aplicación, mientras que el método destroy() lo podemos utilizar para eliminarlos y dejar la base de datos en un estado conocido.
UrlMappings.groovy
Por defecto en Grails, las direcciones tienen el siguiente aspecto: http://localhost:8080/biblioteca/usuario/edit/1, donde:
- localhost, es el nombre del servidor
- 8080, es el puerto utilizado
- biblioteca, es el nombre de la aplicación
- usuario, es el controlador que se encarga de procesar la petición
- edit, es el método del controlador
- 1, es el identificador que se pasa por parámetro
Sin embargo, podemos modificar este comportamiento por defecto de Grails creando nuevas reglas en el archivo UrlMappings.groovy
22 September 2009, 22:39
Cuando nos referimos a la seguridad de una aplicación web, estamos hablando de conceptos como la autenticación o el control de acceso a diferentes tipos de usuarios. Para facilitar esta gestión de la seguridad, podemos ayudarnos de un plugin de Jsecurity disponible en Grails.
En temas de control de acceso podemos pensar en usuarios con un determinado rol, el cual tiene asignado una serie de permisos. Esto precisamente es lo que hace este plugin, dotándo a nuestra aplicación de 6 clases de dominio y sus correspondientes controladores para facilitarnos la labor.
Estas seis clases de dominio son:
- JsecUser, que establece las propiedades necesarias para almacenar el nombre de usuario y la contraseña de los usuarios
- JsecRole, indica los diferentes roles existentes en la aplicación
- JsecPermission, indica los permisos que pueden ser asignados a los usuarios
- JsecRolePermissionRel, establece las relaciones entre los permisos y los roles del sistema
- JsecUserRoleRel, establece las relaciones entre los usuarios y los roles del sistema
- JsecUserPermissionRel, establece las relaciones entre los usuarios y los posibles permisos del sistema
Combinando este plugin con los filtros en Grails, vamos a poder implementar un control de acceso a nuestra aplicación de forma muy rápida.
16 September 2009, 12:37
[3]
Lo ideal para cualquier desarrollador de aplicaciones sería poder despreocuparse de los problemas que en ocasiones suponen recuperar información de la base de datos. Para ello, Grails utiliza GORM como una capa que se superpone a un framework de persistencia de datos tan robusto como es Hibernate.
Gracias a GORM, el desarrollador dispone de una sería de métodos dinámicos para obtener los datos de nuestras clases de dominio. Si por ejemplo necesitáramos conocer cuantos usuarios libros del año 2000 tenemos en nuestra biblioteca, no tendría más que escribir Libro.countByAnyo(2000). Incluso podríamos encadenar criterios de búsqueda para por ejemplo obtener el número de libros del año 2000 cuya editorial fuera Apress de la siguiente forma: Libro.countByAnyoAndEditorial(2000,“Apress”)
Por supuesto, el desarrollador no ha tenido que implementar ninguno de estos métodos y ha sido GORM quien los pone a su disposición de forma dinámica.
Si necesitáramos obtener un listado de esos libros podríamos utilizar la siguiente llamada: Libro.findAllBy(2000,“Apress”), que nos devolvería una lista con todas las instancias recuperadas de la base de datos que cumplan las condiciones pasadas en los parámetros.
GORM dispone de más métodos que vais a poder encontrar en la web http://grails.org/GORM. Sin embargo, es posible que en alguna ocasión necesitemos realizar consultas complejas a la base de datos a las que GORM no puede llegar. Para eso aparecen las consultas con el lenguaje propio de Hibernate, HQL y Criteria, un API propio de Hibernate.
15 September 2009, 15:04
En algunos frameworks de desarrollo de aplicaciones, las clases de dominio son conocidas como el modelo y no hay ninguna diferencia entre ambos términos. Las clases de dominio se refieren al modelo de datos de nuestra aplicación. En ellas definiremos las propiedades de cada una de las clases de nuestra aplicación, así como las restricciones de cada una de estas propiedades.
Un ejemplo de una clase de dominio que representa la típica información de los usuarios de una aplicación podría ser el siguiente:
En el ejemplo se muestra las propiedades de la clase de dominio Usuario, así como las restricciones que debe cumplir cada una de esas propiedades. Podéis encontrar un listado con las posibles restricciones en Grails en la página http://grails.org/Validation. El listado de posibles restricciones predefinidas en Grails es finito, sin embargo, es posible crear nuestras propias restricciones en Grails
A continuación veremos como definir las posibles relaciones entre las clases de dominio de una aplicación
Uno a uno
Uno a muchos / Muchos a uno
Muchos a muchos
GORM
La capa que aparece en Grails en los temas relativos a la persistencia de nuestras clases de dominio es GORM, quien, entre otras características, permite realizar operaciones del tipo Usuario.findAllByTipo(“administrador”), algo que sin duda facilita mucho la labor del desarrollador que se debe centrar únicamente en el desarrollo de la lógica de negocio y olvidarse de aspectos relacionados con la base de datos.
4 September 2009, 18:59
[2]
Grails no simplemente es un frameworks de desarrollo web sino un marco completo de trabajo y en este marco se incluyen las pruebas que las aplicaciones deben superar antes de pasar a producción.
En este sentido, Grails incluye para las pruebas unitarias y de integración el framework JUnit, ampliamente utilizado por la comunidad Java. Mediante estos tests unitarios y de integración vamos a poder comprobar que la aplicación funciona siempre de la misma manera independiente de los cambios que hagamos en el código. Hay mucha teoría muy interesante sobre el desarrollo guiado por pruebas en Internet.
Con el comando grails create-integration-test, Grails creará una nueva clase con el siguiente contenido que posteriormente deberemos completar para realizar las pruebas correspondientes.
La función setUp() permite establecer una serie de acciones que se realizarán antes que cualquier otra prueba mientras que la función tearDown() se ejecutará una vez todas las pruebas se hayan realizado. Por último, la función testSomething() deberá ser sustituida por todas aquellas pruebas que necesitemos realizar sobre nuestra aplicación.
El comando grails test-app nos permitirá ejecutar todas las pruebas realizadas y generar un informe final con los tests realizados.
En el mismo sentido, Grails también permite la realización de tests funcionales mediante un plugin de Canoo. Los tests funcionales pretenden comprobar la funcionalidad de nuestra aplicación. Esas pruebas típicas de hacer clic en tal botón o en tal enlace, rellenar todos los datos de los formularios, etc. han pasado a la historia gracias a los tests funcionales. Canoo es un framework para la realización de tests funcionales que ya tiene su plugin para ser utilizado fácilmente en nuestras aplicaciones Grails.
Una vez hayamos instalado el plugin, podemos crear tests funcionales con el comando grails create-webtest, el cual genera un test por defecto que comprueba que las operaciones de inserción, borrado y edición funcionan correctamente.
Como siempre Grails integra en un único entorno todas las herramientas necesarias para el desarrollo de aplicaciones web.
29 July 2009, 13:12
En una aplicación que siga el patrón Modelo Vista Controlador, los controladores son los componentes que se encargan de recibir las órdenes por parte del usuario, gestionar la ejecución de la lógica de negocio y posteriormente actualizar la vista para que el usuario pueda ver como ha quedado el modelo de datos tras las actualizaciones pertinentes.
Hablando en términos de aplicaciones web, los controladores se encargan de interceptar las peticiones HTTP del navegador y generar la respuesta correspondiente, bien sea html, xml, json o cualquier otro formato, bien desde el propio controlador o delegando el trabajo en una vista GSP.
La convención que utiliza Grails en el caso de los controladores es que un controlador es cualquier clase que se encuentre en el directorio grails-app/controllers de nuestro proyecto y su nombre termine por la palabra Controller.
Cuando comenté el scaffolding de Grails ya vimos el comando grails create-controller que nos creaba el esqueleto de la clase de un controlador. En ese momento realizábamos un scaffolding dinámico o al vuelo. Sin embargo, si ejecutamos el comando grails generate-controller Usuario y abrimos el archivo UsuarioController.groovy, comprobaremos que su contenido se ha modificado bastante del que teníamos al principio y se han generado una serie de métodos index(), list(), show(), delete(), edit(), update(), create() y save(), que coinciden con los métodos necesarios para realizar el scaffolding de forma estática.
Con este scaffolding estático, vamos a tener más margen de maniobra para implementar mejoras en los controladores de la aplicación, para que ésta quede a nuestro gusto. Estas mejoras se suelen referir por ejemplo al establecimiento de controles de seguridad de acceso por parte de los diferentes usuarios del sistema.
16 July 2009, 12:14
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.
« Entradas antiguas
Entradas recientes »
