English | 简体中文 | 繁體中文 | Русский язык | Français | Español | Português | Deutsch | 日本語 | 한국어 | Italiano | بالعربية

Tutoriales de Spring

Ejemplo de configuración xml de AOP de Spring AspectJ

Spring te permite definir aspectos, recomendaciones y puntos de corte en un archivo xml.

En la página anterior, ya vimos el ejemplo de aop utilizando anotaciones. Ahora, veremos el mismo ejemplo a través de un archivo de configuración xml.

Veamos los elementos xml utilizados para definir las recomendaciones.

aop: before Se aplica antes de llamar al método lógico de negocio real. aop: after Se aplica después de llamar al método lógico de negocio real. aop: after returningSe aplica después de llamar al método lógico de negocio real. Se puede usar para interceptar el valor de retorno de la notificación. aop: around Se aplica antes y después de llamar al método lógico de negocio real. aop: after throwingSi el método lógico de negocio real lanza una excepción, aplícalo.
Atención: Para entender el concepto de aop y sus ventajas, etc., visita aquí. Tutorial de concepto AOP

1de ejemplo después de aop: before

Aplica la recomendación AspectJ 'before' antes del método lógico de negocio real. Puedes hacer aquí cualquier operación, como la conversión, la autenticación, etc.

Crea una clase que contenga la lógica de negocio real.

archivo: Operation.java 
package com.w;3codebox;
public  class Operation{
	public void msg(){System.out.println("método msg invocado");}
	public int m(){System.out.println("método m invocado");return 2;}
	public int k(){System.out.println("método k invocado");return 3;}
}

Ahora, crea una clase que se incluye antes de la recomendación.

archivo: TrackOperation.java 

package com.w;3codebox;
import org.aspectj.lang.JoinPoint;
public class TrackOperation{
	public void myadvice(JoinPoint jp)//es un consejo
	{
		System.out.println("preocupación adicional");
		//System.out.println("Firma del método: "  + jp.getSignature());
	}
}

Ahora crea el archivo applicationContext.xml que define el bean.

archivo: 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-3.0.xsd 
	http://www.springframework.org/schema/aop 
	http://www.springframework.org/schema/aop/spring-aop-3.0.xsd ">
<aop:aspectj-autoproxy />
<bean id="opBean" class="com.w3codebox.Operation">	</bean>
<bean id="trackAspect" class="com.w3codebox.TrackOperation"></bean>
<aop:config>
  <aop:aspect id="myaspect" ref="trackAspect" >
     <!-- @Before -->
     <aop:pointcut id="pointCutBefore"	expression="execution(* com.w3codebox.Operation.*(..))" />
     <aop:before method="myadvice" pointcut-ref="pointCutBefore" />
  </aop:aspect>
</aop:config>
</beans>

Ahora, llamémoslo método real.

Archivo: 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("llamando msg...");
		e.msg();
		System.out.println("llamando m...");
		e.m();
		System.out.println("llamando k...");
		e.k();
	}
}

Salida 

llamando msg...
preocupación adicional
msg() método invocado
llamando m...
preocupación adicional
m() método invocado
llamando k...
preocupación adicional
se invoca el método k()

Como puedes ver, antes de llamar a los métodos msg(), m() y k(), también se imprimirán otros problemas.

2de ejemplo después de aop:

Después de llamar al método lógico de negocio real, se aplica AspectJ después de la notificación. Se puede usar para mantener el registro, la seguridad, las notificaciones, etc.

Aquí, suponemos Operation.java , TrackOperation.java y}} Test.java El archivo es el mismo que el ejemplo en aop:

Ahora crea el archivo applicationContext.xml que define el bean.

archivo: 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-3.0.xsd 
	http://www.springframework.org/schema/aop 
	http://www.springframework.org/schema/aop/spring-aop-3.0.xsd ">
<aop:aspectj-autoproxy />
<bean id="opBean" class="com.w3codebox.Operation">	</bean>
<bean id="trackAspect" class="com.w3codebox.TrackOperation"></bean>
<aop:config>
  <aop:aspect id="myaspect" ref="trackAspect" >
     <!-- @After -->
     <aop:pointcut id="pointCutAfter"	expression="execution(* com.w3codebox.Operation.*(..))" />
     <aop:after método="myadvice" punto de corte-ref="pointCutAfter" />
  </aop:aspect>
</aop:config>
</beans>

Salida 

llamando msg...
msg() método invocado
preocupación adicional
llamando m...
m() método invocado
preocupación adicional
llamando k...
se invoca el método k()
preocupación adicional

Puedes ver que después de llamar a los métodos msg(), m() y k(), también aparecen otros problemas.

3、ejemplo de AOP: Después del retorno

Al usar el consejo después de retornar, podemos obtener el resultado en el consejo.

Crear

archivo: Operation.java 

package com.w;3codebox;
public  class Operation{
	public int m(){System.out.println("m() método invocado");return 2;}
	public int k(){System.out.println("k() método invocado");return 3;}
}

Crear la clase de aspecto que contiene el consejo de retorno después de crear.

archivo: TrackOperation.java 

package com.w;3codebox;
import org.aspectj.lang.JoinPoint;
public class TrackOperation{
	public void myadvice(JoinPoint jp,Object result)//es consejo (después del consejo)
	{
		System.out.println("preocupación adicional");
		System.out.println("Firma del método: "  + jp.getSignature());
		System.out.println("Resultado en consejo: "+result);
		System.out.println("final de consejo de retorno...");
	}
}

archivo: 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-3.0.xsd 
	http://www.springframework.org/schema/aop 
	http://www.springframework.org/schema/aop/spring-aop-3.0.xsd ">
<aop:aspectj-autoproxy />
<bean id="opBean" class="com.w3codebox.Operation">	</bean>
<bean id="trackAspect" class="com.w3codebox.TrackOperation"></bean>
<aop:config>
  <aop:aspect id="myaspect" ref="trackAspect" >
     <!-- @AfterReturning -->
     <aop:pointcut id="pointCutAfterReturning"	expression="execution(* com.w3codebox.Operation.*(..))" />
     <aop:after-método de retorno="myadvice" retorno="result" punto de corte-ref="pointCutAfterReturning" />
  </aop:aspect>
</aop:config>
</beans>

Archivo: Test.java

Ahora creamos la clase Test que llama al método real. 

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("llamando m...");
		System.out.println(e.m());
		System.out.println("llamando k...");
		System.out.println(e.k());
	}
}

Salida 

llamando m...
m() método invocado
preocupación adicional
Firma del método: int com.w3codebox.Operation.m()
Resultado en consejo: 2
final del consejo después de regresar...
2
llamando k...
se invoca el método k()
preocupación adicional
Firma del método: int com.w3codebox.Operation.k()
Resultado en consejo: 3
final del consejo después de regresar...
3

Puede ver que el valor de retorno se imprime dos veces, una vez por la clase TrackOperation y la segunda vez por la clase Test.

4、aop: around

El consejo alrededor de AspectJ se aplica antes y después de llamar al método de lógica de negocio real.

Crear una clase

archivo: Operation.java 

package com.w;3codebox;
public  class Operation{
	public void msg(){System.out.println("msg() se invoca");}
	public void display(){System.out.println("display() se invoca");}
}

Crear una clase que rodea el consejo.

Necesita pasar en el método advice PreceedingJoinPoint para que podamos llamar al método proceed() y realizar la solicitud().

archivo: TrackOperation.java 

package com.w;3codebox;
import org.aspectj.lang.ProceedingJoinPoint;
public class TrackOperation
{
	public Object myadvice(ProceedingJoinPoint pjp) throws Throwable 
	{
		System.out.println("Preocupación adicional antes de llamar al método real");
		Object obj=pjp.proceed();
		System.out.println("Preocupación adicional después de llamar al método real");
		devuelve obj;
	}
}

archivo: 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-3.0.xsd 
	http://www.springframework.org/schema/aop 
	http://www.springframework.org/schema/aop/spring-aop-3.0.xsd ">
<aop:aspectj-autoproxy />
<bean id="opBean" class="com.w3codebox.Operation">	</bean>
<bean id="trackAspect" class="com.w3codebox.TrackOperation"></bean>
<aop:config>
  <aop:aspect id="myaspect" ref="trackAspect" >
     <!-- @Around -->
     <aop:pointcut id="pointCutAround"	expression="execution(* com.w3codebox.Operation.*(..))" />
     <aop:around method="myadvice" pointcut-ref="pointCutAround" />
  </aop:aspect>
</aop:config>
</beans>

Archivo: Test.java

Ahora creamos la clase Test que llama al método real. 

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();
	}
}

Salida 

Preocupación Adicional Antes de llamar al método real
se invoca msg()
Preocupación Adicional Después de llamar al método real
Preocupación Adicional Antes de llamar al método real
se invoca display()
Preocupación Adicional Después de llamar al método real

Puedes ver que antes y después de llamar al método msg() y mostrar, también se imprimirán otros problemas.

5、aop: after-throwing

Al usar el consejo después del lanzamiento, podemos imprimir la excepción en la clase TrackOperation. Vamos a ver un ejemplo de consejo AfterThrowing de AspectJ.

Crear una clase que contiene la lógica de negocio.

archivo: Operation.java 

package com.w;3codebox;
public  class Operation{
	public void validate(int age)throws Exception{
	if(age<18){
		throw new ArithmeticException("Edad no válida");
	}
	else{
		System.out.println("Gracias para voto");
	}
	}
}

Crear la clase de aspecto que contiene el consejo desencadenado después.

Aquí, también necesitamos pasar una referencia a Throwable para que podamos interceptar la excepción aquí.

archivo: TrackOperation.java 

package com.w;3codebox;
import org.aspectj.lang.JoinPoint;
public class TrackOperation{
	public void myadvice(JoinPoint jp,Throwable error)//es un consejo
	{
		System.out.println("preocupación adicional");
		System.out.println("Firma del método: "  + jp.getSignature());
		System.out.println("La excepción es: "+error);
		System.out.println("final de after throwing advice...");
	}
}

archivo: 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-3.0.xsd 
	http://www.springframework.org/schema/aop 
	http://www.springframework.org/schema/aop/spring-aop-3.0.xsd ">
<aop:aspectj-autoproxy />
<bean id="opBean" class="com.w3codebox.Operation">	</bean>
<bean id="trackAspect" class="com.w3codebox.TrackOperation"></bean>
<aop:config>
  <aop:aspect id="myaspect" ref="trackAspect" >
     <!-- @AfterThrowing -->
     <aop:pointcut id="pointCutAfterThrowing"	expression="execution(* com.w3codebox.Operation.*(..))" />
     <aop:after-throwing method="myadvice" throwing="error" pointcut-ref="pointCutAfterThrowing" />
  </aop:aspect>
</aop:config>
</beans>

Archivo: Test.java

Ahora creamos la clase Test que llama al método real. 

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("llamando validate...");
		try{
			op.validate(19);
		catch(Exception e){System.out.println(e);}
		System.out.println("llamando validate de nuevo...");
		try{
		    op.validate(11);
		catch(Exception e){System.out.println(e);}
	}
}

Salida 

llamando validate...
Gracias por votar
llamando validate de nuevo...
preocupación adicional
Firma del método: void com.w3codebox.Operation.validate(int)
La excepción es: java.lang.ArithmeticException: Edad no válida
final de después de lanzar el consejo...
java.lang.ArithmeticException: Edad no válida
Ejemplo de PreparedStatement en JdbcTemplate de SpringEjemplo de anotaciones AspectJ de AOP de Spring