Este artigo ou secção contém uma lista de referências no fim do texto, mas as suas fontes não são claras porque não são citadas no corpo do artigo, o que compromete a confiabilidade das informações. Ajude a melhorar este artigo inserindo citações no corpo do artigo. (Maio de 2011)

Groovy
Logo Groovy
Paradigma	orientada a objetos, funcional, imperativa,script
Surgido em	2003
Última versão	4.0.18 (16 de janeiro de 2024)
Versão em teste	2.5.0-beta-3 (20 de fevereiro de 2018)
Criado por	James Strachan
Estilo de tipagem	estática, dinâmica, forte
Influenciada por	Java, Python, Ruby, Perl, Smalltalk, Objective-C
Plataforma	Plataforma Java
Licença	Apache License v2.0
Página oficial	http://groovy-lang.org/

Groovy é uma linguagem de programação orientada a objetos desenvolvida para a plataforma Java como alternativa à linguagem de programação Java. Groovy possui características de Python, Ruby e Smalltalk.

Groovy utiliza uma sintaxe similar à de Java, é compilada dinamicamente para bytecode Java, e integra-se transparentemente com outros códigos e bibliotecas Java.

Groovy está atualmente em processo de padronização através do Java Community Process ( JSR 241 ).

Groovy possui algumas características não presentes no Java padrão:

• Tipagem estática e tipagem dinâmica
• Sintaxe nativa para listas, arrays associativos, vetores, e expressões regulares
• Clausuras
• Sobrecarga de operadores

James Strachan falou sobre o desenvolvimento do Groovy pela primeira vez em seu blog em Agosto de 2003. Em Março de 2004, Groovy foi enviado ao Java Community Process(JCP) como JSR 241 e aceito. Diversas versões foram lançadas entre 2004 e 2006. Depois que o processo de padronização atráves do JCP começou, a numeração de versão mudou, e uma versão chamada "1.0" foi lançada em 2 de Janeiro de 2007. Depois de vários betas numerados como 1.1, em 7 de Dezembro de 2007, Groovy 1.1 Final foi lançado e imediatamente renumerado como Groovy 1.5 para refletir as várias mudanças que foram feitas.

Em 2007, Groovy ganhou o primeiro lugar no prêmio de inovação JAX 2007. Em 2008, Grails, uma Framework para aplicações web Groovy, ganhou o segundo lugar no prêmio de inovação JAX 2008.

Em Novembro de 2008, SpringSource adquiriu a empresa responsável pelo Groovy and Grails(G2One). Em Agosto de 2009, VMware adquiriu a SpringSource.

Em Abril de 2012, após 8 anos de inatividade, o status do JSR 241 mudou para inativo.

Strachan havia deixado o projeto silenciosamente um ano antes do lançamento do Groovy 1.0 em 2007.

Em 2 de Julho de 2012, Groovy 2.0 foi lançado, nas quais, entre outras características, adicionou compilação estática e verificação estática de tipagem.

Groovy graduou da incubadora Apache e se tornou um top-level project(TLP) em Novembro de 2015.

Groovyc é a ferramenta de linha de comando do compilador Groovy. Ele permite que você compile fontes Groovy em bytecode. Ele desempenha o mesmo papel que javac no mundo Java. A maneira mais fácil de compilar um script ou classe Groovy é executar o seguinte comando:

groovyc MinhaClasse.groovy

Isso produzirá um arquivo MinhaClasse.class (bem como outros arquivos .class, dependendo do conteúdo da fonte).

Groovy vem com suporte integrado para conversão entre objetos Groovy e JSON. As classes dedicadas à serialização e análise JSON são encontradas no pacote groovy.json.

• JsonSlurper é uma classe que analisa texto JSON ou conteúdo de leitor em objetos Groovy, e também em estruturas como mapas, listas e tipos primitivos como Integer, Double, Boolean e String. A classe vem com vários métodos de análise sobrecarregados, além de alguns métodos especiais, como parseText, parseFile e outros.

Apesar de ser inspirada e ter diversas funcionalidades de Java, Groovy não é apenas uma linguagem de script. pode ser compilada, gerando bytecodes Java, ou seja, um arquivo de código fonte Groovy pode virar um arquivo .class, recurso não encontrado em JRuby por exemplo. Desta forma, a única coisa necessária para o programador rodar códigos Groovy no ambiente de produção, é a máquina virtual Java e o jar com o runtime e API`s do Groovy.

Ele é totalmente integrado a Java no nível mais baixo. Se instanciado um objeto tipo Date em Groovy, esse nada mais é do que uma instância de Java.util.Date. E tudo funciona de forma transparente, já que debaixo dos panos, tudo é bytecode Java.

Groovy é escolhido muitas vezes pois sua sintaxe é mais simples e enxuta do que Java, mesmo não sendo Java e possuindo recursos poderosos como closures, que não são encontradas na linguagem Java.

Muitos desenvolvedores utilizam Groovy em suas aplicações Java, como extensão da linguagem, para escrever regras de negócio, facilitando a customização para diferentes clientes.

Para cada caso de uso baseado no Java, os desenvolvedores não precisam de todas as capacidades dinâmicas oferecidas pela linguagem. Geralmente esperam que o compilador Groovy ofereça comportamento semelhante ao dado pelo javac. Os desenvolvedores buscam erros de compilação, para casos de digitação incorreta de nomes de variáveis e métodos, atribuições incorretas etc. Por isso, o Groovy 2.0 passou a suportar a verificação estática de tipos.

 class Foo {
   def doSomething() {
     def data = ["name": "James", "location": "London"]
     for (e in data) {
       println("entry ${e.key} is ${e.value}")
     }
   }

   def closureExample(collection) {
     collection.each { println("value ${it}") }
   }

   static void main(args) {
     def values = [1, 2, 3, "abc"]
     def foo = new Foo()
     foo.closureExample(values)
     foo.doSomething()
   }
 }

class Filter {
     static void main(String[] args) {
        List<String> list = ["Alfinete", "Sabrina", "Zina"]
        List<String> shorts

        shorts = list.findAll { String item -> item.length() <= 4 }
        shorts.each { println(it) }
     }
 }

public class Filter {
     public static void main(String[] args) {
         List<String> list = Arrays.asList("Alfinete", "Sabrina", "Zina");
         List<String> shorts = new ArrayList<String>();
         
         for(String item : list) if(item.length() <= 4) shorts.add(item);
         for(String item : shorts) System.out.println(item);
     }
 }

Existe uma implementação alternativa do Groovy:

• O Grooscript converte o código Groovy em código JavaScript. Embora o Grooscript tenha algumas limitações em comparação com o Apache Groovy, ele pode usar classes de domínio no servidor e no cliente. É fornecido suporte de plug-in para Grails versão 3.0, bem como conversões de código online.

Muitas IDEs e editores de texto suportam Groovy:

• Android Studio, IDE usada para desenvolver aplicativos Android

• Editor Atom

• Eclipse, atráves do Groovy-Eclipse

• Emacs

• IntelliJ IDEA, Community Edition, Grails/Griffon somente na Ultimate Edition

• JDeveloper, para uso com a Oracle ADF

• jEdit, um editor de texto avançado para a Plataforma Java

• Kate, um editor de texto avançado para KDE tem suporte para Groovy e mais de 200 outros tipos de formato de arquivo

• NetBeans, desde a versão 6.5

• Notepad++, um editor de texto avançado para Microsoft Windows

• Sublime Text 2, um editor de texto multiplataforma

• TextMate

• Visual Studio Code

• UltraEdit, um editor de propósito geral para programas

• Dierk Koenig, Guillaume Laforge e Andrew Glover. Groovy in Action . Manning, 2006. ISBN 1-932394-84-2. (em inglês)
• Kenneth Barclay e John Savage. Groovy Programming: An Introduction for Java Developers. ISBN 0-123725-07-0 (em inglês)
• Um pouco de Groovy, uma linguagem de scripts

• Grails - framework para desenvolvimento de aplicações web inspirado no Ruby on Rails
• Groovlets - para implementar Servlets de modo fácil utilizando scripts Groovy
• Boo - uma linguagem com objetivos similares mas voltada para o Common Language Runtime
• Jython - uma implementação da linguagem Python que gera bytecode para máquinas Java
• Lista de linguagens de programação

• (em português) Wiki
• (em inglês) Página oficial
• (em português) Comunidade brasileira