Grails es un marco de aplicación web de código abierto que utiliza el lenguaje de programación Apache Groovy [1] : 757, §18 (que a su vez está basado 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 necesaria ]
Grails se conocía anteriormente como "Groovy on Rails"; En marzo de 2006, ese nombre se eliminó en respuesta a una solicitud de David Heinemeier Hansson , fundador del marco Ruby on Rails . [2] El trabajo comenzó en julio de 2005, con la versión 0.1 el 29 de marzo de 2006 y la versión 1.0 anunciada el 18 de febrero de 2008.
Grails se desarrolló para abordar una serie de objetivos:
Grails tiene tres propiedades que lo diferencian de los marcos web tradicionales de Java:
La creación de aplicaciones web en Java tradicionalmente implica configurar entornos y marcos al inicio y durante el desarrollo. Esta configuración suele externalizarse en archivos XML para facilitar la configuración y evitar incrustar la configuración en el código de la aplicación.
Inicialmente, XML fue bien recibido porque proporcionaba una mayor coherencia para configurar las aplicaciones. Sin embargo, en los últimos años se ha hecho evidente que, aunque XML es excelente para la configuración, configurar un entorno puede resultar tedioso. Esto puede reducir la productividad ya que los desarrolladores dedican tiempo a comprender y mantener la configuración del marco a medida que crece la aplicación. Agregar o cambiar funcionalidad en aplicaciones que usan 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 configuración en archivos XML. En cambio, 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 en Controller(por ejemplo BookController) se considera un controlador web.
Cuando se utilizan kits de herramientas web Java tradicionales, corresponde a los desarrolladores ensamblar unidades de desarrollo, lo que puede resultar tedioso. Grails proporciona un entorno de desarrollo que incluye un servidor web para que los desarrolladores puedan comenzar de inmediato. Todas las bibliotecas necesarias forman parte de la distribución de Grails y Grails prepara el entorno web Java para su implementación automáticamente.
Grails presenta métodos dinámicos en varias clases a través de mixins. Un mixin es un método que se agrega a una clase dinámicamente, 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 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 framework 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 LibroController { 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, como se muestra a continuación:
Libro de creación de controlador de Grails
Este comando crea una clase en el grails-app/controllerdirectorio del proyecto Grails. Crear la clase de controlador es suficiente para que Grails la reconozca. La listacción se asigna al http://localhost:8080/book/listmodo de desarrollo.
Grails soporta JSP y GSP. El siguiente ejemplo muestra una vista escrita en GSP que enumera los libros en el modelo preparado por el controlador anterior:
<html> <head> <title> Nuestros libros </title> </head> <body> <ul> <g:each in= "${books}" > <li> ${it.title} (${ it.autor.nombre}) </li> </g:each> </ul> </body> </html> Esta vista debe guardarse a partir grails-app/views/book/list.gspdel proyecto Grails. Esta ubicación se asigna a la acción BookControllery list. Colocar el archivo en esta ubicación es suficiente para que Grails lo reconozca.
También hay una referencia de etiqueta GSP disponible.
Grails proporciona una gran cantidad de bibliotecas de etiquetas listas para usar. [1] : 758-763, §18-2 Sin embargo, también puedes crear y reutilizar tus propias bibliotecas de etiquetas [1] : 792, §18-13 fácilmente: [3]
clase ApplicationTagLib { def formatDate = { atributos , cuerpo -> salida << nuevo java . texto . SimpleDateFormat ( atributos . formato ). formato ( atributos . fecha ) } } La formatDatebiblioteca de etiquetas anterior formatea un java.util.Dateobjeto en formato 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="${miFecha}"/>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 (Mapeo relacional de objetos de Grails). Las clases de dominio se guardan en el grails-app/domaindirectorio y se pueden crear usando el grailscomando como se muestra a continuación:
Grails crear-dominio-clase libro
Este comando solicita el nombre de la clase de dominio y crea el archivo apropiado. A continuación se muestra el código de la Bookclase:
clase Libro { Cadena título Persona autor } Crear esta clase es todo lo que se requiere para que Grails la administre para su persistencia. Con Grails 0.3, GORM se ha mejorado y, por ejemplo, agrega las propiedades id y versión a la clase de dominio si no están presentes. La propiedad id se utiliza como clave principal de la tabla correspondiente. La propiedad de versión 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 conservar las instancias de la clase. [2]
El 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 . ahorrar () El delete()método elimina un objeto de la base de datos:
def libro = Libro . libro findByTitle ( “El Código Da Vinci” ) . borrar () El refresh()método actualiza el estado de un objeto de la base de datos:
def libro = Libro . libro findByTitle ( “El Código Da Vinci” ) . actualizar () 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 . identificador () El count()método devuelve el número de registros en la base de datos para una clase determinada:
def bookCount = Libro . contar () El exists()método devuelve verdadero si existe un objeto en la base de datos con un identificador determinado:
def libroExiste = 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 . buscar ( "del Libro b donde b.título =?" , [ 'El Código Da Vinci' ]) Tenga en cuenta que la sintaxis de consulta es Hibernate HQL .
El findAll()método devuelve todos los objetos existentes en la base de datos:
def libros = Libro . encuentra todos () El findAll()método también puede tomar una declaración de consulta de objeto para devolver una lista de objetos:
def libros = Libro . buscarTodo ( "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 libro = Libro . findDónde ( título: "El Código Da Vinci" ) Grails admite andamios para admitir operaciones CRUD (Crear, Leer, Actualizar, Eliminar). Se puede aplicar scaffolding a cualquier clase de dominio creando un controlador de scaffolding como se muestra a continuación:
clase BookController { andamio estático = verdadero } Al crear esta clase, puede realizar operaciones CRUD en http://localhost:8080/book. Esto funciona porque BookController sigue la misma convención de nomenclatura que la clase de dominio Book. Para aplicar scaffolding a una clase de dominio específica, podríamos hacer referencia a la clase directamente en la propiedad scaffold:
clase SomeController { andamio estático = Libro } Actualmente, Grails no proporciona soporte para las asociaciones.
El mecanismo de persistencia en GORM se implementa mediante Hibernate . Como tal, las bases de datos heredadas se pueden asignar a clases GORM utilizando archivos de mapeo estándar de Hibernate.
El público objetivo de Grails es:
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 integración transparente de clases asignadas con el marco ORM de Hibernate . Esto significa que las aplicaciones existentes que usan Hibernate pueden usar Grails sin volver a compilar el código o reconfigurar las clases de Hibernate mientras usan los métodos de persistencia dinámica discutidos anteriormente. [3] Archivado el 16 de julio de 2011 en Wayback Machine.
Una consecuencia de esto es que se puede configurar el scaffolding para clases Java asignadas 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 hace uso del marco de inversión de control de Spring ; Grails es en realidad una aplicación Spring MVC oculta. [4] El marco Spring se puede utilizar para aprovisionar Spring beans 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 sólido sistema de plantillas. [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
.svg/1280px-Free_and_open-source_software_logo_(2009).svg.png){kind=logo}