Integrando Groovy e Java

Groovy não deve ser visto como uma linguagem alternativa ao Java, mas sim complementar (e vice-versa). Mesmo em meus projetos Grails costumo ter partes escritas em Java (ou Clojure) por uma razão simples: é bom ter as ferramentas certas para cada tipo de problema, e se eu posso ter mais de uma e as domino, a pergunta que fica é: por que não?

Então neste post vou mostrar algumas maneiras que você pode integrar suas bases de código Groovy e Java para assim obter o melhor dos dois mundos. É importante ressaltar que aqui só vão ser expostas algumas das estratégias que costumo usar.

Java chamando Groovy

java_chama_groovy

Groovy como linguagem embarcada

Possivelmente esta é a estratégia mais comum: você já possuí um sistema escrito em Java e quer oferecer pontos de extensão para o usuário final sob a forma de scripts (que podem estar armazenados em um sistema de arquivos, banco de dados, nuvem ou qualquer outro local mágico de sua preferência). Assim seu trabalho como arquiteto/desenvolvedor diminui: você apenas fornece a estrutura básica sob a forma de um framework e os pontos de customização passam a ser feitos pelo próprio usuário final.

O fundamental

Como fazer? Já gravei agluns vídeos sobre isto pra você. O fundamental você pode ver abaixo:

Melhorando o desempenho

Mas esta é apenas a primeira parte do seu trabalho e o resultado vai ser um sistema razoavelmente lento. Como melhorar isto? Ensino no vídeo a seguir:

Sobre o vídeo acima, uma nota: hoje já tenho algumas técnicas que podem aumentar ainda mais a performance de scripts Groovy: em breve gravo um novo vídeo expondo como fazer isto (mas o acima resolve a maior parte dos seus problemas, se não todos).

Garantindo a segurança

Ter uma linguagem embarcada em seu sistema Java é muito bom, mas há um problema: segurança. Como evitar que código mal intencionado entre na sua vida? Imagine que seu usuário final escreva um script Groovy como o abaixo:


System.exit(1)

Ensino como resolver este problema em outro vídeo.

Usando bibliotecas escritas em Groovy já compiladas

Você quer adicionar ao seu projeto Java uma biblioteca ou framework escrito em Groovy. É bastante simples: basta que você adicione esta biblioteca e suas dependências ao classpath do seu projeto e os distribua junto com sua aplicação quando esta for compilada.

Uma nota importante deve ser feita: para evitar chateação, sempre inclua neste caso a biblioteca groovy-all. Esta vêm na distribuição oficial do Groovy e você pode referenciá-la em seu projeto Maven como no exemplo abaixo (basta mudar o número da versão para o que seja compatível com o seu projeto):

<dependency>
    <groupId>org.codehaus.groovy</groupId>
    <artifactId>groovy-all</artifactId>
    <version>2.4.0-beta-3</version>
</dependency>

Esta dependência é importante pois já carrega o Groovy completo (o nome já entrega) e também as classes do GDK (Groovy Development Kit). Evite incluir apenas groovy-lang.

Código Groovy gera bytecode Java normal. Sendo assim, basta que suas classes Java usem as classes Groovy como se fossem… classes Java simples.

Usando código fonte Groovy usando Maven

maven-logo

Seu projeto está sendo escrito em Java e Groovy. Como você organiza seu projeto? Minha experiência principal é com Apache Maven, sendo assim aqui vou expor um exemplo bem rápido de como usar o plugin GMavenPlus.

Este plugin é uma reescrita do antigo GMaven com uma série de novos recursos. O uso é bastante simples: você só precisa incluir as pastas src/groovy e test/groovy para seu código Groovy, que vai ser compilado junto com o código Java.

Como usar o plugin? O caminho mais rápido e direto é você copiar os exemplos presentes neste link. Use o exemplo “joint compilation” que mostra como colocar em um mesmo projeto Maven Java e Groovy lado a lado.

E como seu código Java vai referenciar o Groovy? Exatamente como se fosse código Java convencional. :)

Groovy chamando Java

groovy_chama_java

Executando código Java compilado

Um dos principais pontos de venda do Groovy é justamente o fato de apresentar uma sintaxe próxima à do Java e também executar código Java de forma nativa. Lembre-se sempre desta regra:

Código Groovy vira bytecode Java padrão

Groovy pode executar qualquer código Java sem a necessidade de alteração. Basta que todas as dependências necessárias estejam no classpath do seu projeto. E como executá-lo? Exatamente como se fosse código Groovy. E sabe o que é bacana? Quando código Groovy executa código Java, Java vira Groovy!

Código Java que é essencialmente estático passa a ser dinâmico: você pode alterar os métodos presentes em código Java já compilado, por exemplo, exatamente como se fosse Groovy. Em 2009 escrevi alguma coisa a respeito, que você pode ler neste link.

Como Grails usa código Java?

Anos atrás escrevi um post sobre isto. Para ler, clique neste link.

Executando código fonte Java

Basta usar o GMavenPlus, exatamente como mostrei neste mesmo post. :)

Concluindo

Neste post expus algumas soluções de integração Groovy e Java. Há outras soluções (Gradle, por exemplo), mas como não tenho tanta experiências com estas, preferi não falar a respeito (no futuro aprendendo melhor provavelmente surgirá um post aqui).

Muitas dúvidas que vejo no Grails Brasil são do tipo: “como uso [sua biblioteca favorita Java] com Groovy/Grails”? Resposta simples: exatamente (ou quase em raríssimos casos) como faria se fosse em um projeto Java convencional!

Outro ponto importante: muitas pessoas me procuram dizendo que vão trocar Java por Groovy ou vice-versa: bobagem. Como disse no início deste post, o ganho na plataforma Java está no uso em conjunto de diversas linguagens. O uso exclusivo (só Java ou só Groovy) é tolo: pra que transformar o mundo em um prego?

Leave a Reply

Your email address will not be published. Required fields are marked *

This site uses Akismet to reduce spam. Learn how your comment data is processed.