Spring AOP AspectJ XML 配置示例

17 Mar 2025 | 6 分钟阅读

Spring 允许您在 xml 文件中定义方面、通知和切入点。

在上一页，我们已经看到了使用注解的 AOP 示例。现在我们将通过 xml 配置文件来查看相同的示例。

让我们看看用于定义通知的 xml 元素。

aop:before 它在调用实际的业务逻辑方法之前应用。
aop:after 它在调用实际的业务逻辑方法之后应用。
aop:after-returning 它在调用实际的业务逻辑方法之后应用。它可用于拦截通知中的返回值。
aop:around 它在调用实际的业务逻辑方法之前和之后应用。
aop:after-throwing 如果实际的业务逻辑方法抛出异常，则应用。

要了解 AOP 概念、它的优势等，请访问此处 AOP 概念教程

下载所有示例（使用 MyEclipse IDE 开发）

1) aop:before 示例

AspectJ Before 通知在实际的业务逻辑方法之前应用。您可以在此处执行任何操作，例如转换、身份验证等。

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

文件: Operation.java

package com.javatpoint;
public  class Operation{
	public void msg(){System.out.println("msg method invoked");}
	public int m(){System.out.println("m method invoked");return 2;}
	public int k(){System.out.println("k method invoked");return 3;}
}

现在，创建包含 before 通知的方面类。

文件: TrackOperation.java

package com.javatpoint;
import org.aspectj.lang.JoinPoint;
public class TrackOperation{
	public void myadvice(JoinPoint jp)//it is advice
	{
		System.out.println("additional concern");
		//System.out.println("Method Signature: "  + jp.getSignature());
	}
}

现在创建定义 bean 的 applicationContext.xml 文件。

文件：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.javatpoint.Operation">	</bean>
<bean id="trackAspect" class="com.javatpoint.TrackOperation"></bean>
		
<aop:config>
  <aop:aspect id="myaspect" ref="trackAspect" >
     <!-- @Before -->
     <aop:pointcut id="pointCutBefore"	expression="execution(* com.javatpoint.Operation.*(..))" />
     <aop:before method="myadvice" pointcut-ref="pointCutBefore" />
  </aop:aspect>
</aop:config>
	
</beans>

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

文件：Test.java

package com.javatpoint;

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

输出

正如您所看到的，在调用 msg()、m() 和 k() 方法之前打印了附加的关注点。

2) aop:after 示例

AspectJ after 通知在调用实际的业务逻辑方法之后应用。它可以用于维护日志、安全、通知等。

这里，我们假设 Operation.java、TrackOperation.java 和 Test.java 文件与 aop:before 示例中给出的相同。

现在创建定义 bean 的 applicationContext.xml 文件。

文件：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.javatpoint.Operation">	</bean>
<bean id="trackAspect" class="com.javatpoint.TrackOperation"></bean>
		
<aop:config>
  <aop:aspect id="myaspect" ref="trackAspect" >
     <!-- @After -->
     <aop:pointcut id="pointCutAfter"	expression="execution(* com.javatpoint.Operation.*(..))" />
     <aop:after method="myadvice" pointcut-ref="pointCutAfter" />
  </aop:aspect>
</aop:config>
	
</beans>

输出

您可以看到在调用 msg()、m() 和 k() 方法之后打印了附加的关注点。

3) aop:after-returning 示例

通过使用 after returning 通知，我们可以在通知中获取结果。

创建包含业务逻辑的类。

文件: Operation.java

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

创建包含 after returning 通知的方面类。

文件: TrackOperation.java

package com.javatpoint;

import org.aspectj.lang.JoinPoint;

public class TrackOperation{
	public void myadvice(JoinPoint jp,Object result)//it is advice (after advice)
	{
		System.out.println("additional concern");
		System.out.println("Method Signature: "  + jp.getSignature());
		System.out.println("Result in advice: "+result);
		System.out.println("end of after returning advice...");
	}
}

文件：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.javatpoint.Operation">	</bean>
	
<bean id="trackAspect" class="com.javatpoint.TrackOperation"></bean>
		
<aop:config>
  <aop:aspect id="myaspect" ref="trackAspect" >
     <!-- @AfterReturning -->
     <aop:pointcut id="pointCutAfterReturning"	expression="execution(* com.javatpoint.Operation.*(..))" />
     <aop:after-returning method="myadvice" returning="result" pointcut-ref="pointCutAfterReturning" />
  </aop:aspect>
</aop:config>
	
</beans>

文件：Test.java

现在创建调用实际方法的 Test 类。

package com.javatpoint;

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

输出

您可以看到返回值打印了两次，一次由 TrackOperation 类打印，另一次由 Test 类打印。

4) aop:around 示例

AspectJ around 通知在调用实际的业务逻辑方法之前和之后应用。

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

文件: Operation.java

package com.javatpoint;
public  class Operation{
	public void msg(){System.out.println("msg() is invoked");}
	public void display(){System.out.println("display() is invoked");}
}

创建包含 around 通知的方面类。

您需要在通知方法中传递 PreceedingJoinPoint 引用，以便我们可以通过调用 proceed() 方法来继续请求。

文件: TrackOperation.java

package com.javatpoint;
import org.aspectj.lang.ProceedingJoinPoint;
public class TrackOperation
{
	public Object myadvice(ProceedingJoinPoint pjp) throws Throwable 
	{
		System.out.println("Additional Concern Before calling actual method");
		Object obj=pjp.proceed();
		System.out.println("Additional Concern After calling actual method");
		return obj;
	}
}

文件：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.javatpoint.Operation">	</bean>
	
<bean id="trackAspect" class="com.javatpoint.TrackOperation"></bean>
		
<aop:config>
  <aop:aspect id="myaspect" ref="trackAspect" >
     <!-- @Around -->
     <aop:pointcut id="pointCutAround"	expression="execution(* com.javatpoint.Operation.*(..))" />
     <aop:around method="myadvice" pointcut-ref="pointCutAround" />
  </aop:aspect>
</aop:config>
	
</beans>

文件：Test.java

现在创建调用实际方法的 Test 类。

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

输出

您可以看到在调用 msg() 和 display 方法之前和之后打印了附加的关注点。

5) aop:after-throwing 示例

通过使用 after throwing 通知，我们可以在 TrackOperation 类中打印异常。让我们看看 AspectJ AfterThrowing 通知的示例。

创建包含业务逻辑的类。

文件: Operation.java

package com.javatpoint;
public  class Operation{
	public void validate(int age)throws Exception{
	if(age<18){
		throw new ArithmeticException("Not valid age");
	}
	else{
		System.out.println("Thanks for vote");
	}
	}
	
}

创建包含 after throwing 通知的方面类。

这里，我们还需要传递 Throwable 引用，以便我们可以在此处拦截异常。

文件: TrackOperation.java

package com.javatpoint;
import org.aspectj.lang.JoinPoint;
public class TrackOperation{
			      
	public void myadvice(JoinPoint jp,Throwable error)//it is advice
	{
		System.out.println("additional concern");
		System.out.println("Method Signature: "  + jp.getSignature());
		System.out.println("Exception is: "+error);
		System.out.println("end of after throwing advice...");
	}
}

文件：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.javatpoint.Operation">	</bean>
<bean id="trackAspect" class="com.javatpoint.TrackOperation"></bean>
		
<aop:config>
  <aop:aspect id="myaspect" ref="trackAspect" >
     <!-- @AfterThrowing -->
     <aop:pointcut id="pointCutAfterThrowing"	expression="execution(* com.javatpoint.Operation.*(..))" />
     <aop:after-throwing method="myadvice" throwing="error" pointcut-ref="pointCutAfterThrowing" />
  </aop:aspect>
</aop:config>
	
</beans>

文件：Test.java

现在创建调用实际方法的 Test 类。

package com.javatpoint;

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

输出

下载所有示例（使用 MyEclipse IDE 开发）

下一个主题Spring Jdbc Template 教程

我们提供所有技术（如 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 AspectJ XML 配置示例

要了解 AOP 概念、它的优势等，请访问此处 AOP 概念教程

1) aop:before 示例

输出

2) aop:after 示例

输出

3) aop:after-returning 示例

输出

4) aop:around 示例

输出

5) aop:after-throwing 示例

输出

相关帖子

AOP 概念

Spring1.2 AOP DTD

SP AspectJ 注解

订阅 Tpoint Tech

联系信息

关注我们

教程

面试题

在线编译器