spring AOP(2)

spring AOP(2)

2101发表于2016-11-15

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


小编蓝狐