Hispanopedia WikiGrails es un framework de código abierto para aplicaciones web que utiliza el lenguaje de programación Apache Groovy [ 2 ] : 757, §18 (que a su vez se basa en la plataforma Java ). Su objetivo es ser un framework de alta productividad, siguiendo el paradigma de " codificación por convención ", proporcionando un entorno de desarrollo independiente y ocultando gran parte de los detalles de configuración al desarrollador.
Grails era conocido anteriormente como "Groovy on Rails"; en marzo de 2006 se eliminó ese nombre en respuesta a una solicitud de David Heinemeier Hansson , fundador del framework Ruby on Rails . [ 3 ] El trabajo comenzó en julio de 2005, con el lanzamiento de la versión 0.1 el 29 de marzo de 2006 y el lanzamiento de la versión 1.0 anunciado el 18 de febrero de 2008.
Descripción general
Grails se desarrolló para abordar una serie de objetivos:
- Proporcionar un marco de trabajo web para la plataforma Java.
- Reutilizar tecnologías Java existentes como Hibernate y Spring bajo una única interfaz.
- Ofrecer un marco de desarrollo coherente.
- Ofrecer documentación para las partes clave del marco:
- El marco de persistencia .
- Plantillas que utilizan GSP (Groovy Server Pages).
- Bibliotecas de etiquetas dinámicas para la creación de componentes de páginas web.
- Soporte Ajax personalizable y extensible .
- Proporcione ejemplos de aplicaciones que demuestren el funcionamiento del marco de trabajo.
- Proporcionar un modo de desarrollo completo, que incluya un servidor web y recarga automática de recursos.
Marketing
Grails tiene tres propiedades que lo diferencian de los frameworks web Java tradicionales:
- Sin configuración XML
- Entorno de desarrollo listo para usar
- Funcionalidad disponible a través de mixins
Sin configuración XML
Tradicionalmente, la creación de aplicaciones web en Java implica configurar entornos y frameworks al inicio y durante el desarrollo. Esta configuración suele externalizarse en archivos XML para facilitar su uso y evitar integrarla en el código de la aplicación.
Inicialmente, XML fue bien recibido por su mayor coherencia en la configuración de aplicaciones. Sin embargo, en los últimos años, se ha hecho evidente que, si bien XML es excelente para la configuración, puede resultar tedioso configurar un entorno. Esto puede reducir la productividad, ya que los desarrolladores dedican tiempo a comprender y mantener la configuración del framework a medida que la aplicación crece. Agregar o modificar funcionalidades en aplicaciones que utilizan configuración XML añade un paso adicional al proceso de cambio, lo que ralentiza la productividad y puede disminuir la agilidad de todo el proceso.
Grails elimina la necesidad de agregar configuración en archivos XML. En su lugar, el framework utiliza un conjunto de reglas o convenciones al inspeccionar el código de las aplicaciones basadas en Grails. Por ejemplo, un nombre de clase que termina en Controller(por ejemplo BookController, ) se considera un controlador web.
Entorno de desarrollo listo para usar
Al usar kits de herramientas web Java tradicionales, los desarrolladores deben ensamblar las unidades de desarrollo, lo cual puede resultar tedioso. Grails proporciona un entorno de desarrollo que incluye un servidor web para que los desarrolladores puedan empezar a trabajar de inmediato. Todas las bibliotecas necesarias forman parte de la distribución de Grails, y este prepara automáticamente el entorno web Java para su implementación.
Funcionalidad disponible a través de mixins
Grails ofrece métodos dinámicos en varias clases mediante mixins. Un mixin es un método que se agrega a una clase de forma dinámica, como si la funcionalidad se hubiera compilado en el programa.
Estos métodos dinámicos permiten a los desarrolladores realizar operaciones sin tener que implementar interfaces ni extender clases base. Grails proporciona métodos dinámicos basados en el tipo de clase. Por ejemplo, las clases de dominio tienen métodos para automatizar operaciones de persistencia como guardar, eliminar y buscar.
Marco de trabajo web
El framework web Grails ha sido diseñado siguiendo el paradigma MVC .
Controladores
Grails utiliza controladores para implementar el comportamiento de las páginas web. A continuación se muestra un ejemplo de un controlador:
clase BookController { def lista () { [ libros: Libro . lista () ] } }El controlador anterior tiene una listacción que devuelve un modelo que contiene todos los libros de la base de datos. Para crear este controlador grailsse utiliza el comando que se muestra a continuación:
Libro de creación de controladores de Grails
Este comando crea una clase en el grails-app/controllerdirectorio del proyecto Grails. Crear la clase del controlador es suficiente para que Grails la reconozca. La listacción se corresponde http://localhost:8080/book/listcon el modo de desarrollo.
Vistas
Grails admite JSP y GSP. El siguiente ejemplo muestra una vista escrita en GSP que enumera los libros del modelo preparado por el controlador anterior:
<html> <head> <title> Nuestros libros </title> </head> <body> <ul> <g:each in= "${books}" > <li> ${it.title} (${it.author.name}) </li> </g:each> </ul> </body> </html>Esta vista debe guardarse como parte grails-app/views/book/list.gspdel proyecto Grails. Esta ubicación se corresponde con la acción BookControllery list. Basta con colocar el archivo en esta ubicación para que Grails lo reconozca.
Bibliotecas de etiquetas dinámicas
Grails proporciona una gran cantidad de bibliotecas de etiquetas listas para usar. [ 2 ] : 758-763, §18-2 Sin embargo, también puede crear y reutilizar sus propias bibliotecas de etiquetas [ 2 ] : 792, §18-13 fácilmente: [ 4 ]
clase ApplicationTagLib { def formatDate = { attrs , body -> out << new java . text . SimpleDateFormat ( attrs . format ). format ( attrs . date ) } }La formatDatebiblioteca de etiquetas anterior formatea un java.util.Dateobjeto a un String. Esta biblioteca de etiquetas debe agregarse al grails-app/taglib/ApplicationTagLib.groovyarchivo o a un archivo que termine TagLib.groovyen el grails-app/taglibdirectorio.
A continuación se muestra un fragmento de un archivo GSP que utiliza la formatDatebiblioteca de etiquetas:
<g:formatDate format="yyyyMMdd" date="${myDate}"/> Para usar una biblioteca de etiquetas dinámicas en un archivo GSP, no es necesario usar etiquetas de importación. Las bibliotecas de etiquetas dinámicas también se pueden usar en archivos JSP, aunque esto requiere un poco más de trabajo.Archivado el 17 de octubre de 2010 en Wayback Machine.
Persistencia
Modelo
El modelo de dominio en Grails es GORM (Grails Object Relational Mapping). Las clases de dominio se guardan en el grails-app/domaindirectorio y se pueden crear utilizando el grailscomando que se muestra a continuación:
grails crear-clase-de-dominio Libro
Este comando solicita el nombre de la clase de dominio y crea el archivo correspondiente. A continuación Bookse muestra el código de la clase:
clase Libro { String título Persona autor }Basta con crear esta clase para que Grails la gestione para su persistencia. Con Grails 0.3, GORM se ha mejorado y, por ejemplo, añade las propiedades `id` y `version` a la clase de dominio si no están presentes. La propiedad `id` se utiliza como clave primaria de la tabla correspondiente. La propiedad `version` se utiliza para el bloqueo optimista.
Métodos
Cuando una clase se define como una clase de dominio, es decir, una gestionada por GORM, se añaden métodos dinámicamente para facilitar la persistencia de las instancias de la clase.Archivado el 19 de octubre de 2010 en Wayback Machine.
Métodos de instancia dinámica
Este save()método guarda un objeto en la base de datos:
def libro = nuevo Libro ( título: "El Código Da Vinci" , autor: Autor . findByName ( "Dan Brown" )) libro . guardar ()Este delete()método elimina un objeto de la base de datos:
def libro = Libro.findByTitle ( " El Código Da Vinci" ) libro.delete ( )Este refresh()método actualiza el estado de un objeto desde la base de datos:
def libro = Libro.findByTitle ( " El Código Da Vinci" ) libro.refresh ( )El ident()método recupera la identidad del objeto asignada desde la base de datos:
def libro = Libro.findByTitle ( " El Código Da Vinci" ) def id = libro.ident ( )Métodos estáticos dinámicos (de clase)
Este count()método devuelve el número de registros en la base de datos para una clase determinada:
def bookCount = Book.count ( )El exists()método devuelve verdadero si existe un objeto en la base de datos con un identificador dado:
def bookExists = Book.exists ( 1 )Este find()método devuelve el primer objeto de la base de datos basándose en una consulta de objeto:
def libro = Libro.find ( " from Libro b donde b.título = ?" , [ ' El Código Da Vinci' ])Tenga en cuenta que la sintaxis de la consulta es Hibernate HQL .
El findAll()método devuelve todos los objetos existentes en la base de datos:
def libros = Libro.findAll ( )El findAll()método también puede aceptar una consulta de objeto para devolver una lista de objetos:
def libros = Libro.findAll ( " from Libro " )Los findBy*()métodos devuelven el primer objeto de la base de datos que coincide con un patrón específico:
def libro = Libro.findByTitle ( " El Código Da Vinci " )También:
def libro = Libro.findByTitleLike ( "%Da Vinci % " )Los findAllBy*()métodos devuelven una lista de objetos de la base de datos que coinciden con un patrón específico:
def libros = Libro.findAllByTitleLike ( "The % " )Los findWhere*()métodos devuelven el primer objeto de la base de datos que coincide con un conjunto de parámetros con nombre:
def libro = Libro.findWhere ( título: " El Código Da Vinci" )Andamio
Grails admite la generación automática de código (scaffolding) para dar soporte a las operaciones CRUD (Crear, Leer, Actualizar, Eliminar). Cualquier clase de dominio puede generarse automáticamente creando un controlador de scaffolding como se muestra a continuación:
clase BookController { static scaffold = true }Al crear esta clase, puede realizar operaciones CRUD http://localhost:8080/book. Esto funciona porque BookController sigue la misma convención de nomenclatura que la clase de dominio Book. Para generar una clase de dominio específica, podríamos hacer referencia a la clase directamente en la propiedad scaffold:
clase SomeController { static scaffold = Book }Actualmente, Grails no proporciona una estructura básica para las asociaciones.
Modelos de bases de datos heredados
El mecanismo de persistencia en GORM se implementa mediante Hibernate . Por lo tanto, las bases de datos heredadas se pueden mapear a clases GORM utilizando archivos de mapeo estándar de Hibernate .
Público objetivo
El público objetivo de Grails es:
- Desarrolladores de Java o Groovy que buscan un entorno de desarrollo integrado para crear aplicaciones web.
- Desarrolladores sin experiencia en Java que buscan un entorno de alta productividad para crear aplicaciones web.
Integración con la plataforma Java
Grails se basa en la plataforma Java y forma parte de ella, lo que facilita su integración con bibliotecas, frameworks y bases de código Java existentes. Grails ofrece una integración transparente de clases mapeadas con el framework ORM Hibernate . Esto significa que las aplicaciones existentes que utilizan Hibernate pueden usar Grails sin necesidad de recompilar el código ni reconfigurar las clases de Hibernate, aprovechando los métodos de persistencia dinámica mencionados anteriormente.Archivado el 16 de julio de 2011 en Wayback Machine.
Una consecuencia de esto es que se puede configurar el andamiaje para las clases Java mapeadas con Hibernate. Otra consecuencia es que las capacidades del framework web Grails están totalmente disponibles para estas clases y las aplicaciones que las utilizan.
Grails también utiliza el marco de inversión de control de Spring ; de hecho, Grails es una aplicación MVC de Spring internamente. [ 5 ] El marco de Spring se puede utilizar para aprovisionar beans de Spring adicionales e introducirlos en el contexto de la aplicación. El marco SiteMesh se utiliza para gestionar la capa de presentación, simplificando el desarrollo de páginas mediante un sistema de plantillas robusto. [ 6 ]
Las aplicaciones Grails se empaquetan como artefactos WAR que se pueden implementar en cualquier contenedor de servlets o servidores de aplicaciones Java EE . [ 2 ] : 763, §18-2
Véase también
- Groovy (lenguaje de programación)
- JRuby
- Griffon (framework) , un framework de escritorio inspirado en Grails.
- Micronaut (framework) , otro framework creado por Graeme Rocher.
- Roo de primavera
- Comparación de frameworks web
Referencias
- ↑ "Versión 7.0.9 - apache/grails-core" . github.com . Consultado el 18 de marzo de 2026 .
- 1 2 3 4 Deinum et al. 2014 .
- ↑ Rocher, Graeme. "Groovy on Rails ya no existe (más o menos)" . Archivado del original el 7 de mayo de 2010.
- ↑ 7.3 Bibliotecas de etiquetas
- ↑ "Documentación de Grails" .
- ↑ "Presentación de Slideshare" . 6 de noviembre de 2010.
Lecturas adicionales
- Deinum, Marten; Rubio, Daniel; Long, Josh; Mak, Gary (1 de septiembre de 2014). Recetas de primavera: Un enfoque de problema-solución (Segunda edición). Apress . ISBN 978-1-4302-2499-0.
- Brown, Jeff; Rocher, Graeme (15 de enero de 2009), La guía definitiva de los Griales (2.ª ed.), Apress , pág. 648, ISBN 978-1-59059-995-2
- Smith, Glen; Ledbrook, Peter (28 de junio de 2009), Grails in Action (1.ª ed.), Manning Publications , pág. 520, ISBN 978-1-933988-93-1
- Abdul-Jawad, Bashar (2 de diciembre de 2008), Groovy and Grails Recipes (1.ª ed.), Apress , pág. 424, ISBN 978-1-4302-1600-1
- Fischer, Robert (20 de abril de 2009), Grails Persistence with GORM and GSQL (1.ª ed.), Apress , pág. 125, ISBN 978-1-4302-1926-2Archivado del 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.ª ed.), Apress , 440 págs. , ISBN 978-1-4302-1045-0
- Rudolph, Jason (6 de febrero de 2007), Introducción a Grails (1.ª ed.), Lulu.com , pág. 132, ISBN 978-1-4303-0782-2
Enlaces externos
- Sitio web oficial
- Dominando el Santo Grial: Un tutorial en línea de 18 partes proporcionado por IBM (desde 2008).
Libros
- Java (plataforma de software)
- marcos de trabajo web