AOP - Aspect Skapa

Låt oss nu se hur man skapar en aspekt.
Först skapar vi ett gränssnitt som exempel ska vi skriva till vår pointcuts:

 public interface MyInterface {





  



 public void f1 ();





  



 public int f2 ();





  



 public int f3 () kastar undantag;





  



 public void f4 () kastar undantag;





  



 public int F5 ();







 }

Att skriva en pointcut måste veta AspectJ pointcut beteckningar , i våra exempel kommer vi att använda enbart utförande som matchar ansluta metoder punkten utförande.
Formatet på utförandet är ett uttryck av typen:

 



 utförande (modifierare-mönster? Deklarera RET-type-mönster-type-mönster? namn-mönster (para-mönster) kastar-mönster?)

 

där:

• modifierare-mönster: parametrar genom att de tillämpar de frivilliga modifierare anger vilken typ av metod. Värdet * matchar alla typer av modifierare.
• RET-type-mönster: det visar den avkastning typ av metod. Värdet * matchar alla typer av avkastning.
• Deklarera-type-mönster: alternativet parametern anger den klass som deklarerar metoden. * Värdet används som ett wild card till helt ersätta klassnamnet eller del av den.
• namn-mönster: namnet på metoden. * Värdet används som ett wild card till helt ersätta namnet på metoden eller del av den.
• param-mönster: anges metod parametrar. Värdet () anger en metod som tar några parametrar, medan värdet (..) anger en metod som accepterar noll eller flera parametrar. * Värdet används som ett wild card för att ersätta den type-parametern för en metod, till exempel (*, java.lang.String) matchar en metod som tar som indata två parametrar i den första av något slag, den andra typen String.
• kastar-mönster: valfri parameter anger vilken typ av undantag som kastas av metoden, till exempel, kastar java.lang.Exception

För att bättre förstå syntaxen, börjar vi med exempel.

Först måste vi skapa vår egen aspekt:

 @ Aspect







 {Public class MyAspect



  



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







 }

Som vi ser klassen är kommenterad med @ Aspect. Detta är inte tillräckligt eftersom du måste aktivera stöd för AOP nell'applicationContext XML.:

 <-! ENBLING AspectJ ->







 <aop:aspectj-autoproxy />









 <-! MYASPECT ->







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

När du har gjort dessa två operationer är redo att skapa ett råd, till exempel en åtgärd som utförs före verkställandet av metoden f1 (före råd):

 @ Före ("utförande (* it.mrwebmaster.aop.MyInterface.f1 (..))")







 public void beforeF1 () {



  



 System.out.println ("FÖRE F1");







 }

Som framgår av den kod vi använde @ Innan anteckning som accepterar ett uttryck som ett värde som identifierar en pointcut. I vårt exempel matchar uttrycket alla metoder som kallas gränssnitt it.mrwebmaster.aop.MyInterface F1 indipendetemente av deras modifierare, returtyp och parametrar ingång.
Likaså kan vi använda ett råd som körs när en metod slutför genomförandet (efter att ha återvänt råd) korrekt med hjälp av anteckningar @ AfterReturning:

 @ AfterReturning (pointcut = "utförande (* it.mrwebmaster.aop.MyInterface.f2 (..))", tillbaka =" retVal ")







 public void afterReturningF2 (Object retVal) {



  



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







 }

Detta rekord tar följande parametrar, utöver pointcuts, återvände namnet på det objekt enligt den metod som kan ges som input parameter för Advaita. I detta fall ett uttryck för pointcut är inviarata utom namnet av metoden, som i detta fall, F2.
Mycket liknande är det råd som körs när en metod som ger ett undantag (efter att kasta råd) med anteckning @ AfterThrowing:

 @ AfterThrowing (pointcut = "utförande (* it.mrwebmaster.aop.MyInterface.f3 (..))", kastar =" Throwable ")







 public void afterThrowingF3 (Throwable Throwable) {

 

  



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







 }

Skillnaden är att metoden inte returnerar ett objekt, men ett undantag.

En annan typ av rådgivning alltid sker efter en metod, är det dags normalt eller kastar ett undantag (efter råd). Detta råd har genomförts med hjälp av @ Efter:

 @ Efter ("utförande (* it.mrwebmaster.aop.MyInterface.f4 (..))")







 public void afterF4 () {



  



 System.out.println ("EFTER F4");







 }

Slutligen ser vi hur man gör "omkring råd:

 @ Around ("utförande (* it.mrwebmaster.aop.MyInterface.f5 (..))")







 public void aroundF5 (ProceedingJoinPoint PJP) {



  



 System.out.println ("FÖRE F5");



  



 try {



    



 Objekt retVal = pjp.proceed ();



    



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



  



 } Catch (Throwable e) {



    



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



  



 }







 }

Som vi kan se koden för pointcut uttryck skiljer sig inte från andra råd. Vilka förändringar är samma råd som uttryckligen måste åberopa verkställandet av metoden genom den metoden i klassen ProceedingJoinPoint gå vidare, en vars ansökan skickas som indata. Detta gränssnitt ger också använder andra metoder fortsätta att hämta information om metoden parametrar, returtyp och objektet på vilken metod som exekveras. Det är upp till läsaren något djupare.

För att testa våra råd vi kan göra är att skriva en trivial genomförandet av gränssnittet MyInterface och skapa en viktig test:

 MyInterfaceImpl {public klass implementerar MyInterface





  



 @ Åsidosätt



  



 public void f1 () {



    



 System.out.println ("F1");



  



 }





  



 @ Åsidosätt



  



 public int f2 () {



    



 System.out.println ("F2");



    



 återvända 0;



  



 }





  



 @ Åsidosätt



  



 public int f3 () kastar undantag {



    



 System.out.println ("F3");



    



 kasta nytt undantag ("Exception F3");



  



 }





  



 @ Åsidosätt



  



 public void f4 () kastar undantag {



    



 System.out.println ("F4");



  



 }





  



 @ Åsidosätt



  



 public int F5 () {



    



 System.out.println ("F5");



    



 återvända 0;



  



 }







 }

. nell'applicationContext xml:

 <-! Target: Object ->







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

De viktigaste test:

 public class Huvudnamnrymden {





  



 public void main (String [] args) {





    



 / **



     



 * Instanz IOK behållaren



     



 * /



    



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



  



 }







 }

• <<Föregående lektion
• Hjälp Index
• Nästa lektion>>