fy>
Clique aqui para ler todos os artigos desta edição
Programação orientada a aspectos com o Spring Framework 2.0
A parte final da série de artigos sobre o Spring Framework
Guilherme Arruda Falcão Lima
A programação orientada a aspectos (Aspect-Oriented Programming – AOP) surgiu a partir da identificação de uma dificuldade na programação orientada a objetos em modularizar certos tipos de interesses. Ela foi concebida como uma extensão à OO para introduzir um novo conceito chamado de aspecto ao já conhecido modelo de classes. Um aspecto permite a modularização de interesses que geralmente aparecem espalhados por várias classes de um sistema (denominados de interesses transversais – crosscutting concerns), como o gerenciamento de transações, por exemplo.
Desde suas primeiras versões, o Spring inclui um framework AOP que complementa o seu mecanismo de inversão de controle para prover uma solução mais abrangente de middleware. Com o Spring AOP podemos escrever aspectos customizados para encapsular interesses que atravessam os demais beans gerenciados pelo application context e, assim, obter uma melhora significativa na solução arquitetural do sistema. No Spring 1.2, isto era feito através de uma API provida para descrever aspectos baseados
Neste artigo, apresentamos o mecanismo de AOP do Spring 2.0 demonstrando como utilizar os dois diferentes estilos de programação suportados pelo framework: o estilo baseado no uso de schemas XML e o estilo baseado no uso das anotações @AspectJ. Vamos modificar a aplicação de agenda de contatos criada na edição anterior para acrescentar dois aspectos: um novo mecanismo de gerenciamento de transações e o logging de operações realizadas.
Conceitos da AOP
A idéia de promover a separação de interesses com a introdução do aspecto como uma nova abstração não é exclusividade de Java e muito menos do Spring. A AOP tem suas raízes na década de 70 e percorreu um longo caminho até se consolidar como um novo paradigma de programação com uma terminologia bem definida. Veja a seguir alguns dos principais conceitos introduzidos por esta abordagem:
· Aspect: É a unidade modular que encapsula um interesse que atravessa vários objetos dentro do sistema. O lookup de EJBs é um bom exemplo de um interesse transversal
· Join Point: É um ponto durante a execução do programa que será afetado pelo aspecto. Este ponto pode ser a execução de um método, a modificação do valor de uma variável ou outros. Diferentes linguagens orientadas a aspectos implementam diferentes tipos de join point. No Spring AOP, este ponto sempre é representado pela execução de um método.
· Advice: É a ação executada pelo aspecto em um join point particular. Esta ação pode executar antes, após ou mesmo envolver o join point para decidir se o mesmo deve realmente ser executado. Veja mais adiante a lista dos tipos de advice suportados pelo Spring AOP.
· Pointcut: É um elemento do aspecto representado por uma expressão escrita em uma linguagem específica para a finalidade de identificar join points. Ele permite que o aspecto saiba quais são os pontos na execução do programa em que um advice deve executar. Para isso, todo advice precisa estar sempre associado a um pointcut. O Spring AOP utiliza a linguagem de pointcut definida pelo AspectJ 5. Este conceito torna-se mais claro com os exemplos apresentados ao longo do artigo.
· Objeto Alvo: É o objeto que está sendo interceptado por um ou mais aspectos.
· Weaving: É o mecanismo responsável por ligar o aspecto aos objetos da aplicação. Isto pode ocorrer em tempo de compilação ou em tempo de execução. No Spring AOP, o processo de weaving ocorre sempre em tempo de execução.
· Proxy AOP: É o objeto criado pelo framework AOP para implementar a ligação entre o aspecto e o objeto alvo. No Spring AOP, isto é realizado através da criação de um proxy dinâmico de forma transparente para o desenvolvedor.
Aqui estão os tipos de advice suportados pelo Spring AOP. É recomendado que o desenvolvedor utilize o advice menos poderoso que for capaz de atender à sua necessidade. Isto simplifica o código e reduz a possibilidade de eventuais erros:
· Before: Advice que executa antes do join point, mas não tem o poder de evitar que o join point execute;
· After returning: Advice que executa após o join point apenas se este terminar de forma bem sucedida;
· After throwing: Advice que executa após o join point quando ele finaliza enviando uma exceção;
· After (finally): Advice que executa após o join point independentemente de sua forma de retorno;
· Around: Advice que envolve a execução de um join point. Este é o tipo mais poderoso de advice, pois pode realizar ações antes e após a execução do join point. Também é de sua responsabilidade decidir se o join point deve ou não ser chamado.
AOP no Spring
O Spring AOP define um subconjunto das funcionalidades existentes no AspectJ. A solução, entretanto, é puramente Java, não havendo a necessidade do processo de compilação. Os aspectos são configurados no framework através da sintaxe normal de definição de beans.
O principal objetivo do Spring AOP é ser totalmente integrado com o container de inversão de controle e não prover a implementação mais completa possível de AOP, de modo que seja usado como um mecanismo para ajudar a resolver problemas comuns em sistemas de software. Em resumo, o Spring AOP foi criado para permitir o uso de aspectos que interceptam os beans gerenciados pelo Spring. Não é possível definir pointcuts para objetos que não estejam configurados no application context.
Na versão 2.0, o Spring suporta apenas join points representados pela execução de métodos. Se houver a necessidade de interceptar tipos diferentes de join points, então o desenvolvedor deve considerar o uso de uma linguagem como o AspectJ (para saber um pouco mais sobre o AspectJ, veja a Nota 1).
Para podermos utilizar o Spring AOP precisamos acrescentar ao classpath do projeto duas bibliotecas fornecidas pelo AspectJ 5:
aspectjrt.jar
aspectjweaver.jar
Estes arquivos podem ser encontrados dentro da pasta “lib\aspectj” no diretório de instalação do pacote do Spring que vem com as dependências necessárias. Vamos ver em seguida como implementar um aspecto em cada um dos estilos de programação disponíveis para o framework.
Nota 1. AspectJ
O AspectJ é uma extensão orientada a aspectos para a linguagem Java. Ele foi criado em 2001 pela Xerox PARC sob a tutela de Gregor Kiczales, um dos principais colaboradores para o desenvolvimento da AOP que conhecemos hoje. Atualmente, o AspectJ é mantido como um projeto dentro do Eclipse Foundation. A sua homepage é http://www.eclipse.org/aspectj. Lá, podemos encontrar a documentação oficial e fazer o download do compilador.
Outro site interessante é o http://www.eclipse.org/ajdt, homepage do AJDT (AspectJ Development Tools) que é um conjunto de plugins para o Eclipse para suportar o desenvolvimento de aplicações com AspectJ. Com o AJDT, qualquer programador familiarizado com o Eclipse pode rapidamente começar a desenvolver aspectos para os seus sistemas em Java.
Suporte a @AspectJ
Este estilo se refere ao uso do conjunto de anotações introduzidas pelo AspectJ 5 para permitir a definição de aspectos a partir de classes Java. O Spring 2.0 é capaz de interpretar estas mesmas anotações, o que facilita bastante a utilização do framework pelos desenvolvedores que já costumam trabalhar com AspectJ. É importante lembrar que um pré-requisito para o uso deste estilo de programação é que a aplicação rode sobre a JVM 5.0 ou superior, devido à necessidade do uso da API de anotações. Além disso, para habilitar o suporte a @AspectJ, basta acrescentar a seguinte linha ao application context:
Isto pressupõe que o arquivo XML tenha sido configurado com suporte a schema, ao invés de DTD, e que o schema aop tenha sido incluído. No apêndice “A” da documentação de referência do Spring 2.0 encontramos a descrição de como usar o suporte a schema, inclusive como importar as tags no namespace aop.
Vejamos a seguir como ficaria o applicationContext.xml para definir um aspecto baseado no estilo @AspectJ. Observe na linha 2 da Listagem 1 que configuramos um namespace para o schema que define as tags específicas para o Spring AOP. O aspecto é mapeado como um bean normal (linhas
Listagem 1. Configuração do applicationContext para o estilo @AspectJ.
1. xml version="1.0" encoding="UTF-8"?>
2. <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi=http://www.w3.org/2001/XMLSchema-instance xmlns:aop=" http://www.springframework.org/schema/aop" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd">
3.
4.
5.
6.
7. ...
