Apostila Aspect J

AOP AspectJ 1.5.
4 Programao Orientada a Aspectos
AOP AspectJ 1.5.4 Programao Orientada a Aspectos
Diego Pacheco
Dezembro/2007
HTTP://DIEGO-PACHECO.BLOGSPOT.COM
Sumrio
1. Conceitos Bsicos sobre AOP ........................ Error! Bookmark not defined.-1 Objetivos .................................................................................................................................... 0 Conceitos Bsicos .................................................................................................................. 0 Concerns VS Crosscuting Concerns ............................................................................ 0 Aspectos .................................................................................................................................... 0 Pilares do AspectJ ............................................................................................................... 0 Mecanismos de Weaving ................................................................................................... 0 Exerccios ............................................................................................................................... 0 2. Join Points e Pointcuts ....................................... Error! Bookmark not defined. Objetivos .................................................................................................................................... 0 Pointcuts................................................................................................................................... 0 Suporte ao Java 5 ................................................................................................................ 0 Anotaes para Pointcuts ................................................................................................ 0 Join point Match com anotaes ................................................................................. 0 Recursos Avanados em Pointcuts .............................................................................. 0 Declarao de erros e warnings ................................................................................... 0 Injeo de anotaes............................................................................................................ 0 Exerccios ................................................................................................................................. 0 3. Advice........................................................................... Error! Bookmark not defined. Objetivos .................................................................................................................................... 0 Tipos de Advices ................................................................................................................... 0 ThisJoinPoint........................................................................................................................ 0 Aspects........................................................................................................................................ 0 inner-type declarations ................................................................................................... 0 Exercicos ................................................................................................................................. 0 4. Recursos Adicionais.............................................. Error! Bookmark not defined. Objetivos .................................................................................................................................... 0 AspectJ com Anotaes ...................................................................................................... 0 Declare Soft ............................................................................................................................. 0 DBC ............................................................................................................................................. 0 Exerccios ................................................................................................................................. 0
1. Conceitos Bsicos sobre AOP
Objetivos
Conhecer os conceitos bsicos sobre AOP/AspectJ Conhecer o conceito de Concern e Crosscuting Concern Conhecer a estrutura bsica de um aspecto Conhecer os pilares do AspectJ Conhecer como funciona o mecanismo padro de weaving do AspectJ
Conceitos Bsicos
AOP (Aspect Oriented Programing) ou em portugus POA (Programao Orientada a Aspectos) traz aos desenvolvedores uma separao de conceitos, especialmente conceitos Cross-Cuting, que so aspectos de um programa que afetam outros conceitos. Esses Conceitos (Crossscut) no so facilmente desacoplados do sistema. Vamos a um exemplo prtico, estamos desenvolvendo um sistema para um hotel, neste sistema deve conter: check-in, check-out, sistema de tarifao e integrao com sistema de aluguel de carros, estes seriam os nossos conceitos chave ou core concerms, enquanto fazer a persistncia de informaes e autenticao do sistema, gerenciamento de recursos (I/O) so os nossos Conceitos transversais, em ingls crosscuting comcermes. Essa diviso entre conceitos e conceitos transversais muito importante, quando realizada, obtemos uma maior modularizao e o sistema ganha e manutenibilidade. Utilizamos esse nomenclatura em engenharia de software porque os conceitos cross-cuting atravessam uma aplicao de ponta a ponta, como por exemplo gerenciamento transacional. O Time de pesquisa da Xerox, no Xerox PARC que um centro de pesquisas, desenvolveu a primeira implementao de AOP e mais popular de todas, o AspectJ. O AspectJ est hospedado no site do projeto Eclipse e pode ser encontrado na seguinte url: http://www.eclipse.org/aspectj/. O Primeiro release do projeto foi em 2001. AspectJ uma extenso da linguagem Java, usa todos os recursos da linguagem e acresenta seus recursos de AOP.
Concerns VS Crosscuting concerns
Muitas vezes desenvolvemos aplicaes em que precisamos levar em considerao requisitos no funcionais, tais como: gerncia de transao, gerncia de recursos, concorrncia, persistncia, processamento em Batch, integrao de dados, etc... Esses seriam conceitos candidatos de natureza Crosscuting concerns, muitas vezes esses conceitos esto espalhados pelos nossos componentes de negcio do sistema. Essa mistura no benfica, pois o desenvolvedor que est produzindo um artefato de negcio no deveria estar se preocupando com tais requisitos, essa preocupao pode trazer os mais diversos problemas, entre eles destacam-se: Acoplamento com 3rd-party framewroks Mais tempo para desenvolver um componente Mais difcil de fazer manutenes Mais propenso a erros Menos coeso Mais difcil de migrar Menos legvel Para solucionar estes problemas devemos separar ao mximo os conceitos de natureza crosscuting concerns (que atravessam o sistema) dos de natureza concerns, que seriam os de negcio. O ideal seria manter esses conceitos em extremidades opostas sempre que possvel.
Figura 1.1 Concerns vs crosscuting concerns.
Concerns VS Crosscuting concerns

Neste paradigma os aspectos so os crosscuting concerns e os requisitos de negcio (cdigo java) so os concerm, nada impede de requisitos funcionais serem tratados como crosscuting concerns, mas isso no o que ocorre na maioria dos casos. Requisitos funcionais so concerns e requisitos no funcionais so cosscuting concerns. Quando desenvolvemos uma soluo em termos de software existem dois tipos de desafios envolvidos, conforme na figura a baixo.
Figura 1.2 Menor esforo A figura a cima demonstra que com aspectos possivel reduzir o esforo de implementao de uma soluo, assim obtendo mais produtividade e reduzindo o custo de desenvolvimento. Os aspectos acabam com o dilema over design vs under design, este dilema se norteia no seguinte princpio: desenvolver um wrapper em cima de algum framework como por exemplo o Log4J ou us-lo de maneira pura. Essa questo pode criar dois resultados distintos, no primeiro over design, ns usamos o framework de maneira pura e, se precisarmos alguma funcionalidade adicional vamos ter um retrabalho. A outra auternativa under design, desde o inicio usamos um wrapper para o framework, o que pode acontecer que no exista necessidade e por isso trabalharemos toa. O Uso de POA elimina este problema.
Pilares do AspectJ
O AspectJ possui classes como na linguagem Java, porm com mais recursos ao desenvolvedor, essas classes so chamados de Aspects. Os aspectos tem entidades especiais que no existem nas classes Java comuns, so elas: Iner-type: Permite ao desenvolvedor adicionar campos, mtodos ou at mesmo interfaces a classes j existentes. Join points: So pontos de programas onde os aspectos e o cdigo Java se encontram. Pointcuts: So expresses que o programador pode formular, servem para representar qualquer ponto de execuo de um programa, por exemplo, a execuo de um mtodo ou a criao de um objeto de determinado tipo. Advice: Permite a execuo de um cdigo aps a juno vinda de um pointcut. Ex.: poderamos gerar um log toda a vez que um objeto for salvo, isso seria detectado por um pointcut e esse cdigo de log estaria em um advice. Os tipos de adivices se resumem a : Before: Antes da execuo do mtodo do pointcut. Ex.: antes de gravar um objeto quero logar tudo. After: Depois da execuo do mtodo do pointcut. Ex.: depois de gravar um objeto quero logar tudo. Around: No meio da execuo de um mtodo do pointcut. Ex.: No momento de gravar um objeto se ele for uma PessoaFisica fazer log.
Aspects
Aspects so os artefatos do AspectJ para criao dos componentes de natureza crosscuting, como se fosse uma classe Java porm, para necessidades globais. Aspectos tem a seguinte estrutura bsica:
package <<Nome do pacote se existir>>; import <<Import java/AspectJ se existir>>; public aspect <<Nome do aspecto padro java >> { // Pointcuts // Advices }
Cdigo 1.1 Estrutura bsica de um aspecto O Aspecto pode estar dentro de um package, regido pelos mesmos padres Java, tambm possvel acessar qualquer recurso Java de dentro de um aspecto, este aspecto pode importar classes atravs da diretiva import, assim como em uma classe java. Depois vem a visibilidade do aspecto (public por exemplo) seguida por um nome, esse nome deve obedecer os padres Java de nomes de classes. Dentro do aspecto ficam as definies, as expresses para join points, essas expresses so os pointcuts, podemos ter diversos pointcuts em um aspecto, desde que eles tenham nomes diferentes. No final ficam os advices, possvel ter multiplos advices para um mesmo aspecto, dentro dos advices possvel executar qualquer cdigo Java.
Mecanismos de Weaving
Quando trabalhamos com aspectos em AspectJ, os aspectos conhecem as classes Java, mas as classes Java no conhecem os aspectos, esta abordagem garante uma maior modularizao e coeso entre artefatos de um sistema. Para que os aspectos faam as operaes que desejamos, necessrio que em algum ponto do programa ocorra a juno desse aspecto com o seu cdigo Java, esta juno se chama weaving. Existem diversas formas de weaving, dentre elas as mais comuns so: Modificar a JVM: Seria modificado o funcionamento da JVM para reconhecer os aspectos como se fossem nativos da linguagem. Load Time: Adicionado o weaving em tempo de carregamento, para essa implementao usa-se Reflection. Compile time: Adiciona o weaving em tempo de compilao dos artefatos Java. Para essas tcnicas existem vantagens e desvantagens, so elas: Modificar a JVM: Vantagens: Suporte completo ao AspectJ Informaes dos aspectos separadas Mais performtico Desvantagens: Perda de portabilidade Fere as especificao de bytecodes Compilado de mudar as especificao Java
Load Time: Vantagens: Modifica o cdigo somente quando carregado, assim carregando sob-demanda. Desvantagens: Mais lento Dificuldades de fazer otimizaes
Compile time Vantagens: Portvel, pois no modifica o bytecode Mais performtico, aplicao Java como qualquer outra Mais fcil de implementar
Desvantagens: Possui mais limitaes: Ligar aspectos em tempo de compilao. Dificuldade em disernir cdigo Java e cdigo AspectJ depois do cdigo ser gerado.
O AspectJ preferencialmente utiliza o mecanismo de compile time weaving como sua estratgia padro de weaving. Mas essa estratgia pode ser modificada. A Figura a baixo ilustra como funciona o mecanismo de weaving baseado na estratgia de compile time para o AspectJ.
Figura 1.2 Mecanismo de Weaving na estratgia de compile time. O processo demonstrado na figura acima acontece da seguinte forma: 1. Apartir de um cdigo Java feita a compilao com o compilador AspectJ. 2. Apartir de um cdigo AspectJ feita a compilao com o compilador AspectJ. 3. Aps as operaes anteriores vamos ter dois bytecodes, o do cdigo Java e o do AspectJ. 4. Com esses dois bytecodes gerado o weaving, que mistura dos dois cdigos.
5. Finalmente gerado um nico bytecode contendo aspectos e cdigo Java, no quebrando a especificao bytecode Java e ao mesmo tempo atendendo os requisitos funcionais do AspectJ. No mecanismo de weaving importante mencionar que todos os fontes Java (.class) devem estar disponiveis em tempo de compilao, caso contrrio a compilao AspectJ ir falhar, isso significa que no possvel colocar advices sobre mtodos nativos.
Exerccios
1) Descreva com suas palavras o conceito de AOP/AspectJ. 2) Descreva para que serve: Join point, Pointcut, Advice e Iner-type declarations. 3) Cite 3 vantagens de usar AOP 4) Descreva com suas palavras a diferena entre crosscuting e concern. 5) Descreva com suas palavras como funciona o mecanismo de weaving do AspectJ. Cite 2 vantagens.
2. Pointcuts
Objetivos
Saber utilizar pointcuts com call e execution Saber utilizar anotaes para aspectos Saber realizar expresses pointcut considerando anotaes Saber declarar warnigs e erros Saber realizar injeo de anotaes
Pointcuts
Pointcuts so alguns join points de um programa que so capturados pelo mecanismo de AOP do AspectJ. No AspectJ existem 11 possveis join points, veja: Chamada de mtodo Execuo de mtodo Chamada de construtor Execuo de construtor Getter de uma propriedade Setter de uma propriedade Pre-inicializao Inicializao Inicializao esttica Handler Advice de execuo de join points
A Captura ocorre baseada em expresses definidas pelo programador. A sintaxe de um um pointcut a seguinte:
pointcut <<nome>>(): <<expressao>;
Exemplo:
package br.com.targettrust.aop.pointcuts; public aspect PointcutSample { pointcut nomePointcut(): call (void metodoX()); }
Cdigo 2.1 Pointcut sample No exemplo acima estamos declarando um pointcut de nome nomePointcut que ir capturar todas as chamadas ao mtodo metodoX() de qualquer classe. Quando montamos as expresses dos pointcuts podemos utilizar operadores lgicos para juntar mais de uma expresso. O AspectJ disponibiliza os seguintes operadores lgicos: &&, || e !. Veja no exemplo a baixo como usar cada um. HTTP://DIEGO-PACHECO.BLOGSPOT.COM
package br.com.targettrust.aop.pointcuts; public aspect PointcutLogicalOperators { pointcut operadorAnd(): call ( String br.com.targettrust.aop.java.domain.model.Pessoa.getNome() ) && call ( String br.com.targettrust.aop.java.domain.model.PessoaFisica.getNome() ); pointcut operadorOr(): call ( String br.com.targettrust.aop.java.domain.model.Pessoa.getNome() ) || call ( String br.com.targettrust.aop.java.domain.model.Pessoa.getEndereco() ); pointcut operadorNot(): call ( ! String br.com.targettrust.aop.java.domain.model.Pessoa.getNome() ); }
Cdigo 2.2 Pointcut operadores lgicos No exemplo acima foi demostrado o uso dos trs operadores lgicos para pointcuts, possvel combinar ou usar quantas vezes forem necessrias estes operadores. Ainda possvel fazer com que um pointcut capture mais de um mtodo e de vrias classes de seu sistema, quanto a isso no existem restries. As expresses dos pointcuts ainda suportam o wild card *. Esse wild card pode ser utilizado para os casos em que no queremos informar o nome completo de um pacote, classe ou mtodo. Ex.: supondo uma classe de negcio que tem os mtodos findCliente(), findClienteByName(), findClienteByCpf(), findClienteByTelefone() neste caso, poderamos com uma nica expresso pegar todos estes mtodos, o cdigo AspectJ ficaria assim:
pointcut finds(): call (* find*(..));
Cdigo 2.3 Pointcut com wild cards. No exemplo acima estamos informando que queremos capturar todos os mtodos find* que recebam quaisquer parmetros e que retornem qualquer coisa. Nesse exemplo aparece a propriedade: .. que neste contexto significa qualquer parametro ou seja, de 0..* e com qualquer tipo de dado. Outro recurso interessante o pointcut primitivo cflow(), com ele podemos pegar a execuo de outros pointcuts, por exemplo o pointcut: pointcut x(): call (* exec*(..)); se fizermos cflow(exec()) significa que enquanto o metodo exec() estiver executando alguma operao poder ser feita. Quando ele para de executar esse ponto se torma invlido. Esse recurso muito til , pois podemos fazer controles enquanto algo est em execuo ou enquanto algum mtodo ainda no foi executado. HTTP://DIEGO-PACHECO.BLOGSPOT.COM
Para os 11 joinpoints, os pointcuts equivalentes so: call, execution, get, set, preinicialization, inicialization, staticinicialization, handler e adviceexecution. A figura abaixo resume o contexto de cada um destes pointcuts de forma geral.
Figura 2.1 Contexto de pointcuts.
Call VS Execution
Para capturar a execuo de um mtodo podemos utilizar tanto o operador call como o operador execution. Porm existem algumas diferenas dos mesmos. Quando utilizamos o operador call com o operador withincode o funcionamento diferenciado, considerando a expresso pointcut: call(void metodo()) && withincode(void metodo()). Esse pointcut s ser atingido se o mtodo estiver fazendo chamas recursivas. O operador execution j considera que o programa est em execuo ento a expresso: execution(void metodo()) equivale a call(void metodo()) && withincode(void metodo()). Outro aspecto importante que o call no captura chamadas de procedncias superiores para mtodos no estticos, ou seja, somente para mtodos da prpria classe e os mtodos que estejam em uma classe pai, porm, que sejam estaticos. A regra geral : se voc deseja capturar algum trecho de cdigo em particular para realizar algum tracing por exemplo, utilize execution. Mas se voc deseja capturar um mtodo com uma assinatura particular que normalmente utilizado em aspectos que vo para produo, utilize call.
Suporte ao Java 5.0
A verso 1.5.X do AspectJ prove suporte completo aos recursos do Java 5.0 como: varargs, anotaes, retorno co-variante, enumerations, generics e autoboxing. O AspectJ prove um set muito rico de recursos para anotaes que sero bem detalhadas na sequncia. Os recursos de auto-boxing so transparentes para o AspectJ, ou seja, no h diferenas em join points, pointcuts ou advices entre primitivos e wrappers. args(Integer) ou args(int) so equivalentes. Os recursos de co-variante so aplicados a expresses de pointcuts tambm, e isso acontece de forma natural. O Mecanismo do AspectJ j ir levar essas consideraes quanto a retorno covariante em considerao. Quando utilizamos varargs podemos realizar expresses pointcuts levando em considerao a sua existncia. Por exemplo: initialization(org.xyz.*.new((Foo || Goo)...)) Pegaria a criao de todos os objetos do pacote xyz que tiverem no construtor um varargs de Foo ou Goo. Ateno: Quando utilizamos varargs a syntax <<Tipo>>..., no confunda essa syntax com os recursos do prprio AspectJ(..). O recurso .. captura quaisquer argumentos. No que diz respeito aos recursos de enumerations exatamente igual ao Java, a mesma sintaxe e as mesmas limitaes. Exemplo:
Anotaes para Pointcuts
Anotaes foram introduzidas no Java 5.0 e provem um mecanismo elegante para informar metadados. Uma anotao se caracteriza pela syntax: @<<nome>>. As anotaes podem ser utilizadas em: classes, interfaces, construtores, mtodos, atributos de classes e parmetros. As anotaes podem ser de um nico valor ou de muitos valores. Quando utilizamos anotaes, lidamos com polticas de reteno: Cdigo Fonte: So lidas no processo de compilao, mas no so colocadas no class gerado. Class gerado: a politica de reteno padro, as informaes esto tanto em tempo de compilao quanto no class gerado. Runtime: So lidas pelo compilador, vo para o class gerado e ainda podem ser obtidas em tempo de runtime. Podemos recuperar as informaes de annotations em tempo de runtime se a poltica de reteno permitir, e para atravs isso dos utilizamos mtodos: reflection, existe uma interface AnnotatedElement getAnnotation(), getAnnotations(),
isAnnotationPresent(). Por padro annotations no so herdadas no mecanismo padro de herana do Java. Mas possvel fazer herana utilizando a annotao @Inherited. O AspectJ Prove anotaes bem como alternativa a sua syntax de aspectos, existe um conunto de annotation para a utilizao do AspectJ . No Java 5.0 quando usamos alguma Collection no tipada o compilador emite um warning, podemos eliminar esse warning com uma annotation, isso existe no AspectJ tambm, pois possvel que o compilador AspectJ no consiga estabelecer nenhum join point para seu pointcut ento, para evitar warnings podemos utilizar a annotation @SuppressAjWarnings. No AspectJ Podemos colocar anotaes em: aspectos, mtodos, atributos, construtores, advice, iner-type declaration com aspectos. No podemos utilizar annotation em declaraes de pointcus.
Join Point match com annotations
possivel realizar matching de join points com presena ou falta de determinada annotation. Basicamente existem duas formas sintticas de utilizar join points com annotation, so elas: Nome qualificado: Neste caso, podemos capturar todos os elementos que contenham determinada annotation. EX: @Gravavel ou @com.targettrust.aop.Curso ou !@Gravavel Type + Pattern: Nesse estilo podemos capturar todas as annotations de determinado tipo e ainda utilizando expresses com wild cards. Ex.: @(org.target..*) ou @( Gravavel || NaoGravavel) O Mecanismo de join points com annotation bastante fexvel, abaixo temos algumas das possveis combinaes para criarmos expresses de pointcuts utilizando annotations. Os exemplos a seguir se aplicam a call() e execution().
Expresso (@Executavel * *) (!@Executavel * *) (@Executavel @Runnable * * )
Exemplo de uso Contm a annotation @Executavel No contm a annotation @Executavel Que contm as annotations @Executavel e @Runnable
( @(Executavel || Runnable) * *)
Que contm a annotation @Executavel ou a
annotation @Runnable
@(br.targettrust..*) Qualquer annotation que esteja no pacote ou subpacote br.targettrust
Tabela 2.1 Exemplos com annotation e operadores lgicos Os recursos de match de join point com annotation em AspectJ so muito maleveis (como demostrado na tabela acima), agora ser exemplificado o uso dessas annotations em atributos e construtores. A Prxima tabela exemplifica como utilizar annotation para os poitcuts com construrores baseados em annotation.
Expresso @Criavel new(..)
Exemplo de uso Qualquer construtor que tenha a
annotation @Criavel
!@Criavel new(..) Qualquer construtor que no tenha a
annotation @Criavel. Cuidado com a

interceptao de aspectos. @Criavel new(java.util.List) Qualquer construtor que receba um parmetro do tipo List. @Criavel private new(..) Qualquer construtor privado que possua a
annotation @Criavel. Tbela 2.1 Exemplos com anotaes e operadores lgicos para construtores
Poderamos ainda utilizar mais operadores lgicos como || ou &&, ainda seria possvel elaborar expresses mais complexas, quando fazemos um pointcut para construtor utilizamos a propriedade initialization, mas podemos usar outras propriedades juntas a esta. Para fazer as expresses sobre atributos, usamos o padro Java Bean e os mtodos getters/setters. Veja abaixo um exemplo de como utilizar esse recurso com annotations.
Recursos Avanados em pointcuts
Alm dos recursos j demonstrados anteriomente nesta apostila, o AspectJ possui recursos ainda mais apurados para criarmos expresses mais poderosas, dentre esses recursos contamos com: args, this, target, within, whitioncode, annotation. Todos estes recursos citados acima tem suas equivalncias com a @ na frente indicando que o mesmo recurso porm utilizando annotations. @args/args: Este recurso faz o match apartir do tipo e da ordem dos argumentos. baseado no tipo do objeto em tempo de runtime, o recurso @args tambm pode ser utilizado em conjunto com annotations. Podemos utilizar os wild cards * e ... Ex.: @args(*,Persistivel) este exemplo captura um recurso em que tenha qualquer tipo no primeiro argumento e no segundo argumento tenha uma annotations do tipo Persistvel. @this/this: Este recurso faz o match apartir do objeto que foi interceptado, com isso podemos especificar sub-clausulas nas expresses de join points. Ex.: @this(Persistivel) && within(br.com) esse exemplo pega todos os objetos do pacote br.com que tenham a annotations @Persistivel. @target/target: Esse recurso faz o match apartir do objeto que o alvo do match AOP. Quando utilizandomos target estamos nos referindo simplesmente ao alvo e @target refere-se as annotations que o alvo tem. Este alvo o objeto que foi capturado pelo mecanismo AOP. Ex.: @target(Simples) captura se o target tiver a annotations simples. @within/within:Esse recurso faz o match apartir do objeto que instanciado. Esse recurso utilizado para fazer filtros de aspectos em determinados pacotes, e o @within a mesma coisa, porm para annotations em pacotes ou sub-pacotes. Ex.: call (* *(..)) && within(com.br.*) essa expresso capturaria qualquer execuo de mtodo, porm que esteja no pacote com.br ou sub-pacote. @withincode/withincode: Esse recurso muito poderoso. Ele semelhante ao within, com a vantagem de podermos avaliar os cdigos, blocos de cdigos, ele utilizado para o reforo de contrato, nos prximos captulos ser abordado com mais detalhes.
@annotation: Esse um recurso bastante avanado nas expresses de pointcuts do AspectJ 1.5.X, com esse recurso podemos capturar annotations que tenham uma poltica de reteno forte, ou seja, poltica de reteno em runtime. Ex: call (* * (..)) && @annotation(Forte) captura qualquer chamada de mtodo em que o interceptado tenha a annotation @Forte e essa anotao tenha poltica de reteno em runtime.
Declarao de erros e warnings
possivel gerar warnings e at mesmo erros com aspectos, isso se torna muito interessante por exemplo para evitar que desenvolvedores acessem mtodos @Deprecated. Esse recurso pode ser utilizado para o reforo de contratos e at mesmo para evitar o acoplamentos de cdigo. Quando usamos warnigs o mecanismo do AspectJ no impede a compilao, ou seja, o mecanismo de weaver acontece sem problemas, porm quando declaramos erros como se existissem erros sintticos no cdigo e ele no compilasse, logo isso impossibilitaria a execuo do programa. Veja no cdigo a baixo exemplos de como utilizar os recursos do AspectJ para declarao de erros e warnings, neste mecanismo no necessrio ter um advice relacionado ao pointcut, este um caso especial em que o pointcut fica sem um advice explcito.
package br.com.targettrust.aop.pointcuts.annotation.erroswarnings; public aspect JoinPointMacthWithAnnotationErrosWarnings { declare warning : within(br.com.targettrust.aop.pointcuts.annotation.erroswarnings.java.*) && call(* faz*(..)) : "Voc no deve chamar metodos com o prefixo faz*"; declare error : within(br.com.targettrust.aop.pointcuts.annotation.erroswarnings.java.*) && call(* deleteAll*(..)) : "Voc no deve deletar tudo tche!!!"; }
Cdigo 2.4 Utilizao de error e warning em pointcuts.
Injeo de Annotaes
No AspectJ 1.5.X possvel adicionar annotations em tempo de runtime em objetos Java. Esse recurso muito til, pois com ele fica fcil de realizar tarefas dinmicas baseadas em annotations. Esse recurso possibilita adicionar annotations em: Classes Mtodos Construtores Atributos
Este recurso realizado atravs de expresses de pointcuts, este tambm um caso especial de pointcut, porque assim como os recursos de declarao de warnings e erros no necessitam ter um advice associado, esse recurso tambm. Para isso utilizamos o operador declare, porm com annotations indicando o tipo de recurso que ser injetado. As terminologias permitidas para estes recursos so: @type, @method, @constructor, @field. Ainda no existe suporte para injeo de annotations em pacotes. Veja no cdigo abaixo exemplos de uso destes recursos.
package br.com.targettrust.aop.pointcuts.annotation.declareann; import br.com.targettrust.aop.pointcuts.annotation.declareann.java.*; public aspect JoinPointMacthWithAnnotationDeclareAnn { declare @type : br.com.targettrust.aop.pointcuts.annotation.declareann.java..* : @Exportavel; declare @field : * br.com.targettrust.aop.pointcuts.annotation.declareann.java..*.*
: @Campo;
declare @method : public * br.com.targettrust.aop.pointcuts.annotation.declareann.java.DeclareAnnTest4.* (..) :@Metodo; declare @constructor : br.com.targettrust.aop.pointcuts.annotation.declareann.java.DeclareAnnTest3+. new(..) : @Novo; }
Cdigo 2.5 Exemplos de utilizao de injeo de annotations
Exerccios
1) Faa um aspecto que intercepte toda criao de objetos que o construtor receba uma String. 2) Faa um aspecto que intercepte toda execuo de mtodos que recebam um Map como argumento. 3) Faa um aspecto que declare erros se o desenvolvedor instanciar algum objeto do tipo ArrayList. 4) Faa um aspecto que injete annotations em objetos de pacotes dao. 5) Faa um aspecto que intercepte todas os getters que tenha a anotao @Serializavel no target.
3. Advice
Objetivos
Saber utilizar os tipos de Advices do AspectJ Conhecer recursos de ThisJoinPoint Saber criar aspectos Saber utilizar inner-type declarations
Advices
No AspectJ 1.5.X quando criamos pointcuts ( e atingimos um ou mais join points) para podemos aplicar algum tipo de processamento sobre os join points. Pointcuts em si no realizam nenhuma ao sobre o cdigo Java, para realizar essa tarefa nececitamos de um advice. O AspectJ prove diversos tipos de advices, so eles: Before Around After
Quando utilizamos advices, precisamos fazer referncia a um pointcut ou podemos declarar um pointcut diretamente aps a declarao do advice. A primeira forma til quando queremos utilizar mltiplos advices e a segunda quando s temos um nico advice. Veja abaixo o exemplo de uso de um simples advice.
public aspect SimpleAdvice { before(int x): call (* *.*.exec*(int)) && args(x) { System.out.println("[SimpleAdvice]modificado: " + (x+1)); } }
Cdigo 3.1 Exemplo de um Advice simples.
No exemplo acima foi declarado um advice do tipo before(), e este advice ir interceptar todos os mtodos exec* de qualquer classe, de qualquer package. Esse advice est capturando o parmetro int do mtodo exec*, este parmetro referenciado pela varivel x. Esse advice no faz nada alm de imprimir na tela o nmero do argumento, atribuindo mais um.
Tipos de Advices
Before: Esse tipo de advice executado antes da execuo do pointcut. Supondo que voc declarou um pointcut que pega todas as execues mtodos que retornem um double, com o advice before voc tem o controle antes da execuo do mtodo. Esse advice permite modificar os parmetros do mtodo, ideal para fazer todo o tipo de inicializao. Outra boa aplicao para este advice para validaes, podemos fazer validaes antes da execuo de determinados mtodos. Veja abaixo exemplos de uso do advice before em aspectos com AspectJ.
public aspect BeforeSimple { before(): call(* *.*save(Object)) { System.out.println("Simples execucao antes do metodo."); } }
Cdigo 3.2 Exemplo de um Advice do tipo before.
O Advice acima captura todas as execues do mtodo save que recebe um Object como parmetro. Foi utilizado pointcuts em linha por questes de facilidades. Esse advice s imprime uma mensagem na tela. Seria possvel fazer validaes neste advice e com isso poupar tempo dos desenvolvedores e garantir que todos os acessos ao banco sejam menos custosos. Para exemplificar isso o advice acima foi alterado, veja o resultado na figura abaixo.
before(Object x): call(* *.*save(Object)) && args(x) { if (x==null) throw new RuntimeException("No pode salvar um objeto nulo!"); }
Cdigo 3.2 Exemplo de um Advice do tipo before com validao.
As modificaes relevantes aqui so as seguintes: *foi adicionada a expresso pointcut args que possibilida fazer referncias aos argumentos dos mtodos e *no advice before foi adicionada uma varivel de pilha chamada x, que a mesma do args.
After: Este tipo de advice executado depois da execuo do pointcut. Supondo que voc declarou um pointcut que pega todas as execues mtodos que retornem um double, com o advice after voc tem o controle posterior execuo do mtodo. Esse tipo de advice permite modificar o retorno de um mtodo. til para aplicar filtros e adicionar informaes a grafos de objetos. Este tipo de recurso pode ser utilizado para realizaes de bind dos mais diversos tipos, como por exemplos de-paras. Veja abaixo exemplos de uso do advice before em aspectos com AspectJ.
public aspect AfterSimple { after(): call(* *.*save(Object)){ System.out.println("Simples execucao depois do metodo."); } }
Cdigo 3.3 Exemplo de um Advice do tipo after.
Outra forma de usar o advice after com o retituring que permite capturar o retorno da execuo de algum pointcut. Esse recurso pode ser usado de forma opcional. No exemplo abaixo mostra como utilizar o recurso.
after() returning(Object o): call(public Object *.*.find()){ String x = (String)o; x += "123"; System.out.println("retorno: " + x); }
Cdigo 3.4 Exemplo de um Advice do tipo after com returning.
Este advice pega o retorno do mtodo find, sendo que esse mtodo retorna um objeto. No advice foi feito um cast para String e adicionado o sufixo 123 na String original e depois impresso na tela. O Advice after ainda possui o recurso de throwing que serve para capturarmos aps o levantamento de Exception. Veja abaixo um exemplo de uso desse recurso.
O Advice do tipo after ainda possui mais uma forma, a throwing, com isso podemos realizar operaes aps um mtodo levantar uma determinada exception por exemplo. Esse recurso faz com que o advice seja executado apenas se a Exception corretamente definida na expresso pointcut for lanada. Veja a baixo um exemplo prtico de como usar o after throwing.
after() throwing(Exception e): call(public void *.*.delete()) { System.out.println("Erro! Mensagem: " + e.getMessage()); }
Cdigo 3.5 Exemplo de um Advice do tipo after com throwing.
No advice after acima, dentro da palavra reservada throwing, informamos a Exception que desejamos capturar, nesse exemplo foi utilizada uma exception genrica mas poderamos informar uma exception especfica, como por exemplo FileNotFoundException. Este recurso muito bom para aplicar logs e todo o tipo de controles ps erro. Outra aplicao seria na tolerncia a falha, em um sistema assncrono poderamos disparar um segundo processo caso determinado erro ocorra.
Around: Com certeza este o tipo de advice mais poderoso e mais utilizado. Com esse advice podemos interferir na execuo do mtodo de forma que possamos: Impedir a execuo Modificar os parmetros Modificar o retorno Levantar um Exception Engolir um Exception
Esse advice abre uma imensa gama de possibilidades. Quando utilizamos around necessrio especificar uma sintaxe um pouco diferente dos outros advices, dentre as diferenas existe o proceed(). Este mtodo faz com que a execuo do mtodo prossiga. Para o mesmo ocorrer necessrio informar os parmetros do mtodo, podemos repassar os parmetros originais, novos ou modificados.
int around(): call(public int *.*.soma(int,int)){ System.out.println("Around advice modificando valores constante 1"); return 1; }
Cdigo 3.6 Exemplo de um Advice do tipo around.
No exemplo acima o advice around est interceptando o mtodo soma de qualquer classe, est imprimindo uma mensagem e retornando 1. Como o advice around est definido como int isso torna obrigatrio o retorno de um inteiro. Esse retorno est hardcoded, mas poderia ser dinmico. abaixo como podemos fazer isso utilizando o proceed().
int around(int x,int y): call(public int *.*.soma2(int,int)) && args(x,y){ System.out.println("Around advice modificando valores dinamicos"); return proceed(x,y); }
Veja no exemplo
Cdigo 3.6 Exemplo de um Advice do tipo around com proceed().
Neste exemplo foi utilizado o recurso args para recuperar os argumentos do mtodo soma2 e esse argumentos x,y foram referenciados dentro do advice around. No final executado o proceed que executa o mtodo real com os parmetros.
OBS: Quando utilizamos around como advice de extrema importncia utilizar o proceed(), mesmo quando o mtodo void. Se o proceed() no for executado dentro do advice around o mtodo original no ser executado. s vezes voc pode querer fazer como forma de alguma poltica de segurana, mas lembre-se: o mtodo no ser executado. Quando declaramos exceptions checadas em advices elas devem ser declaradas com a clusula throws, e a mesma deve ser compatvel com a do mtodo original, caso ocorra de modo contrrio o compilador ir apresentar um erro. Sobre a precedncia de advices: Quando existem dois advices em dois aspectos disitintos impossvel determinar qual ir executar primeiro. Quando existe um advice que est em um aspecto abstrato e outro em um aspecto concreto que extende o do abstrato, o abstrato tem precedncia. E quanto a dois advices declarados no mesmo aspecto, o que for declarado primeiro ter precedncia sobre os outros. Estas informaes so importantes se voc deseja aplicar algum mecanismo de proxy como segurana, transao, autenticao, log. Pode ser necessrio estabelecer uma precedncia entre os aspectos que aplicam os cross cuting concerns.
ThisJoinPoint
AspectJ prove uma varivel de referncia especial chamada de thisJoinPoint. Essa varivel de referncia contm informaes sobre o joint point corrente para que possamos utilizar estas informaes no advice. O recurso thisJoinPoint s pode ser utilizado no contexto de um advice, existe um objeto AspectJ que ele representa que org.aspectj.lang.JoinPoint. Supondo que tenhamos a seguinte classe Java:
package br.com.targettrust.aop.advice.thisJoinPoint.java; public class ThisJoinPointTest { public static void execute(){}; public static void main(String[] args) { execute(); } }
Cdigo 3.7 Exemplo de uso de thisJoinPoint. O mtodo execute no faz nada, mas est sendo invocado no mtodo main.
package br.com.targettrust.aop.advice.thisJoinPoint; public aspect ThisJoinPoint { void around(): call(void *.*.execute()) && within(br.com.targettrust.aop.advice.thisJoinPoint.java.*){ System.out.println("Executando: " + thisJoinPoint.toString()); } }
Cdigo 3.8 Exemplo de uso de thisJoinPoint em aspecto. O aspecto acima apenas imprime uma mensagem usando algumas informaes que existem no join point corrente. Veja o resultado da execuo deste programa abaixo.
Executando: call(void br.com.targettrust.aop.advice.thisJoinPoint.java.ThisJoinPointTest.execute())
Cdigo 3.9 Resultado da execuo.
Como demostra o cdigo acima, o uso de thisJoinPoint leva a um objeto JoinPoint do AspectJ, e foi invocado o metodo toString() que retorna uma representao em forma de String do joinpoint relacionado. Os principais mtodos de thisJoinPoint() so:
Mtodo getArgs() getSignature() getSourceLocation() getClass() getKind() getTarget() getStaticPart() Descrio
Retorna os argumentos do mtodo Retorna a assinatura do mtodo Fonte e linha do cdigo Java Retorna a classe de implementao do JoinPoint Tipo de join point. Ex.: method-call Retorna o objeto (Java) em execuo um helper do join point que contm as informaes que podem ser acessadas de forma esttica.
getThis()
Semelhante ao target, porm sempre ir retornar o objeto que estiver relacionado ao this() de expresso pointcut.
Quando estamos em um advice do tipo after ou before e existe uma expresso call(), possvel acessar informaes do joint point passado quando ele existe, para isso usamos a varivel thisEnclosingJoinPointStaticPart.
Aspects
Aspectos so tipos de dados em AspectJ semelhantes a uma classe Java, os aspectos so os meios que possibilitam a expresso de um crosscuting concern. dentro dos Aspectos que so declaradas as expresses pointcuts e os advices. A declarao de aspectos semelhante a declarao de uma classe Java. Quando estamos declarando um aspecto podemos: Declarar mtodos e variveis Java Aspectos alinhados precisam ser estticos Aspectos no so instanciados
Quanto a caracterstica de os aspectos no serem instanciados com a palavra reservada new, os mesmos no so clonados ou serializados diretamente. Aspectos podem ter um construtor desde que o mesmo no tenha argumentos e no retorne exceptions checadas. Os aspectos podem estender classes e at mesmo implementar interfaces. As classes Java no podem estender aspectos, isso gera um erro de compilao. Aspectos podem extender outros aspectos, desde que abstratos, se um aspecto tenta estender outro aspecto que no abstrato causa um erro de compilao. Por default os aspectos so singletons, significa que a mesma instncia do aspecto ser para toda execuo de um programa Java. Podemos recuperar a instncia de um aspecto com uma classe utilitria do AspectJ, a org.aspectj.lang.Aspects que tem os seguintes metodos: aspectOf(Class c): Que recebe a class do aspecto e retorna a intncia do mesmo aspecto. Pode ser chamado por qualquer aspecto. hasAspect(Class c): Retorna true ou false se a classe for um aspecto.
Obs.: A Classe utilitria org.aspectj.lang.Aspects no pode ser utilizada em uma classe Java, pois isso quebra o conceito bsico de AOP, os aspectos podem ver as classes Java, entretanto as classes Java no vem os aspectos. Se voc fizer isso ir receber um erro de compilao.
Veja abaixo um exemplo de como podemos utilizar aspectos abstratos e extenso de aspectos com os recursos da classe utilitria Aspects.
package br.com.targettrust.aop.aspect.java; class A{ public void func(){} } class B{ public void func(){} } public class SingletonTeste { public static void main(String[] args) { A a = new A(); B b = new B(); a.func(); b.func(); } }
Cdigo 3.10 Classe java de testes.
Supondo que temos as trs classes acima, a classe A e B com o mtodo func() e uma classe main com a instanciao e invocao dos mtodos func() de A e B. Agora se quisssemos contrar quantas vezes o mtodo func() foi chamado. poderamos fazer um aspecto conforme este abaixo:
package br.com.targettrust.aop.aspect; public abstract aspect PaiBurro { protected String nome = "Aspecto Contador"; }
Cdigo 3.11 Exemplo de um aspecto abstrato.

package br.com.targettrust.aop.aspect; import org.aspectj.lang.Aspects; public aspect Singleton extends PaiBurro{ private int cont = 0; after(): call(* *.*.func()){ cont++; Singleton o = (Singleton)Aspects.aspectOf(Singleton.class); System.out.println("Metodo:" + thisJoinPoint.getSignature().getName() + " invocado: " + cont + " vezes! Monitor: " + o.nome); } }
Cdigo 3.12 Exemplo de um usando a classe utilitria Aspects
Obs.: Se mltiplos classloaders carregarem mltiplas classes, e essas classes tenham join points com aspectos, esses aspectos sero instnciados uma vez a cada classloader. Como mencionado antes, os aspectos so singletons, porm por classloaders. Um advice s pode rodar no contexto de um aspecto, se o mesmo no tiver sido instnciado ele no pode rodar, se por algum motivo um advice for executado antes da criao do aspecto, como por exemplo fazer um before advice de um execuo new(), isso far com que o AspectJ levante um exception: org.aspectj.lang.NoAspectBoundException. Por default aspectos tem as mesmas regras de acesso e privilgios que o Java tem, mas podemos modificar essas polticas tornando o aspecto privilegiado. Quando um aspecto privilegiado, o mesmo pode acessar variveis protected e at mesmo variveis private. Porm esses recursos s so vlidos para innertype declarations feitas pelo mesmo aspecto ou por outros.
Inner-Type Declarations
Recurso do AspectJ que permite adicionar membros nas classes de forma dinmica. Com este recuroso podemos adicionar atributos a um classe Java e utilizar essa informao para algum processamento em algum advice de um aspecto. No difcil adicionar mtodos a classes Java com os recursos de inner-type declarations do AspectJ, podemos inclusive fazer com que determinada classe implemente um set de interfaces. Como mencionado anteriormente, possivel modificar at mesmo as regras de acesso do Java, assim um aspecto privilegiado pode acessar mtodos proteced e at mesmo private. Para adicionar uma classe ou interface na hierarquia de uma classe em um aspecto podemos usar o recurso declare parents. O cdigo abaixo mostra como adicionar a Classe br.com.A como classe pai da classe br.com.B.
declare parents: br.com.B extends br.com.A;
Cdigo 3.13 Exemplo de adio de classes com inner-type. Poderamos adicionar interfaces tambm, e isso podemos fazer quantas vezes quizermos, porm vlido lembrar que quando fazemos isso somos obrigados a implementar todos os mtodos definidos na interface.
declare parents: br.com.B implements br.com.A;
Cdigo 3.14 Exemplo de adio de classes com inner-type. No exemplo acima foi feito que a classe br.com.B implementase a interface br.com.A, quando fazemos isso essas informaes podem ser acessadas at mesmo por uma classe Java atravs de cast para a interface ou com o uso de Reflection. Para adicionar atributos a uma classe Java podemos fazer conforme o exemplo abaixo:
private List<Porta> Casa.portas = new ArrayList<Porta>();
Cdigo 3.15 Exemplo de adio de atributo em classes com inner-type.
No exemplo acima est sendo adicionda uma List<Porta> no objeto casa. Perceba que o atributo est sendo adicionado de forma privada, isso significa que no poder ser acessada de fora da classe a no ser que o aspecto seja privilegiado.
Para adicionar mtodos a uma classe ( Isso necessrio quando implementamos uma interface via aspectos) podemos fazer conforme o exemplo abaixo.
public void Casa.pintar(Cor c){ System.out.println("Pintando a casa de cor:" + c); }
Cdigo 3.16 Exemplo de adio de metodo em classes com inner-type. No cdigo acima foi adicionado o mtodo pintar ao objeto Casa, esse mtodo tem como parmetro um objeto Cor, esse mtodo pode ser acessvel normalmente se ele estiver em uma interface ou via Reflection. Dentro de um advice ou de um outro aspecto isto pode ser acessado de forma natural pois o mtodo ser pblico. Outro recurso que podemos utilizar a adio de contrutores a classes Java atravs de inner-type declarations, confira o exemplo abaixo.
public Casa.new(String rua) { super(); System.out.println(rua); }
Cdigo 3.17 Exemplo de adio de construtor em classes com inner-type. No exemplo acima foi adicionado um construtor ao objeto Casa, esse objeto agora tem um construtor que recebe um String contendo a rua. A chamada super() opcional, mas o compilador AspectJ ir lanar um warning se voc no a colocar. Por questes de boas prticas de programao recomenda-se utilizar. Para um exemplo mais completo com inner-type declarations, consulte o projeto do eclipse com fontes que acompanha essa apostila, l voc encontrar um exemplo de implementao do pattern observer com aspectos utilizando muito os recursos de inner-type com declare parents tambm. Voc encontra os fontes em dois pacotes que so: br.com.targettrust.aop.innertype e br.com.targettrust.aop.innertype.java.
Exerccios
1) Faa um Aspecto utilizando o advice do tipo before() log em um arquivo texto todas as chamadas de mtodos da classe Sistema. Essa classe deve ter 5 mtodos: ligar(), parar(), desligar(), acelerar() e explodir(), crie a classe e fornea qualquer implementao, aps isso chame algumas vezes esses mtodos. 2) Aproveite o exercicio anterior e mude o advice before para o advice after e faa o mtodo desligar(String motivo) e log isso tambm. 3) Faa um advice around que no execute o mtodo ligar se o dia de hoje for par, e alm disso levante um exception do tipo RuntimeExecption(Hoje o sistema est desligado!). 4) Crie a interface Contador com o mtodo int contar(int i) e int showTotalCount(). Faa via inner-type declaration com que a classe sistema tenha um contador com todas as chamadas aos mtodos acelerar() e parar(). Mostre o resultado em uma classe main, use cast ou reflection.
4. Recursos Adicionais
Objetivos
Saber utilizar AspectJ com annotations. Saber utilizar o recurso de declare soft. Conhecer o conceito DBC.
AspectJ com Annotations
A verso 1.5.X do AspectJ prove um mecanismo no estilo de anotaes do Java 5.0. O AspectJ prove um conjunto de anotaes que possibilita o desenvolvimento neste estilo, porm o efeito o mesmo que no desenvolvimento utilizando a sintaxe AspectJ. possvel combinar os dois estilos de desenvolvimento em uma mesma aplicao, podemos perfeitamente mixar os estilos at no mesmo fonte, mas isso no recomendado por questes de boas prticas. Os recursos de anotaes disponveis no AspectJ 1.5.X esto no pacote
org.aspectj.lang.annotation, l podemos destacar a anotao @Aspect, ela define que uma classe um aspecto para o AspectJ. Um ponto importante que deve ser lembrado quando optamos por uma abordagem dirigida a anotaes, que quando utilizamos aspectos com anotaes no possivel declarar aspectos privilegiados. Podemos utilizar pointcuts e advices atravs do set de anotaes: @Pointcut, @Before, @After, @AfterReturning, @AfterThrowing e @Around. Quando utilizamos o @Pointcut para declarar o pointcut existem algumas regras, tais como: o mtodo deve retornar void, no deve ter nada no seu corpo (exeto o caso if que ser abordado mais tarde). Para declarar um pointcut abstrato basta fazer com que o mtodo seja abstrato. Ao fazer desta maneira pode parecer um pouco estranha a forma de uso, e mesmo bastante incomun. O que se pode fazer utilizar expresses pointcuts direto em anotaes advice, isso faz com que o cdigo fique mais natural. Se voc utilizar algum recurso do tipo: args(), target(), this(), @args(), @this(), @annotation, o parmetro em questo dever aparcer na assinatura do mtodo que contm a annotation @Pointcut. Obs.: No escopo de desenvolvimento AspectJ com anotaes os imports no surtem efeito para as anotaes, ento se voc que usar um List, deve colocar o nome completo da classe. Ex.: java.util.List ao invs de List. Para o uso do recurso if() o mtodo deve ser public static boolean como no exemplo abaixo.
@Pointcut("call(* *.*(int)) && args(i) && if()") public static boolean chamadaIf(int i) { return i > 0; }
Cdigo 4.1 Exemplo de anotaes com if() e com annotations O exemplo acima define um pointcut que captura todas as chamadas de mtodos que recebam um inteiro e este inteiro seja maior que zero. Esse cdigo acima tem equivalncia ao seguinte cdigo AspectJ:
pointcut chamadaIf(int i) : call(* *.*(int)) && args(i) && if(i > 0);
Cdigo 4.2 Exemplo de anotaes com if() na sintaxe AspectJ Para capturar o joint point corrente para algum processamento, basta declarar o org.aspectj.lang.JoinPoint no Pointcut e depois no Advice e pronto! O mecanismo de annotations ir prover a instncia desse objeto. Para utilizarmos as anotaes destinadas a advices o mtodo Java deve retornar void e ser pblico, porm no caso do advice around, o advice deve retornar o tipo de dado conforme a especificao do pointcut do advice around. No caso dos advices @AfterReturning e @AfterThrowing, eles no expe o mtodo em questo anotado ao retorno ou a execption levantada, conforme mostra o exemplo abaixo.
@AfterReturning("criticalOperation()") public void phew() { System.out.println("phew"); } @AfterReturning(pointcut="call(Foo+.new(..))",returning="f") public void itsAFoo(Foo f) { System.out.println("It's a Foo: " + f); }
Cdigo 4.3 Exemplo de anotaes advice afterReturning. No exemplo acima estamos capturando todas as instncias das classes Foo ou filhas dele e pegando o retorno em f que utilizando no advice. @AfterThrowing funciona da mesma forma porm ao invs do atributo returning ele possui o atributo throwing.
Com o advice do tipo @Around existe o problema do proceed() que no pode ser chamado no meio do cdigo Java, se no voc ter um erro de compilao, para manter um bom design e a compatibilidade de compilao do mecanismo de annotaes dos parmetros do mtodo com a anotao @Around.
@Around("call(* *.*.now(..))") public String getData(ProceedingJoinPoint pjp){ try { System.out.println(pjp.getSignature()); return (String)pjp.proceed(); }catch (Throwable e) { return null; } }
do
Java 5.0 devemos utilziar a interface org.aspectj.lang.ProceedingJoinPoint que ser um
Cdigo 4.5 Exemplo de anotaes advice around com uso de proceed. No exemplo acima fica bem claro que utilizar esse recurso simples, e na instncia de ProceedingJoinPoint ainda contamos com recursos do JoinPoint, como por exemplo a assinatura do pointcut().
Inner-type declarations
Quando estamos desenvolvendo voltado para anotaes tambm podemos utilizar os recursos de inner-type declarations do AspectJ. Para respeitar os padres do Java 5.0, quando usamos inner-type declarations atravs de anotaes no temos disponveis os recursos de adio de campos e construtores. Isso ocorre porque o compilador javac no tem os recursos que o compilador AspectJ possui. Somente os recursos de adio de interfaces esto disponveis, com uma sutil diferena possivel utilizar esses recursos. Veja o exemplo abaixo.
Considere a seguinte classe Java.

package br.com.targettrust.aop.annotation.innertype.clazz; public class SimpleCalc { public public public public } int int int int soma(int a,int b) sub(int a,int b) multi(int a,int b) div(int a,int b) { { { { return return return return a+b; a-b; a*b; a/b; } } } }
Cdigo 4.6 Classe Java para o exemplo de inner-type com anotaes. Como voc pode perceber uma classe Java comum. uma calculadora muito simples com apenas as operaes bsicas de soma, subtrao, diviso e multiplicao. Para esse exemplo ser adicionada a operao de potenciao a essa calculadora atravs do recurso de inner-type com anotaes. S podemos utilizar esse recurso associado a uma interface.
package br.com.targettrust.aop.annotation.innertype; public interface Potencia { public int pow(int num); }
Cdigo 4.7 Interface de Potencia. A Interface acima define como a operao de potncia deve ser. Agora vamos a implementao padro dessa operao com o cdigo abaixo.
package br.com.targettrust.aop.annotation.innertype; public class PotenciaImpl implements Potencia{ public PotenciaImpl() { } public int pow(int num) { return num*num; } }
Cdigo 4.8 Implementao padro da interface Potencia. Essa uma implementao simples. Apenas feita a multiplicao do nmero pelo proprio nmero e retornado isso como resultado da operao de potenciao. Veja no Aspecto seguinte como fazer a classe SimpleCacl ter os recursos da Potencia.
package br.com.targettrust.aop.annotation.innertype; import org.aspectj.lang.annotation.Aspect; import org.aspectj.lang.annotation.DeclareParents; @Aspect public class AnnotationInnerTypeAspect { @DeclareParents( value="br.com.targettrust.aop.annotation.innertype.clazz.*", defaultImpl=PotenciaImpl.class) public Potencia implementadores; }
Cdigo 4.9 Aspecto com anotaes que utiliza inner-type declarations. O Aspecto a cima faz a grande jogada. Atravs da anotao
org.aspectj.lang.annotation.DeclareParents vide @DeclareParents que feito uso de inner-type. A anotao @DeclareParents tem duas propriedades value e defaultImpl. Sendo que a propriedade value serve para informar que classe ou conjunto de classes vai ganhar a nova interface, a propropriedade defaultImpl opicional, mas sem isso a classe que recebe a interface (nesse exemplo SimpleCalc) ter de prover todos os mtodos que a interface necessita. Veja que essa anotao s pode ser aplicada a tipos de dados que so interfaces, ou seja, nesse exemplo a interface Potencia est sendo dada a todas as classes do pacote br.com.targettrust.aop.annotation.innertype.clazz.*. Para testar esse recurso observe a seguinte classe Java.
package br.com.targettrust.aop.annotation.innertype.java; import br.com.targettrust.aop.annotation.innertype.Potencia; import br.com.targettrust.aop.annotation.innertype.clazz.SimpleCalc; public class AnnotationInnerTypeAspectTest { @SuppressWarnings("unchecked") public static void main(String[] args) { SimpleCalc sc = new SimpleCalc(); Class[] ints = SimpleCalc.class.getInterfaces(); for(Class c: ints){ System.out.println("Implementa: " + c); } System.out.println("Potencia de 5 = " + ((Potencia)sc).pow(5)); } }
Cdigo 4.10 Classe de teste para inner-type declarations com anotaes.

Ao rodar a classe do teste acima voc ver um resultado semelhante a este:

Implementa: interface br.com.targettrust.aop.annotation.innertype.Potencia Potencia de 5 = 25
Cdigo 4.11 Resultado da execuo da classe AnnotationInnerTypeAspectTest Como voc pode perceber a classe de fato implementa a interface que injetamos via AspectJ, e foi feito o cast de maneira natual para a interface Potencia. Aps o cast foi invocado o mtodo pow(5) e obtivemos o resultado correto da execuo.
Declare warnings e errors
Outro recurso disponvel no desenvolvimento de aspectos baseados em anotaes o recurso de gerao de warnings e erros. Para declarar um warning basta utilizar a anotao
org.aspectj.lang.annotation.DeclareWarning vide @DeclareWarning. Veja no exemplo abaixo como utiliz-la.

@DeclareWarning("call(java.util.Date.new(..))") static final String message = "Voc no deve utilizar java.util.Date. Utilize Joda-Time!";
Cdigo 4.12 Exemplo de uso de declare warning com anotaes. Nessa anotao voc deve informar uma expresso pointcut que ser responsvel por determinar quais sero os alvos de seu warning. Essa anotao deve se utilizada em cima de um atributo do tipo String que deve ser obrigatoriamente final, por questes de boas praticas voc pode colocar static tambm. Para declarar um error basta utilizar a anotao org.aspectj.lang.annotation.DeclareError vide @DeclareError. Veja no exemplo abaixo como utiliz-la.
@DeclareError("call(public void *.apagaGeral()) ") static final String error = "Isso um erro no apague nada!";
Cdigo 4.13 Exemplo de uso de declare error com anotaes. O Recurso de declarar erro muito semelhante ao recurso de declarar um warning. Tambm devemos informar uma expresso pointcut que ser responsvel por
determinar quais classes ficaram com erros. Claro que tambm necessrio um String do tipo final para ser a mensagem de erro.
Declare Soft
Esse recurso foi introduzido apartir do AspectJ 1.5.X. um recurso muito importante com ele podemos fazer com que as Exceptions do Java sejam encapsuladas em uma Exception do AspectJ que do tipo unchecked e por consequncia estende RuntimeException. Se a exceo que for utilizada para o soft for uma Exception que estende RuntimeException voc receber um warning e o soft no ir ocorrer. A Exception do AspectJ que vai ser a encapsuladora de sua exeo ser a org.aspectj.lang.SoftException. Esse recurso til para tratar os erros provocados porventura por aspectos. Veja como utilizar o recurso no exemplo abaixo:
package br.com.targettrust.aop.declaresoft; public class MinhaExcpetionChata extends Exception { private static final long serialVersionUID = 1L; public MinhaExcpetionChata(String msg) { super(msg); } public MinhaExcpetionChata(String msg,Throwable rootCause) { super(msg,rootCause); } }
Cdigo 4.14 Exemplo de uso de declare soft. Esta apenas uma Exception checada chamada de MinhaExceptionChata. Veja como fazer o soft dela no cdigo AspectJ abaixo:
package br.com.targettrust.aop.declaresoft; public aspect DeclareSoft { declare soft : MinhaExcpetionChata : execution(* *(..)); }
Cdigo 4.15 Aspecto que faz o soft. No aspecto acima foi informado em qual Exception deveria ser feito o soft e qual expresso pointcut deveria ser aplicado. Assim podemos limitar o soft somente para alguns mtodos. Para testar o recurso observe a classe Java de testes abaixo:
package br.com.targettrust.aop.declaresoft.java; import org.aspectj.lang.SoftException; import br.com.targettrust.aop.declaresoft.MinhaExcpetionChata; public class DeclareSoftTest { public void fazAlgo() throws Exception { throw new MinhaExcpetionChata("Exception chata mesmo"); } public static void main(String[] args) { try { DeclareSoftTest dst = new DeclareSoftTest(); dst.fazAlgo(); } catch (SoftException se) { System.out.println(" 1 - SoftExcetion: " + se.getWrappedThrowable()); } catch (Exception e) { System.out.println(" 2 - Exception: " + e); } } }
Cdigo 4.16 Classe de testes para declare soft. Essa classe de testes chama o metodo fazAlgo() que retorna um Exception do tipo MinhaExceptionChata essa exception vai sofrer o soft. Podemos observar que isso ocorre pelo seguinte bloco de try/cacth neste bloco est sendo tratada uma exception do Java e a SoftException do AspectJ. Veja o resultado da execuo desse cdigo abaixo.
1 - SoftExcetion: br.com.targettrust.aop.declaresoft.MinhaExcpetionChata: Exception chata mesmo
Cdigo 4.16 Resultado da execuo da classe DeclareSodtTest.
DBC: Design By Contract
O AspectJ possibilita a aplicao dos conceitos de DBC. Design By Contract um conceito que se norteia basicamente em pr condies, ps condies e invariantes. O seu propsito garantir um contrato mais consistente do que ns temos por exemplo com uma interface Java. Considere a seguinte interface:
package br.com.targettrust.aop.dbc; import java.math.BigDecimal; public interface ContaCorrente { public void debitar(BigDecimal valor); public void creditar(BigDecimal valor); public BigDecimal consultaSaldo(); }
Cdigo 4.17 Interface de conta corrente. Em Java, interfaces so conhecidas como contratos, porm se analizarmos de maneira mais crtica vamos ver que um contrato muito fraco. Nada impede que a implementao de ContaCorrente faa um dbito em uma conta que no tenha saldo ou fazer um saque em uma conta que no tem fundos. Podemos resolver estes problemas em tempo de design? Sim, com DBC podemos fazer isto. Para isto, usaremos os conceitos de pr-condies, ps-condies e invariantes. Pr-Condies: Condies que devem ser atendidas antes da execuo do mtodo em questo. Ex: No queremos que o mtodo debitar receba um valor negativo, ento podemos dizer que uma pr-condio que o argumento valor no pode ser menor que 1. Ps-Condies: Condies que devem ser aceitas aps a execuo do mtodo em questo. Ex.: No queremos que aps um saque a conta fique no negativo, ou seja, o usurio do banco no pode sacar mais do que ele tem na conta. Ento podemos determinar uma ps-condio, que diz que aps a execuo do mtodo debitar() seja executado o mtodo consultaSaldo() e o mesmo no pode ter um retorno menor que zero. Invariantes: Invariantes so como constantes. So operaes ou variveis que desejamos que sempre tenham determinado valor. Ex.: Poderamos dizer que uma invariante que o saldo da conta nunca pode ficar menos que 100 reais.
DBC um conceito em tem diversas implementaes em muitas linguagens como C, Java, .NET , Ruby, etc. Podemos fazer uso fruto dos conceitos de DBC com o prprio AspectJ, porm no temos recursos prontos na linguagem para isso. O recomendo um framework de DBC para Java, existem muitos dentre eles o JContract, C4J, Contract4J que utiliza o AspectJ como base. Veja um exemplo de implementao de DBC utilizando AspectJ puro. Considere a interface ContaCorrente mostrada acima. Considere as seguintes regras: Pr-Condies: O mtodo debitar no pode receber um argumento menor que 1. O mtodo debitar no pode receber um argumento maior que 1.000 Ps-Condies: Aps o saque a conta deve ter no mnimo 5 reais. Invariantes: A Conta nunca pode estar no negativo. Para atender esse contrato estabelecido atravs das premissas do DBC veja a classe Java abaixo.
package br.com.targettrust.aop.dbc; import java.math.BigDecimal; public class ContaCorrenteImpl implements ContaCorrente { private BigDecimal grana = new BigDecimal(5); public BigDecimal consultaSaldo() { return grana; } public void creditar(BigDecimal valor) { grana = grana.add(valor); } public BigDecimal debitar(BigDecimal valor) { grana = grana.subtract(valor); return grana; } }
Cdigo 4.18 Classe Java para implementao padro da conta corrente.
Pela implementao da classe Java podemos ver que no foi implementado nenhum tipo de validao para atender o contrato DBC que foi estipulado previamente. Provavelmente se esta classe fosse executada do jeito que ela se encontra, teramos srios problemas. Agora vamos ver o aspecto que ter a implementao DBC.
package br.com.targettrust.aop.dbc; import java.math.BigDecimal; public aspect DBCAspect { private pointcut debitarPointcut(BigDecimal b): execution(public BigDecimal *.debitar(BigDecimal)) && args(b) && within(br.com.targettrust.aop.dbc.*); before(BigDecimal b): debitarPointcut(b){ if (b.doubleValue()<1) throw new RuntimeException("O Metodo ContaCorrente.debitar(BigDecimal) " + " no pode receber um valor menor que 1! Valor: " + b.doubleValue()); } before(BigDecimal b): debitarPointcut(b){ if (b.doubleValue()>1000.0) throw new RuntimeException("O Metodo ContaCorrente.debitar(BigDecimal) " + "no pode receber um valor maior que 1.000! Valor: " + b.doubleValue()); } after(ContaCorrente cc): execution(public BigDecimal *.debitar(BigDecimal)) && target(cc) && within(br.com.targettrust.aop.dbc.*) { BigDecimal saldo = cc.consultaSaldo(); if (cc.consultaSaldo().doubleValue()<=0){ cc.creditar(new BigDecimal(5d).subtract(saldo)); throw new RuntimeException("Erro a contacorrente no pode ter saldo" +"negativo! Valor: " + saldo.doubleValue()); } if (cc.consultaSaldo().doubleValue()<=4){ cc.creditar(new BigDecimal(5d).subtract(saldo)); throw new RuntimeException("Erro a contacorrente no pode ter saldo" + "menor que 5 reais! Valor: " + saldo.doubleValue()); } } }
Cdigo 4.19 Aspecto de uma implementao DBC. Nesta implementao no h nehum recurso que no tenha sido discutido nesta apostila, ela utiliza os recursos que voc j deve estar familiarizado agora. Porm, aqui esto inseridos os conceitos de DBC que expressam pelas pr-condies, pscondies e invariantes.
Veja um cdigo Java para testar esses recursos em ao.

package br.com.targettrust.aop.dbc.java; import java.math.BigDecimal; import br.com.targettrust.aop.dbc.ContaCorrenteImpl; import br.com.targettrust.aop.dbc.ContaCorrente; public class DBCTest { public static void main(String[] args) { ContaCorrente cc = new ContaCorrenteImpl(); try{ cc.debitar(new BigDecimal("-1")); }catch(Exception e){ System.out.println(e.getMessage()); } try{ cc.debitar(new BigDecimal("1001")); }catch(Exception e){ System.out.println(e.getMessage()); } try{ cc.debitar(new BigDecimal("2")); }catch(Exception e){ System.out.println(e.getMessage()); System.out.println("Saldo atual: " + cc.consultaSaldo()); } try{ cc.debitar(new BigDecimal("200")); }catch(Exception e){ System.out.println(e.getMessage()); System.out.println("Saldo atual: " + cc.consultaSaldo()); } } }
Cdigo 4.20 Classe Java para testes. Nessa classe foi forado todos os tipos de situaes que iriam estourar algum tipo de erro. Ao executar essa classe ns teremos o seguinte resultado.
O Metodo ContaCorrente.debitar(BigDecimal) no pode receber um valor menor que 1! Valor: -1.0 O Metodo ContaCorrente.debitar(BigDecimal) no pode receber um valor maior que 1.000! Valor: 1001.0 Erro a conta corrente no pode ter saldo menor que 5 reais! Valor: 3.0 Saldo atual: 5 Erro a conta corrente no pode ter saldo negativo! Valor: -195.0 Saldo atual: 5
Cdigo 4.21 Resultado da execuo de um aspecto estilo DBC. O Resultado comprova o esperado, conseguimos aplicar de fato uma consistncia de contrato muito superior a que o mecanismo de interfaces do Java nos prove.
Exerccios
1) Faa um aspecto utilizando anotaes que faa tracing. Este aspecto deve mostrar todos os parmetros do mtodo e o seu retorno tambm. Chame o mtodo execute (String proc, Object inst) vrias vezes em uma classe de testes. 2) Declare um erro utilizando anotaes para quando for utilizando a classe java.util.HashMap() em uma classe TesteMapEx02 com os mtodos usaMap() e testaMap(). 3) Baseado no exercicio anterior, faa o mesmo, s que agora gere um warning, utilizando anotaes tambm. 4) Utilizando os conceitos de DBC faa um aspecto que valide as seguintes premissas: 1 Pr condies: 1. O hotel no aceita hospedes de cabelo verde. 2. O hotel no aceita chekin antes das 10:00hs. 2 Ps condies: 1. Ao sair do hotel deve-se pagar a conta. 2. Ao sair do hotel deve-se deixar 20% de gorjeta. 3 Invariantes: 1. Para alugar o quarto a pessoa deve ter, no mnimo R$ 500,00. Para esse execcio implemente a interface Hotel que segue:
Package br.com.targettrust.aop.advice.after.java; import java.math.BigDecimal; public interface Hotel { public void checkIn(String corCabelo, int horaEntrada, BigDecimal dinheiroQueVoceTem); public BigDecimal getTotalConta(); public void checkOut(BigDecimal vindeDaPropina); }
Cdigo 4.22 Interface para o exercicio 4
Espao para Anotaes

Apostila Aspect J

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Apostila Aspect J

Enviado por

Direitos autorais:

Formatos disponíveis

AOP AspectJ 1.5.

4 Programao Orientada a Aspectos

AOP AspectJ 1.5.4 Programao Orientada a Aspectos

AOP AspectJ 1.5.4 Programao Orientada a Aspectos

AOP AspectJ 1.5.4 Programao Orientada a Aspectos

AOP AspectJ 1.5.4 Programao Orientada a Aspectos

AOP AspectJ 1.5.4 Programao Orientada a Aspectos

AOP AspectJ 1.5.4 Programao Orientada a Aspectos

1. Conceitos Bsicos sobre AOP

AOP AspectJ 1.5.4 Programao Orientada a Aspectos

AOP AspectJ 1.5.4 Programao Orientada a Aspectos

AOP AspectJ 1.5.4 Programao Orientada a Aspectos

Concerns VS Crosscuting concerns

Figura 1.1 Concerns vs crosscuting concerns.

AOP AspectJ 1.5.4 Programao Orientada a Aspectos

Concerns VS Crosscuting concerns

AOP AspectJ 1.5.4 Programao Orientada a Aspectos

AOP AspectJ 1.5.4 Programao Orientada a Aspectos

AOP AspectJ 1.5.4 Programao Orientada a Aspectos

AOP AspectJ 1.5.4 Programao Orientada a Aspectos

AOP AspectJ 1.5.4 Programao Orientada a Aspectos

AOP AspectJ 1.5.4 Programao Orientada a Aspectos

AOP AspectJ 1.5.4 Programao Orientada a Aspectos

AOP AspectJ 1.5.4 Programao Orientada a Aspectos

AOP AspectJ 1.5.4 Programao Orientada a Aspectos

AOP AspectJ 1.5.4 Programao Orientada a Aspectos

AOP AspectJ 1.5.4 Programao Orientada a Aspectos

AOP AspectJ 1.5.4 Programao Orientada a Aspectos

Figura 2.1 Contexto de pointcuts.

AOP AspectJ 1.5.4 Programao Orientada a Aspectos

Suporte ao Java 5.0

AOP AspectJ 1.5.4 Programao Orientada a Aspectos

Anotaes para Pointcuts

AOP AspectJ 1.5.4 Programao Orientada a Aspectos

Join Point match com annotations

Expresso (@Executavel * *) (!@Executavel * *) (@Executavel @Runnable * * )

Que contm a annotation @Executavel ou a

AOP AspectJ 1.5.4 Programao Orientada a Aspectos

Expresso @Criavel new(..)

Exemplo de uso Qualquer construtor que tenha a

annotation @Criavel. Cuidado com a

AOP AspectJ 1.5.4 Programao Orientada a Aspectos

Recursos Avanados em pointcuts

AOP AspectJ 1.5.4 Programao Orientada a Aspectos

AOP AspectJ 1.5.4 Programao Orientada a Aspectos

Declarao de erros e warnings

Cdigo 2.4 Utilizao de error e warning em pointcuts.

AOP AspectJ 1.5.4 Programao Orientada a Aspectos

Cdigo 2.5 Exemplos de utilizao de injeo de annotations

AOP AspectJ 1.5.4 Programao Orientada a Aspectos

AOP AspectJ 1.5.4 Programao Orientada a Aspectos

AOP AspectJ 1.5.4 Programao Orientada a Aspectos

AOP AspectJ 1.5.4 Programao Orientada a Aspectos

Cdigo 3.1 Exemplo de um Advice simples.

AOP AspectJ 1.5.4 Programao Orientada a Aspectos

Cdigo 3.2 Exemplo de um Advice do tipo before.

Cdigo 3.2 Exemplo de um Advice do tipo before com validao.

AOP AspectJ 1.5.4 Programao Orientada a Aspectos

Cdigo 3.3 Exemplo de um Advice do tipo after.

Cdigo 3.4 Exemplo de um Advice do tipo after com returning.

AOP AspectJ 1.5.4 Programao Orientada a Aspectos

Cdigo 3.5 Exemplo de um Advice do tipo after com throwing.

AOP AspectJ 1.5.4 Programao Orientada a Aspectos

Expresso (@Executavel * ) (!@Executavel ) (@Executavel @Runnable * )