BT

Disseminando conhecimento e inovação em desenvolvimento de software corporativo.

Contribuir

Tópicos

Escolha a região

Início Notícias Groovy 1.8: mais suporte a DSLs e melhorias de sintaxe e desempenho

Groovy 1.8: mais suporte a DSLs e melhorias de sintaxe e desempenho

Favoritos

Foi disponibilizada recentemente a versão 1.8 estável do Groovy, a linguagem dinâmica que executa sobre a JVM, mantida pela SpringSource. Dentre as novidades, há recursos adicionais para a definição de DSLs (Linguagens Específicas ao Domínio), melhorado significativamente a legibilidade e a expressividade das regras de negócio. Também foi embutido o suporte a JSON, que antes estava disponível apenas através de bibliotecas externas. Outras mudanças foram a incorporação de facilidades para programação concorrente e novas funcionalidades para metaprogramação.

Baseando-se em exemplos do longo e detalhado Release Notes da nova versão, apresentamos a seguir alguns dos principais novos recursos.

1) DSLs mais parecidas com a linguagem natural

Pode ser utilizada uma linguagem praticamente natural em muitas situações. Contribui para isso a flexibilidade de sintaxe do Groovy, pois algumas pontuações (parênteses, pontos e dois-pontos) são opcionais. O código a seguir define uma "DSL" muito simples e a utiliza para obter a raiz quadrada de 100.

/* Os métodos show e square_root são definidos usando closures*/
show = { println it }
square_root = { Math.sqrt(it) }
def please(action) {
[the: { what ->
   [of: { n -> action(what(n)) }]
 }]
}

O código abaixo equivale a please(show).the(square_root).of(100)

please show the square_root of 100  

2)  JSON Builder e PrettyPrint 

Os Builders do Groovy são um grande facilitador. Este exemplo mostra como utilizar o JsonBuilder para definir uma estrutura JSON:

import groovy.json.*
def json = new JsonBuilder()
json.person {
   name "Guillaume"
   age 33
   pets "Hector", "Felix"
}
println JsonOutput.prettyPrint(json.toString())

A chamada  a json.toString() já seria suficiente para mostrar o conteúdo em formato JSON, porém aqui ilustramos o JsonOutput.prettyPrint, que apresenta a saída de forma indentada e estruturada:

{
   "person": {
       "name": "Guillaume",
       "age": 33,
       "pets": [
           "Hector",
           "Felix"
       ]
   }
}

3) Injeção de logs com @Log

Ao utilizar a nova anotação @Log, automaticamente a variável log estará disponível para uso:

import groovy.util.logging.*
@Log<
class Car {
   Car() {
       log.info 'Car constructed'
   }
}
def c = new Car()

3) Método toString() com @ToString

A anotação @ToString automaticamente cria e disponibiliza, usando recursos de metaprogramação, um método toString() com todos os atributos da classe. A saída do exemplo abaixo é Person(Pete, 15):

import groovy.transform.ToString
@ToString
class Person {
   String name
   int age
}

println new Person(name: 'Pete', age: 15)

4) Programação concorrente com @WithReadLock and @WithWriteLock

É possível definir bloqueios de leitura ou escrita de maneira mais fácil que usando synchronized do Java.

import groovy.transform.*
class ResourceProvider {
   private final Map<String, String> data = new HashMap<>()
 
   @WithReadLock
   String getResource(String key) {
       return data.get(key)
   }
   @WithWriteLock
   void refresh() {
       //recarregar os recursos para a memória
   }
}

5) Slashy Strings

O recurso de strings em multilinhas aumenta a legibilidade:

String poem = /
to be
or
not to be
/

assert poem.readLines().size() == 4 

Unindo uma sintaxe similar à da linguagem Java à facilidade de desenvolvimento das linguagens dinâmicas, o Groovy vem ganhando popularidade por sua flexibilidade e expressividade. A linguagem tem o suporte dos principais IDEs e vem evoluindo rapidamente. O crescimento em adoção é impulsionado em parte pelo Grails, um framework que facilita o desenvolvimento de aplicações web inspirado no Ruby on Rails.

Avalie esse artigo

Relevância
Estilo/Redação

Conteúdo educacional

  • Prototipação, bind de função.

    by Gustavo Maia Neto,

    Seu comentário está aguardando aprovação dos moderadores. Obrigado por participar da discussão!

    Parabéns Serge!

    Realmente estou precisando dar uma olhada melhor no groovy!

    Existe alguma forma de fazer bindname para função. Algo semelhante a prototipação do Javascript?

    Exemplo:
    poem.prototype.lines = poem.prototype.readLines

    E agora me corrija, poderia escrever o teste assim:

    assert poem lines size == 4

  • Re: Prototipação, bind de função.

    by Serge Rehem,

    Seu comentário está aguardando aprovação dos moderadores. Obrigado por participar da discussão!

    Olá Gustavo,

    Se entendi bem sua pergunta, o que dá para fazer é modificar a classe String em tempo de execução, adicionando novos métodos. Exemplo:


    // Adicionando os métodos lines() e numberOfLines() à classe String
    String.metaClass.lines << {-> delegate.readLines() }
    String.metaClass.numberOfLines << {-> delegate.readLines().size() }

    // Chamando os novos métodos
    assert poem.lines().size() == 4
    assert poem.numberOfLines() == 4


    Outra coisa que dá para fazer é criar uma DSL para isso, veja:


    give_me = { it }
    number_of_lines = { it.readLines().size() }
    def please(action) {
    [the: { what ->
    [of: { n -> action(what(n)) }]
    }]
    }

    def poemSize = please give_me the number_of_lines of poem
    assert poemSize == 4


    Se quiser executar esse Script, coloquei ele na Web no Groovy Web Console: groovyconsole.appspot.com/script/479002

    Abraço
    Serge Rehem<><>

HTML é permitido: a,b,br,blockquote,i,li,pre,u,ul,p

HTML é permitido: a,b,br,blockquote,i,li,pre,u,ul,p

BT