个性化阅读
专注于IT技术分析

Spring AOP AspectJ Xml配置示例

  1. aop:before示例
  2. aop:after示例
  3. aop:return示例
  4. aop:around示例
  5. aop:throw示例

Spring使你可以在xml文件中定义方面, Advice和切入点。

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

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

  1. aop:before在调用实际的业务逻辑方法之前应用。
  2. aop:after在调用实际的业务逻辑方法之后应用。
  3. aop:return返回后, 在调用实际的业务逻辑方法后应用。它可用于截获通知中的返回值。
  4. aop:around在调用实际业务逻辑方法之前和之后应用。
  5. aop:after-throwing如果实际的业务逻辑方法引发异常, 则将其应用。

要了解aop概念及其优势等, 请访问此处。AOP概念教程


下载所有示例(使用MyEclipse IDE开发)


1)aop:before示例

在实际业务逻辑方法之前应用AspectJ Before Advice。你可以在此处执行任何操作, 例如转换, 身份验证等。

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

文件:Operation.java

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

现在, 创建包含在Advice之前的方面类。

文件:TrackOperation.java

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

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

文件:Test.java

package com.srcmini;

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 …调用了附加关注msg()方法调用了m …调用了附加关注m()方法调用了k …调用了附加关注k()方法

如你所见, 在调用msg(), m()和k()方法之前, 需要打印其他一些问题。


2)aop:after示例

调用实际的业务逻辑方法后, 将应用忠于Advice的AspectJ。它可以用来维护日志, 安全性, 通知等。

在这里, 我们假设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.srcmini.Operation">	</bean>
<bean id="trackAspect" class="com.srcmini.TrackOperation"></bean>
		
<aop:config>
  <aop:aspect id="myaspect" ref="trackAspect" >
     <!-- @After -->
     <aop:pointcut id="pointCutAfter"	expression="execution(* com.srcmini.Operation.*(..))" />
     <aop:after method="myadvice" pointcut-ref="pointCutAfter" />
  </aop:aspect>
</aop:config>
	
</beans>

输出

调用msg … msg()方法调用附加关注点调用m … m()方法调用附加关注点调用k … k()方法调用附加关注点

你可以看到在调用msg(), m()和k()方法之后, 还会显示其他问题。


3)aop:return示例

通过在返回Advice后使用, 我们可以在Advice中获得结果。

创建包含业务逻辑的类。

文件:Operation.java

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

返回Advice后, 创建包含的方面类。

文件:TrackOperation.java

package com.srcmini;

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

文件:Test.java

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

package com.srcmini;

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

输出

调用m … m()方法调用了其他方法方法签名:int com.srcmini.Operation.m()通知结果:2返回Advice后的结尾… 2调用k … k()方法调用了其他方法有关方法签名:int com.srcmini.Operation.k()通知结果:3返回Advice后的结尾… 3

你会看到返回值被打印两次, 一次是由TrackOperation类打印, 第二次是由Test类打印。


4)aop:around示例

围绕Advice的AspectJ在调用实际的业务逻辑方法之前和之后都会应用。

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

文件:Operation.java

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

创建包含围绕Advice的方面类。

你需要在advice方法中传递PreceedingJoinPoint引用, 以便我们可以通过调用progress()方法来进行请求。

文件:TrackOperation.java

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

文件:Test.java

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

package com.srcmini;
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()之前的其他问题调用实际方法之后的其他问题

你可以看到在调用msg()和display方法之前和之后都会打印出其他问题。


5)aop:throw示例

通过使用引发Advice后的用法, 我们可以在TrackOperation类中打印异常。让我们看一下AspectJ AfterThrowingAdvice的示例。

创建包含业务逻辑的类。

文件:Operation.java

package com.srcmini;
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");
	}
	}
	
}

创建Advice后包含的方面类。

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

文件:TrackOperation.java

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

文件:Test.java

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

package com.srcmini;

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

输出

调用验证…感谢投票再次验证…其他关注方法签名:void com.srcmini.Operation.validate(int)异常是:java.lang.ArithmeticException:抛出Advice后无效的年龄结束… java.lang.ArithmeticException:无效年龄


下载所有示例(使用MyEclipse IDE开发)


赞(0) 打赏
未经允许不得转载:srcmini » Spring AOP AspectJ Xml配置示例
分享到: 更多 (0)

评论 抢沙发

评论前必须登录!

 

觉得文章有用就打赏一下文章作者

微信扫一扫打赏