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

Tutoriales de Spring

Ejemplo de Spring AOP

Se proporciona Spring1.2AOP antiguo ejemplo implementado basado en dtd.

Aunque en Spring 3Se admite, pero el uso de advice se aprenderá en la página siguiente.

spring1.2se admite en la implementación antigua de AOP4tipos de Advice.

Before Adviceque se ejecuta antes de la llamada al método real. After Adviceque se ejecuta después de la llamada al método real. Si el método devuelve un valor, se ejecuta después del valor de retorno. Around Adviceque se ejecuta antes y después de la llamada al método real. Throws Advicesi el método real lanza una excepción, se ejecuta este Advice.

Nota: Para entender los conceptos básicos de Spring AOP, visite la página anterior.

Jerarquía de Advice

Vamos a entender la jerarquía de Advice a través del siguiente gráfico:

todos son interfaces en AOP.

MethodBeforeAdvice interfaz que extiende BeforeAdvice interfaz.

AfterReturningAdvice interfaz que extiende AfterAdvice interfaz.

ThrowsAdvice interfaz que extiende AfterAdvice interfaz.

MethodInterceptor interfaz que extiende Interceptor interfaz. Se utiliza alrededor de Advice.

1Ejemplo de MethodBeforeAdvice

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

文件: A.java

package com.w3codebox;
public class A {
public void m(){System.out.println("lógica de negocio real");}
}

Ahora, crear una clase de asesor que implemente la interfaz MethodBeforeAdvice.

文件: BeforeAdvisor.java

package com.w3codebox;
import　java.lang.reflect.Method;
import org.springframework.aop.MethodBeforeAdvice;
public class BeforeAdvisor implements MethodBeforeAdvice{
	@Override
	public void before(Method method, Object[] args, Object target) throws Throwable {
		System.out.println("preocupación adicional antes de la lógica real");
	}
}

En el archivo xml, crear3un bean, uno para la clase A, el segundo para la clase Advisor, el tercero para ProxyFactoryBean clase.

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:p="http://www.springframework.org/schema/p"
	xsi:schemaLocation="http://www.springframework.org/schema/beans　
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
<bean　id="obj"　class="com.w3codebox.A"></bean>
<bean　id="ba"　class="com.w3codebox.BeforeAdvisor"></bean>
<bean id="proxy" class="org.springframework.aop.framework.ProxyFactoryBean">
<property name="target" ref="obj"></property>
<property name="interceptorNames">
<list>
<value>ba</value>
</list>
</property>
</bean>
</beans>

Entender la clase ProxyFactoryBean:

ProxyFactoryBean La clase es proporcionada por Spring Famework. Contiene2dos propiedades: target e interceptorNames. La instancia de la clase A se considerará el objeto de destino, y la instancia de la clase Advisor se considerará el interceptador. Necesita pasar el objeto de asesor como objeto de lista de la misma manera que se muestra en el archivo xml proporcionado anteriormente.

La escritura de la clase ProxyFactoryBean es la siguiente:

public class ProxyFactoryBean{
private Object target;
private List interceptorNames;
//getters y setters
}

Ahora, llamemos al método real.

archivo: Test.java

package com.w3codebox;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.Resource;
public class Test {
public static void main(String[] args) {
	Resource r=new ClassPathResource("applicationContext.xml");
	BeanFactory factory=new XmlBeanFactory(r);
	A a=factory.getBean("proxy",A.class);
	a.m();
}
}

Salida

preocupación adicional antes de la lógica real
lógica de negocio real

En MethodBeforeAdvice, podemos imprimir otras informaciónes, como el nombre del método, los parámetros del método, el objeto de destino, el nombre de la clase del objeto de destino, la clase del agente, etc.

Solamente necesita modificar dos clases, BeforeAdvisor.java y Test.java.

文件: BeforeAdvisor.java 

package com.w3codebox;
import　java.lang.reflect.Method;
import org.springframework.aop.MethodBeforeAdvice;
public class BeforeAdvisor implements MethodBeforeAdvice{
	@Override
	public void before(Method method, Object[] args, Object target) throws Throwable {
		System.out.println("preocupación adicional antes de la lógica real");
		System.out.println("información de método:");+method.getName()+" "+method.getModifiers());
		System.out.println("información de argumento:");
		for(Object arg:args)
			System.out.println(arg);
		System.out.println("objeto objetivo:");+target);
		System.out.println("nombre de clase objetivo: ");+target.getClass().getName());
	}
}

archivo: Test.java 

package com.w3codebox;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.Resource;
public class Test {
public static void main(String[] args) {
	Resource r=new ClassPathResource("applicationContext.xml");
	BeanFactory factory=new XmlBeanFactory(r);
	A a=factory.getBean("proxy",A.class);
　　　　　　　　System.out.println("nombre de clase proxy: ");+a.getClass().getName());
	a.m();
}
}

Salida

nombre de clase proxy: com.w3codebox.A$EnhancerByCGLIB$409872b1
preocupación adicional antes de la lógica real
información de método:m　1
información de argumento:
objeto objetivo: com.w3codebox.A@11dba45
nombre de clase objetivo: com.w3codebox.A
lógica de negocio real

Ejemplo de AfterReturningAdvice

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

文件: A.java

igual que en el ejemplo anterior.

Ahora, cree una clase asesor que implemente la interfaz AfterReturningAdvice.

文件: AfterAdvisor.java

package com.w3codebox;
import　java.lang.reflect.Method;
import　org.springframework.aop.AfterReturningAdvice;
public　class　AfterAdvisor　implements　AfterReturningAdvice{
	@Override
	public　void　afterReturning(Object　returnValue,　Method　method,
　　　　　　　　　Object[]　args,　Object　target)　throws　Throwable　{
		System.out.println("preocupación adicional después de regresar el consejo");
	}
}

Como en el ejemplo anterior, cree un archivo xml y solo necesita cambiar aquí la clase del programa asesor.

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:p="http://www.springframework.org/schema/p"
	xsi:schemaLocation="http://www.springframework.org/schema/beans　
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
<bean　id="obj"　class="com.w3codebox.A"></bean>
<bean　id="ba"　class="com.w3codebox.AfterAdvisor"></bean>
<bean id="proxy" class="org.springframework.aop.framework.ProxyFactoryBean">
<property name="target" ref="obj"></property>
<property name="interceptorNames">
<list>
<value>ba</value>
</list>
</property>
</bean>
</beans>

archivo: Test.java

igual que en el ejemplo anterior.

Salida

lógica de negocio real
preocupación adicional después de regresar el consejo

3)Ejemplo de MethodInterceptor(AroundAdvice)

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

archivo: A。java

igual que en el ejemplo anterior.

Ahora, cree una clase asesor que implemente la interfaz MethodInterceptor.

archivo: AroundAdvisor.java 

package com.w3codebox;
import　org.aopalliance.intercept.MethodInterceptor;
import　org.aopalliance.intercept.MethodInvocation;
public　class　AroundAdvisor　implements　MethodInterceptor{
	@Override
	public　Object　invoke(MethodInvocation　mi)　throws　Throwable　{
		Object　obj;
		System.out.println("preocupación adicional antes de la lógica real");
		obj=mi.proceed();
		System.out.println("preocupación adicional después de la lógica real");
		return　obj;
	}
}

Como en el ejemplo anterior, cree un archivo xml y solo necesita cambiar aquí la clase del programa asesor.

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:p="http://www.springframework.org/schema/p"
	xsi:schemaLocation="http://www.springframework.org/schema/beans　
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
<bean　id="obj"　class="com.w3codebox.A"></bean>
<bean　id="ba"　class="com.w3codebox.AroundAdvisor"></bean>
<bean id="proxy" class="org.springframework.aop.framework.ProxyFactoryBean">
<property name="target" ref="obj"></property>
<property name="interceptorNames">
<list>
<value>ba</value>
</list>
</property>
</bean>
</beans>

archivo: Test.java

igual que en el ejemplo anterior.

Salida

preocupación adicional antes de la lógica real
lógica de negocio real
preocupación adicional después de la lógica real

4ejemplo de ThrowsAdvice

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

archivo: Validator.java

package com.w3codebox;
public　class　Validator　{
	public　void　validate(int　age)throws　Exception{
		if(age<18){
			throw　new　ArithmeticException("Edad No Válida");
		}
		else{
			System.out.println("voto confirmado");
		}
	}
}

Ahora, crea una clase consejera que implemente la interfaz ThrowsAdvice.

archivo: ThrowsAdvisor.java 

package com.w3codebox;
import　org.springframework.aop.ThrowsAdvice;
public　class　ThrowsAdvisor　implements　ThrowsAdvice{
	public　void　afterThrowing(Exception　ex){
		System.out.println("preocupación adicional si ocurre una excepción");
	}
}

Crea un archivo xml como en el ejemplo anterior, solo debes cambiar las clases Validator y Advisor.

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:p="http://www.springframework.org/schema/p"
	xsi:schemaLocation="http://www.springframework.org/schema/beans　
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
<bean　id="obj"　class="com.w3codebox.Validator"></bean>
<bean　id="ba"　class="com.w3codebox.ThrowsAdvisor"></bean>
<bean id="proxy" class="org.springframework.aop.framework.ProxyFactoryBean">
<property name="target" ref="obj"></property>
<property name="interceptorNames">
<list>
<value>ba</value>
</list>
</property>
</bean>
</beans>

archivo: Test.java 

package com.w3codebox;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.Resource;
public class Test {
public static void main(String[] args) {
	Resource r=new ClassPathResource("applicationContext.xml");
	BeanFactory factory=new XmlBeanFactory(r);
	Validator v=factory.getBean("proxy",Validator.class);
	try{
	v.validate(12);
	}catch(Exception e){e.printStackTrace();}
}
}

Salida

java.lang.ArithmeticException: Edad no válida
consideración adicional si ocurre una excepción
	en com.w3codebox.Validator.validate(Validator.java:7)
	en com.w3codebox.Validator$FastClassByCGLIB$562915cf.invoke(<generado>)
	en net.sf.cglib.proxy.MethodProxy.invoke(MethodProxy.java:191)
	en org.springframework.aop.framework.Cglib2invocar(AopProxy$CglibMethodInvocation.invoke
Punto de unión(Cglib2AopProxy.java:692)
	en org.springframework.aop.framework.ReflectiveMethodInvocation.
proceder(ReflectiveMethodInvocation.java:150)
	en org.springframework.aop.framework.adapter.ThrowsAdviceInterceptor.
invocar(ThrowsAdviceInterceptor.java:124)
	en org.springframework.aop.framework.ReflectiveMethodInvocation.
proceder(ReflectiveMethodInvocation.java:172)
	en org.springframework.aop.framework.Cglib2AopProxy$DynamicAdvisedInterceptor.
interceptar(Cglib2AopProxy.java:625)
	en com.w3codebox.Validator$EnhancerByCGLIB$4230ed28.validar(<generado>)
	en com.w3codebox.Test.main(Test.java:15)
Ejemplo de anotaciones AspectJ de AOP de SpringDiferencia entre constructor y inyección de setter