@AspectJ basato AOP con la primavera

@AspectJ fa riferimento a uno stile di dichiarazione degli aspetti come normali classi Java annotate con annotazioni Java 5. Il supporto @AspectJ viene abilitato includendo il seguente elemento nel file di configurazione basato su XML Schema.

<aop:aspectj-autoproxy/>

Avrai anche bisogno delle seguenti librerie AspectJ sul classpath della tua applicazione. Queste librerie sono disponibili nella directory "lib" di un'installazione di AspectJ, altrimenti è possibile scaricarle da Internet.

aspectjrt.jar
aspectjweaver.jar
aspectj.jar
aopalliance.jar

Dichiarare un aspetto

Le classi degli aspetti sono come qualsiasi altro bean normale e possono avere metodi e campi proprio come qualsiasi altra classe, tranne per il fatto che saranno annotati con @Aspect come segue:

package org.xyz;

import org.aspectj.lang.annotation.Aspect;

@Aspect
public class AspectModule {
}

Verranno configurati in XML come qualsiasi altro bean come segue:

<bean id = "myAspect" class = "org.xyz.AspectModule">
   <!-- configure properties of aspect here as normal -->
</bean>

Dichiarare un taglio a punti

UN pointcutaiuta a determinare i punti di unione (cioè i metodi) di interesse da eseguire con diversi consigli. Mentre si lavora con la configurazione basata su @ AspectJ, la dichiarazione pointcut ha due parti:

Un'espressione pointcut che determina esattamente a quali esecuzioni del metodo siamo interessati.
Una firma di taglio a punti che comprende un nome e un numero qualsiasi di parametri. Il corpo effettivo del metodo è irrilevante e in effetti dovrebbe essere vuoto.

L'esempio seguente definisce un pointcut denominato "businessService" che corrisponderà all'esecuzione di ogni metodo disponibile nelle classi nel pacchetto com.xyz.myapp.service -

import org.aspectj.lang.annotation.Pointcut;

@Pointcut("execution(* com.xyz.myapp.service.*.*(..))") // expression 
private void businessService() {}  // signature

L'esempio seguente definisce un pointcut denominato 'getname' che corrisponderà all'esecuzione del metodo getName () disponibile nella classe Student nel pacchetto com.tutorialspoint -

import org.aspectj.lang.annotation.Pointcut;

@Pointcut("execution(* com.tutorialspoint.Student.getName(..))") 
private void getname() {}

Dichiarare consigli

Puoi dichiarare uno qualsiasi dei cinque consigli utilizzando le annotazioni @ {ADVICE-NAME} come indicato nello snippet di codice. Ciò presuppone che abbiate già definito un metodo di firma pointcut businessService () -

@Before("businessService()")
public void doBeforeTask(){
   ...
}

@After("businessService()")
public void doAfterTask(){
   ...
}

@AfterReturning(pointcut = "businessService()", returning = "retVal")
public void doAfterReturnningTask(Object retVal) {
   // you can intercept retVal here.
   ...
}

@AfterThrowing(pointcut = "businessService()", throwing = "ex")
public void doAfterThrowingTask(Exception ex) {
  // you can intercept thrown exception here.
  ...
}

@Around("businessService()")
public void doAroundTask(){
   ...
}

È possibile definire un punto di taglio in linea per qualsiasi consiglio. Di seguito è riportato un esempio per definire il punto di taglio in linea per prima del consiglio:

@Before("execution(* com.xyz.myapp.service.*.*(..))")
public doBeforeTask(){
   ...
}

Esempio di AOP basato su @AspectJ

Per comprendere i concetti sopra menzionati relativi all'AOP basato su @AspectJ, scriviamo un esempio che implementerà alcuni dei consigli. Per scrivere il nostro esempio con pochi consigli, disponiamo di un IDE Eclipse funzionante e procediamo come segue per creare un'applicazione Spring:

Passi	Descrizione
1	Crea un progetto con un nome SpringExample e crea un pacchetto com.tutorialspoint sottosrc cartella nel progetto creato.
2	Aggiungere le librerie Spring richieste utilizzando l' opzione Aggiungi JAR esterni come spiegato nel capitolo Esempio Spring Hello World .
3	Aggiungi librerie specifiche per Spring AOP aspectjrt.jar, aspectjweaver.jar e aspectj.jar nel progetto.
4	Crea classi Java Logging, Student e MainApp nel pacchetto com.tutorialspoint .
5	Crea il file di configurazione Beans Beans.xml sottosrc cartella.
6	Il passaggio finale consiste nel creare il contenuto di tutti i file Java e nel file di configurazione Bean ed eseguire l'applicazione come spiegato di seguito.

Ecco il contenuto di Logging.javafile. Questo è in realtà un esempio di modulo di aspetto che definisce i metodi da chiamare in vari punti.

package com.tutorialspoint;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Around;

@Aspect
public class Logging {
   /** Following is the definition for a pointcut to select
      *  all the methods available. So advice will be called
      *  for all the methods.
   */
   @Pointcut("execution(* com.tutorialspoint.*.*(..))")
   private void selectAll(){}

   /** 
      * This is the method which I would like to execute
      * before a selected method execution.
   */
   @Before("selectAll()")
   public void beforeAdvice(){
      System.out.println("Going to setup student profile.");
   }

   /** 
      * This is the method which I would like to execute
      * after a selected method execution.
   */
   @After("selectAll()")
   public void afterAdvice(){
      System.out.println("Student profile has been setup.");
   }

   /** 
      * This is the method which I would like to execute
      * when any method returns.
   */
   @AfterReturning(pointcut = "selectAll()", returning = "retVal")
   public void afterReturningAdvice(Object retVal){
      System.out.println("Returning:" + retVal.toString() );
   }

   /**
      * This is the method which I would like to execute
      * if there is an exception raised by any method.
   */
   @AfterThrowing(pointcut = "selectAll()", throwing = "ex")
   public void AfterThrowingAdvice(IllegalArgumentException ex){
      System.out.println("There has been an exception: " + ex.toString());   
   }
}

Di seguito è riportato il contenuto del file Student.java file

package com.tutorialspoint;

public class Student {
   private Integer age;
   private String name;

   public void setAge(Integer age) {
      this.age = age;
   }
   public Integer getAge() {
	  System.out.println("Age : " + age );
      return age;
   }
   public void setName(String name) {
      this.name = name;
   }
   public String getName() {
      System.out.println("Name : " + name );
      return name;
   }
   public void printThrowException(){
      System.out.println("Exception raised");
      throw new IllegalArgumentException();
   }
}

Di seguito è riportato il contenuto del file MainApp.java file

package com.tutorialspoint;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MainApp {
   public static void main(String[] args) {
      ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
      
      Student student = (Student) context.getBean("student");
      student.getName();
      student.getAge();
      
      student.printThrowException();
   }
}

Di seguito è riportato il file di configurazione Beans.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-3.0.xsd 
   http://www.springframework.org/schema/aop 
   http://www.springframework.org/schema/aop/spring-aop-3.0.xsd ">

   <aop:aspectj-autoproxy/>

   <!-- Definition for student bean -->
   <bean id = "student" class = "com.tutorialspoint.Student">
      <property name = "name" value = "Zara" />
      <property name = "age"  value = "11"/>      
   </bean>

   <!-- Definition for logging aspect -->
   <bean id = "logging" class = "com.tutorialspoint.Logging"/> 
      
</beans>

Una volta terminata la creazione dei file di configurazione dei bean e dei sorgenti, eseguiamo l'applicazione. Se tutto va bene con la tua applicazione, stamperà il seguente messaggio:

Going to setup student profile.
Name : Zara
Student profile has been setup.
Returning:Zara
Going to setup student profile.
Age : 11
Student profile has been setup.
Returning:11
Going to setup student profile.
Exception raised
Student profile has been setup.
There has been an exception: java.lang.IllegalArgumentException
.....
other exception content

↰ Previous page

@AspectJ basato AOP con la primavera

Dichiarare un aspetto

Dichiarare un taglio a punti

Dichiarare consigli

Esempio di AOP basato su @AspectJ

Nozioni di base su Spring Core

Domande e risposte sulla primavera