AOP - Aspect erstellen

Nun wollen wir sehen, wie man einen Aspekt zu schaffen.
Zuerst erstellen wir eine Schnittstelle auf dem das Beispiel wir unsere Pointcuts schreiben wird:

 public interface MyInterface {





  



 public void f1 ();





  



 public int f2 ();





  



 public int f3 () throws Exception;





  



 public void f4 () throws Exception;





  



 public int f5 ();







 }

So schreiben Sie eine Pointcut müssen wissen, die AspectJ Pointcut designators , in unseren Beispielen werden wir nur die Ausführung, dass die Join Points Ausführungsmethoden Spielen verwenden.
Das Format der Ausführung ist ein Ausdruck der Art:

 



 Ausführung (Modifikatoren-Muster? deklarieren ret-Typ-Muster-Typ-Muster? name-Muster (param-pattern) throws-Muster?)

 

wo:

• Modifikatoren-pattern: Parameter durch die Anwendung des optionalen Modifier gibt die Art des Verfahrens. Der Wert * entspricht allen Arten von Modifikatoren.
• ret-Typ-Muster: Es gibt den Rückgabetyp der Methode. Der Wert * entspricht allen Arten von zurückzukehren.
• Deklarieren-Typ-Muster: die Möglichkeit, Parameter, zeigt die Klasse, die die Methode deklariert. * Der Wert wird als eine Wild Card vollständig ersetzt den Namen der Klasse oder einen Teil davon verwendet.
• name-Muster: der Name der Methode. * Der Wert wird als eine Wild Card vollständig ersetzt den Namen der Methode oder einen Teil davon verwendet.
• param-pattern: zeigt die Parameter der Methode. Der Wert () gibt eine Methode, die keine Parameter übernimmt, während der Wert (..) gibt eine Methode, die keine oder mehrere Parameter zu akzeptieren. * Der Wert wird als Joker eingesetzt, um den Typ Parameter einer Methode, zum Beispiel (*, java.lang.String) ersetzen Spielen eine Methode, die als Input nimmt zwei Parameter in der ersten jeglicher Art, die zweite Art String.
• wirft-pattern: optionale Parameter gibt den Typ der Ausnahme von der Methode ausgelöst, zum Beispiel, wirft java.lang.Exception

Zum besseren Verständnis der Syntax, beginnen wir mit Beispielen.

Zuerst müssen wir unsere eigenen Aspekt:

 @ Aspect







 {Public class MyAspect



  



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







 }

Wie wir sehen die Klasse mit @ Aspect. Dies ist nicht genug, weil Sie um Unterstützung für AOP nell'applicationContext Xml ermöglichen haben.:

 <-! ENBLING AspectJ ->







 <aop:aspectj-autoproxy />









 <-! MYASPECT ->







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

Sobald Sie haben diese beiden Vorgänge sind bereit, einen Rat zu schaffen, zum Beispiel eine Klage vor dem Ablauf des Verfahrens f1 (vor Beratung) durchgeführt:

 @ Before ("execution (* it.mrwebmaster.aop.MyInterface.f1 (..))")







 public void beforeF1 () {



  



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







 }

Wie aus dem Code ersichtlich benutzten wir die @ Before Annotation, die einen Ausdruck als Wert, der einen Pointcut identifiziert akzeptiert. In unserem Beispiel entspricht dem Ausdruck alle Methoden, die aufgerufen Schnittstelle it.mrwebmaster.aop.MyInterface f1 indipendetemente zeichnen sich durch ihre Modifikatoren, Rückgabetyp und Input-Parameter.
Ebenso können wir eine Empfehlung, dass, wenn eine Methode ihrer Ausführung (nach der Rückkehr Beratung) korrekt mit der Annotation @ AfterReturning vervollständigt ausführt:

 @ AfterReturning (Pointcut = "Ausführung (* it.mrwebmaster.aop.MyInterface.f2 (..))", zurück =" retVal ")







 public void afterReturningF2 (Object retVal) {



  



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







 }

Dieser Rekord nimmt die folgenden Parameter, zusätzlich zu Pointcuts, kehrte der Name für das Objekt durch die Methode, die als Input-Parameter von Advaita gegeben werden kann. In diesem Fall ist der Ausdruck der Pointcut ist inviarata außer den Namen der Methode, die in diesem Fall, f2.
Sehr ähnlich ist die Beratung, die ausgeführt werden, wenn eine Methode löst eine Ausnahme (nach dem Werfen Beratung) über die Annotation @ AfterThrowing ist:

 @ AfterThrowing (Pointcut = "Ausführung (* it.mrwebmaster.aop.MyInterface.f3 (..))", werfen =" throwable ")







 public void afterThrowingF3 (Throwable Throwable) {

 

  



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







 }

Der Unterschied ist, dass die Methode nicht ein Objekt zurückgeben, aber eine Ausnahme.

Eine andere Art von Beratung wird immer ausgeführt, nach einer Methode ist es in der Regel bis zum Ende oder eine Ausnahme auslöst (nach Beratung). Diese Beratung wird durch die Verwendung von @ Nach implementiert:

 @ After ("execution (* it.mrwebmaster.aop.MyInterface.f4 (..))")







 public void afterF4 () {



  



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







 }

Schließlich sehen wir, wie man die "rund um Ratschläge zu machen:

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







 public void aroundF5 (ProceedingJoinPoint PJP) {



  



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



  



 try {



    



 Object retVal = pjp.proceed ();



    



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



  



 } Catch (Throwable e) {



    



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



  



 }







 }

Wie wir aus dem Code des Pointcut Ausdruck kann sehen, ist nicht anders als andere Ratschläge. Welche Veränderungen wird die gleichen Ratschläge, die explizit aufrufen müssen die Ausführung der Methode durch die Methode der Klasse ProceedingJoinPoint gehen, einer, dessen Anwendung als Eingabe übergeben. Diese Schnittstelle bietet auch anderen Zwecken Methoden vorgehen, um Informationen über Methodenparameter, Rückgabetyp und die Aufgabe, die Methode wird ausgeführt, abrufen. Es ist dem Leser einen tieferen links.

Um zu testen, unsere Ratschläge können wir tun, ist schreiben Sie eine triviale Implementierung der Schnittstelle MyInterface, und erstellen Sie eine Hauptprüfung:

 MyInterfaceImpl {public-Klasse implementiert 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



  



 public void f4 () throws Exception {



    



 System.out.println ("F4");



  



 }





  



 @ Override



  



 public int f5 () {



    



 System.out.println ("F5");



    



 return 0;



  



 }







 }

. nell'applicationContext xml:

 <-! Target: Object ->







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

Der wichtigste Test:

 public class main {





  



 public static void main (String [] args) {





    



 / **



     



 * Instanz des IOC-Container



     



 * /



    



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



  



 }







 }

• <<Zurück Lektion
• Hilfe-Index
• Nächste Lektion>>