spring AOP(2)

 

       前面写过一篇关于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应用了。怎么样，并不是很难吧。大家已经看到，如果我们的接口里面定义了很多方法，那么所有的方法都会置入这些通知，但有时候我们是希望有所选择的，怎么改进呢？还有，如果我们还有很多个这样需要置入这些通知的对象存在，那针对每一个目标都要做一个几乎一样的代理的配置，似乎也欠妥。那么，如何优化呢。这就是我们下一篇文章的主题了。呵呵，继续前进吧！