AOP - Aspect Criar

Agora vamos ver como criar um aspecto.
Primeiro de tudo, criar uma interface em que o exemplo, vamos escrever a nossa pointcuts:

 public interface MyInterface {





  



 f1 public void ();





  



 public int f2 ();





  



 public int f3 () throws Exception;





  



 f4 public void () throws Exception;





  



 f5 int público ();







 }

Para escrever um pointcut deve saber o designadores AspectJ pointcut , em nossos exemplos usaremos a execução apenas que corresponde a métodos de execução join point.
O formato da execução é uma expressão do tipo:

 



 execução (modificadores de padrão? Declarando ret-tipo-padrão do tipo de padrão? nome do padrão (param-padrão) lança-padrão?)

 

onde:

• modificadores padrão: parâmetros, aplicando o modificador opcional indica o tipo de método. * O valor corresponde a todos os tipos de modificadores.
• ret tipo-padrão: indica o tipo de retorno do método. * O valor corresponde a todos os tipos de retorno.
• Declarando-tipo-padrão: o parâmetro de opção, indica a classe que declara o método. * O valor é usado como um curinga para substituir totalmente o nome da classe ou parte dele.
• nome do padrão: o nome do método. * O valor é usado como um curinga para substituir totalmente o nome do método ou parte dela.
• param-padrão: indica os parâmetros do método. O valor () indica um método que leva sem parâmetros, enquanto o valor (..) indica um método que aceita zero ou mais parâmetros. * O valor é usado como um curinga para substituir o parâmetro de tipo de um método, por exemplo (*, java.lang.String) corresponde a um método que recebe como entrada dois parâmetros na primeira de qualquer tipo, o segundo tipo String.
• joga-padrão: parâmetro opcional indica o tipo de exceção gerada pelo método, por exemplo, joga java.lang.Exception

Para entender melhor a sintaxe, começamos com exemplos.

Primeiro temos que criar nosso próprio aspecto:

 @ Aspect







 {Public class MyAspect



  



 .............







 }

Como podemos ver a classe está anotada com @ Aspect. Isso não é suficiente porque você tem que habilitar o suporte a AOP nell'applicationContext Xml.:

 <-! ENBLING AspectJ ->







 <aop:aspectj-autoproxy />









 <-! MYASPECT ->







 <bean id="myAspect" class="it.mrwebmaster.aop.MyAspect" />

Depois de ter feito estas duas operações estão prontos para criar um conselho, por exemplo, uma ação realizada antes da execução do método de f1 (antes conselho):

 @ Before (execução "(* it.mrwebmaster.aop.MyInterface.f1 (..))")







 beforeF1 public void () {



  



 System.out.println ("ANTES F1");







 }

Como pode ser visto a partir do código que usamos a anotação @ Before que aceita uma expressão como um valor que identifica um pointcut. No nosso exemplo, a expressão corresponde a todos os métodos que são chamados de interface it.mrwebmaster.aop.MyInterface f1 indipendetemente por seus modificadores, tipo de retorno e parâmetros de entrada.
Da mesma forma, podemos usar um conselho que é executado quando um método termina sua execução (após voltar conselho) corretamente usando a anotação @ AfterReturning:

 @ AfterReturning pointcut (= "de execução (* it.mrwebmaster.aop.MyInterface.f2 (..))", retorno =" retVal ")







 afterReturningF2 public void (Object retVal) {



  



 System.out.println ("RETURN F2" + retVal);







 }

Este registro tem os seguintes parâmetros, além de pointcuts, o nome dado ao objeto retornado pelo método que pode ser dado como um parâmetro de entrada de Advaita. Neste caso, a expressão do pointcut é inviarata exceto para o nome do método, que neste caso, f2.
Muito semelhante é o conselho que é executado quando um método lança uma exceção (depois de jogar o conselho), utilizando a anotação @ AfterThrowing:

 @ AfterThrowing pointcut (= "de execução (* it.mrwebmaster.aop.MyInterface.f3 (..))", jogando =" throwable ")







 public void afterThrowingF3 (Throwable throwable) {

 

  



 System.out.println ("F3 joga" + throwable);







 }

A diferença é que o método não retorna um objeto, mas uma exceção.

Outro tipo de conselho é sempre executado após um método, é hora normalmente ou gera uma exceção (após o conselho). Este conselho é implementado através do uso de @ After:

 @ After ("execução (* it.mrwebmaster.aop.MyInterface.f4 (..))")







 afterF4 public void () {



  



 System.out.println ("APÓS F4");







 }

Finalmente vemos como fazer o "ao redor conselho:

 @ Around (execução "(* it.mrwebmaster.aop.MyInterface.f5 (..))")







 public void aroundF5 (ProceedingJoinPoint PJP) {



  



 System.out.println ("ANTES F5");



  



 try {



    



 Objeto retVal = pjp.proceed ();



    



 System.out.println ("F5 RETURN" + retVal);



  



 } Catch (Throwable e) {



    



 System.out.println ("F5 lança" + e);



  



 }







 }

Como podemos ver a partir do código da expressão pointcut não é diferente de outros conselhos. O que muda é o mesmo conselho que deve chamar explicitamente a execução do método através do método da classe ProceedingJoinPoint prosseguir, uma cuja aplicação é passado como entrada. Essa interface fornece também usa outros métodos proceder para recuperar informações sobre parâmetros do método, tipo de retorno eo objeto sobre o qual método é executado. É deixado para o leitor mais profundo.

Para testar os nossos conselhos que podemos fazer é escrever uma aplicação trivial da MyInterface interface, e criar um teste principais:

 MyInterfaceImpl classe implementa {public MyInterface





  



 @ Override



  



 public void f1 () {



    



 System.out.println ("F1");



  



 }





  



 @ Override



  



 public int f2 () {



    



 System.out.println ("F2");



    



 return 0;



  



 }





  



 @ Override



  



 public int f3 () throws Exception {



    



 System.out.println ("F3");



    



 throw new Exception ("Exceção F3");



  



 }





  



 @ Override



  



 f4 public void () throws Exception {



    



 System.out.println ("F4");



  



 }





  



 @ Override



  



 f5 public int () {



    



 System.out.println ("F5");



    



 return 0;



  



 }







 }

. nell'applicationContext xml:

 <-! Alvo: Object ->







 <bean id="myInterfaceImpl" class="it.mrwebmaster.aop.MyInterfaceImpl" />

O principal teste:

 public class Main {





  



 public static void main (String [] args) {





    



 / **



     



 * Instanz o container IoC



     



 * /



    



 ApplicationContext ApplicationContext ClassPathXmlApplicationContext = new ("applicationContext.xml");





    



 MyInterface MyInterface = (MyInterface) applicationContext.getBean ("myInterfaceImpl");





    



 myInterface.f1 ();



    



 System.out.println ("########## \ n ");





    



 myInterface.f2 ();



    



 System.out.println ("########## \ n ");





    



 try {



      



 myInterface.f3 ();



    



 } Catch (Exception e) {}



    



 System.out.println ("########## \ n ");





    



 try {



      



 myInterface.f4 ();



    



 } Catch (Exception e) {}



    



 System.out.println ("########## \ n ");





    



 myInterface.f5 ();



    



 System.out.println ("########## \ n ");



  



 }







 }

• <<Lição anterior
• Índice da Ajuda
• Próxima lição>>