Groovy como linguagem de script – como instalar e minha experiência

Groovy tem sido minha linguagem de script favorita por pelo menos um ano, conseguindo algo que até então era impensável pra mim: substituir o Perl, que até então quebrava todos os meus galhos e troncos (muitos troncos). Claro: meu caso não é uma regra, porém acredito que seja muito próximo da realidade de diversos programadores que trabalhem com Java.

Tudo começou da forma mais gambiarristica possível. Um belo dia um cliente me pediu para implementar um relatório que só seria utilizado uma única vez. Dado que conheço bem o que este “só vai ser usado uma única vez” significa, normalmente minha primeira opção consiste em implementar este relatório em uma aplicação independente, só para garantir que no futuro, caso seja necessário, o próprio usuário a execute de acordo com suas necessidades.

Porém, desta vez foi diferente. O relógio marcava 16 horas e eu tinha um compromisso às 17. A esmagadora maioria do código que eu precisaria já se encontrava implementado em Java. Somando 2 + 2, qual linguagem escolher? Groovy, é óbvio. Em meia hora o trabalho estava pronto, o cliente tinha em mãos sua bendita planilha gigantesca no formato Microsoft Excel e eu ainda cheguei pontualmente ao meu compromisso.

Como 90% do meu tempo é gasto com código Java, que não é tão simples assim de se acessar usando Perl, Groovy caiu como uma luva. Bastou configurar o meu ambiente de execução e boom. De repente, executo 90% das minhas tarefas corriqueiras com meus scripts escritos em Groovy. E o mais interessante foi: configurar o ambiente é MUITO simples, tal como irei expor abaixo.

Configurando o seu ambiente Groovy

O primeiro passo, claro: consiste em possuir instalado no seu computador o JDK 1.4 ou posterior (1.5 ou posterior seria o ideal). Com o JDK já instalado, baixe a última versão binária do Groovy no seu site oficial: http://groovy.codehaus.org

Em seguida, descompacte o arquivo zipado no diretório de sua escolha e, basicamente, siga os passos abaixo:

• Crie uma nova variável de ambiente chamada GROOVY_HOME, cujo valor deverá consistir no diretório no qual o Groovy foi desinstalado.
• Inclua no path do seu sistema o diretório GROOVY_HOME/bin

Para testar se as coisas realmente estão funcionando, no seu ambiente de linha de comando, execute o comando “groovy”. Se tudo estiver de acodo, será impresso algo similar a

error: neither -e or filename provided
usage: groovy [options] [args]
options:
-p                               process files line by line and print result
(see also -n)
-D,--define <name=value>         define a system property
-a,--autosplit <splitPattern>    split lines using splitPattern (default '\s')
using implicit 'split' variable
-c,--encoding <charset>          specify the encoding of the files
-d,--debug                       debug mode will print out full stack traces
-e <script>                      specify a command line script
-h,--help                        usage information
-i <extension>                   modify files in place; create backup if
extension is given (e.g. '.bak')
-l <port>                        listen on a port and process inbound lines
-n                               process files line by line using implicit
'line' variable
-v,--version                     display the Groovy and JVM versions

Porém, ainda não podemos dizer que seu ambiente esteja 100% pronto, uma vez que seu código legado ainda não será visto pelo seu interpretador groovy. O último passo portanto consiste em tornar seu código legado (ou suas bibliotecas) visíveis ao mesmo. Fazer isto é “quase” simples. :)

Dentro do seu diretório GROOVY_HOME, busque um subdiretório chamado conf. Em seu interior há um arquivo chamado groovy-starter.conf, cujo conteúdo será mais ou menos o que exponho abaixo:

# alguns comentários acima

# load required libraries
load !{groovy.home}/lib/*.jar

# load user specific libraries
load !{user.home}/.groovy/lib/*.jar

# tools.jar for ant tasks
load ${tools.jar}

Como pode ser visto, este arquivo é responsável por instruir ao interpretador/compilador Groovy quais diretórios analisar em busca das suas bibliotecas favoritas. No meu caso, bstou incluir uma linha a mais:

load !{user.home}/.groovy/lib/*.jar

Nesta linha, eu aponto para o diretório .groovy/lib que criei dentro do meu diretório de usuário no Mac e pronto. Se preciso usar alguma biblioteca ou código legado, simplesmente incluo os arquivos .jar em seu interior e estou pronto para criar meus scripts!

(para obter mais detalhes a respeito, acesse este endereço)

Groovy Console é seu amigo

Um ponto que consta muito em favor do Groovy como linguagem de script no meu caso consiste no Groovy Console. Para aqueles que já programaram em Ruby, é exatamente a mesma idéia do irb, ou seja, um ambiente de execução composto por dois componentes: um editor e uma caixa de texto de somente leitura a partir da qual seja possível visualizar a saída do meu script.

Para executar o Groovy Console, na linha de comando, simplesmente execute o programa groovyconsole. Surgirá uma janela similar à que exponho na imagem abaixo:

Trata-se de uma interface bem espartana, mas que contém os elementos fundamentais para a criação de novos scripts, como por exemplo as opções de salvar e carregar scripts, além de, o que é fundamental, executá-los e visualizar o resultado de sua execução imediatamente.

Claro: se você for um viciado em IDEs que completem o seu código enquanto você digita, provávelmente odiará profundamente o Groovy Console. Porém, ele possui a grande vantagem de, em momentos nos quais você precisa apenas criar um script, não consumir toda a memória do seu computador para que você possa simplesmente escrever algumas linhas e executá-las em seguida.

Reusabilidade conta (e muito)

Finalmente, não podemos esquecer a questão da reusabilidade. É bacana ter uma ferramenta que lhe permita criar quebra galhos rapidamente, porém é fato que estes quebra galhos acabam virando quebra troncos. A partir de então, é necessário criar uma aplicação mais decente que possa ser usada pelo usuário.

Neste caso, o que fazer? Simples: como no final das contas, código Groovy vira bytecode padrão Java, você pode simplesmente adaptar o seu script para que se torne uma classe e, em seguida, transformá-la em um software mais decente ou, mais interessante ainda, integra-lo a um sistema já existente (claro, que com as devidas precauções).

Concluindo

Não quero dizer aqui que você deva substituir a sua linguagem de script por Groovy. Porém, se em seu cotidiano, é necessário lidar com código Java legado (ou bibliotecas), Groovy se apresenta como uma opção formidável para esta situação.

Existem outras linguagens que você pode experimentar também, como JRuby, Clojure, Scala, etc. Porém, Groovy possui como diferencial o fato de apresentar uma sintaxe extremamente parecida com a que programadores Java já estão acostumados. Consequentemente, a curva de aprendizado é menor (nos momentos de aperto, isto COM CERTEZA faz A diferença) e o aspecto de facilidade que linguagens de script apresnetam será acentuado.

PS: e com relação àquele “incêndio” que citei no início do post? Nunca mais apareceu! (até agora)