Compilação Dinâmica no Java 6 - Revista Java Magazine 94

Praticamente toda aplicação Java desenvolvida segue o mesmo processo até ser executada. Tudo começa com a escrita dos códigos-fonte das classes, que posteriormente são compilados para uma linguagem intermediária chamada bytecode. Depois, no momento em que a aplicação começa a ser executada, a JVM faz o carregamento e interpretação destas classes compiladas, a fim de que tudo funcione de acordo com o que foi implementado.

Embora este seja o processo mais comum, ele não é o único. A partir do Java 6 foi introduzida na linguagem a Compiler API, que possibilita uma variação no processo descrito anteriormente. Com esta API, classes da aplicação podem ser definidas, compiladas e terem seus bytecodes carregados pela JVM enquanto a aplicação é executada. Na prática, isto significa que estas classes não existem durante a compilação.

A apesar de a Compiler API ser relativamente recente (a partir da versão 6 do Java), a ideia de gerar classes em tempo de execução não é nova. Existem diversos frameworks e APIs que tiram proveito deste recurso. Para que isso fosse possível há alguns anos, eles utilizavam bibliotecas desenvolvidas por terceiros como o CGLIB e o ASM, as quais permitem a manipulação direta de bytecode; ou o Apache Commons JCI, que é uma interface para um compilador Java já existente, responsável por gerar as classes. Para mais informações sobre estas APIs, consulte a seção de Links.

Um exemplo bastante claro de utilização deste recurso vem dos JSPs, que são utilizados para renderizar páginas web dinâmicas para os usuários. Quando um JSP é requisitado pela primeira vez, o servidor executa um processo de conversão do arquivo JSP para uma classe de Servlet, compila este arquivo e o carrega. Isto possibilita que o desenvolvedor faça a programação da página como se ela fosse um JSP, mas na hora da execução a página dinâmica é gerada por um Servlet. A vantagem disso é que a facilidade de implementar a estrutura de uma página web dinâmica em JSP é muito maior.

Outro framework que utiliza a geração dinâmica de classes é o Hibernate. Para que ele possa fazer o gerenciamento de persistência das entidades, o Hibernate precisa criar classes de proxy, as quais agem como classes intermediárias no momento em que o framework precisa acessar as entidades reais, criadas pelo desenvolvedor. Os proxies são gerados em tempo de execução e escondem do programador a complexidade deste processo, uma vez que estas classes não existem antes do código ser executado.

Por fim, outro exemplo de API que utiliza este recurso é o RMI (Remote Method Invocation). Ele possibilita que o usuário faça chamadas de métodos em objetos que podem estar localizados em outro computador da rede. Mas para quem faz a chamada, toda esta complexidade da invocação remota é transparente, uma vez que o código é escrito como se ela fosse local (dentro da própria JVM). Isto só é possível devido a um componente chamado stub, que é uma espécie de objeto local que representa o objeto remoto. É dele a responsabilidade de fazer com que a requisição ao objeto real seja feita via rede e também de receber o retorno da invocação. Para que o desenvolvedor não se preocupe com todos estes detalhes, os stubs necessários são gerados durante a execução da aplicação.

Com base nos exemplos citados, é possível perceber que a compilação dinâmica tem os seus benefícios. A geração de código em tempo de execução pode ser muito útil no desenvolvimento de frameworks que buscam reduzir a complexidade de escrita de código por parte dos desenvolvedores. Pode também ser utilizada para gerar código Java a partir de uma linguagem qualquer, que poderia ser específica de um domínio ou aplicação. E ferramentas que automatizam a geração de código também podem se beneficiar deste recurso, podendo gerar classes a partir de templates pré-definidos.

Este artigo é dividido em três partes. Na primeira, o processo de compilação dinâmica com a Compiler API será explicado em detalhes. Na segunda, um framework que gera classes DAO (Data Access Object) será proposto, com o objetivo de mostrar um exemplo prático da compilação em tempo de execução. E na terceira e última parte, a utilização deste framework será demonstrada através da criação da camada DAO de uma aplicação fictícia, cuja função é gerenciar infrações de trânsito. A proposta desta divisão é mostrar não só a teoria, mas também os benefícios práticos da Compiler API.

A Java Compiler API

Como já foi mencionado, existem diversas formas de gerar classes em tempo de execução no Java. Antes da versão 6, nenhuma delas era padrão da linguagem e sempre houve a dependência de bibliotecas criadas por terceiros.

Com o intuito de padronizar este recurso e torná-lo nativo do Java, foi criada a JSR 199, que define a Compiler API. Implementada a partir do Java 6 e localizada no pacote javax.tools, ela tornou possível compilar classes durante a execução da aplicação e permitir que elas sejam carregadas pela JVM para serem utilizadas. Com esta API, os desenvolvedores não precisam mais recorrer a bibliotecas externas, que podem não acompanhar os lançamentos de novas versões da linguagem. Além disso, a Compiler API é capaz de gerar classes a partir de códigos-fonte armazenados em qualquer lugar (como arquivos ou até strings), e em nenhum momento o desenvolvedor precisa se envolver diretamente com o bytecode gerado. Isto reduz significativamente a complexidade de implementação.

A utilização desta API exige a criação de algumas classes, o que resulta em um volume considerável de código. Por este motivo, o ideal é encapsular toda a implementação necessária, de forma que ela possa ser reaproveitada em diversas aplicações da forma mais simples possível. Ao final desta primeira parte do artigo, você terá esta biblioteca criada e pronta para ser utilizada em diversos projetos.

Independente da complexidade envolvida no processo de compilação dinâmica, a essência deste recurso é simples: a partir de um código-fonte é gerada uma classe compilada. Com base nisso, a primeira classe importante que será criada é denominada JavaCodeCompiler. Ela possui apenas o método compile(), que recebe os nomes do pacote e da classe que será compilada e o código-fonte. O seu retorno é um objeto Class, que representa a classe já compilada. Outro detalhe é que JavaCodeCompiler pode ser parametrizada, pois suporta o uso de generics. Isto permite definir a classe de retorno do método.

Definir a classe retornada pelo método compile() pode parecer estranho à primeira vista, já que não é possível referenciar no código-fonte uma classe que só vai existir quando a aplicação for iniciada. No entanto, é bastante comum que as classes compiladas dinamicamente sejam subclasses ou implementações de interfaces. Neste caso, o tipo parametrizado especificado é o mais genérico, que já é conhecido no momento da compilação.

Veja um exemplo de utilização da classe JavaCodeCompiler na "

ATENÇÃO! A exibição deste artigo foi interrompida.

  Este é um post disponível para assinantes MVP

Este post também está disponível para assinantes da Java Magazine DIGITAL ou para quem possui Créditos DevMedia.  Clique aqui para saber mais!

Saiba como acessar este post através de Créditos DevMedia:

Assinatura de Créditos – Aqui este post custa R$ 1,50
Com esse plano você compra R$ 180,00 em créditos e ganha, em média, 80% de desconto no preço do post.  
Assine agora

Plano ocasional - Aqui este post custa: R$ 2,00 (assinante) ou R$ 2,50 (não-assinante)
Você compra um mínimo de R$ 60,00 em créditos e ganha, em média, 50% de desconto no preço do post.  
Compre agora

Plano conveniência – Neste plano este post custa R$ 5,00
Neste plano você compra somente um post, pagando seu preço sem desconto.  
Compre agora