Introdução à programação orientada a aspectos - Tratamento de Exceções

Você precisa estar logado para dar um feedback. Clique aqui para efetuar o login
Para efetuar o download você precisa estar logado. Clique aqui para efetuar o login
Confirmar voto
0
 (0)  (0)

Este artigo trata de um aspecto simples, porém bem útil, o tratamento de exceções.

 

Esta é a terceira parte de uma série de artigos básicos sobre AOP. Para rever os conceitos de AOP, leia o meu artigo anterior aqui no portal.

 

Este artigo trata de um aspecto simples, porém bem útil, o tratamento de exceções.

 

Lembrando o conceito de interesse transversal, o tratamento de exceções em um programa Java, em geral, segue um padrão:

 

  • o trecho de código que pode gerar uma Exception (ou alguma exceção que seja subclasse dela), está envolto num try/catch
  • os blocos catch partem do tipo mais específico de exceções para o mais genérico
  • dentro do bloco catch, deve-se criar um log da exceção e dependendo da gravidade, fazer um throws ou terminar o thread.

Se no seu programa este padrão se aplica, pode utilizar o aspecto deste artigo, mas se for adotado um procedimento diferente na maioria de seus blocos try/catch, altere o código do aspecto a seu gosto. O importante é entender como a AOP pode ajudar a resolver interesses transversais.

 

Para demonstrar o aspecto de exceções, e por conseguinte a utilização da ferramenta AJDT (veja o artigo anterior - ferramentas), a abordagem usada é de converter um projeto Java comum em um projeto que utiliza AOP, e então programar o aspecto de exceções.

 

O projeto Java que este artigo utiliza como base é muito simples, tem apenas duas classes e mantém um cadastro de Link Favoritos de Internet (conhecidos como bookmarks). Este projeto se tornará mais completo com o avanço dos artigos publicados. Para facilitar o estudo, o download do arquivo compactado contendo o projeto Favoritos pode ser feito aqui no portal. Descompacte o arquivo no seu diretório workspace do Eclipse. Eventuais problemas no projeto, mandem uma mensagem com o sintoma.

 

Primeiramente é necessário converter o projeto Java em um projeto que utiliza AOP, chamado no Eclipse de "AspectJ Project".

 

Felizmente o AJDT torna esta tarefa muito fácil. Com o projeto Favoritos aberto no Eclipse, clique com o botão direito do mouse sobre o nome do projeto e escolha a opção "AspectJ Tools"->"Convert to AspectJ Project". Note que o ícone da pasta do projeto Favoritos que antes possuía a letra J (Java Project), agora possui as letras AJ (AspectJ Project).

 

Um AspectJ Project possui as mesmas características de um projeto Java, mas as bibliotecas do AspectJ aparecem no Build Path do projeto (ASPECTJRT_LIB) e para cada vez que o Build do projeto for executado, o weaving (combinador) dos aspectos com o código Java no projeto, é verificado.

 

Como o projeto Favoritos ainda não possui nenhum aspecto, nada de muito diferente ocorre. O próximo passo então é criar o aspecto para o tratamento de exceções, seguindo o padrão de tratamento que seu projeto utiliza. No projeto Favoritos este tratamento foi simplificado para simplesmente imprimir o stackTrace da exceção.

 

O AJDT facilita a criação de aspectos, bem como a visualização de seus efeitos no projeto Java. Para criar o aspecto, clique com o botão direito do mouse no nome do projeto e escolha "New"->"Aspect", o dialogo que se abre é bem semelhante ao de criação de classe Java. Digite "aspectos" no nome do Package (pacote) onde será criado o aspecto, poderia ser qualquer nome de pacote válido. No campo "Name", digite "Excecao" para dar nome ao aspecto e pressione o botão "Finish". O código do aspecto Excecao estará aberto no editor de aspectos do AJDT. Note que o ícone ao lado do nome na aba do editor mostra AJ e que o arquivo tem ".aj" como extensão. Existem outras formas de uso do AJDT para criar aspectos, mas se começa com um passo de cada vez.

 

Para implementar o código do aspecto Extensao.aj, digite o código abaixo (os números de linhas são apenas referências) :

 

<PRE>

 

1:  package aspectos;

2:

3:  import java.util.logging.*;

4:  public aspect Excecao {

5:    /**

6:    * Captura a execução do método

7:    */

8:    pointcut tratamentoExcecao(): handler(Exception+) && !within(aspectos.*);

9:

10:   before() : tratamentoExcecao(){

11:         Logger l=Logger.getLogger("favoritos");

12:         l.log(Level.SEVERE, "Log da Exceção sendo tratada");

13:   }

14: }

 

</PRE>

 

A linha 8 define qual pointcut o aspecto vai usar (tratamentoExcecao()). Este pointcut mapeia o ponto de interesse (joinpoint) de tratamentos de Exception (handler) e de todas as suas descendentes (+). O comando !within na expressão certifica que o pacote dos aspectos não será alvo do próprio aspecto, impedindo ciclos.

 

Na linha 10 é definido o advice do tipo before(), que executa antes do joinpoint, isto é, antes do tratamento da exceção programada. Este advice implementa o log de uma mensagem. O resultado ao se executar o programa, se ocorrer o disparo de uma IOException, será primeiro gerar o log para depois continuar realizando o tratamento de exceção programado na classe.

 

Por exemplo, no código da classe Favoritos, onde tem um tratamento de IOException, está programado no catch apenas o printStackTrace da exceção. Com o aspecto atuando no momento da exceção, primeiro é gerado o log, e aqui poderia ser o que mais quiser usar no corpo do advice, para depois então continuar com o tratamento, imprimindo o stackTrace da IOException.

 

O aspecto trabalha direto no bytecode da classe Favoritos, não mudando seu código fonte. O AJDT ajuda a controlar quais pontos do programa estão sendo afetados pelo seu aspecto. Note que na coluna bem a esquerda do código do aspecto, aparece um sinal de uma seta laranja, posicione o ponteiro do mouse sobre a seta. Aparece um toolip (texto de dica) indicando quem este advice está mapeando, e se clicar na seta com o botão direito do mouse, escolha "Advices" e verá os pontos onde se aplica, escolha um deles (somente um no projeto Favoritos) e o fonte do código Java abre o editor posicionado no ponto. Neste código Java pode-se notar uma seta laranja presente, mas apontando para o outro lado (para direita) indicando que este código esta sendo modificado por um aspecto. Com o botão direito do mouse pode-se obter a opção "Advised by" permitindo se chegar de volta ao código do respectivo advice no aspecto Excecoes.

 

Este artigo introduziu a sintaxe básica de um aspecto, pointcut e advice, bem como o uso de funções simples do AJDT no Eclipse. Nos próximos artigos continuará sendo abordado AOP, com mais detalhes do AJDT e do AspectJ.

 

Se tiverem interesse no uso de AOP em alguma situação, me escrevam e talvez seja possível abordar nesta série de artigos.

 
Você precisa estar logado para dar um feedback. Clique aqui para efetuar o login
Receba nossas novidades
Ficou com alguma dúvida?