Top Posts

Hello world!

Continue lendo

Série Spring: Spring Aspect Object Programming – AOP

Posted by camilolopes | Posted in Series, Spring | Posted on 05-05-2013

0

olá Pessoal,

O post de hoje veremos com brincar com AOP. Opsss… O que é isso? Veremos um pouco mais a seguir a utilidade de usar AOP e faremos um exemplo simples para vê-lo em ação.

lets go…

AOP – Aspect Object Programming

Em poucas palavras a orientação a aspectos surgiu para eliminar os chamados de cross cutting concerns, ou seja, aquele código que é necessário, mas que não faz parte das principais obrigações do objeto, por exemplo: logging, transação etc. E para isso precisamos entender trêsp ontos apenas:

 

1. Advice: separa o código nada ver em um lugar especifico

2. join point: define dentro do advice o momento que o código separado executa

3.point cuts: é onde será feito.

Então o advice é o que será feito. O joint cuts é quando será feito. E o point cuts é o onde será feito.

 

Antes de começarmos colocar mão na masa precisamos fazer download do .jar do AspectJ http://www.eclipse.org/aspectj/downloads.php após baixar, descompacte o .jar com o winrar por exemplo vá na pasta lib copie os .jars existentes e adicione ao seu projeto.

 

Precisamos também do AOP Alliance http://ebr.springsource.com/repository/app/bundle/version/detail?name=com.springsource.org.aopalliance&version=1.0.0  faça o download e adicione ao seu projeto.

 

Adicione também o commons-logging-1.x http://commons.apache.org/logging/

 


AOPBankProject

Na diferente do que vimos no primeiro post. O objetivo de nossa aplicação é apenas logar informações quando um saque ou desposito for realizado. No exemplo logamos isso no console, em uma aplicação logariamos isso em arquivo de log por exemplo.

 

 

Desenvolvimento

 

1. crie o bean a seguir:

 

package br.com.camilolopes.bean;

import java.math.BigDecimal; 

public class Client  { 

                public void sacar(BigDecimal value) {

                               System.out.println(“Saque realizado com sucesso ” + value);

                }

                public void depositar(BigDecimal value) {

                               System.out.println(“Deposito realizado ” + value);

                }}

 

2. Agora vamos passar a resposabilidade para o Spring cuidar do nosso bean:

 

<?xml version=”1.0″ encoding=”UTF-8″?>

<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-3.2.xsd

http://www.springframework.org/schema/aop

http://www.springframework.org/schema/aop/spring-aop-3.2.xsd”>

<bean id=”client”  />

<bean class=”br.com.camilolopes.manager.ManagerTransationAccount”/>

<aop:aspectj-autoproxy />

</beans>

 

Há uma pequena mudança no nosso arquivo xml, observe que adicionamos ao cabeçalho xmlns e http referente aop. E em seguida criamos  um bean para cada classe. A ManagerTransationAccount ainda não criamos, mas não há problemas em colocarmos ela no xml. Vamos criar um pouco mais adiante. A tag de proxy que adicionamos acima estamos falando para o Spring fazer o trabalho duro de criar proxy para nós.

Agora vamos criar a nossa classe que vai controlar as mensagens, ou seja, tudo que acontece na conta será logado:

 

@Aspect

public class ManagerTransationAccount {

                @Pointcut(“execution(* *.sacar(..)”)

                public void transacao(){}               

                @Before(“transacao()”)

                public void saque(){

//                           poderia logar a info no arquivo de log

                               System.out.println(“Transação de saque inicializada”);

                }

                @AfterReturning(“transacao()”)

                public void retirada(){

                               System.out.println(“Transação de saque concluida com sucesso”);

                }

               

                @Pointcut(“execution(* *.depositar(..))”)

                public void deposito(){}

               

                @Before(“deposito()”)

                public void depositar(){

                               System.out.println(“Transação de deposito iniciada”);

                }

               

                @AfterReturning(“deposito()”)

                public void depositado(){

                               System.out.println(“deposito realizado com sucesso”);

                }

}

 

Explicando:

Bem, anotação na classe é bem intuitiva certo? é preciso dizer que essa classe é orientada a aspect. Dai por isso anotação no inicio dela. Em seguida criamos um método da classe onde tudo começa o segredo está na anotação. Observe que é um pointcut, ou seja, onde será feito o trabalho e ali estamos dizendo que será feito quando o método sacar for chamado de qualquer classe passando qualquer parametro.

 

Atenção: Nenhum método criado nessa classe tem relação com os métodos que criamos na interface Machine. Poderiamos aqui chamar nosso método de qualquer coisa. O segundo que criamos e chamamos de saque que leva anotação @Before diz o seguinte: antes de chamar transacao(), ou seja, o métod que tem o pointcut, execute este aqui, ou seja, vai imprimir no console uma mensagem. Mas, poderiamos gravar uma informação no arquivo de log.

As demais anotações falam por si só.

 

Agora vamos testar, crie uma classe com método main:

public class MainBankMachine {

                public static void main(String[] args) {

                               ApplicationContext applicationContext = new ClassPathXmlApplicationContext(“conf/springconfiguration.xml”);

                               Client bean = (Client) applicationContext.getBean(“client”);

                               bean.sacar(BigDecimal.TEN);

                              

                }

}

 

O resultado

 

 aopresult

Agora fazendo deposito e saque:

 

aopresult2

      public static void main(String[] args) {

            ApplicationContext applicationContext = new ClassPathXmlApplicationContext(“conf/springconfiguration.xml”);

            Client bean = (Client) applicationContext.getBean(“client”);

            bean.sacar(BigDecimal.TEN);

            bean.depositar(BigDecimal.ONE);

      }

bom, é isso. Bem mais simples e fácil de dar manutenção não?

Vou ficando por aqui espero que tenham gostado do post.

abracos, see ya!!!

Related Posts with Thumbnails

Write a comment