Griales (marco)

Este artículo contiene contenido promocional . Ayúdenos a mejorarlo eliminando el lenguaje promocional y los enlaces externos inapropiados , y agregando texto enciclopédico escrito desde un punto de vista neutral . ( Octubre de 2010 ) ( Aprenda cómo y cuándo eliminar este mensaje )

Griales

Desarrollador(es)	Graeme Rocher
Lanzamiento inicial	Octubre de 2005
Versión estable	6.1.2 / 31 de enero de 2024
Repositorio	Repositorio Grails
Escrito en	Genial
Sistema operativo	Multiplataforma
Plataforma	Multiplataforma ( JVM )
Tipo	Marco de aplicación web
Licencia	Licencia Apache 2.0
Sitio web	Grails.org

Grails es un marco de trabajo de código abierto para aplicaciones web que utiliza el lenguaje de programación Apache Groovy ^{[1] : 757, §18} (que a su vez se basa en la plataforma Java ). Su objetivo es ser un marco de trabajo 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. ^{[ cita requerida ]}

Grails se conocía anteriormente como "Groovy on Rails"; en marzo de 2006 ese nombre se abandonó en respuesta a una solicitud de David Heinemeier Hansson , fundador del marco Ruby on Rails . ^[2] 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.

Grails fue desarrollado para abordar una serie de objetivos:

• Proporcionar un marco web para la plataforma Java.
• Reutilice tecnologías Java existentes como Hibernate y Spring bajo una única interfaz
• Ofrecer un marco de desarrollo consistente.
• Ofrecer documentación para partes clave del marco:
  • El marco de persistencia .
  • Plantillas que utilizan GSP (Groovy Server Pages).
  • Bibliotecas de etiquetas dinámicas para crear componentes de páginas web.
  • Soporte Ajax personalizable y extensible .
• Proporcionar aplicaciones de muestra que demuestren el marco.
• Proporciona un modo de desarrollo completo, que incluye un servidor web y recarga automática de recursos.

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

La creación de aplicaciones web en Java implica tradicionalmente la configuración de entornos y marcos de trabajo al principio y durante el desarrollo. Esta configuración suele externalizarse en archivos XML para facilitar la configuración y evitar la incrustación de la configuración en el código de la aplicación.

En un principio, XML fue bien recibido porque ofrecía una mayor coherencia para configurar las 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 marco a medida que la aplicación crece. Agregar o cambiar funcionalidades en aplicaciones que utilizan la configuración XML agrega 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 configuraciones en archivos XML. En su lugar, el marco 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 con Controller(por ejemplo BookController) se considera un controlador web.

Al utilizar los kits de herramientas web tradicionales de Java, los desarrolladores deben ensamblar las unidades de desarrollo, lo que puede resultar tedioso. Grails ofrece un entorno de desarrollo que incluye un servidor web para que los desarrolladores puedan comenzar a trabajar de inmediato. Todas las bibliotecas necesarias forman parte de la distribución de Grails y Grails prepara el entorno web de Java para la implementación de forma automática.

Grails incluye métodos dinámicos en varias clases a través de 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 o ampliar las 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.

El marco web Grails ha sido diseñado según el paradigma MVC .

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 list ( ) { [ libros: Book.list ( ) ] } }          

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. La creación de la clase del controlador es suficiente para que Grails la reconozca. La listacción se asigna al http://localhost:8080/book/listmodo de desarrollo.

Grails admite JSP y GSP. El ejemplo siguiente 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 grails-app/views/book/list.gspdel proyecto Grails. Esta ubicación corresponde a la acción BookControllery list. Colocar el archivo en esta ubicación es suficiente para que Grails lo reconozca.

También hay disponible una referencia de etiqueta GSP.

Grails proporciona una gran cantidad de bibliotecas de etiquetas listas para usar. ^{[1] : 758-763, §18-2} Sin embargo, también puede crear y reutilizar sus propias bibliotecas de etiquetas ^{[1] : 792, §18-13} fácilmente: ^[3]

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

La formatDatebiblioteca de etiquetas anterior formatea un java.util.Dateobjeto como 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 formato="aaaaMMdd" fecha="${myDate}"/>

Para utilizar una biblioteca de etiquetas dinámicas en un GSP no es necesario utilizar etiquetas de importación. Las bibliotecas de etiquetas dinámicas también se pueden utilizar en archivos JSP , aunque esto requiere un poco más de trabajo. [1] Archivado el 17 de octubre de 2010 en Wayback Machine.

El modelo de dominio en Grails se conserva en la base de datos mediante GORM (Grails Object Relational Mapping). Las clases de dominio se guardan en el grails-app/domaindirectorio y se pueden crear mediante 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 }      

La creación de esta clase es todo lo que se necesita para que Grails la administre de forma persistente. Con Grails 0.3, GORM se ha mejorado y, por ejemplo, agrega las propiedades id y version a la clase de dominio si no están presentes. La propiedad id se utiliza como clave principal de la tabla correspondiente. La propiedad version se utiliza para el bloqueo optimista.

Cuando una clase se define como una clase de dominio, es decir, una clase administrada por GORM, se agregan métodos dinámicamente para ayudar a mantener las instancias de la clase. [2] Archivado el 19 de octubre de 2010 en Wayback Machine.

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

def book = new Book ( título: " El Código Da Vinci" , autor: Author.findByName ( " Dan Brown" )) book.save ( )     

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

def libro = Libro.findByTitle ( " El Código Da Vinci " ) libro.delete ( )   

El refresh()método actualiza el estado de un objeto de 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 de la base de datos:

def libro = Libro.findByTitle ( " El Código Da Vinci " ) def id = libro.ident ( )      

El count()método devuelve el número de registros en la base de datos para una clase determinada:

def bookCount = Libro . count ()   

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

def bookExists = Libro . existe ( 1 )   

El find()método devuelve el primer objeto de la base de datos basándose en una declaración de consulta de objeto:

def libro = Libro . find ( "del 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 tomar una declaración de consulta de objeto para devolver una lista de objetos:

def libros = Libro . findAll ( "del 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 ( "El%" )   

Los findWhere*()métodos devuelven el primer objeto de la base de datos que coincide con un conjunto de parámetros nombrados:

def book = Book . findWhere ( title: "El Código Da Vinci" )   

Grails admite el uso de estructuras para respaldar las operaciones CRUD (Crear, Leer, Actualizar, Eliminar). Es posible usar estructuras para cualquier clase de dominio mediante la creación de un controlador de estructuras, como se muestra a continuación:

clase BookController { static scaffold = true }      

Al crear esta clase, puede realizar operaciones CRUD en http://localhost:8080/book. Esto funciona porque BookController sigue la misma convención de nombres que la clase de dominio Book. Para crear una estructura de una clase de dominio específica, podríamos hacer referencia a la clase directamente en la propiedad de estructura:

clase SomeController { andamio estático = Libro }      

Actualmente Grails no proporciona andamiaje para asociaciones.

El mecanismo de persistencia en GORM se implementa a través de Hibernate . Por lo tanto, las bases de datos heredadas se pueden asignar a clases GORM mediante archivos de asignación estándar de Hibernate.

El público objetivo de Grails es:

• Desarrolladores de Java o Groovy que buscan un entorno de desarrollo integrado para crear aplicaciones basadas en web.
• Desarrolladores sin experiencia en Java que buscan un entorno de alta productividad para crear aplicaciones basadas en la web. ^{[ cita requerida ]}

Grails está construido sobre la plataforma Java y es parte de ella, lo que significa que es muy fácil de integrar con bibliotecas, marcos y bases de código existentes de Java. Grails ofrece una integración transparente de clases que están mapeadas con el marco ORM de Hibernate . Esto significa que las aplicaciones existentes que usan Hibernate pueden usar Grails sin tener que volver a compilar el código o reconfigurar las clases de Hibernate mientras usan los métodos de persistencia dinámica que se mencionaron anteriormente. [3] 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 marco web Grails están completamente disponibles para estas clases y las aplicaciones que las utilizan.

Grails también utiliza el marco de inversión de control Spring ; Grails es en realidad una aplicación Spring MVC. ^[4] El marco Spring se puede utilizar para aprovisionar beans 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 a través de un sistema de plantillas robusto. ^[5]

Las aplicaciones Grails están empaquetadas como artefactos de guerra que se pueden implementar en cualquier contenedor de servlets o servidores de aplicaciones Java EE . ^{[1] : 763, §18-2}

• Groovy (lenguaje de programación)
• JRuby
• Griffon (framework) , un framework de escritorio inspirado en Grails
• Canguro de primavera
• Comparación de frameworks web

This article includes a list of general references, but it lacks sufficient corresponding inline citations. Please help to improve this article by introducing more precise citations. (October 2012) (Learn how and when to remove this message)

• Sitio web oficial
• Mastering Grails Un tutorial en línea de 18 partes proporcionado por IBM (desde 2008)

• Rocher, Graeme Keith (2009). La guía definitiva de Grails (2.ª ed.). Berkeley, CA: Apress. ISBN 9781590599952.
• Brown, Jeff; Rocher, Graeme (2013). La guía definitiva de Grails 2. [Nueva York]: Apress. ISBN 9781430243779.