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

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.

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

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