Groovy

Origem: Wikipédia, a enciclopédia livre.
Saltar para a navegação Saltar para a pesquisa


Groovy
Logo Groovy
Paradigma orientada a objetos, funcional, imperativa,script
Surgido em 2003
Última versão 2.5.6 (1 de fevereiro de 2019)
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:

História[editar | editar código-fonte]

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[editar | editar código-fonte]

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).

Produção de JSON[editar | editar código-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.

Funcionalidades[editar | editar código-fonte]

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.

Utilização[editar | editar código-fonte]

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.

Exemplos[editar | editar código-fonte]

 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()
   }
 }

Comparação entre código Java e equivalente código Groovy[editar | editar código-fonte]

Groovy[editar | editar código-fonte]

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) }
     }
 }

Java[editar | editar código-fonte]

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);
     }
 }

Dialetos[editar | editar código-fonte]

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.

Suporte de IDEs[editar | editar código-fonte]

Muitas IDEs e editores de texto suportam Groovy:

  • Eclipse, atráves do Groovy-Eclipse
  • IntelliJ IDEA, Community Edition, Grails/Griffon somente na Ultimate Edition
  • 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
  • Notepad++, um editor de texto avançado para Microsoft Windows
  • TextMate
  • UltraEdit, um editor de propósito geral para programas

Referências[editar | editar código-fonte]

Veja também[editar | editar código-fonte]

  • 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

Ligações externas[editar | editar código-fonte]