Spring Aop Schema 实现

本例使用的是Spring2.5

1、Aop配置文件spring-aop.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"
	xmlns:aop="http://www.springframework.org/schema/aop"
	xsi:schemaLocation=
		"http://www.springframework.org/schema/beans 
		http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
		http://www.springframework.org/schema/aop
		http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
		">
	
	<bean id = "helloWorldServiceImpl" class="com.spring.xkey.aop.HelloWorldServiceImpl">
	</bean>
	
	<bean id = "aspect" class = "com.spring.xkey.aop.HelloWorldAspect">
	</bean>
	
	<aop:config>
		<aop:pointcut id="pointcut" expression="execution(* com.spring..*.sayHello(..)) and args(user)"/>
		<aop:aspect ref="aspect">
			<aop:before pointcut-ref = "pointcut" method="beforeAdvice(java.lang.String)" arg-names="user"/>
			<aop:after pointcut="execution(* com.spring..*.sayHello(..))" method="afterAdvice"/>
			<aop:after-returning pointcut="execution(* com.spring..*.sayAfterReturning(..))" 
								 method="afterReturningAdvice"
								 arg-names="value"
								 returning="value"/>
			<aop:after-throwing pointcut="execution(* com.spring..*.sayAfterThrowing(..))"
								method="afterThrowingAdvice"
								arg-names="e"
								throwing="e"/>
			<aop:around pointcut="execution(* com.spring..*.sayAround(..))"
						method="aroundAdvice"
						/>
		</aop:aspect>
	</aop:config>
</beans>

2、HelloWorldService接口

package com.spring.xkey.aop;

public interface HelloWorldService {

	public void sayHello(String username);
	public boolean sayAfterReturning(); 
	public void sayAfterThrowing();
	public int sayAround(String username,String password);
}

3、HelloWorldServiceImpl类

package com.spring.xkey.aop;
import java.lang.RuntimeException;

public class HelloWorldServiceImpl  implements HelloWorldService{
	public void sayHello(String username){
		System.out.println("My first Aop test "+username);
	}
	public boolean sayAfterReturning(){
		System.out.println("after returning");
		return true;
	}
	
	public void sayAfterThrowing(){
		System.out.println("After throwing");
		throw new RuntimeException();
	}
	
	public int sayAround(String username,String password){
		System.out.println("Around::: "+username+", "+password);
		int val = 1;
		return val;
	}
}

4、具体实现AOP编程的HelloWorldAspect类

package com.spring.xkey.aop;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;


public class HelloWorldAspect {
	
	public void beforeAdvice(String user){
		//System.out.println(jp.getArgs()[0].toString());
		System.out.println("before advice " + user);
	}
	
	public void afterAdvice(JoinPoint jp){
		System.out.println("after advice "+jp.getArgs()[0].toString());
	}
	
	public void afterReturningAdvice(Object value){
		System.out.println("afterReturning advice "+value);
		
	}
	public void afterThrowingAdvice(Exception e){
		System.out.println("after throwing advice exception:" + e); 
	}
	
	public Object aroundAdvice(ProceedingJoinPoint pjp) throws Throwable{
		/**System.out.println(pjp.toLongString());
		System.out.println(pjp.getSignature().toString());
		System.out.println(pjp.getKind().toString());
		System.out.println(pjp.getArgs()[0].toString());
		System.out.println("name+psd");*/
		Object [] obj = pjp.getArgs();
		String username = (String) obj[0];
		String password = (String) obj[1];
		System.out.println(username+","+password);
		Object retVal;
		if(username.equals("xkey") && password.equals("color")){
			retVal = pjp.proceed();
		}else{
			retVal = pjp.proceed(new Object[]{"ideal","*******"});
		}
		System.out.println("name+psd");
		if(retVal == null) System.out.println("false");
		else{
			System.out.println(retVal.toString());
		}
		return 2;
	}
}

5、测试类

package com.spring.xkey.aop;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class AopTest {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		ApplicationContext context =
			new ClassPathXmlApplicationContext("com/spring/xkey/aop/spring-aop.xml");
		HelloWorldService hello = (HelloWorldService)context.getBean("helloWorldServiceImpl");
		hello.sayHello("xkey");
		System.out.println("===================================");
//		hello.sayAfterReturning();
//		System.out.println("===================================");
//		hello.sayAfterThrowing();
//		System.out.println("===================================");
		Object val = (Object)hello.sayAround("xkey", "colo");
		System.out.println(val.toString());
	}
}

6、AOP Around（环绕通知）可以控制返回对象，即你可以返回一个与目标对象完全不同的返回值，虽然这很危险，但是你却可以办到。目标方法的返回值 就是 环绕通知的返回值。proceed() 方法可以在通知体内调用一次、多次 或根本不用调用；还可以控制执行方法的参数值。具体见aroundAdvice方法的实现。

7、给个更直观的结果

before advice xkey
My first Aop test xkey
after advice xkey
===================================
xkey,colo
Around::: ideal, ********
name+psd
In the AroundAdvice the return value is 1
After AroundAdvice modify return value is 2

这里使用AOP Around就可以用来进行一个身份验证，通过面向切面编程（AOP）将验证部分独立出来，使得代码的耦合度降低，如果使用面向对象思想（OOP）就应该是独立写一个身份验证的方法，然后当需要使用该方法再去new 一个身份验证方法的类，然后传递参数通过验证类中的方法去验证，这样代码的耦合度就变强了。