SpringFramework中的AOP简单使用

SpringFramework中的AOP简单使用

AOP作为Spring这个轻量级的容器中很重要的一部分，得到越来越多的关注，Spring的Transaction就是用AOP来管理的，今天就通过简单的例子来看看Spring中的AOP的基本使用方法。

  首先确定将要Proxy的目标，在Spring中默认采用JDK中的dynamic proxy，它只能够实现接口的代理，如果想对类进行代理的话，需要采用CGLIB的proxy。显然，选择“编程到接口”是更明智的做法，下面是将要代理的接口：

  public interface FooInterface {

    public void printFoo();

    public void dummyFoo();

  }

  以及其一个简单的实现：

  public class FooImpl implements FooInterface {

    public void printFoo() {

      System.out.println("In FooImpl.printFoo");

    }

    public void dummyFoo() {

      System.out.println("In FooImpl.dummyFoo");

  接下来创建一个Advice，在Spring中支持Around,Before,After returning和Throws四种Advice，这里就以简单的Before Advice举例：

  public class PrintBeforeAdvice implements MethodBeforeAdvice {

    public void before(Method arg0, Object[] arg1, Object arg2) throws Throwable {

      System.out.println("In PrintBeforeAdvice");

  有了自己的business interface和advice，剩下的就是如何去装配它们了，首先利用ProxyFactory以编程方式实现，如下：

  public class AopTestMain {

    public static void main(String[] args) {

      FooImpl fooImpl = new FooImpl();

      PrintBeforeAdvice myAdvice = new PrintBeforeAdvice();

      ProxyFactory factory = new ProxyFactory(fooImpl);

      factory.addBeforeAdvice(myAdvice);

      FooInterface myInterface = (FooInterface)factory.getProxy();

      myInterface.printFoo();

      myInterface.dummyFoo();

  现在执行程序，神奇的结果就出现了：

  In PrintBeforeAdvice

  In FooImpl.printFoo

  In FooImpl.dummyFoo

  虽然这样能体会到Spring中AOP的用法，但这决不是值得推荐的方法，既然使用了Spring，在ApplicationContext中装配所需要 的bean才是最佳策略，实现上面的功能只需要写个简单的applicationContext就可以了，如下：

  <?xml version="1.0" encoding="UTF-8"?>

  <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"

    "http://www.springframework.org/dtd/spring-beans.dtd">

  <beans>

    <description>The aop application context</description>

    <bean id="fooTarget" class="FooImpl"/>

    <bean id="myAdvice" class="PrintBeforeAdvice"/>

    <bean id="foo" class="org.springframework.aop.framework.ProxyFactoryBean">

     <property name="proxyInterfaces">

       <value>FooInterface</value>

     </property>

     <property name="target">

       <ref local="fooTarget"/>

     <property name="interceptorNames">

       <list>

         <value>myAdvice</value>

       </list>

    </bean>

  </beans>

  当然，main中的代码也要进行相应的修改：

  public static void main(String[] args) {

    ClassPathXmlApplicationContext context = new 

             ClassPathXmlApplicationContext("applicationContext.xml");

    FooInterface foo = (FooInterface)context.getBean("foo");

    foo.printFoo();

    foo.dummyFoo();

  现在运行一下，结果将和上面的运行结果完全一样，这样是不是更优雅？当需要更改实现时，只需要修改配置文件就可以了，程序中的代码不需任何改动。

  但是，这时候会发现被proxy的object中的所有方法调用时都将运行advice中的before，这显然不能满足绝大多数情况下的需要，此时，只 需借用Advisor就可以了，当然要在Advisor中利用pattern设置好哪些方法需要advice，更改applicationContext 如下：

    <description>The springeva application context</description>

    <bean id="printBeforeAdvice" class="PrintBeforeAdvice"/>

    <bean id="myAdvisor"

          class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">

      <property name="advice">

        <ref local="printBeforeAdvice"/>

      </property>

      <property name="pattern">

        <value>.*print.*</value>

      <property name="proxyInterfaces">

        <value>FooInterface</value>

      <property name="target">

        <ref local="fooTarget"/>

      <property name="interceptorNames">

        <list>

          <value>myAdvisor</value>

        </list>

  主程序不需进行任何修改，运行结果已经变样了：

  至此，应该已经理解了Spring中AOP的使用方法，当然Spring中AOP最重要的应用是Transaction Manager，举个这方面的applicationContext例子看看：

  <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "spring-beans.dtd">

    <bean id="propertyConfigurer"   

         class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">

      <property name="location">

        <value>/WEB-INF/jdbc.properties</value>

    <bean id="dataSource"

          class="org.springframework.jdbc.datasource.DriverManagerDataSource">

      <property name="driverClassName">

        <value>${jdbc.driverClassName}</value>

      <property name="url">

        <value>${jdbc.url}</value>

      <property name="username">

        <value>${jdbc.username}</value>

      <property name="password">

        <value>${jdbc.password}</value>

    <bean id="sessionFactory"

          class="org.springframework.orm.hibernate.LocalSessionFactoryBean">

      <property name="dataSource">

        <ref local="dataSource"/>

      <property name="mappingResources">

        <value>smartmenu.hbm.xml</value>

      <property name="hibernateProperties">

        <props>

          <prop key="hibernate.dialect">${hibernate.dialect}</prop>

        </props>

    <bean id="transactionManager"       

          class="org.springframework.orm.hibernate.HibernateTransactionManager">

      <property name="sessionFactory">

        <ref local="sessionFactory"/>

    <bean id="smartmenuTarget" class="SmartMenuHibernate">

    <bean id="smartMenu"

        class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">

      <property name="transactionManager">

        <ref local="transactionManager"/>

        <ref local="smartmenuTarget"/>

      <property name="transactionAttributes">

          <prop key="get*">PROPAGATION_REQUIRED,readOnly</prop>

          <prop key="find*">PROPAGATION_REQUIRED,readOnly</prop>

  要想彻底理解Spring的AOP，最好还是多看看源码，开源就是好啊！