BT

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

por Serge Rehem em 05 Mai 2011 |

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.

Olá visitante

Você precisa cadastrar-se no InfoQ Brasil ou para enviar comentários. Há muitas vantagens em se cadastrar.

Obtenha o máximo da experiência do InfoQ Brasil.

Dê sua opinião

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

Receber mensagens dessa discussão

Prototipação, bind de função. by 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

Re: Prototipação, bind de função. by 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<><>

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

Receber mensagens dessa discussão

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

Receber mensagens dessa discussão

2 Dê sua opinião

Conteúdo educacional

Feedback geral
Bugs
Publicidade
Editorial
InfoQ Brasil e todo o seu conteúdo: todos os direitos reservados. © 2006-2014 C4Media Inc.
Política de privacidade
BT