13 jan 2016

Vamos falar sobre POA (Programação Orientada a Aspecto) , surgiu de uma necessidade de solucionar código emaranhados e código espelhados e com o surgimento dessa extensão podemos separar o que se refere a negócio e que se refere aos interesses transversais, de forma definida e centralizada.

Isso se deve ao fato da complexidade dos programas sendo ampliado por surgimento de novas tecnologias e novas soluções, fazendo com que o nível de abstração seja maior.

O intuito é familiarizar com alguns conceitos fundamentais para que possamos fazer uma melhor abordagem em nossos sistemas e contornando algumas limitações da programação orientada a objeto.

Conceitos e anotações

  • Pontos de junção: Identificados por uma chamada de um método ou ocorrência ou até uma exceção.
  • Pontos de atuação: Tem como objetivo criar regras as quais definirão quais serão os pontos de junção a serem executados.
  • Adendo: Similar a um método, a qual sua função é declarar o código que deve ser executado.

@Before (Anotação define que a intercepção de informação será feita antes da execução do método)

1
2
3
4
5
6
@Before("execution(* com.estudo.service.Cliente.addCliente(..))")
public void logBefore(JoinPoint joinPoint) {

System.out.println("logBefore() em execução!");
System.out.println("Antes do Main : " + joinPoint.getSignature().getName());
}

 

@After (Anotação define que a intercepção da informação será feita após execução do método)

1
2
3
4
5
6
@After("execution(* com.estudo.service.Cliente.addCliente(..))")
public void logAfter(JoinPoint joinPoint) {

System.out.println("logAfter() executado!");
System.out.println("Depois do Main : " + joinPoint.getSignature().getName());
}

 

@AfterReturning (Após execução do método retornar o resultado definido)

1
2
3
4
5
6
7
@AfterReturning(pointcut = "execution(*com.estudo.service.Cliente.addClienteReturnValue(..))", returning = "result")
public void logAfterReturning(JoinPoint joinPoint, Object result) {

System.out.println("logAfterReturning() em execução!");
System.out.println("Interceptado : " + joinPoint.getSignature().getName());
System.out.println("Retorno do valor : " + result);
}

 

@AfterThrowing(Após execução será retornado a exceção definida)

1
2
3
4
5
6
7
@AfterThrowing(pointcut = "execution(* com.mkyong.customer.bo.Cliente.addClienteThrowException(..))", throwing = "error")
public void logAfterThrowing(JoinPoint joinPoint, Throwable error) {

System.out.println("logAfterThrowing() is running!");
System.out.println("Execução do método : " + joinPoint.getSignature().getName());
System.out.println("Exception : " + error);
}

 

@Around (Antes da execução do método será interceptado o estado atual dos dados, para que possamos comparar)

1
2
3
4
5
6
7
8
9
10
11
@Around("execution(* com.estudo.service.Cliente.addClienteAround(..))")
public void logAround(ProceedingJoinPoint joinPoint) throws Throwable {

System.out.println("logAround() em execução!");
System.out.println("Interceptado : " + joinPoint.getSignature().getName());
System.out.println("Argumentos interceptados : " + Arrays.toString(joinPoint.getArgs()));

System.out.println("Antes do Main!");
joinPoint.proceed();
System.out.println("Depois do Main!");
}

Link de estudo de caso utilizando as anotações.
Baixar código

Leave a Comment