前面写过一篇关于Spring AOP方面的文章，探讨了Spring AOP底层实现的一些细节知识，这里面涉及到了JAVA反射机制，代理模式以及CGLIB库的使用。也就是说，Spring AOP底层实现就是靠动态代理（针对有接口的类）和CGLIB（针对没有实现接口的一般类），那么，有了这些知识，再辅佐对核心配置XML文件解析的能力，其实就可以实现一个简易的基于IOC和AOP的小框架，大家可以自己尝试着写一下。下面呢我们就由浅入深地来看看在Spring中AOP是怎么实现的。
最简单的AOP实现只需要涉及3个概念：目标(Target)，通知(Advice)和代理(Proxy)。目标呢，当然就是真实的需要被代理的对象，一般它会实现至少一个接口。通知呢，就是当目标的方法调用时需要调用的代码，也叫拦截器。而代理，毫无疑问就是加入了通知的目标了，它可以作为目标的替身出现。为了说明这三者的关系，我们来看一个网上有趣的小例子：一间书店开始打折促销，规则是每一名顾客只能买一本书，并且当顾客来到书店时，要说喜欢您来。顾客走的时候，还要说喜欢您再来！（麦当劳啊^_^） 顾客如果买到<hibernate in action>这本书，要抛出异常，告知他没有存货！呵呵，好啦，洪哥，我们动手吧！
package com.wepull.spring.book;
public class NoThisBookException extends Exception {
public NoThisBookException(String msg) {
super(msg);
}
}
package com.wepull.spring.book;
public interface BuyBook {
public void buyBook(String customer,String book) throws NoThisBookException;
}
package com.wepull.spring.book;
public class MyBuyBook implements BuyBook{
public void buyBook(String customer, String book)
throws NoThisBookException {
if(book.equals("<hibernate in action>"))
throw new NoThisBookException("对不起，没有"+book+"的存货了！");
System.out.println(customer+",你好，你已经购买了一本"+book+"!");
}
}
看上面，我们做了一个异常类和一个简单买书的接口，并且目标MyBuyBook也已经出现。OK,再来看看通知吧！
Spring中主要有以下四种通知类型：
（1）Around通知
（2）Before通知
（3）Throws通知
（4）After Returning通知
例子分别如下：
package com.wepull.spring.book;
import java.util.HashSet;
import java.util.Set;
import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
public class MyAroundAdvice implements MethodInterceptor {
private Set customers=new HashSet(); //保存购过书的顾客信息
public Object invoke(MethodInvocation invocation) throws Throwable {
Object[] args= invocation.getArguments();
if(customers.contains(args[0])){
System.out.println("对不起，一名顾客只能买一本打折书！");
return null;
}
customers.add(args[0]);
return invocation.proceed();
}
}
package com.wepull.spring.book;
import java.lang.reflect.Method;
import org.springframework.aop.MethodBeforeAdvice;
public class MyBeforeAdvice implements MethodBeforeAdvice {
public void before(Method arg0, Object[] arg1, Object arg2)
throws Throwable {
String customer=(String)arg1[0]; //第2个参数组就是被通知的方法传入的参数，本例中即customer,book
System.out.println("喜欢您来!"+customer+"!"); //显示欢迎信息！，在buyBook方法前调用
}
}
package com.wepull.spring.book;
import java.lang.reflect.Method;
import org.springframework.aop.ThrowsAdvice;
public class MyThrowsAdvice implements ThrowsAdvice {
public void afterThrowing(Method method, Object[] args, Object target, NoThisBookException e){
//可以定义多个方法，只要传入的参数是不同异常
System.out.println("对不起"+args[0]+"，没货了。通知仓库，赶紧加书！");
}
}
package com.wepull.spring.book;
import java.lang.reflect.Method;
import org.springframework.aop.AfterReturningAdvice;
public class MyAfterAdvice implements AfterReturningAdvice {
public void afterReturning(Object arg0, Method arg1, Object[] arg2,
Object arg3) throws Throwable {
String customer=(String)arg2[0]; //同前置通知一样，参数组3为传入参数，具体见spring doc
System.out.println("喜欢您再来！"+customer+"!"); //显示欢送信息!
}
}
现在目标类有了，通知类也写好了，写了就要配，这是框架的基本使用原则。呵呵，下面就来看看核心配置文件src/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"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">
<!-- 各种通知 -->
<!-- 前置通知 -->
<bean id="myBeforeAdvice"
class="com.wepull.spring.book.MyBeforeAdvice">
</bean>
<!-- 后置通知 -->
<bean id="myAfterAdvice"
class="com.wepull.spring.book.MyAfterAdvice">
</bean>
<!-- 异常通知 -->
<bean id="myThrowsAdvice"
class="com.wepull.spring.book.MyThrowsAdvice">
</bean>
<!-- 环绕通知 -->
<bean id="myAroundAdvice"
class="com.wepull.spring.book.MyAroundAdvice">
</bean>
<!-- 目标对象 -->
<bean id="buyBookTarget"
class="com.wepull.spring.book.MyBuyBook">
</bean>
<!-- 代理对象 -->
<!-- ProxyFactoryBean被用于创建代理 -->
<bean id="buyBook"
class="org.springframework.aop.framework.ProxyFactoryBean">
<!-- 实现的接口 -->
<property name="proxyInterfaces">
<value>com.wepull.spring.book.BuyBook</value>
</property>
<!-- 应用所有 (通知)拦截器对象到所有调用 -->
<property name="interceptorNames">
<list>
<value>myBeforeAdvice</value>
<value>myAfterAdvice</value>
<value>myThrowsAdvice</value>
<value>myAroundAdvice</value>
</list>
</property>
<!-- 代理的目标对象 -->
<property name="target">
<ref bean="buyBookTarget" />
</property>
</bean>
</beans>
注意上面的ProxyFactoryBean类是在BeanFactory中显式地创建代理对象的中心类。你给它一个要实现的接口，一个要代理的目标对象，若干个要织入的通知，它就会创建一个崭新的代理对象。所以通常配置ProxyFactoryBean，让它实现和目标对象一样的接口。最后当然是测试代码了。
package com.wepull.spring.book;
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");
BuyBook buyBook = (BuyBook) context.getBean("buyBook");
try {
buyBook.buyBook("leno", "<struts in action>");
buyBook.buyBook("leno", "<spring in action>");
buyBook.buyBook("lenotang", "<hibernate in action>");
} catch (NoThisBookException e) {
e.printStackTrace();
}
}
}
这就是Spring中最简单的AOP应用了。怎么样，并不是很难吧。大家已经看到，如果我们的接口里面定义了很多方法，那么所有的方法都会置入这些通知，但有时候我们是希望有所选择的，怎么改进呢？还有，如果我们还有很多个这样需要置入这些通知的对象存在，那针对每一个目标都要做一个几乎一样的代理的配置，似乎也欠妥。那么，如何优化呢。这就是我们下一篇文章的主题了。呵呵，继续前进吧！