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

Postado por Serge Rehem em 05 Mai 2011

Seções

Desenvolvimento

Tópicos

JVM ,

Virtual Machines ,

Runtimes ,

Java ,

Linguagens Dinâmicas ,

Linguagens ,

Arquitetura ,

Programação

Compartilhar |

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.

1. Voltar ao topo

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

   por Gustavo Maia Neto

   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

   Responder

2. Voltar ao topo

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

   por Serge Rehem

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

   Responder