Groovy on Grails (III): Tecnologías asociadas :: Grails

Grails

En este apartado, se va a profundizar en los aspectos más relevantes de Grails mediante descripciones y ejemplos. No se puede considerar este apartado como un manual de usuario de Grails, más bien como un pequeño tutorial de introducción a éste potente framework web.

En los siguientes apartados vamos a tratar varios aspectos de Grails, desde su estructura hasta llegar a su funcionalidad pasando por la implementación de controladores, gsp’s, etc …

1. Estructura de la aplicación

El primer paso en la implementación de un nuevo 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.

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 del 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'
   }
}

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:

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

• 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 grailsapp\ controllers. 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.

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])
      }
   }
}

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 war

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

Leer más...

Groovy on Grails (II): Tecnologías asociadas :: Groovy

Groovy

En este apartado, se va a profundizar en los aspectos más relevantes de Groovy mediante descripciones y ejemplos. No se puede considerar este apartado como un manual de usuario de Groovy, más bien  como un pequeño tutorial de introducción a éste potente lenguaje de scripting.

En algunos de estos ejemplos se hará una comparativa directa con Java con el objetivo de demostrar la disminución de código entre uno y otro.

1. Primeros pasos: “Hola Mundo”

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

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. Erealidad las listas son en el fondo java.util.ArrayList y los mapas java.util.HashMap, por lo que se podrán utilizatodos los métodos ya conocidos en Java relacionados conlistas y mapas. Además, Groovy permite que los índices llaves sean manipulados a través del operador ‘[]’, y en elcaso 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”]  


<-- 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.

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  de 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.

import java.util.Date


if (session == null) {
    session = request.getSession(true);
}


if (session.counter == null) {
    session.counter = 1
}


println """
<html>
    <head>
         <title>Groovy Servlet</title>
    </head>
    <body>   
        Hello, ${request.remoteHost}: ${session.counter}! ${new Date()}
    </body>
</html>
"""
session.counter = session.counter + 1 

Leer más...

Groovy on Grails (I): Introducción

En los últimos años Internet ha ido evolucionando poco a poco hacia un entorno colaborativo entre usuarios, hasta llegar a la actualidad y a la Web 2.0, donde el entorno colaborativo ha culminado con la aparición de Blogs, Wikis, el e-commerce, … Esto último implica el estudio e investigación de nuevas tecnologías que hagan más sencillo el desarrollo de nuevas aplicaciones web tanto para el desarrollador como para el usuario llano.

El desarrollo de frameworks web ha ido evolucionando constantemente, desde los struts, framework que implementa el patrón de arquitectura Modelo Vista-Controlador en Java, hasta, por ejemplo, “Groovy on Grails”, buscando siempre una simplificación de código pero sin comprender una reducción de la calidad del producto final.

El problema abordado por este proyecto es la creación de una aplicación web de e-commerce, concretamente una tienda virtual de mascotas, utilizando la nueva tecnología basada en Groovy, Grails. Para la implementación de esta aplicación han sido necesarios varios estudios previos de cada una de las tecnologías que comprenden el mundo de “Groovy on Grails”, los cuales podriamos dividir en:

• Estudio del lenguaje de programación Groovy

• Estudio del framework basado en Groovy, Grails

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

Groovy como lenguaje de programación

El 2 de Enero de 2007 aparecía la versión 1.0 de Groovy, un nuevo lenguaje de programación orientado a objetos desarrollado por Guillaume Laforge, Jefe de Proyecto y JSR-241 Spec Lead.

La implementación de Groovy se realiza sobre la plataforma Java además, tiene características similares a Python, Ruby, Perl y Smalltalk. Gracias a la especificación JSR-241, se busca su estandarización para una futura inclusión como componente oficial de la plataforma Java.

Groovy utiliza una sintaxis muy parecida a Java, compartiendo el mismo modelo de objetos, de hilos y de seguridad. Mediante importaciones, Groovy puede acceder a todas las API de Java ampliando la compilación, ya que el bytecode generado es totalmente compatible con el que Java genera para la Java Virtual Machine.

Para Groovy, Java no es un lenguaje incompatible con su código, todo lo contrario, todo el código escrito en Java es válido en Groovy. Este aspecto hace su aprendizaje mucho más sencillo a programadores Java que otros lenguajes que se ejecutan sobre la Java Virtual Machine, como Jython o Jruby. 

Java es totalmente compatible con Groovy, pero esto no hace que Groovy pierda todas las ventajas de un lenguaje de scripting, ya que también se puede ejecutar de forma dinámica. Por ejemplo, en Java la salida estándar de “Hello World” hace necesaria la escritura de una clase, un método main con una serie de argumentos, etc… Pero en Groovy, no es necesario escribir todo el código, te puedes ahorrar la declaración de la clase y el método main, y sólo escribir una línea de código que muestre por pantalla “Hello World”.

El contenido del archivo HelloWorld.groovy sería:

println “Hello World”

Como podemos observar, el dinamismo de un lenguaje de scripting se encuentra presente en Groovy, pero, ¿y la compatibilidad con Java?


Groovy da soporte a listas, mapas, etc… y aún podemos demostrar
la simplicidad de Groovy y su capacidad para ejecutar código en
Java:

//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 directamente
java.util.Date y no importamos un soporte para colecciones para
trabajar con listas, mapas y rangos. Aunque no es necesario,como en el ejemplo, podemos exportar librerías Java para que el
proceso de desarrollo sea más cómodo.
En el apartado de tecnologías asociadas, profundizaremos más en
el mundo de Groovy mediante explicaciones y ejemplos.


Grails como framework Web

Grails es un framework para aplicaciones Web de libre distribución, que tiene como base el lenguaje de programación Groovy. Grails es un framework de alta productividad que viene distribuido bajo el paradigma del “código por convención” (MVC), el cuál proporciona un entorno de desarrollo independiente y unos detalles de configuración escondidos para el desarrollador.


Grails se llamó previamente “Groovy on Rails” (nombre que se le
puso en como homenaje a David Heinemeier Hansson, fundador de
Ruby on Rails, otro framework web). El trabajo de desarrollo
comenzó en Julio de 2005 que dio como fruto la versión 0.1 el 29
de Marzo de 2006 i la versión 1.0 el 18 de Febrero de 2008.


En el momento de su implementación, se estudiaron varios
conceptos a favor de Grails entre los que destacaban:
Proporcionar una alta productividad basándose en la
plataforma de Java.

• Utilizar de manera más simple tecnologías de Java como Hibernate y Spring, mediante una interface consistente.
• Un framework sencillo y fácil de aprender.
• Documentación con participación de los usuarios.
• Proporcionar simplicidad en áreas donde antes solo podían adentrarse usuarios expertos:

• Framework persistente potente y consistente.

• Uso sencillo pero potente de las templates de vista utilizando GSP (Páginas de Servidor Groovy).

• Librerías de tags dinámicas para una creación de componentes web sencilla.

• Buen soporte a Ajax pero simple de ampliar 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.

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

• Framework sencillo y simple

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

• Controllers: 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 ) ]
}

• 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

• 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.

• 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]
}

• 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 la par sencillo, ahora sólo hemos nombrado los aspectos más relevantes por lo que a continuación, en el apartado de tecnologías asociadas, profundizaremos más en el mundo de Grails mediante explicaciones y ejemplos, posteriormente realizaremos una implementación completa de una aplicación web de e-comerce.

Leer más...

Proximamente: Groovy on Grails

Después de mucho tiempo, me he decido a reflotar el Blog reorientando una série de posts de manera didáctica, ya que en breve comenzaré a introducir el bonito, pero complicado mundo de Groovy on Grails.

No se lo pierdan!

Leer más...