Grails se ha desarrollado con una serie de objetivos en mente:

• Ofrecer un framework web de alta productividad para la plataforma Java.
• Reutilizar tecnologías Java ya probadas como Hibernate y Spring bajo una interfaz simple y consistente.
• Ofrecer un framework consistente que reduzca la confusión y que sea fácil de aprender.
• Ofrecer documentación para las partes del framework relevantes para sus usuarios.
• Proporcionar lo que los usuarios necesitan en áreas que a menudo son complejas e inconsistentes:
  • Framework de persistencia potente y consistente.
  • Patrones de visualización potentes y fáciles de usar con GSP (Groovy Server Pages).
  • Bibliotecas de etiquetas dinámicas para crear fácilmente componentes web.
  • Buen soporte de Ajax que sea fácil de extender y personalizar.
• Proporcionar aplicaciones ejemplo que muestren la potencia del framework.
• Proporcionar un entorno de desarrollo orientado a pruebas.
• Proporciona un entorno completo de desarrollo, incluyendo un servidor web y recarga automática de recursos.

Grails se ha diseñado para ser fácil de aprender, fácil para desarrollar aplicaciones y extensible. Intenta ofrecer el equilibrio adecuado entre consistencia y funcionalidades potentes.

Grails tiene tres características que intentan incrementar su productividad comparándolo con los framework Java tradicionales:

• Inexistencia de configuración XML.
• Entorno de desarrollo preparado para funcionar desde el primer momento.
• Funcionalidad disponible mediante métodos dinámicos.

Crear aplicaciones web en Java tradicionalmente implica configurar entornos y frameworks al inicio y durante el desarrollo. Esta configuración a menudo está en ficheros XML para facilitar dicha configuración y evitar tenerla en el código fuente. XML fue inicialmente bienvenido para proporcionar consistencia para configurar aplicaciones. Sin embargo aunque el XML es muy útil para la configuración resulta complicado y tedioso utilizarlo para los entornos de desarrollo. La productividad de los programadores baja mucho mientras pasan tiempo configurando y manteniendo los frameworks mientras la aplicación crece. Añadir o modificar configuración en las aplicaciones que utilizan la configuración XML añade un paso extra al proceso de escribir aplicaciones que repercute en la productividad, reduciéndola y hace que el proceso completo sea poco ágil.

Grails elimina la necesidad de configurar ficheros XML. En su lugar el framework utiliza una serie de reglas de convención mientras examina el código de las aplicaciones basadas en Grails. Por ejemplo, una clase que termina en Controller es considerada un controlador web.

Mientras usamos herramientas Java tradicionales, es tarea del desarrollador ensamblar los componentes, lo cual puede ser tedioso. Grails tiene un servidor web integrado preparado para desplegar la aplicación desde el primer momento. Todas las librerías requeridas son parte de la distribución de Grails y están preparadas para ser desplegadas automáticamente.

Grails proporciona métodos dinámicos en varias de sus clases. Un método dinámico se añade a la clase en tiempo de ejecución, como si su funcionalidad hubiera sido compilada. Estos métodos dinámicos permiten a los desarrolladores realizar operaciones sin tener que implementar interfaces o heredar clases base. Grails proporciona método dinámicos basándose en el tipo de clase. Por ejemplo, la clases de dominio tienen métodos para automatizar operaciones de persistencia, como save para salvar, delete para borrar y find para buscar.

El framework web de Grails se ha diseñado según el paradigma Modelo Vista Controlador.

Grails usa controladores para implementar el comportamiento de las páginas web. A continuación hay un ejemplo de un controlador:

 class BookController {
    def list = {
       [ books: Book.findAll() ]
    }
 }

El controlador tiene una acción list que devuelve un modelo conteniendo todos los libros de la base de datos. Para crear este controlador se usa un comando grails:

grails create-controller

Este comando recoge el nombre del controlador y crea una clase en el directorio grails-app/controller del proyecto Grails. Crear la clase del controlador es suficiente para que Grails lo reconozca. La acción list se mapea a la dirección http://web.archive.org/web/http://localhost:8080/book/list en el entorno de desarrollo.

Grails soporta JSP y GSP. En el siguiente ejemplo se muestra una vista escrita en GSP que lista los libros del modelo preparado por el controlador anterior:

<html>
  <head>
    <title>Our books</title>
  </head>
  <body>
    <ul>
      <g:each in="${books}">
        <li>${it.title} (${it.author.name})</li>
      </g:each>
    </ul>
  </body>
</html>

Esta vista debe estar en grails-app/views/book/list.gsp del proyecto Grails. Esta localización es mapeada automáticamente por el BookController y la acción list.

Existe también una referencia a las Tags GSP.

Grails soporta varias librerías Ajax incluidas OpenRico, Prototype, Dojo y YUI.^[5]​ Existen librerías de tags para crear HTML con código Ajax. También existe la posibilidad de crear librerías de tags propias.

Grails proporciona un gran número de tag libraries. De todas maneras se pueden crear y reutilizar librerías de tags fácilmente:

 def formatDate = { attrs ->
    out << new java.text.SimpleDateFormat(attrs.format).format(attrs.date)
 }

El tag formatDate formatea el objeto java.util.Date a String. Este tag debe ser situado en el directorio grails-app/taglib para que Grails lo reconozca automáticamente.

A continuación un trozo de código de una GSP que utiliza el tag formatDate:

<g:formatDate format="yyyyMMdd" date="${myDate}"/>

Para usar una librería de tags en una página GSP no son necesarios import. Las librerías de tag también pueden ser utilizadas en JSP aunque esto requiere un poco más de esfuerzo. [1]

El modelo de datos en Grails se graba en la base de datos utilizando GORM (Grails Object Relational Mapping). Las clases de dominio se graban en el directorio grails-app/domain y se pueden crear utilizando el comando grails así:

grails create-domain-class

Este comando recibe el nombre de la clase y crea los ficheros adecuados. A continuación se muestra el código de la clase Book:

 class Book {
    String title
    Person author
 }

Crear esta clase es todo lo que se necesita para que sea persistida de forma automática por Grails. A partir de Grails 0.3, GORM ha sido mejorado y añade las propiedades id y version automáticamente si no se declaran. En la propiedad id se almacena la clave única de la tabla, mientras version se utiliza para gestionar el bloqueo optimista.

Las clases de dominio gestionadas por GORM tienen métodos dinámicos y estáticos para realizar operaciones de persistencia sobre estas clases y sus objetos. [2]

El método save() salva un objeto en la base de datos:

 def book = new Book(title:"The Da Vinci Code", author:Author.findByName("Dan Brown"))
 book.save()

El método delete() borra un objeto de la base de datos:

 def book = Book.findByTitle("The Da Vinci Code")
 book.delete()

El método refresh() refresca el estado de un objeto de la base de datos:

 def book = Book.findByTitle("The Da Vinci Code")
 book.refresh()

El método ident() recupera el identificador del objeto de la base de datos:

 def book = Book.findByTitle("The Da Vinci Code")
 def id = book.ident()

El método count() recupera el número de registros de una clase dada:

 def bookCount = Book.count()

El método exists() devuelve verdadero si el objeto existe en la base de datos con el identificador dado:

 def bookExists = Book.exists(1)

El método find() devuelve el primer objeto de la base de datos que corresponde con la consulta realizada:

 def book = Book.find("from Book b where b.title = ?", [ 'The Da Vinci Code' ])

La sintaxis utilizada es Hibernate HQL.

El método findAll() devuelve todos los objetos existentes en la base de datos:

 def books = Book.findAll()

El método findAll() también puede recibir una consulta como parámetro:

 def books = Book.findAll("from Book")

El método findBy*() devuelve el primer objeto de la base de datos que coincide con el patrón especificado:

 def book = Book.findByTitle("The Da Vinci Code")

También:

 def book = Book.findByTitleLike("%Da Vinci%")

El método findAllBy*() devuelve una lista de objetos de la base de datos que coincide con el patrón especificado:

 def books = Book.findAllByTitleLike("The%")

El método findWhere*() devuelve el primer objeto de la base de datos que coincide con los parámetros especificados:

 def book = Book.findWhere(title:"The Da Vinci Code")

Grails soporta scaffolding para implementar operaciones CRUD (Create, Read, Update, Delete). Cualquier clase de dominio puede crear su "Scaffolding" como se muestra a continuación:

 class BookController {
    def scaffold = true
 }

Creando esta clase se pueden realizar operaciones CRUD en la dirección http://web.archive.org/web/http://localhost:8080/book. Actualmente no todas las relaciones entre entidades están soportadas por Grails.

El mecanismo de persistencia en GORM se implementa mediante Hibernate. Las bases de datos heredadas pueden ser mapeadas a clases GORM utilizando lo ficheros de Mapeo Hibernate.

Grails ha sido creado teniendo como objetivo el facilitar la labor del desarrollador a la hora de realizar pruebas automáticas, lo que lo hace apto para algoritmos complejos. Se han implementado utilizando Groovy Tests.

Grails organiza los test en fases y tipos. Una fase se refiere al estado de la aplicación durante el test, y el tipo se refiere al mecanismo de test. Grails soporta cuatro fases de test (unitarios, integración, funcional y otros) y tipo JUnit para las fases unitarios e integración. Estos tipos tienen el mismo nombre que la fase.

Un proyecto Grails se crea así:

• Sigue las instrucciones de descarga e instalación del sitio web de Grails.^[6]​
• Abre una pantalla de terminal:

grails create-app

Este comando recibe el nombre del proyecto como parámetro y crea el directorio del proyecto con el mismo nombre. Hay que entrar en dicho directorio para poder ejecutar otros comandos dentro del proyecto.

Ejecutando el comando grails run-app puedes probar la aplicación en la URL http://web.archive.org/web/http://localhost:8080/

Los posibles usuarios de Grails son:

• Desarrolladores Java que buscan un entorno de desarrollo integrado para crear aplicaciones web.
• Desarrolladores sin experiencia en Java buscando un entorno de alta productividad para desarrollar aplicaciones web.

Grails está construido sobre la plataforma Java, con lo que es muy fácil integrarlo con librerías Java, framework y código existente. La mejor característica que Grails ofrece en este ámbito es una integración transparente con clases mapeada mediante el framework Hibernate ORM. Esto significa que aplicaciones existentes que utilicen Hibernate pueden utilizar Grails sin recompilar el código o reconfigurar las clases Hibernate, aprovechando los métodos de persistencia que se mencionan anteriormente. [3]

Una consecuencia es que se puede utilizar scaffolding con las clases Java mapeadas con Hibernate. Otra consecuencia es que las capacidades de Grails están totalmente disponibles para estas clases y las aplicaciones que las usan.

• GroovyMag for Groovy and Grails developers Archivado el 19 de agosto de 2010 en Wayback Machine. (En inglés)

• Escuela de Groovy proporciona servicios relacionados con la plataforma.
• OSOCO

• Brown, Jeff; Rocher, Graeme (15 de enero de 2009), The Definitive Guide to Grails (2ª edición), Apress, p. 648, ISBN 1590599950, archivado desde el original el 5 de marzo de 2010, consultado el 14 de febrero de 2010 .
• Smith, Glen; Ledbrook, Peter (28 de junio de 2009), Grails in Action (1ª edición), Manning Publications, p. 520, ISBN 1933988932 .
• Dickinson, Jon (27 de mayo de 2009), Grails 1.1 Web Application Development (1ª edición), Packt Publishing, p. 328, ISBN 1847196683 .
• Abdul-Jawad, Bashar (2 de diciembre de 2008), Groovy and Grails Recipes (1ª edición), Apress, p. 424, ISBN 143021600X, archivado desde el original el 2 de enero de 2010, consultado el 14 de febrero de 2010 .
• Fischer, Robert (20 de abril de 2009), Grails Persistence with GORM and GSQL (1ª edición), Apress, p. 125, ISBN 1430219262, archivado desde el original el 16 de diciembre de 2009, consultado el 22 de octubre de 2009 .
• M. Judd, Christopher; Nusairat, Joseph Faisal; Shingler, Jim (18 de junio de 2008), Beginning Groovy and Grails: From Novice to Professional (1ª edición), Apress, pp. 440, ISBN 1430210451, archivado desde el original el 19 de agosto de 2009, consultado el 22 de octubre de 2009 .
• Rudolph, Jason (6 de febrero de 2007), Getting Started with Grails (2ª edición), Lulu.com, p. 132, ISBN 143030782X .

• Groovy
• JRuby
• Griffon (framework) - Un framework desktop inspirado en Grails.