AOP - Pomer Vytvoriť

Teraz sa pozrime, ako vytvoriť aspekt.
V prvom rade sme sa vytvoriť užívateľské rozhranie, na ktorom príklade budeme písať naše pointcuts:

 verejné rozhranie MyInterface {





  



 public void f1 ();





  



 public int f2 ();





  



 public int f3 () throws výnimkou;





  



 public void f4 () hádže výnimkou;





  



 public int f5 ();







 }

Ak chcete napísať pointcut musí poznať AspectJ pointcut označovatelé , v našich príkladoch budeme používať iba výkon, ktorý zodpovedá spojeniu metódy miesto popravy.
Formát prevedenie je výraz typu:

 



 prevedenie (modifikátory-vzor? Deklarácie pera typu, vzor typu, vzor? meno, vzor (param-pattern) hody-vzor?)

 

kde:

• modifikátory-vzor: parametrov za použitia voliteľného modifikátora určuje typ metódy. Hodnota * zodpovedá všetky typy modifikátorov.
• ret typu, vzor: znamená to, že návratový typ metódy. Hodnota * hodí ku všetkým typom návratu.
• Deklarácia typu, vzor: Voľba parametra, označuje triedu, ktorá deklaruje metódy. * Hodnota sa používa ako zástupný znak nahradiť úplne meno triedy alebo jeho časť.
• Meniny vzoru: názov metódy. * Hodnota sa používa ako zástupný znak nahradiť úplne názov metódy alebo jeho časti.
• param-vzor: označuje metódu parametrov. Value () označuje metódu, ktorá má žiadne parametre, zatiaľ čo hodnota (..) označuje metódu, ktorá prijíma nula alebo viac parametrov. * Táto hodnota je použitá ako divoká karta nahradiť typ parametra metódy, napríklad (* java.lang.String) zodpovedá metódu, ktorá berie ako vstup dva parametre v prvej akéhokoľvek typu, druhý typ String.
• hodí-vzor: voliteľný parameter udáva typ výnimka vyvolá metódou, napríklad hodí java.lang.Exception

Pre lepšie pochopenie syntaxe, začneme s príkladmi.

Najprv musíme vytvoriť vlastné hľadisko:

 @ Pomer







 {Public class MyAspect



  



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







 }

Ako vidíme, že trieda je poznámkami s @ aspektom. To nestačí, pretože musíte povoliť podporu AOP nell'applicationContext Xml.:

 <- ENBLING AspectJ ->







 <aop:aspectj-autoproxy />









 <- MYASPECT ->







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

Akonáhle ste vykonali tieto dve operácie sú pripravení vytvoriť radu, napríklad akcie vykonané pred popravou metódy F1 (predtým poradenstvo):

 @ Pred ("prevedenie (* it.mrwebmaster.aop.MyInterface.f1 (..))")







 public void beforeF1 () {



  



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







 }

Ako je vidieť z kódu sme použili @ Pred anotácia ktorý prijíma výraz ako hodnotu, ktorá identifikuje pointcut. V našom príklade výraz spĺňa všetky metódy, ktoré sa nazývajú rozhranie it.mrwebmaster.aop.MyInterface F1 indipendetemente ich modifikátory, návratový typ a vstupné parametre.
Podobne môžeme použiť radu, ktorá spustí, keď dokončí spôsob jeho vykonania (po návrate rady) správne pomocou anotácie @ AfterReturning:

 @ AfterReturning (pointcut = "prevedenie (* it.mrwebmaster.aop.MyInterface.f2 (..))", návrate =" retval ")







 public void afterReturningF2 (Object retval) {



  



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







 }

Tento záznam má nasledujúce parametre okrem pointcuts, meno danej objekt vrátený metódou, ktorá môže byť zadaný ako vstupný parameter Advaita. V tomto prípade je výraz pointcut inviarata je okrem názvu metódy, ktorý v tomto prípade, F2.
Veľmi podobná je rada, ktorá ich vykoná, keď metóda vyvolá výnimku (po hádzať rady) pomocou anotácie @ AfterThrowing:

 @ AfterThrowing (pointcut = "prevedenie (* it.mrwebmaster.aop.MyInterface.f3 (..))", hádzanie =" Throwable ")







 public void afterThrowingF3 (Throwable Throwable) {

 

  



 System.out.println ("F3 hodí" + Throwable);







 }

Rozdiel je v tom, že metóda nevracia objektu, ale výnimkou.

Ďalším typom poradenstvo je vždy vykonaný po metóde, je na čase normálne, alebo vyvolá výnimku (po konzultácii). Táto rada je realizovaný pomocou @ po:

 Po @ ("prevedenie (* it.mrwebmaster.aop.MyInterface.f4 (..))")







 public void afterF4 () {



  



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







 }

Konečne vidíme, ako urobiť "po odporúčaní:

 @ Around ("prevedenie (* it.mrwebmaster.aop.MyInterface.f5 (..))")







 public void aroundF5 (ProceedingJoinPoint PJP) {



  



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



  



 try {



    



 Objekt retval pjp.proceed = ();



    



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



  



 } Catch (Throwable e) {



    



 System.out.println ("F5 spôsobí" + e);



  



 }







 }

Ako je vidieť z kódu pointcut vyjadrenia sa nijako nelíši od iných rád. Aké zmeny je rovnaká odporúčania, ktoré musí explicitne vyvolať prevedenie metóda, metóda triedy ProceedingJoinPoint pokračovať, ktorého použitie je odovzdaný ako vstup. Toto rozhranie poskytuje tiež používa iné metódy pristúpiť na získanie informácií o spôsobe parametrov, návratový typ a objekt, na ktorom sa vykonáva metódou. To je ponechané na čitateľovi hlbšie.

Ak chcete vyskúšať naše rady, čo môžeme urobiť, je napísať triviálne implementácia rozhrania MyInterface, a vytvoriť hlavné test:

 MyInterfaceImpl {public class implementuje MyInterface





  



 @ Override



  



 public void f1 () {



    



 System.out.println ("F1");



  



 }





  



 @ Override



  



 public int f2 () {



    



 System.out.println ("F2");



    



 return 0;



  



 }





  



 @ Override



  



 public int f3 () {hádže výnimku



    



 System.out.println ("F3");



    



 throw new výnimky ("Výnimka F3");



  



 }





  



 @ Override



  



 public void f4 () {hádže výnimku



    



 System.out.println ("F4");



  



 }





  



 @ Override



  



 public int f5 () {



    



 System.out.println ("F5");



    



 return 0;



  



 }







 }

. Nell'applicationContext XML:

 <- Cieľ: Object ->







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

Hlavný test:

 {Public class Hlavné





  



 public static void main (String [] args) {





    



 / **



     



 * Instanz MOV kontajner



     



 * /



    



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



  



 }







 }

• <<Predchádzajúci lekcie
• Nápoveda Index
• Ďalšia lekcia>>