AOP - Aspect Créer

Maintenant, nous allons voir comment créer un aspect.
Tout d'abord, nous créons une interface sur laquelle l'exemple, nous allons écrire notre pointcuts:

 public interface MyInterface {





  



 public void f1 ();





  



 public int f2 ();





  



 public int f3 () throws Exception;





  



 f4 public void () throws Exception;





  



 publique f5 int ();







 }

Pour écrire un pointcut doit connaître les désignateurs AspectJ pointcut , dans nos exemples, nous allons utiliser l'exécution seule qui correspond à l'exécution de méthodes de jointure point.
Le format de l'exécution est une expression du type:

 



 exécution (modificateurs-modèle? Déclarer ret de type-modèle-type-modèle? nom-motif (pattern-param) throws-modèle?)

 

où:

• modificateurs-modèle: les paramètres en appliquant le modificateur facultatif indique le type de méthode. La valeur * correspond à tous les types de modificateurs.
• ret-type-modèle: il indique le type de retour de méthode. La valeur * correspond à tous les types de retour.
• Déclarant type-modèle: le paramètre option, indique la classe qui déclare la méthode. * La valeur est utilisée comme un joker pour remplacer entièrement le nom de classe ou d'une partie de celui-ci.
• nom-motif: le nom de la méthode. * La valeur est utilisée comme un joker pour remplacer entièrement le nom de la méthode ou d'une partie de celui-ci.
• param-modèle: indique les paramètres du procédé. La valeur () indique une méthode qui ne prend aucun paramètre, alors que la valeur (..) indique une méthode qui accepte de zéro ou plusieurs paramètres. * La valeur est utilisée comme un joker pour remplacer le paramètre de type d'une méthode, par exemple (*, java.lang.String) correspond à une méthode qui prend en entrée deux paramètres dans le premier de tout type, le deuxième type String.
• jette-modèle: paramètre optionnel indique le type d'exception levée par la méthode, par exemple, jette java.lang.Exception

Afin de mieux comprendre la syntaxe, nous commençons avec des exemples.

D'abord nous devons créer notre propre aspect:

 @ Aspect







 {Public class MyAspect



  



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







 }

Comme on le voit la classe est annotée avec @ Aspect. Ce n'est pas suffisant parce que vous devez activer le support pour les AOP nell'applicationContext Xml.:

 <! - ENBLING AspectJ ->







 <aop:aspectj-autoproxy />









 <! - MYASPECT ->







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

Une fois que vous avez fait ces deux opérations sont prêts à créer un conseil, par exemple, une action réalisée avant l'exécution de la méthode de F1 (avant les conseils):

 @ Avant («exécution (* it.mrwebmaster.aop.MyInterface.f1 (..))")







 beforeF1 public void () {



  



 System.out.println ("Avant la F1");







 }

Comme peut être vu à partir du code, nous avons utilisé l'annotation @ Avant qui accepte une expression comme une valeur qui identifie un point de coupure. Dans notre exemple, l'expression correspond à toutes les méthodes qui sont appelées interfaces it.mrwebmaster.aop.MyInterface f1 indipendetemente par leurs modificateurs, type de retour et les paramètres d'entrée.
De même, nous pouvons utiliser un conseil qui s'exécute lorsque une méthode complète de son exécution (après le retour de conseils) correctement en utilisant l'annotation @ AfterReturning:

 @ AfterReturning pointcut (= "l'exécution (* it.mrwebmaster.aop.MyInterface.f2 (..))", retour =" retVal ")







 afterReturningF2 public void (Object retVal) {



  



 System.out.println ("retour sur F2" + retval);







 }

Cet enregistrement prend les paramètres suivants, en plus de pointcuts, le nom donné à l'objet retourné par la méthode qui peut être donné comme paramètre d'entrée de l'Advaita. Dans ce cas, l'expression de la pointcut est inviarata sauf pour le nom de la méthode, qui dans ce cas, f2.
Très semblable est le conseil qui est exécuté quand une méthode lève une exception (après avoir jeté des conseils) en utilisant l'annotation @ AfterThrowing:

 @ AfterThrowing pointcut (= "l'exécution (* it.mrwebmaster.aop.MyInterface.f3 (..))", jeter =" Throwable ")







 public void afterThrowingF3 (Throwable Throwable) {

 

  



 System.out.println ("F3 jette" + Throwable);







 }

La différence est que la méthode ne retourne pas un objet mais une exception.

Un autre type de conseil est toujours exécuté après une méthode, il est temps normalement ou lève une exception (après avis). Ce conseil est mis en œuvre grâce à l'utilisation de @ Après:

 @ Après ("exécution (* it.mrwebmaster.aop.MyInterface.f4 (..))")







 afterF4 public void () {



  



 System.out.println ("Après F4»);







 }

Enfin, nous voyons comment faire de la 'autour conseil:

 Autour @ («exécution (* it.mrwebmaster.aop.MyInterface.f5 (..))")







 public void aroundF5 (ProceedingJoinPoint PJP) {



  



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



  



 try {



    



 Objet retval = pjp.proceed ();



    



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



  



 } Catch (Throwable e) {



    



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



  



 }







 }

Comme nous pouvons le voir dans le code de l'expression pointcut n'est pas différent de d'autres conseils. Ce qui change est le même conseil qui doit invoquer explicitement l'exécution de la méthode par la méthode de la classe ProceedingJoinPoint procéder, celui dont la demande est transmis en entrée. Cette interface fournit aussi utilise d'autres méthodes procéder à récupérer des informations sur les paramètres de méthode, type de retour et l'objet sur lequel la méthode est exécutée. Il est laissé au lecteur plus profondément.

Pour tester nos conseils, nous pouvons faire est d'écrire une application triviale de la MyInterface interface et créer un test principaux:

 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 ("Exception F3");



  



 }





  



 @ Override



  



 f4 public void () throws Exception {



    



 System.out.println ("F4");



  



 }





  



 @ Override



  



 publique f5 int () {



    



 System.out.println ("F5");



    



 return 0;



  



 }







 }

. nell'applicationContext xml:

 <! - Target: Object ->







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

Le critère principal:

 public class Principal {





  



 public static void main (String [] args) {





    



 / **



     



 * Instanz le conteneur 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 ");



  



 }







 }

• <<Leçon précédente
• Index de l'aide
• Leçon suivante>>