Spring AOP 示例

17 Mar 2025 | 5 分钟阅读

这里给出了 Spring1.2 旧式 AOP（基于 DTD）实现的示例。

虽然它在 Spring 3 中受支持，但建议使用 Spring AOP 与 AspectJ，我们将在下一页学习。

Spring1.2 旧式 AOP 实现支持 4 种类型的 advice。

Before Advice 在实际方法调用之前执行。
After Advice 在实际方法调用之后执行。如果方法返回一个值，则在返回值之后执行。
Around Advice 在实际方法调用之前和之后执行。
Throws Advice 如果实际方法抛出异常则执行。

要了解 Spring AOP 的基本概念，请访问上一页。

理解 advice 接口的层次结构

让我们通过下面给出的图表来理解 advice 的层次结构

所有都是 AOP 中的接口。

MethodBeforeAdvice 接口扩展了 BeforeAdvice 接口。

AfterReturningAdvice 接口扩展了 AfterAdvice 接口。

ThrowsAdvice 接口扩展了 AfterAdvice 接口。

MethodInterceptor 接口扩展了 Interceptor 接口。它用于 around advice。

1) MethodBeforeAdvice 示例

创建一个包含实际业务逻辑的类。

文件：A.java

package com.javatpoint;
public class A {
public void m(){System.out.println("actual business logic");}
}

现在，创建实现 MethodBeforeAdvice 接口的 advisor 类。

文件：BeforeAdvisor.java

package com.javatpoint;
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("additional concern before actual logic");
	}
}

在 xml 文件中，创建 3 个 bean，一个用于 A 类，第二个用于 Advisor 类，第三个用于 ProxyFactoryBean 类。

文件：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.javatpoint.A"></bean>
<bean id="ba" class="com.javatpoint.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>

理解 ProxyFactoryBean 类

ProxyFactoryBean 类由 Spring Framework 提供。它包含两个属性 target 和 interceptorNames。A 类的实例将被视为目标对象，advisor 类的实例将被视为拦截器。您需要在 xml 文件中将 advisor 对象作为列表对象传递。

ProxyFactoryBean 类的写法类似这样

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

现在，让我们调用实际的方法。

文件：Test.java

package com.javatpoint;
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();
}
}

输出

在 MethodBeforeAdvice 中打印附加信息

我们可以打印附加信息，如方法名称、方法参数、目标对象、目标对象类名、代理类等。

您只需要更改 BeforeAdvisor.java 和 Test.java 这两个类。

文件：BeforeAdvisor.java

package com.javatpoint;
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("additional concern before actual logic");
		System.out.println("method info:"+method.getName()+" "+method.getModifiers());
		System.out.println("argument info:");
		for(Object arg:args)
			System.out.println(arg);
		System.out.println("target Object:"+target);
		System.out.println("target object class name: "+target.getClass().getName());
	}
}

文件：Test.java

package com.javatpoint;
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("proxy class name: "+a.getClass().getName());
	a.m();
}
}

输出

2) AfterReturningAdvice 示例

创建一个包含实际业务逻辑的类。

文件：A.java

与前面的示例相同。

现在，创建实现 AfterReturningAdvice 接口的 advisor 类。

文件：AfterAdvisor.java

package com.javatpoint;
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("additional concern after returning advice");
	}

}

创建 xml 文件，与前面的示例一样，您只需要在这里更改 advisor 类。

文件：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.javatpoint.A"></bean>
<bean id="ba" class="com.javatpoint.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>

文件：Test.java

与前面的示例相同。

输出

3) MethodInterceptor (AroundAdvice) 示例

创建一个包含实际业务逻辑的类。

文件：A.java

与前面的示例相同。

现在，创建实现 MethodInterceptor 接口的 advisor 类。

文件：AroundAdvisor.java

package com.javatpoint;
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("additional concern before actual logic");
		obj=mi.proceed();
		System.out.println("additional concern after actual logic");
		return obj;
	}

}

创建 xml 文件，与前面的示例一样，您只需要在这里更改 advisor 类。

文件：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.javatpoint.A"></bean>
<bean id="ba" class="com.javatpoint.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>

文件：Test.java

与前面的示例相同。

输出

4) ThrowsAdvice 示例

创建一个包含实际业务逻辑的类。

文件：Validator.java

package com.javatpoint;
public class Validator {
	public void validate(int age)throws Exception{
		if(age<18){
			throw new ArithmeticException("Not Valid Age");
		}
		else{
			System.out.println("vote confirmed");
		}
	}
}

现在，创建实现 ThrowsAdvice 接口的 advisor 类。

文件：ThrowsAdvisor.java

package com.javatpoint;
import org.springframework.aop.ThrowsAdvice;
public class ThrowsAdvisor implements ThrowsAdvice{
	public void afterThrowing(Exception ex){
		System.out.println("additional concern if exception occurs");
	}
}

创建 xml 文件，与前面的示例一样，您只需要更改 Validator 类和 advisor 类。

文件：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.javatpoint.Validator"></bean>
<bean id="ba" class="com.javatpoint.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>

文件：Test.java

package com.javatpoint;

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

输出

下一篇Spring AOP AspectJ 注解示例

我们提供所有技术（如 Java 教程、Android、Java 框架）的教程和面试问题

联系信息

G-13, 2nd Floor, Sec-3, Noida, UP, 201301, India

hr@tpointtech.com

+91-9599086977

关注我们

Python

Java

.Net Framework

AI, ML and Data Science

Cloud Technology

B.Tech and MCA

Web Technology

PHP

Software Testing

Technical Interview

Java Interview

Python

Web Interview

Database Interview

B.Tech / MCA

Important Interview

Software Testing Interview

Company Interviews

Online Compilers

Multiple Choice Questions

Spring 教程

IDE 中的 Spring

依赖注入

Spring JdbcTemplate

Spring AOP

Spring ORM

SPEL

Spring MVC

MVC 表单标签库

MVC 应用

Spring MVC 验证

MVC Tiles

Spring Remoting

Spring OXM

Spring Java Mail

Spring Web

Spring Security 教程

Spring 面试

Spring 测验

Spring Boot

Spring + Angular

其他

Spring AOP 示例

要了解 Spring AOP 的基本概念，请访问上一页。

理解 advice 接口的层次结构

1) MethodBeforeAdvice 示例

输出

在 MethodBeforeAdvice 中打印附加信息

输出

2) AfterReturningAdvice 示例

输出

3) MethodInterceptor (AroundAdvice) 示例

输出

4) ThrowsAdvice 示例

输出

相关帖子

SP AspectJ 注解

AOP 概念

SP AspectJ XML

订阅 Tpoint Tech

联系信息

关注我们

教程

面试题

在线编译器