Apache Groovy es un lenguaje de programación orientado a objetos compatible con la sintaxis de Java para la plataforma Java . Es un lenguaje estático y dinámico con características similares a las de Python , Ruby y Smalltalk . Puede ser utilizado tanto como un lenguaje de programación y un lenguaje de script para la plataforma Java, se compila a máquina virtual Java (JVM) de código de bytes , e interopera perfectamente con otros código Java y bibliotecas . Groovy usa una sintaxis de corchetes similar al de Java. Groovy admite cierres , cadenas de varias líneas y expresiones incrustadas en cadenas . Gran parte del poder de Groovy radica en sus transformaciones AST , activadas a través de anotaciones.
Paradigma | Orientado a objetos , imperativo , scripting |
---|---|
Diseñada por | James Strachan |
Desarrollador | Guillaume Laforge (presidente del PMC) Jochen Theodorou ( director técnico) Paul King Cedric Champeau |
Apareció por primera vez | 2003 |
Lanzamiento estable | 3.0.8 (16 de abril de 2021 [1] ) [±] |
Versión de vista previa | 4.0.0-alpha-3/13 de marzo de 2021 [1] |
Disciplina de mecanografía | Dinámico , estático , fuerte , pato |
Plataforma | Java SE |
Licencia | Licencia Apache 2.0 |
Extensiones de nombre de archivo | .groovy, .gvy, .gy, .gsh [2] |
Sitio web | groovy-lang |
Implementaciones importantes | |
Gradle , Grails | |
Influenciado por | |
Java , Python , Ruby , Smalltalk | |
Influenciado | |
Kotlin |
Groovy 1.0 se lanzó el 2 de enero de 2007 y Groovy 2.0 en julio de 2012. Desde la versión 2, Groovy se puede compilar estáticamente , ofreciendo inferencia de tipos y un rendimiento cercano al de Java. [3] [4] Groovy 2.4 fue la última versión importante bajo el patrocinio de Pivotal Software que finalizó en marzo de 2015. [5] Groovy ha cambiado desde entonces su estructura de gobierno a un Comité de Gestión de Proyectos en la Apache Software Foundation . [6]
Historia
James Strachan habló por primera vez sobre el desarrollo de Groovy en su blog en agosto de 2003. [7] En marzo de 2004, Groovy fue presentado al JCP como JSR 241 [8] y aceptado por votación. Se lanzaron varias versiones entre 2004 y 2006. Después de que comenzó el esfuerzo de estandarización de Java Community Process (JCP), la numeración de la versión cambió y el 2 de enero de 2007 se lanzó una versión llamada "1.0". Después de varias betas y candidatos de lanzamiento numerados 1.1, el 7 de diciembre de 2007, Groovy 1.1 Final fue lanzado e inmediatamente renumerado como Groovy 1.5 para reflejar los muchos cambios realizados.
En 2007, Groovy ganó el primer premio en el premio a la innovación JAX 2007. [9] En 2008, Grails , un marco web Groovy , ganó el segundo premio en el premio a la innovación JAX 2008. [10]
En noviembre de 2008, SpringSource adquirió la empresa Groovy and Grails (G2One). [11] En agosto de 2009, VMware adquirió SpringSource. [12]
En abril de 2012, después de ocho años de inactividad, Spec Lead cambió el estado de JSR 241 a inactivo. [8]
Strachan había dejado el proyecto silenciosamente un año antes del lanzamiento de Groovy 1.0 en 2007. [ cita requerida ] En octubre de 2016, Strachan declaró: "Todavía amo groovy (¡los pipelines de jenkins son tan geniales!), Java, go, mecanografiado y kotlin". [13]
El 2 de julio de 2012, se lanzó Groovy 2.0, que, entre otras características nuevas, agregó compilación estática y verificación de tipos estáticos .
Cuando EMC Corporation (EMC) y VMware escindieron la empresa conjunta Pivotal Software en abril de 2013, Groovy and Grails formaron parte de su cartera de productos. Pivotal dejó de patrocinar a Groovy y Grails a partir de abril de 2015. [5] Ese mismo mes, Groovy cambió su estructura de gobierno de un repositorio de Codehaus a un Comité de Gestión de Proyectos (PMC) en Apache Software Foundation a través de su incubadora. [6] Groovy se graduó de la incubadora de Apache y se convirtió en un proyecto de alto nivel en noviembre de 2015. [14]
Características
La mayoría de los archivos Java válidos también son archivos Groovy válidos. Aunque los dos lenguajes son similares, el código Groovy puede ser más compacto, porque no necesita todos los elementos que necesita Java. [15] Esto hace posible que los programadores de Java aprendan Groovy gradualmente al comenzar con la sintaxis de Java familiar antes de adquirir más modismos de programación Groovy . [dieciséis]
Las características maravillosas que no están disponibles en Java incluyen tipado estático y dinámico (con la palabra clave def
), sobrecarga de operadores , sintaxis nativa para listas y matrices asociativas (mapas), soporte nativo para expresiones regulares , iteración polimórfica, interpolación de cadenas , métodos auxiliares agregados y el operador de navegación segura ?.
para comprobar automáticamente si hay punteros nulos (por ejemplo variable?.method()
, o variable?.field
). [17]
Dado que la versión 2, Groovy también admite modularidad (pudiendo enviar solo los frascos necesarios de acuerdo con las necesidades del proyecto, reduciendo así el tamaño de la biblioteca de Groovy), verificación de tipos, compilación estática, mejoras de sintaxis de Project Coin, bloques de multidifusión y mejoras de rendimiento continuas utilizando el invokedynamic
instrucción introducida en Java 7 . [18]
Groovy proporciona soporte nativo para varios lenguajes de marcado como XML y HTML , logrado a través de una sintaxis de Modelo de Objetos de Documento (DOM) en línea. Esta característica permite la definición y manipulación de muchos tipos de activos de datos heterogéneos con una metodología de programación y sintaxis uniforme y concisa. [ cita requerida ]
A diferencia de Java, un archivo de código fuente maravillosa puede ser ejecutado como una (sin compilar) guión , si contiene código fuera de cualquier definición de clase, si se trata de una clase con un principal método, o si se trata de un Ejecutable o GroovyTestCase . Un script Groovy se analiza, compila y genera completamente antes de ejecutarse (similar a Python y Ruby). Esto ocurre bajo el capó y la versión compilada no se guarda como un artefacto del proceso. [19]
GroovyBeans, propiedades
GroovyBeans son la versión de JavaBeans de Groovy . Groovy genera implícitamente getters y setters. En el siguiente código, setColor(String color)
y getColor()
se generan implícitamente. Las dos últimas líneas, que parecen acceder al color directamente, en realidad están llamando a los métodos generados implícitamente. [20]
class AGroovyBean { String color }def myGroovyBean = nuevo AGroovyBean ()myGroovyBean . setColor ( 'baby blue' ) afirmar myGroovyBean . getColor () == 'azul bebé'myGroovyBean . color = 'peltre' afirmar myGroovyBean . color == 'peltre'
Groovy ofrece una sintaxis simple y consistente para manejar listas y mapas , que recuerda la sintaxis de matriz de Java . [21]
def movieList = [ 'Dersu Uzala' , 'Ran' , 'Seven Samurai' ] // Parece una matriz, pero es una lista assert movieList [ 2 ] == 'Seven Samurai' movieList [ 3 ] = 'Casablanca' // Agrega un elemento a la lista assert movieList . tamaño () == 4def monthMap = [ 'Enero' : 31 , 'Julio' : 28 , 'Marzo' : 31 ] // Declara un mapa afirman monthMap [ 'Marzo' ] == 31 // Permite acceder a una entrada monthMap [ 'April' ] = 30 // Agrega una entrada al mapa assert monthMap . tamaño () == 4
Extensión de prototipo
Ofertas maravilloso soporte para la extensión del prototipo a través ExpandoMetaClass
, módulos de extensión (sólo en Groovy 2), Objective-C-como Categorías y DelegatingMetaClass
. [22]
ExpandoMetaClass
ofrece un lenguaje específico de dominio (DSL) para expresar los cambios en la clase fácilmente, similar al concepto de clase abierta de Ruby :
Número . metaClass { sqrt = { Math . sqrt ( delegado ) } }afirmar 9 . sqrt () == 3 afirmar 4 . sqrt () == 2
Los cambios de Groovy en el código a través de la creación de prototipos no son visibles en Java, ya que cada invocación de atributo / método en Groovy pasa por el registro de metaclase. Solo se puede acceder al código cambiado desde Java yendo al registro de metaclase.
Groovy también permite anular métodos como getProperty()
, propertyMissing()
entre otros, permitir al desarrollador interceptar llamadas a un objeto y especificar una acción para ellos, de una manera simplificada orientada a aspectos . El siguiente código permite que la clase java.lang.String
responda a la hex
propiedad:
enum Color { NEGRO ( '# 000000' ), BLANCO ( '#FFFFFF' ), ROJO ( '# FF0000' ), AZUL ( '# 0000FF' ) Cadena hexadecimal Color ( Cadena hexadecimal ) { this . hex = hex } }Cadena . metaClass . getProperty = { String propiedad -> def stringColor = delegate if ( property == 'hex' ) { Color . valores (). encontrar { ella . nombre (). equalsIgnoreCase stringColor } ?. hex } }afirmar "BLANCO" . hex == "#FFFFFF" afirmar "AZUL" . hex == "# 0000FF" afirmar "NEGRO" . hex == "# 000000" afirmar "VERDE" . hex == nulo
El marco de Grails utiliza la metaprogramación ampliamente para habilitar buscadores dinámicos GORM , como User.findByName('Josh')
y otros. [23]
Punto y paréntesis
La sintaxis de Groovy permite omitir paréntesis y puntos en algunas situaciones. El siguiente código maravilloso
tomar ( café ). con ( azúcar , leche ). y ( licor )
Se puede escribir como
tomar café con azúcar , leche y licor
permitiendo el desarrollo de lenguajes específicos de dominio (DSL) que se parecen al inglés simple.
Programación funcional
Aunque Groovy es principalmente un lenguaje orientado a objetos, también ofrece características de programación funcional .
Cierres
Según la documentación de Groovy: "Los cierres en Groovy funcionan de forma similar a un 'puntero de método', lo que permite escribir y ejecutar código en un momento posterior". [24] Los cierres de Groovy admiten variables libres, es decir, variables que no se le han pasado explícitamente como un parámetro, pero existen en su contexto de declaración, aplicación parcial (que denomina ' currying ' [25] ), delegación, implícita, tipada y parámetros sin tipo.
Al trabajar en Colecciones de un tipo determinado, se puede inferir el cierre pasado a una operación sobre la colección:
lista = [ 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 ]/ * * Los números distintos de cero se convierten en verdaderos, por lo que cuando% 2 == 0 (par), es falso. * El tipo del parámetro implícito "it" se puede inferir como un entero por el IDE. * También podría escribirse como: * list.findAll {Integer i -> i% 2} * list.findAll {i -> i% 2} * / def odds = list . findAll { it % 2 }afirmar probabilidades == [ 1 , 3 , 5 , 7 , 9 ]
Se puede escribir un grupo de expresiones en un bloque de cierre sin hacer referencia a una implementación y el objeto de respuesta se puede asignar en un momento posterior mediante la delegación:
// Este bloque de código contiene expresiones sin referencia a una implementación def operaciones = { declare 5 sum 4 divide 3 print }
/ * * Esta clase manejará las operaciones que se pueden usar en el cierre anterior. Otra clase * podría declararse con los mismos métodos, pero usando, por ejemplo, operaciones de servicio web * en los cálculos. * / class Expression { valor BigDecimal / * * Aunque se pasa un entero como parámetro, se convierte en un BigDecimal, como se * definió. Si la clase tuviera un método 'declare (valor entero)', se usaría en su lugar. * / def declare ( valor BigDecimal ) { this . valor = valor } def sum ( BigDecimal valueToAdd ) { esto . value + = valueToAdd } def divide ( divisor BigDecimal ) { esto . valor / = divisor } def propertyMissing ( String property ) { if ( property == "print" ) println value } }
// Aquí se define quién va a responder a las expresiones en el bloque de código anterior. operaciones . delegado = nuevas operaciones de Expresión () ()
Curry
Usualmente llamada aplicación parcial , [25] esta característica de Groovy permite que los parámetros de los cierres se establezcan en un parámetro predeterminado en cualquiera de sus argumentos, creando un nuevo cierre con el valor enlazado. Proporcionar un argumento al curry()
método arreglará el argumento uno. El suministro de N argumentos arreglará los argumentos 1 .. N.
def joinTwoWordsWithSymbol = { símbolo , primero , segundo -> primer + símbolo + segundo } afirmar joinTwoWordsWithSymbol ( '#' , 'Hola' , 'Mundo' ) == 'Hola # mundo'def concatWords = joinTwoWordsWithSymbol . curry ( '' ) afirmar concatWords ( 'Hola' , 'Mundo' ) == 'Hola mundo'def prependHello = concatWords . curry ( 'Hola' ) // def prependHello = joinTwoWordsWithSymbol.curry ('', 'Hello') assert prependHello ( 'World' ) == 'Hello World'
Curry también se puede usar en la dirección inversa (fijando los últimos N argumentos) usando rcurry()
.
def potencia = { valor BigDecimal , potencia BigDecimal -> valor ** potencia } def cuadrado = potencia . rcurry ( 2 ) def cube = potencia . curry ( 3 )afirmar poder ( 2 , 2 ) == 4 afirmar cuadrado ( 4 ) == 16 afirmar cubo ( 3 ) == 27
Groovy también admite la evaluación perezosa , [26] [27] reducir / plegar , [28] estructuras infinitas e inmutabilidad , [29] entre otros. [30]
Procesamiento JSON y XML
En la notación de objetos JavaScript ( JSON ) y el procesamiento XML, Groovy emplea el patrón Builder , lo que hace que la producción de la estructura de datos sea menos detallada. Por ejemplo, el siguiente XML:
year = "1995" > Java orientado a objetos static year = "1995" > Ruby funcional, orientado a objetos tipado pato, dinámico year = "2003" > Groovy funcional, orientado a objetos tipado pato, dinámico, estático
se puede generar a través del siguiente código Groovy:
def escritor = nuevo StringWriter () def constructor = nuevo maravilloso . xml . MarkupBuilder ( escritor ) constructor . lenguajes { lenguaje ( año: 1995 ) { nombre "Java" paradigma "orientado a objetos" mecanografiado "estático" } lenguaje ( año: 1995 ) { nombre "Ruby" paradigma "funcional, orientado a objetos" mecanografiado "escritura pato, dinámico" } lenguaje ( año: 2003 ) { nombre "Groovy" paradigma "funcional," mecanografía " orientada a objetos, escritura de pato, dinámica, estática" } }
y también se puede procesar de forma continua a través de StreamingMarkupBuilder
. Para cambiar la implementación a JSON, se MarkupBuilder
puede cambiar a JsonBuilder
. [31]
Para analizarlo y buscar un lenguaje funcional, el findAll
método de Groovy puede servir:
def idiomas = nuevo XmlSlurper (). escritor de parseText . toString ()// Aquí se emplea la sintaxis de expresiones regulares de Groovy para un comparador (= ~) que será coaccionado a un // valor booleano: verdadero, si el valor contiene nuestra cadena, o falso en caso contrario. def funcional = idiomas . idioma . findAll { it . paradigma = ~ "funcional" } afirmar funcional . recoger { it . name } == [ "Groovy" , "Ruby" ]
Interpolación de cadenas
En Groovy, las cadenas se pueden interpolar con variables y expresiones usando GStrings: [32]
BigDecimal account = 10.0 def text = "La cuenta muestra actualmente un saldo de $ cuenta" assert text == "La cuenta muestra actualmente un saldo de 10.0"
Los GStrings que contienen variables y expresiones deben declararse con comillas dobles.
Una expresión compleja debe incluirse entre corchetes. Esto evita que partes de él se interpreten como pertenecientes a la cadena circundante en lugar de a la expresión:
BigDecimal minus = 4.0 text = "La cuenta muestra actualmente un saldo de $ {account - minus}" assert text == "La cuenta muestra actualmente un saldo de 6.0"// Sin los corchetes para aislar la expresión, esto resultaría: text = "La cuenta muestra actualmente un saldo de $ cuenta - menos" assert text == "La cuenta muestra actualmente un saldo de 10.0 - menos"
La evaluación de expresiones se puede diferir empleando la sintaxis de flecha:
BigDecimal tax = 0.15 text = "La cuenta muestra actualmente un saldo de $ {-> cuenta - cuenta * tax}" tax = 0.10// El valor del impuesto se cambió DESPUÉS de la declaración de GString. Las variables de expresión // están vinculadas solo cuando la expresión realmente debe evaluarse: assert text == "La cuenta muestra actualmente un saldo de 9.000"
Transformación de árbol de sintaxis abstracta
Según la propia documentación de Groovy, "Cuando el compilador de Groovy compila las clases y los scripts de Groovy, en algún momento del proceso, el código fuente terminará representándose en la memoria en forma de un árbol de sintaxis concreto, y luego se transformará en un árbol de sintaxis abstracto. . El propósito de AST Transformations es permitir que los desarrolladores se conecten al proceso de compilación para poder modificar el AST antes de que se convierta en un código de bytes que será ejecutado por la JVM. AST Transformations proporciona a Groovy capacidades mejoradas de metaprogramación en tiempo de compilación que permiten una gran flexibilidad a nivel de idioma, sin penalización de rendimiento en tiempo de ejecución ". [33]
Ejemplos de AST en Groovy son:
- Categoría y transformación Mixin
- Macro AST inmutable
- Newify transformación
- Transformación singleton
entre otros.
Rasgos
Según la documentación de Groovy, "los rasgos son una construcción estructural del lenguaje que permite: composición de comportamientos, implementación de interfaces en tiempo de ejecución, anulación de comportamiento y compatibilidad con compilación / verificación de tipos estáticos".
Los rasgos pueden verse como interfaces que llevan implementaciones y estados predeterminados. Un rasgo se define mediante la palabra clave rasgo:
rasgo FlyingAbility { / * declaración de un rasgo * / String fly () { "¡Estoy volando!" } / * declaración de un método dentro de un rasgo * / }
Luego, se puede usar como una interfaz normal usando la palabra clave implements
:
class Bird implementa FlyingAbility {} / * Agrega el rasgo FlyingAbility a las capacidades de la clase Bird * / def bird = new Bird () / * instancia de un nuevo Bird * / assert bird . fly () == "¡Estoy volando!" / * la clase Bird obtiene automáticamente el comportamiento del rasgo FlyingAbility * /
Los rasgos permiten una amplia gama de habilidades, desde la composición simple hasta las pruebas.
Adopción
Ejemplos notables de adopción de Groovy incluyen:
- Adaptavist ScriptRunner, incorpora una implementación Groovy para automatizar y extender las herramientas de Atlassian , en uso por más de 20000 organizaciones en todo el mundo. [34] [35]
- Apache OFBiz , el sistema de planificación de recursos empresariales (ERP) de código abierto , utiliza Groovy. [36] [37]
- Eucalyptus , un sistema de gestión de la nube, utiliza una cantidad significativa de Groovy.
- Gradle es una popular herramienta de automatización de compilación que utiliza Groovy.
- LinkedIn usa Groovy y Grails para algunos de sus subsistemas. [38]
- LogicMonitor, una plataforma de monitoreo basada en la nube, usa Groovy en fuentes de datos basadas en scripts. [39]
- Jenkins , una plataforma para la integración continua . Con la versión 2, Jenkins incluye un complemento Pipeline que permite que las instrucciones de compilación se escriban en Groovy. [40]
- Liferay, usa groovy en su flujo de trabajo de kaleo
- Sky.com utiliza Groovy y Grails para ofrecer contenido multimedia masivo en línea. [41]
- SmartThings , una plataforma abierta para hogares inteligentes y el consumidor de Internet de las cosas , utiliza un subconjunto orientado a la seguridad de Groovy [42]
- SoapUI proporciona Groovy como lenguaje para el desarrollo de pruebas de servicios web. [43]
- Survata , una startup de investigación de mercado, usa Groovy y Grails. [ cita requerida ]
- La Oficina Europea de Patentes (EPO) desarrolló un lenguaje de programación de flujo de datos en Groovy "para aprovechar las similitudes en los procesos de comunicación con la oficina de patentes de cada país y transformarlos en un proceso único y universal". [ cita requerida ]
- Aunque Groovy se puede integrar en cualquier entorno JVM, el marco JBoss Seam proporciona Groovy, además de Java, como lenguaje de desarrollo, listo para usar. [44]
- vCalc.com usa Groovy para todas las matemáticas definidas por el usuario en su motor de búsqueda colectiva de matemáticas. [45]
- Wired.com utiliza Groovy y Grails para la sección independiente Reseñas de productos del sitio web. [46]
- XWiki SAS utiliza Groovy como lenguaje de scripting en su producto colaborativo de código abierto. [47]
Soporte IDE
Muchos entornos de desarrollo integrados (IDE) y editores de texto admiten Groovy:
- Android Studio , IDE utilizado para crear aplicaciones de Android
- Editor de átomo
- Eclipse , a través de Groovy-Eclipse
- Emacs , usando el modo groovy-mode del proyecto groovy-emacs-mode.
- IntelliJ IDEA , Community Edition, Grails / Griffon solo en la Ultimate Edition
- JDeveloper , para usar con Oracle ADF
- jEdit , un editor de texto avanzado para la plataforma Java
- Kate , un editor de texto avanzado para KDE es compatible con Groovy y más de 200 formatos de archivo más
- NetBeans , desde la versión 6.5
- Notepad ++ , un editor de texto avanzado para Microsoft Windows
- Sublime Text , un editor de texto multiplataforma
- TextMate
- Código de Visual Studio
- UltraEdit , editor de programas de propósito general
Dialectos
Hay una implementación alternativa de Groovy:
- Grooscript convierte el código Groovy en código JavaScript . [48] Aunque Grooscript tiene algunas limitaciones en comparación con Apache Groovy, puede usar clases de dominio tanto en el servidor como en el cliente. [49] Se proporciona compatibilidad con complementos para Grails versión 3.0, así como conversiones de código en línea. [50]
Ver también
- Comparación de lenguajes de programación
- Griffon (marco) : un marco de escritorio
- Proyecto cero
- Spock (marco de prueba)
Referencias
Citas
- ^ a b "Lanzamientos - apache / groovy" . Consultado el 10 de diciembre de 2020 a través de GitHub .
- ^ https://mrhaki.blogspot.com/2011/10/groovy-goodness-default-groovy-script.html
- ^ "Rendimiento Groovy 2.0 en comparación con Java" . 25 de agosto de 2012.
- ^ "Java vs Groovy2.0 vs Scala Simple Performance Test" . 10 de julio de 2012. Archivado desde el original el 10 de diciembre de 2012 . Consultado el 7 de octubre de 2012 .
- ^ a b "Groovy 2.4 y Grails 3.0 serán los últimos lanzamientos importantes bajo el patrocinio fundamental" . 19 de enero de 2015.
- ^ a b "Groovy se une a Apache Incubator" . 11 de marzo de 2015.
- ^ James Strachan (29 de agosto de 2003). "Groovy - el nacimiento de un nuevo lenguaje dinámico para la plataforma Java" . Archivado desde el original el 1 de septiembre de 2003.
- ^ a b "Java Community Process JSR 241" .
- ^ "Groovy gana el primer premio en el premio a la innovación JAX 2007" . 2007-04-26. Archivado desde el original el 13 de mayo de 2015 . Consultado el 7 de octubre de 2012 .
- ^ "Dicen que pueden pasar muchas cosas con una taza de café" . Archivado desde el original el 19 de abril de 2011 . Consultado el 7 de octubre de 2012 .
- ^ "SpringSource adquiere la empresa Groovy and Grails (G2One)" . 11 de noviembre de 2008.
- ^ "VMWare adquiere SpringSource" . 10 de agosto de 2009.
- ^ "Tweet de James Strachan" . 24 de noviembre de 2016 . Consultado el 24 de noviembre de 2016 .
- ^ "Anuncio en lista de correo de desarrollo" .
- ^ König 2007, pág. 32
- ^ "Pautas de características de lenguaje y estilo maravilloso para desarrolladores de Java" . Groovy.codehaus.org. Archivado desde el original el 17 de enero de 2015 . Consultado el 22 de enero de 2015 .
- ^ "Groovy - Diferencias de Java" . Groovy.codehaus.org. Archivado desde el original el 17 de marzo de 2009 . Consultado el 12 de agosto de 2013 .
- ^ "¿Qué hay de nuevo en Groovy 2.0?" . 28 de junio de 2012.
- ^ König 2007, págs. 37-8
- ^ König 2007, págs. 38-9
- ^ König 2007, págs. 41-3
- ^ "JN3525-MetaClasses" . Archivado desde el original el 1 de octubre de 2012 . Consultado el 7 de octubre de 2012 .
- ^ "Técnicas de metaprogramación en Groovy y Grails" . 11 de junio de 2009.
- ^ "Groovy - Cierres" . Archivado desde el original el 22 de mayo de 2012.
- ^ a b "¿Groovy llama aplicación parcial 'curry' ", 10 de agosto de 2013
- ^ "Groovy - Transformación perezosa" . Archivado desde el original el 8 de octubre de 2012 . Consultado el 7 de octubre de 2012 .
- ^ "Notas al margen: listas perezosas en Groovy" . 3 de febrero de 2011.
- ^ "Groovy's Fold" . 20 de junio de 2011. Archivado desde el original el 13 de febrero de 2015 . Consultado el 12 de febrero de 2015 .
- ^ "Programación funcional con Groovy" . 5 de noviembre de 2011.
- ^ "Programación de funciones en Groovy" . Archivado desde el original el 8 de octubre de 2012 . Consultado el 7 de octubre de 2012 .
- ^ "JsonBuilder" . Archivado desde el original el 2 de octubre de 2012 . Consultado el 7 de octubre de 2012 .
- ^ "Groovy Strings - Diferentes formas de crearlas" . 26 de diciembre de 2009.
- ^ "Metaprogramación en tiempo de compilación - Transformaciones AST" . Archivado desde el original el 14 de octubre de 2012 . Consultado el 7 de octubre de 2012 .
- ^ "Documentación de ScriptRunner" .
- ^ "Comunicado de prensa de ScriptRunner con estadísticas de adopción" .
- ^ "DSL Groovy para lógica empresarial OFBiz" . Wiki abierto del proyecto Apache OFBiz .
- ^ "Ejemplos de métodos simples usando Groovy" . Wiki abierto del proyecto Apache OFBiz .
- ^ "Griales en LinkedIn" . Consultado el 2 de junio de 2015 .
- ^ "Scripting Groovy incrustado" . www.logicmonitor.com . Consultado el 20 de noviembre de 2020 .
- ^ "Jenkins Pipeline" .
- ^ Rocher, Graeme (2 de octubre de 2008). "Blog de Graeme Rocher: relanzamientos de Sky.com escrito en Grails" . Blog de Graeme Rocher . Consultado el 2 de junio de 2015 .
- ^ Análisis de seguridad de aplicaciones emergentes para hogares inteligentes
- ^ "Scripting y la biblioteca de scripts | Scripting y propiedades" . www.soapui.org . Consultado el 2 de junio de 2015 .
- ^ "Capítulo 11. Integración Groovy" . docs.jboss.org . Consultado el 2 de junio de 2015 .
- ^ "vCalc, la primera plataforma social para el mundo de las matemáticas" . Consultado el 5 de mayo de 2016 .
- ^ "Wired.Com" (PDF) . www.springsource.org . Consultado el 2 de junio de 2015 .
- ^ "XWiki SAS" (PDF) . www.springsource.org . Consultado el 2 de junio de 2015 .
- ^ "Documentación Grooscript" . 12 de septiembre de 2016. Archivado desde el original el 28 de junio de 2017 . Consultado el 4 de julio de 2017 .
- ^ "Presentación en SpringOne / 2GX sobre Grooscript" . 13 de diciembre de 2015.
- ^ "Conversiones online de Grooscript" . 15 de mayo de 2017. Archivado desde el original el 9 de julio de 2017 . Consultado el 4 de julio de 2017 .
Fuentes
- König, Dierk; Paul King; Guillaume Laforge; Hamlet D'Arcy; Cédric Champeau; Erik Pragt; Jon Skeet (2015). Groovy in Action, segunda edición . Manning. ISBN 978-1-935182-44-3.
- Barclay, Kenneth; John Savage (2007). Programación Groovy: Introducción para desarrolladores de Java . ISBN 978-0-12-372507-3. Archivado desde el original el 12 de enero de 2010 . Consultado el 19 de julio de 2007 .
- Davis, Scott (2008). Recetas maravillosas: engrasar las ruedas de Java . ISBN 978-0-9787392-9-4.
- Subramaniam, Venkat (2008). Programming Groovy: Productividad dinámica para el desarrollador de Java . ISBN 978-1-934356-09-8.
enlaces externos
- Página web oficial
- Página de inicio de Grooscript
- Groovy en Curlie