AOP - Aspecto Crear

Ahora vamos a ver cómo crear un aspecto.
En primer lugar, creamos una interfaz en la que el ejemplo vamos a escribir nuestros puntos de corte:

 pública MyInterface interfaz {





  



 public void f1 ();





  



 public int f2 ();





  



 public int f3 () throws Exception;





  



 f4 public void () throws Exception;





  



 f5 public int ();







 }

Para escribir un punto de corte debe conocer los designadores de AspectJ punto de corte , en nuestro ejemplo vamos a utilizar sólo la ejecución que coincide con el punto de unirse a los métodos de ejecución.
El formato de la ejecución es una expresión del tipo:

 



 ejecución (modificadores de patrón? Declarar ret-tipo-modelo-tipo de patrón? nombre de patrón (param-patrón) lanza-patrón?)

 

donde:

• modificadores de patrón: los parámetros, aplicando el modificador opcional indica el tipo de método. * El valor coincide con todos los tipos de modificadores.
• ret tipo de patrón: indica el tipo de retorno del método. * El valor coincide con todos los tipos de cambio.
• La declaración de tipo de patrón: el parámetro de opción, indica la clase que declara el método. * El valor se utiliza como un comodín para reemplazar por completo el nombre de clase o parte de ella.
• el nombre de patrón: el nombre del método. * El valor se utiliza como un comodín para reemplazar por completo el nombre del método o parte de ella.
• param-patrón: indica los parámetros del método. El valor de () indica un método que no toma parámetros, mientras que el valor (..) indica un método que acepta cero o más parámetros. * El valor se utiliza como un comodín para sustituir el parámetro de tipo de un método, por ejemplo (*, java.lang.String) coincide con un método que toma como entrada dos parámetros en la primera de cualquier tipo, el segundo tipo cadena.
• lanza-patrón: parámetro opcional indica el tipo de excepción que se produce por el método, por ejemplo, lanza java.lang.Exception

Para entender mejor la sintaxis, se comienza con ejemplos.

En primer lugar tenemos que crear nuestro propio aspecto:

 @ Aspecto







 {Public MyAspect clase



  



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







 }

Como vemos, la clase está anotado con @ aspecto. Esto no es suficiente porque hay que activar el soporte de AOP nell'applicationContext Xml.:

 <-! ENBLING AspectJ ->







 <aop:aspectj-autoproxy />









 <-! MYASPECT ->







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

Una vez realizadas estas dos operaciones están dispuestos a crear un consejo, por ejemplo, una acción realizada antes de la ejecución de la f1 método (antes consejo):

 @ Antes ("ejecución (* it.mrwebmaster.aop.MyInterface.f1 (..))")







 beforeF1 public void () {



  



 System.out.println ("Antes de F1");







 }

Como puede verse en el código que utiliza la anotación @ Antes de que acepta una expresión como un valor que identifica un punto de corte. En nuestro ejemplo, la expresión coincide con todos los métodos que se denominan interfaz it.mrwebmaster.aop.MyInterface f1 indipendetemente por sus modificadores, tipo de retorno y parámetros de entrada.
Del mismo modo se puede utilizar un consejo que se ejecuta cuando un método termina su ejecución (después de volver asesoramiento) el uso correcto de la anotación @ AfterReturning:

 @ AfterReturning punto de corte (= "La ejecución (* it.mrwebmaster.aop.MyInterface.f2 (..))", volver =" retval ")







 afterReturningF2 public void (Object retval) {



  



 System.out.println ("retorno F2" + retval);







 }

Este registro tiene los siguientes parámetros, además de los puntos de corte, el nombre dado al objeto devuelto por el método que se puede dar como parámetro de entrada de Advaita. En este caso la expresión del punto de corte es inviarata excepto por el nombre del método, que en este caso, f2.
Muy similar es el consejo que se ejecuta cuando un método lanza una excepción (después de lanzar consejo) se usa la anotación @ AfterThrowing:

 @ AfterThrowing punto de corte (= "La ejecución (* it.mrwebmaster.aop.MyInterface.f3 (..))", tirar =" arrojadiza ")







 public void afterThrowingF3 (Throwable arrojadizas) {

 

  



 System.out.println ("F3 lanza" + arrojadizas);







 }

La diferencia es que el método no devuelve un objeto sino una excepción.

Otro tipo de consejos se ejecuta siempre después de un método, es el momento con normalidad o se produce una excepción (previa consulta). Este consejo se aplica mediante el uso de @ Después:

 Después de @ ("ejecución (* it.mrwebmaster.aop.MyInterface.f4 (..))")







 afterF4 public void () {



  



 System.out.println ("después de F4");







 }

Finalmente podemos ver cómo hacer que el "todo consejo:

 @ Around ("ejecución (* it.mrwebmaster.aop.MyInterface.f5 (..))")







 public void aroundF5 (ProceedingJoinPoint PJP) {



  



 System.out.println ("Antes de F5");



  



 try {



    



 Objeto retval = pjp.proceed ();



    



 System.out.println ("F5 VOLVER" + retval);



  



 } Catch (Throwable e) {



    



 System.out.println ("F5 lanza" + e);



  



 }







 }

Como podemos ver en el código de la expresión de punto de corte no es diferente de otros consejos. Lo que cambia es el mismo consejo que debe invocar explícitamente a la ejecución del método a través del método de la clase ProceedingJoinPoint proceder, cuya aplicación se pasa como entrada. Esta interfaz proporciona también utiliza otros métodos de proceder para recuperar información sobre los parámetros del método, el tipo de cambio y el objeto sobre el método que se ejecuta. Se deja al lector más profundo.

Para poner a prueba nuestros consejos que podemos hacer es escribir una implementación trivial de la MyInterface interfaz, y crear una prueba principal:

 MyInterfaceImpl {public class 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 ("Excepción F3");



  



 }





  



 @ Override



  



 f4 public void () throws Exception {



    



 System.out.println ("F4");



  



 }





  



 @ Override



  



 f5 public int () {



    



 System.out.println ("F5");



    



 return 0;



  



 }







 }

. nell'applicationContext xml:

 <- Objetivo: Object ->







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

La prueba principal:

 público principal la clase {





  



 public static void main (String [] args) {





    



 / **



     



 * Instanz el COI contenedor



     



 * /



    



 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 ");



  



 }







 }

• <<Lección anterior
• Índice de la ayuda
• Lección siguiente>>