English | 简体中文 | 繁體中文 | Русский язык | Français | Español | Português | Deutsch | 日本語 | 한국어 | Italiano | بالعربية
Cadre SpringNous vous recommandons d'utiliser Spring 1.2Utilisé sur l'implémentation AOP de l'ancien style dtd Implémentation Spring AspectJ AOPFacile à utiliser.
Il y a deux méthodes pour utiliser l'implémentation Spring AOP AspectJ:
Par annotation: nous allons l'apprendre ici. Par configuration xml (basé sur le schéma): nous allons l'apprendre sur la page suivante.
L'implémentation Spring AspectJ AOP fournit de nombreuses annotations:
@Aspect Déclarer cette classe en tant que aspect. @Pointcut Déclarer l'expression de pointcut.
Les annotations utilisées pour créer les avis sont les suivantes:
@Before Déclaré l'avis avant. Il est appliqué avant l'appel de la méthode réelle. @After Déclaré l'avis après. Il est appliqué après l'appel de la méthode réelle et avant le retour de la valeur. @AfterReturning Déclaré l'avis après le retour. Il est appliqué après l'appel de la méthode réelle et avant le retour de la valeur. Mais vous pouvez obtenir la valeur de retour dans l'avis. @Around Déclaré l'avis autour. Il est appliqué avant et après l'appel de la méthode réelle. @AfterThrowing Déclaré l'avis throws. S'il y a une exception levée par la méthode réelle, cette méthode est appliquée.
L'expression de pointcut est une langue d'expression de Spring AOP.
@Pointcut Les commentaires sont utilisés pour définir les expressions de pointcut. Nous pouvons également faire référence aux expressions de pointcut par leur nom. regardons un exemple simple d'expression de pointcut.
@Pointcut("execution(")* Opération.*(..))")
private void doSomething() {}
Le nom de l'expression de pointcut est doSomething(). Peu importe le type de retour, elle s'appliquera à toutes les méthodes de la classe Operation.
Essayons de comprendre l'expression de pointcut à travers l'exemple suivant:
@Pointcut("execution(public * *(..))")
Cela s'appliquera à toutes les méthodes public.
@Pointcut("execution(public \ Operation.*(..))")
Cela s'appliquera à toutes les méthodes public de la classe Operation.
@Pointcut("execution(")* Opération.*(..))")
Cela s'appliquera à toutes les méthodes de la classe Operation.
@Pointcut("execution(public \ Employee.set*(..))")
Cela s'appliquera à toutes les méthodes public de la classe Employee.
@Pointcut("execution(int \ Operation.*(..))")
Il sera appliqué à toutes les méthodes de la classe Operation retournant int.
Appliquer l'Advice Before AspectJ avant la logique métier réelle. Vous pouvez effectuer toute action ici, par exemple la conversion, l'authentification, etc.
创建一个包含实际业务逻辑的类。
Fichier: Operation.java
package com.w;3codebox;
public class Operation{
public void msg(){System.out.println("msg méthode invoquée");}
public int m(){System.out.println("m méthode invoquée");return 2;}
public int k(){System.out.println("k méthode invoquée");return 3;}
}
Maintenant, créez une classe aspect incluse dans le conseil.
Fichier: 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(")* Opération.*(..))")
public void k(){}//nom du pointcut
@Before("k()")//Appliquer le point d'interception sur l'avis avant
public void myadvice(JoinPoint jp)//c'est une conseil (conseil avant)
{
System.out.println("concern supplémentaire");
//System.out.println("Signature de la méthode: "} + jp.getSignature());
}
}
Maintenant, créez le fichier applicationContext.xml définissant le bean.
Fichier: 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>
Maintenant, appelons la méthode réelle.
Fichier: 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("appelant msg...");
e.msg();
System.out.println("calling m...");
e.m();
System.out.println("calling k...");
e.k();
}
}
Sortie
calling msg... concern supplémentaire msg() method invoked calling m... concern supplémentaire m() method invoked calling k... concern supplémentaire k() method invoked
Comme vous le voyez, avant l'appel des méthodes msg(), m() et k(), d'autres problèmes apparaissent également.
Maintenant, si vous modifiez l'expression de pointcut comme suit:
@Pointcut("execution(")* Operation.m*(..))")
Maintenant, nous nous concentrerons davantage sur les méthodes commençant par m dans la classe Operation. La sortie sera comme suit:
calling msg... concern supplémentaire msg() method invoked calling m... concern supplémentaire m() method invoked calling k... k() method invoked
Maintenant, vous pouvez voir qu'avant l'appel de la méthode k(), d'autres problèmes ne sont pas imprimés.
Après l'appel de la méthode de logique métier réelle, l'AspectJ après la suggestion after est appliqué. Il peut être utilisé pour maintenir les journaux, la sécurité, les notifications, etc.
Ici, nous supposons Operation.java , applicationContext.xml et Test.java 文件与@Before示例中给出的文件相同。
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(")* Opération.*(..))")
public void k(){}//nom du pointcut
@After("k()")//appliquer le pointcut sur l'aspect après la suggestion
public void myadvice(JoinPoint jp)//it is advice (after advice)
{
System.out.println("concern supplémentaire");
//System.out.println("Signature de la méthode: "} + jp.getSignature());
}
}
Sortie
calling msg... msg() method invoked concern supplémentaire calling m... m() method invoked concern supplémentaire calling k... k() method invoked concern supplémentaire
Vous pouvez voir qu'après l'appel des méthodes msg(), m() et k(), d'autres problèmes apparaissent également.
En utilisant après la suggestion de retour, nous pouvons obtenir le résultat dans la suggestion.
Créer la logique métier incluant le contenu suivant.
Fichier: Operation.java
package com.w;3codebox;
public class Operation{
public int m(){System.out.println("m() method invoked");return 2;}
public int k(){System.out.println("k() method invoked");return 3;}
}
Créer la classe aspect incluant les aspects après la suggestion de retour.
Fichier: 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(* Opération.*(..))",
returning = "result")
public void myadvice(JoinPoint jp, Object result)//it is advice (after returning advice)
{
System.out.println("concern supplémentaire");
System.out.println("Signature de la méthode: "} + jp.getSignature());
System.out.println("Result in advice: ")+result);
System.out.println("end of after returning advice...");
}
}
Fichier: applicationContext.xml
comme indiqué dans l'exemple de conseil @Before
Fichier: Test.java
Maintenant, nous créons la classe Test pour appeler la méthode réelle.
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 m...");
System.out.println(e.m());
System.out.println("calling k...");
System.out.println(e.k());
}
}
Sortie
calling m... m() method invoked concern supplémentaire Method Signature: int com.w3codebox.Operation.m() Result in advice: 2 end of after returning advice... 2 calling k... k() method invoked concern supplémentaire Method Signature: int com.w3codebox.Operation.k() Result in advice: 3 end of after returning advice... 3
您可以看到返回值已打印两次，一次是由TrackOperation类打印，第二次是Test类。
围绕通知的AspectJ在调用实际的业务逻辑方法之前和之后都得到应用。
在这里，我们是假设 applicationContext.xml 文件与@Before示例中给出的文件相同。
创建一个包含实际业务逻辑的类。
Fichier: Operation.java
package com.w;3codebox;
public class Operation{
public void msg(){System.out.println("msg() is invoked");}
public void display(){System.out.println("display() is invoked");}
}
创建包含围绕建议的方面类。
您需要在advice方法中传递 PreceedingJoinPoint 引用，以便我们可以通过调用proce来进行请求()方法。
Fichier: 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(")* Opération.*(..))")
public void abcPointcut(){}
@Around("abcPointcut()")
public Object myadvice(ProceedingJoinPoint pjp) throws Throwable
{
System.out.println("Préoccupations supplémentaires avant l'appel de la méthode réelle");
Object obj = pjp.proceed();
System.out.println("Préoccupations supplémentaires après l'appel de la méthode réelle");
retourner obj;
}
}
Fichier: Test.java
Maintenant, nous créons la classe Test pour appeler la méthode réelle.
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();
}
}
Sortie
Préoccupations supplémentaires avant l'appel de la méthode réelle msg() est appelé Préoccupations supplémentaires après l'appel de la méthode réelle Préoccupations supplémentaires avant l'appel de la méthode réelle display() est appelé Préoccupations supplémentaires après l'appel de la méthode réelle
Vous pouvez voir que d'autres problèmes sont également imprimés avant et après l'appel de msg() et de la méthode d'affichage.
En utilisant l'avis après le lancement, nous pouvons imprimer l'exception dans la classe TrackOperation. Voici un exemple de l'avis AspectJ AfterThrowing.
Créer une classe contenant la logique métier.
Fichier: Operation.java
package com.w;3codebox;
public class Operation{
public void validate(int age) throws Exception{
if(age<18){
lance une nouvelle ArithmeticException("Âge non valide");
}
else{
System.out.println("Merci pour le vote");
}
}
}
Créer une classe aspect qui contient après avoir lancé le conseil.
Ici, nous devons également transmettre une référence Throwable afin que nous puissions intercepter les exceptions ici.
Fichier: 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(* Opération.*(..))",
throwing = "error")
public void myadvice(JoinPoint jp, Throwable error)//c'est un conseil
{
System.out.println("concern supplémentaire");
System.out.println("Signature de la méthode: "} + jp.getSignature());
System.out.println("L'exception est: "}+error);
System.out.println("fin de afterThrowing...");
}
}
Fichier: applicationContext.xml
comme indiqué dans l'exemple de conseil @Before
Fichier: Test.java
Maintenant, nous créons la classe Test pour appeler la méthode réelle.
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("appeler validate...");
try{
op.validate(19);
}catch(Exception e){System.out.println(e);}
System.out.println("appeler validate à nouveau...");
try{
op.validate(11);
}catch(Exception e){System.out.println(e);}
}
}
Sortie
appeler validate... Merci de votre vote appeler validate à nouveau... concern supplémentaire Signature de méthode: void com.w3codebox.Operation.validate(int) L'exception est: java.lang.ArithmeticException: Age non valide fin de l'avis après l'exception... java.lang.ArithmeticException: Age non valide