English | 简体中文 | 繁體中文 | Русский язык | Français | Español | Português | Deutsch | 日本語 | 한국어 | Italiano | بالعربية
Spring FrameworkWir empfehlen, auf der Basis von Spring 1.2Die AOP-Implementierung auf der alten Stil dtd verwendet Spring AspectJ AOP-ImplementierungEinfach zu verwenden.
Es gibt zwei Methoden, um die Spring AOP AspectJ-Implementierung zu verwenden:
Durch Annotationen: Wir werden es hier lernen. Durch xml-Konfiguration (basierend auf Schema): Wir werden es auf der nächsten Seite lernen.
Die Spring AspectJ AOP-Implementierung bietet viele Kommentare:
@Aspect Diese Klasse wird als Aspect deklariert. @Pointcut Es wird der Pointcut-Ausdruck erklärt.
Die folgenden Kommentare werden verwendet, um Bevelop zu erstellen:
@Before Es wurde der Before-Bevelop erklärt. Er wird vor dem Aufruf der tatsächlichen Methode angewendet. @After Es wurde der After-Bevelop erklärt. Er wird nach dem Aufruf der tatsächlichen Methode und vor dem Rückgabewert angewendet. @AfterReturning Es wurde der AfterReturning-Bevelop erklärt. Er wird nach dem Aufruf der tatsächlichen Methode und vor dem Rückgabewert angewendet. Aber Sie können den Wert im Bevelop erhalten. @Around Es wurde der Around-Bevelop erklärt. Er wird vor und nach dem Aufruf der tatsächlichen Methode angewendet. @AfterThrowing Es wurde der throws-Bevelop erklärt. Wenn die tatsächliche Methode eine Ausnahme auslöst, wird dieser Bevelop angewendet.
Pointcut ist eine Ausdruckslanguage von Spring AOP.
@Pointcut Kommentare werden verwendet, um Pointcut zu definieren. Wir können auch Pointcut-Ausdrücke durch Namen referenzieren. Lassen Sie uns einen einfachen Beispiel von Pointcut-Ausdruck betrachten.
@Pointcut("execution(")* Operation.*(..))")
private void doSomething() {}
Der Name des Pointcut-Ausdrucks ist doSomething(). Es wird auf alle Methoden der Operation-Klasse angewendet, egal was der Rückgabetyp ist.
Lassen Sie uns versuchen, durch folgenden Beispiel zu verstehen, wie wir切入点 Ausdrücke:
@Pointcut("execution(public * *(..))")
Es wird auf alle öffentlichen Methoden angewendet.
@Pointcut("execution(public \ Operation.*(..))")
Es wird auf alle öffentlichen Methoden der Operation-Klasse angewendet.
@Pointcut("execution(")* Operation.*(..))")
Es wird auf alle Methoden der Operation-Klasse angewendet.
@Pointcut("execution(public \ Employee.set*(..))")
Es wird auf alle öffentlichen Set-Methode der Employee-Klasse angewendet.
@Pointcut("execution(int \ Operation.*(..))")
Es wird auf alle Methoden der Operation-Klasse angewendet, die int-Werte zurückgeben.
Wenden Sie den AspectJ Before Advice vor dem tatsächlichen Geschäftslogikmethoden an. Sie können hier beliebige Aktionen ausführen, z.B. Transformation, Authentifizierung usw.
Erstellen Sie eine Klasse, die die tatsächliche Geschäftslogik enthält.
Datei: Operation.java
package com.w;3codebox;
public class Operation{
public void msg(){System.out.println("msg method invoked");}
public int m(){System.out.println("m method invoked");return 2;}
public int k(){System.out.println("k method invoked");return 3;}
}
Erstellen Sie jetzt die Aspektklasse, die vor dem Rat enthalten ist.
Datei: TrackOperation.java
package com.w;3codebox;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
@Aspect
public class TrackOperation{
@Pointcut("execution(")* Operation.*(..))")
public void k(){}//Pointcut-Name
@Before("k()")//Wenden Sie den切入点 auf die before-Benachrichtigung an
public void myadvice(JoinPoint jp)//es ist Rat (before Rat)
{
System.out.println("additional concern");
//System.out.println("Method Signature: "} + jp.getSignature());
}
}
Erstellen Sie jetzt die applicationContext.xml-Datei, die die Definition des Beans enthält.
Datei: applicationContext.xml
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd"> <bean id="opBean" class="com.w3codebox.Operation"> </bean> <bean id="trackMyBean" class="com.w3codebox.TrackOperation"></bean> <bean class="org.springframework.aop.aspectj.annotation.AnnotationAwareAspectJAutoProxyCreator"></bean> </beans>
Nun, nennen wir das tatsächliche Verfahren.
Datei: Test.java
package com.w;3codebox;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Test{
public static void main(String[] args){
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
Operation e = (Operation) context.getBean("opBean");
System.out.println("calling msg...");
e.msg();
System.out.println("Aufruf von m...");
e.m();
System.out.println("Aufruf von k...");
e.k();
}
}
Ausgabe
Aufruf von msg... Zusätzliche Bedenken msg() Methode aufgerufen Aufruf von m... Zusätzliche Bedenken m() Methode aufgerufen Aufruf von k... Zusätzliche Bedenken k() Methode aufgerufen
Wie Sie sehen können, treten vor dem Aufruf der Methoden msg(), m() und k() auch andere Probleme auf.
Jetzt, wenn Sie den Pointcut-Ausdruck wie folgt ändern:
@Pointcut("execution(")* Operation.m*(..))")
Jetzt, konzentrieren wir uns mehr auf die Methoden, die mit m beginnen, in der Klasse Operation. Die Ausgabe wird wie folgt sein:
Aufruf von msg... Zusätzliche Bedenken msg() Methode aufgerufen Aufruf von m... Zusätzliche Bedenken m() Methode aufgerufen Aufruf von k... k() Methode aufgerufen
Jetzt können Sie sehen, dass vor dem Aufruf der Methode k() keine anderen Probleme gedruckt werden.
Nach dem Aufruf der tatsächlichen Geschäftslogikmethode wird der AspectJ nach dem Anwenden des after-Rats angewendet. Es kann verwendet werden, um Protokolle, Sicherheit, Benachrichtigungen usw. zu warten.
Hier gehen wir davon aus Operation.java ， applicationContext.xml und Test.java Die Datei ist mit der im Beispiel @Before angegebenen Datei identisch.
package com.w;3codebox;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Pointcut;
@Aspect
public class TrackOperation{
@Pointcut("execution(")* Operation.*(..))")
public void k(){}//Pointcut-Name
@After("k()")//Anwendung von Pointcut auf nach Rat
public void myadvice(JoinPoint jp)//es ist Rat (nach Rat)
{
System.out.println("additional concern");
//System.out.println("Method Signature: "} + jp.getSignature());
}
}
Ausgabe
Aufruf von msg... msg() Methode aufgerufen Zusätzliche Bedenken Aufruf von m... m() Methode aufgerufen Zusätzliche Bedenken Aufruf von k... k() Methode aufgerufen Zusätzliche Bedenken
Sie können sehen, dass nach dem Aufruf der Methoden msg(), m() und k() auch andere Probleme auftreten.
Durch die Verwendung nach dem Rückgaberat können wir das Ergebnis im Rat erhalten.
Erstellen Sie die Klasse, die die folgenden Inhalte enthält.
Datei: Operation.java
package com.w;3codebox;
public class Operation{
public int m(){System.out.println("m() Methode aufgerufen");return 2;}
public int k(){System.out.println("k() Methode aufgerufen");return 3;}
}
Erstellen Sie die Klasse, die nach dem Erstellen des Rückgaberates enthalten ist.
Datei: TrackOperation.java
package com.w;3codebox;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Aspect;
@Aspect
public class TrackOperation{
@AfterReturning(
pointcut = "execution(* Operation.*(..))",
returning= "result")
public void myadvice(JoinPoint jp, Object result)//es ist Rat (nach Rückgabe des Rates)
{
System.out.println("additional concern");
System.out.println("Method Signature: "} + jp.getSignature());
System.out.println("Rückgabeergebnis in Rat: ")+result)}
System.out.println("Ende der nach dem Rückgabeadvice...");
}
}
Datei: applicationContext.xml
entsprechend dem Beispiel von @Before
Datei: Test.java
Nun wird die Test-Klasse erstellt, die die tatsächlichen Methoden aufruft.
package com.w;3codebox;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Test{
public static void main(String[] args){
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
Operation e = (Operation) context.getBean("opBean");
System.out.println("Aufruf von m...");
System.out.println(e.m());
System.out.println("Aufruf von k...");
System.out.println(e.k());
}
}
Ausgabe
Aufruf von m... m() Methode aufgerufen Zusätzliche Bedenken Methodensignatur: int com.w3codebox.Operation.m() Ergebnis im Advice: 2 Ende der nach dem Rückgabeadvice... 2 Aufruf von k... k() Methode aufgerufen Zusätzliche Bedenken Methodensignatur: int com.w3codebox.Operation.k() Ergebnis im Advice: 3 Ende der nach dem Rückgabeadvice... 3
Sie können sehen, dass der Rückgabewert zweimal gedruckt wurde, einmal vom TrackOperation-Klasse und zweimal von der Test-Klasse.
Umgebender AspectJ wird vor und nach dem Aufruf der tatsächlichen Geschäftslogikmethode angewendet.
Hier gehen wir davon aus applicationContext.xml Die Datei ist mit der im Beispiel @Before angegebenen Datei identisch.
Erstellen Sie eine Klasse, die die tatsächliche Geschäftslogik enthält.
Datei: Operation.java
package com.w;3codebox;
public class Operation{
public void msg(){System.out.println("msg() ist aufgerufen");}
public void display(){System.out.println("display() ist aufgerufen");}
}
Erstellen Sie eine Klasse, die die umschließende Aspektklasse enthält.
Sie müssen es im Advice-Methodenaufruf übergeben PreceedingJoinPoint Verweis, damit wir den Anruf der Methode request() durch Ausführen von proce durchführen können.
Datei: TrackOperation.java
package com.w;3codebox;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
@Aspect
public class TrackOperation
{
@Pointcut("execution(")* Operation.*(..))")
public void abcPointcut(){}
@Around("abcPointcut()")
public Object myadvice(ProceedingJoinPoint pjp) throws Throwable
{
System.out.println("Zusätzlicher Bedenken vor dem Aufruf der tatsächlichen Methode");
Object obj = pjp.proceed();
System.out.println("Zusätzlicher Bedenken nach dem Aufruf der tatsächlichen Methode");
return obj;
}
}
Datei: Test.java
Nun wird die Test-Klasse erstellt, die die tatsächlichen Methoden aufruft.
package com.w;3codebox;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Test{
public static void main(String[] args){
ApplicationContext context = new classPathXmlApplicationContext("applicationContext.xml");
Operation op = (Operation) context.getBean("opBean");
op.msg();
op.display();
}
}
Ausgabe
Zusätzlicher Bedenken vor dem Aufruf der tatsächlichen Methode msg() wird aufgerufen Zusätzlicher Bedenken nach dem Aufruf der tatsächlichen Methode Zusätzlicher Bedenken vor dem Aufruf der tatsächlichen Methode display() wird aufgerufen Zusätzlicher Bedenken nach dem Aufruf der tatsächlichen Methode
Sie können sehen, dass vor und nach dem Aufruf von msg() und dem Anzeigen von Methoden auch andere Fragen ausgegeben werden.
Durch die Verwendung des AfterThrowing-Ratschlags können wir im TrackOperation-Klasse Ausnahmen ausgeben. Lassen Sie uns ein Beispiel für den AspectJ AfterThrowing-Ratschlag sehen.
Erstellen Sie eine Klasse, die die Geschäftslogik enthält.
Datei: Operation.java
package com.w;3codebox;
public class Operation{
public void validate(int age) throws Exception{
if(age<18){
throw new ArithmeticException("Ungültiges Alter");
}
else{
System.out.println("Vielen Dank für die Abstimmung");
}
}
}
Erstellen Sie eine Aspect-Klasse, die nach dem Auswerfen des Rates enthalten ist.
Hier müssen wir auch den Referenz von Throwable übergeben, damit wir die Ausnahme hier abfangen können.
Datei: TrackOperation.java
package com.w;3codebox;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Aspect;
@Aspect
public class TrackOperation{
@AfterThrowing(
pointcut = "execution(* Operation.*(..))",
throwing = "error")
public void myadvice(JoinPoint jp, Throwable error)//es ist Rat
{
System.out.println("additional concern");
System.out.println("Method Signature: "} + jp.getSignature());
System.out.println("Exception is: "}+error);
System.out.println("end of after throwing advice...");
}
}
Datei: applicationContext.xml
entsprechend dem Beispiel von @Before
Datei: Test.java
Nun wird die Test-Klasse erstellt, die die tatsächlichen Methoden aufruft.
package com.w;3codebox;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Test{
public static void main(String[] args){
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
Operation op = (Operation) context.getBean("opBean");
System.out.println("validate aufrufen...");
try{
op.validate(19);
}catch(Exception e){System.out.println(e);}
System.out.println("validate erneut aufrufen...");
try{
op.validate(11);
}catch(Exception e){System.out.println(e);}
}
}
Ausgabe
validate aufrufen... Vielen Dank für die Stimme validate erneut aufrufen... Zusätzliche Bedenken Methodensignatur: void com.w3codebox.Operation.validate(int) Ausnahme ist: java.lang.ArithmeticException: Ungültiges Alter Ende des After-Throwing-Ratschlags... java.lang.ArithmeticException: Ungültiges Alter