advice是你想向别的程序内部不同的地方注入的代码。pointcut定义了需要注入advice的位置，通常是某个特定的类的一个public方法。advisor是pointcut和advice的装配器，是将advice注入主程序中预定义位置的代码。

      既然我们知道了需要使用advisor向主要代码中注入“不可见的”advice，让我们实现一个Spring AOP的例子。 在这个例子中，我们将实现一个before advice，这意味着advice的代码在被调用的public方法开始前被执行。 以下是这个before advice的实现代码：

package com.company.springaop.test;

import java.lang.reflect.Method;
import org.springframework.aop.MethodBeforeAdvice;

public class TestBeforeAdvice implements MethodBeforeAdvice { //这里还有after，Exception，around等Advice
/**
*before 是在方法执行之前执行advice的内容，around是在方法执行之前和之后都得到了执行
*Exception是抛出异常的时候，可以使用aop的方法来统一处理业务的异常。
×在编程的时候，可以由专门的人处理业务的异常，其它人还是一样的编程，不用考虑业务类异常的处理。
*/

  public void before(Method m, Object[] args, Object target)
  throws Throwable { //这里能用反射？
    System.out.println("Hello world! (by "
        + this.getClass().getName()
        + ")");
  }
}

接口MethodBeforeAdvice只有一个方法before需要实现，它定义了advice的实现。before方法共用三个参数，它们提供了相当丰富的信息。参数Method m是advice开始后执行的方法。方法名称可以用作判断是否执行代码的条件。Object[] args是传给被调用的public方法的参数数组。当需要记日志时，参数args和被执行方法的名称，都是非常有用的信息。你也可以改变传给m的参数，但要小心使用这个功能；编写最初主程序的程序员并不知道主程序可能会和传入参数的发生冲突。Object target是执行方法m对象的引用。 在下面的BeanImpl类中，每个public方法调用前，都会执行advice：

package com.company.springaop.test;

public class BeanImpl implements Bean {

  public void theMethod() {
    System.out.println(this.getClass().getName()
        + "." + new Exception().getStackTrace()[0].getMethodName()
        + "()"
        + " says HELLO!");
  }
}

类BeanImpl实现了下面的接口Bean：

package com.company.springaop.test;

public interface Bean {
  public void theMethod();
}

 虽然不是必须使用接口，但面向接口而不是面向实现编程是良好的编程实践，Spring也鼓励这样做。 pointcut和advice通过配置文件来实现，因此，接下来你只需编写主方法的Java代码：

package com.company.springaop.test;

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

public class Main {

  public static void main(String[] args) {
    //Read the configuration file
    ApplicationContext ctx
        = new FileSystemXmlApplicationContext("springconfig.xml");

    //Instantiate an object
    Bean x = (Bean) ctx.getBean("bean");

    //Execute the public method of the bean (the test)
    x.theMethod();
  }
}

我们从读入和处理配置文件开始，接下来马上要创建它。这个配置文件将作为粘合程序不同部分的“胶水”。读入和处理配置文件后，我们会得到一个创建工厂ctx。任何一个Spring管理的对象都必须通过这个工厂来创建。对象通过工厂创建后便可正常使用。 仅仅用配置文件便可把程序的每一部分组装起来。

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC  "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">

<beans>
  <!--CONFIG-->
  <bean id="bean" class="org.springframework.aop.framework.ProxyFactoryBean">
    <property name="proxyInterfaces">
      <value>com.company.springaop.test.Bean</value>
    </property>
    <property name="target">
      <ref local="beanTarget"/>
    </property>
    <property name="interceptorNames">
      <list>
        <value>theAdvisor</value>
      </list>
    </property>
  </bean>

  <!--CLASS-->
  <bean id="beanTarget" class="com.company.springaop.test.BeanImpl"/>

  <!--ADVISOR-->
  <!--Note: An advisor assembles pointcut and advice-->
  <bean id="theAdvisor" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
    <property name="advice">
      <ref local="theBeforeAdvice"/>
    </property>
    <property name="pattern"> //pointcut?
      <value>com\.company\.springaop\.test\.Bean\.theMethod</value>
    </property>
  </bean>

  <!--ADVICE-->
  <bean id="theBeforeAdvice" class="com.company.springaop.test.TestBeforeAdvice"/>
</beans>
 

四个bean定义的次序并不重要。我们现在有了一个advice，一个包含了正则表达式pointcut的advisor， 一个主程序类和一个配置好的接口，通过工厂ctx，这个接口返回自己本身实现的一个引用。 BeanImpl 和TestBeforeAdvice都是直接配置。我们用一个唯一的ID创建一个bean元素，并指定了一个实现类。这 就是全部的工作。advisor通过Spring framework提供的一个RegexMethodPointcutAdvisor类来实现。我 们用advisor的一个属性来指定它所需的advice-bean。第二个属性则用正则表达式定义了pointcut，确保 良好的性能和易读性。 最后配置的是bean，它可以通过一个工厂来创建。bean的定义看起来比实际上要 复杂。bean是ProxyFactoryBean的一个实现，它是Spring framework的一部分。这个bean的行为通过一下 的三个属性来定义：

属性proxyInterface定义了接口类。 属性target指向本地配置的一个bean，这个bean返回一个接口的实现。 属性interceptorNames是唯一允许定义一个值列表的属性。这个列表包含所有需要在beanTarget上执行的advisor。 注意，advisor列表的次序是非常重要的。

Spring工具

虽然你可以手工修改Ant构建脚本，但使用SpringUI（译注：SpringUI现在是Spring framework的一部分，并改名 为spring-ide），使用Spring AOP变得很简单，只要点点鼠标即可。你可以把SpringUI安装成Eclipse的一个plug-in。 然后，你只需在你的project上右击鼠标，并选择“add Spring Project Nature”。在project属性中，你可以在“Spring Project”下添加Spring配置文件。在编译前把下面的类库加入project：aopalliance.jar，commons-logging.jar， jakarta-oro-2.0.7.jar和spring.jar。运行程序时你会看到下面的信息：

... (logging information)
Hello world! (by com.company.springaop.test.TestBeforeAdvice)
com.company.springaop.test.BeanImpl.theMethod() says HELLO!

优点和缺点

Spring比起其他的framework更有优势，因为除了AOP以外，它提供了更多别的功能。 作为一个轻型framework，它在J2EE不同的部分都可以发挥作用。因此，即使不想使用Spring AOP， 你可能还是想使用Spring。另一个优点是，Spring并不要求开发团队所有的人员都会用它。 学习Spring应该从Spring reference的第一页开始。读了本文后，你应该可以更好地理解Spring reference了。 Spring唯一的缺点是缺乏更多的文档，但它的mailing list是个很好的补充，而且会不断地出现更多的文档。

Spring 2.0 的重头戏之一就是AspectJ 式 AOP 配置。 但是一定要通过对比，才能看到2.0式的AOP配置是如何跳出一片新天空的。

1. 对比
先看1.0的标准事务配置:

    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource">
            <ref bean="dataSource"/>
        </property>
    </bean>

<bean id="baseTxService" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean"  abstract="true">  
        <property name="transactionManager" ref="transactionManager"/>  
        <property name="proxyTargetClass" value="true"/>  
        <property name="transactionAttributes">  
            <props>  
                <prop key="get*">PROPAGATION_REQUIRED,readOnly</prop>  
                <prop key="find*">PROPAGATION_REQUIRED,readOnly</prop>  
                <prop key="save*">PROPAGATION_REQUIRED</prop>  
                <prop key="remove*">PROPAGATION_REQUIRED</prop>  
            </props>  
        </property>  
        <property name="preInterceptors">  
            <list>  
                <ref bean="methodSecurityInterceptor"/>  
            </list>  
        </property>  
 </bean>  

<bean id="bookManager" parent="baseTxService">  
        <property name="target">  
            <bean class="org.springside.bookstore.admin.manager.BookManager"/>  
        </property>  
 </bean>

再看2.0的新配置：

<aop:config proxy-target-class="true">  
    <aop:advisor pointcut="execution(* yourpackagename..*Manager.*(..))" advice-ref="txAdvice"/>  
    <aop:advisor pointcut="execution(* yourpackagename..*Manager.save(..))" advice-ref="fooAdvice"/>  
</aop:config>

<tx:advice id="txAdvice" transaction-manager="transactionManager">  
    <tx:attributes>  
        <tx:method name="save*"/>  
        <tx:method name="remove*"/>  
        <tx:method name="*" read-only="true"/>  
   </tx:attributes>  
</tx:advice>  

<bean id="bookManager" class="org.springside.bookstore.commons.service.BookManager"/>  

再来看看 appfuse1.9.4的配置 ：




2.进步
1. AOP的配置方式也AOP了。
对比1.0的配置文件，因为下面2提到的限制，事关安全acegi methodSecurityInterceptor 拦截器要配置在关于事务的TransactionProxyFactoryBean的preInterceptors属性里，这样子就一点不AOP了，而2.0使用ponintcut expression，很AOP的配置一切Aspect。

2. 1.0时，一个已经AOP过的object不能再次被AOP。
在Spring 1.0的文档里Rod说，比如<bean id="bookManager" parent="baseTxService">已经进行了一次AOP，如果想在这个Bean上再配一层AOP，比如要对方法执行结果缓存，无论以1.0 还是2.0的方式定义，cglib方式是会报错的，而基于接口的方式，结果不确定。

3. BookManager能直接定义自己，而不是像1.0那样作匿名内部target。

虽然在1.0时代的BeanNameAutoProxyCreator 达到类似作用，但只能用BeanName来匹配比较危险，没有AspectJ的pointcut语法细致。

3. 语法
满江红翻译的Spring参考文档 6.3 schema-based AOP support 提供了aspect,advisor,advide三种组装方法的解释，其中aspect是aspectJ原装，但稍复杂.

唯一有点难懂的是pointcut里的语法，其实也很好学，Spring参考文档6.2.3.4里有完整说明 ，其实一排子过去是

execution(modifiers-pattern? ret-type-pattern declaring-type-pattern? name-pattern(param-pattern) throws-pattern?) 

其中带问号的modifiers-pattern?(public/protected) 和 declaring-type-pattern? throws-pattern? 可以不填

可见execution(* *..BookManager.save(..))

第一颗* 代表ret-type-pattern 返回值可任意，
 
*..BookManager 代表任意Pacakge里的BookManager类。

如果写成com.xyz.service.* 则代表com.xyz.service下的任意类
com.xyz.service..*  com.xyz.service则代表com.xyz.service及其子package下的任意类
save代表save方法，也可以写save* 代表saveBook()等方法
(..) 匹配0个参数或者多个参数的，任意类型
(x,..) 第一个参数的类型必须是X
(x,,,s,..) 匹配至少4个参数，第一个参数必须是x类型，第二个和第三个参数可以任意，第四个必须是s类型。

注意name-pattern千万不要写成*..*Manager ，这样子的话会把所有第三方类库的Manager比如Spring的PlatformTranstationManager 也加入aop，非常危险。所以最好还是加上项目的package前缀，如org.springside 

1. 对比
先看1.0的标准事务配置:

< bean id = " baseTxService "   class = " org.springframework.transaction.interceptor.TransactionProxyFactoryBean "   abstract = " true " >   
         < property name = " transactionManager "  ref = " transactionManager " />   
         < property name = " proxyTargetClass "  value = " true " />   
         < property name = " transactionAttributes " >   
             < props >   
                 < prop key = " get* " > PROPAGATION_REQUIRED,readOnly </ prop >   
                 < prop key = " find* " > PROPAGATION_REQUIRED,readOnly </ prop >   
                 < prop key = " save* " > PROPAGATION_REQUIRED </ prop >   
                 < prop key = " remove* " > PROPAGATION_REQUIRED </ prop >   
             </ props >   
         </ property >   
         < property name = " preInterceptors " >   
             < list >< ref bean = " methodSecurityInterceptor " /></ list >   
         </ property >   
  </ bean >   
  < bean id = " bookManager "  parent = " baseTxService " >   
         < property name = " target " >< bean  class = " org.springside.bookstore.admin.manager.BookManager " /></ property >   
  </ bean >  

<aop:config proxy-target-class="true">  
    <aop:advisor pointcut="execution(* yourpackagename..*Manager.*(..))" advice-ref="txAdvice"/>  
    <aop:advisor pointcut="execution(* yourpackagename..*Manager.save(..))" advice-ref="fooAdvice"/>  
</aop:config>

<tx:advice id="txAdvice" transaction-manager="transactionManager">  
    <tx:attributes>  
        <tx:method name="save*"/>  
        <tx:method name="remove*"/>  
        <tx:method name="*" read-only="true"/>  
   </tx:attributes>  
</tx:advice>  
  
<bean id="bookManager" class="org.springside.bookstore.commons.service.BookManager"/>  

通知（Advice）：横切操作时具体的操作。
切入点（Pointcut）：描述什么时候需要进行横切操作，即在哪些地方需要加入通知，但是切入点不关心具体的通知是什么。
通知者（Advisor）：由于通知者是通过切入点来创建的（切入点作为创建一个通知者实例时的参数），切入点可以对目标类和目标方法进行详细的描述，所以通知者告诉代理哪些类的哪些方法需要进行横切操作，从而对需要实现横切的方法进行灵活的定制。我把通知者理解为切入点和通知的绑定（通知作为创建通知者实例时的另一个参数），它描述了哪些类的哪些方法需要进行哪些横切操作（即哪个通知）。

再说说代理，代理的作用就是透明的为我们提供获得了通知的目标类（具体的使用方法看一下例子就明白了，非常简单）。这个目标类可以是我们自己写的任何类或者其他第三方类。我们在调用通过代理得到的目标类中的方法时就会触发某个通知，从而完成横切操作。

最后是我总结的实现横切的一般步骤
简单的切入：
1，创建某个通知的实例（spring提供五种通知）
2，创建代理的的实例
3，将通知加入代理
4，通过代理获取目标类实例
5，调用目标类的方法。

可对需要横切的方法进行具体定制的切入：
1，创建切入点实例（Spring提供了七种可对目标类和目标方法进行定制的切入点实现）
2，通过切入点和通知创建通知者实例
3，将通知者加入代理
4，通过代理获取目标类实例
5，调用目标类的方法。

实现Spring IoC容器的访问,可以通过如下两个接口完成
1.BeanFactory:开发者借助于配置文件实现对JavaBean的配置和管理.
2.ApplicationContext:构建在BeanFactory基础上,既继承于它,除了具有BeanFactory的功能外,还添加其他的功能
.3区别:BeanFactory 延迟载入所有的Bean,至到getBean()被调用时才被创建。
ApplicationContext 在上下文启动后预载入所有的单实例Bean
 

spring中有2种aop代理类实现，一种是jdk的动态代理，另外一种是CGLib实现的代理类,看看动态代理，对理解aop非常有好处的。

　　AOP（Aspected Oriented Programming）是一种新兴的编程技术。它可以解决OOP和过程化方法不能够很好解决的横切（crosscut）问题，如：事务、安全、日志等横切关注。当未来系统变得越来越复杂，横切关注点就成为一个打问题的时候，AOP就可以很轻松的解决横切关注点这个问题，使得AOP编程成为。Spring 是基于J2EE的轻量级开源开发框架，其中Spring AOP组件实现了面向方面编程。

　　AOP 概述

　　面向方面编程 (AOP) 提供从另一个角度来考虑程序结构以完善面向对象编程（OOP）。 面向对象将应用程序分解成各个层次的对象，而AOP将程序分解成各个方面或者说关注点 。这使得可以模块化诸如事务管理等这些横切多个对象的关注点。

　　1、AOP 基本概念

　　方面（Aspect）： 一个关注点的模块化，这个关注点实现可能另外横切多个对象。事务管理是J2EE应用中一个很好的横切关注点例子。方面用Spring的 Advisor或拦截器实现。

　　连接点（Joinpoint）: 程序执行过程中明确的点，如方法的调 用或特定的异常被抛出。

　　通知（Advice）: 在特定的连接点，AOP框架执行的动作。各种类 型的通知包括“around”、“before”和“throws”通知。通知类型将在下面讨论。许多AOP框架 包括Spring都是以拦截器做通知模型，维护一个“围绕”连接点的拦截器链。

　　切入点（Pointcut）: 指定一个通知将被引发的一系列连接点 的集合。AOP框架必须允许开发者指定切入点：例如，使用正则表达式。

　　引入（Introduction）: 添加方法或字段到被通知的类。 Spring允许引入新的接口到任何被通知的对象。例如，你可以使用一个引入使任何对象实现 IsModified接口，来简化缓存。

　　目标对象（Target Object）: 包含连接点的对象。也被称作 被通知或被代理对象。

　　AOP代理（AOP Proxy）: AOP框架创建的对象，包含通知。 在Spring中，AOP代理可以是JDK动态代理或者CGLIB代理。

　　织入（Weaving）: 组装方面来创建一个被通知对象。这可以在编译时 完成（例如使用AspectJ编译器），也可以在运行时完成。Spring和其他纯Java AOP框架一样， 在运行时完成织入。

　　Spring AOP 介绍

　　Spring的一个关键组件就是AOP框架。 Spring IoC容器(BeanFactory 和ApplicationContext)并不依赖于AOP, 这意味着如果你不需要使用，AOP可以不用，AOP完善了Spring IoC，使之成为一个有效的中间件解决方案。

　　Spring AOP 是Spring 框架的重要组成部分，它实现了AOP联盟约定的接口。Spring AOP 是由纯Java开发完成的。Spring AOP 只实现了方法级别的连接点，在J2EE应用中，AOP拦截到方法级的操作已经足够。OOP倡导的是基于setter/getter 的方法访问，而非直接访问域，而Spring 有足够理由仅仅提供方法级的连接点。为了使控制反转（IoC）很方便的使用到非常健壮、灵活的企业服务，则需要Spring AOP 的实现。Spring AOP 在运行时才创建Advice 对象。Spring AOP的优点如下：

　　·允许开发者使用声明式企业服务，比如事务服务、安全性服务。

　　·开发者可以开发满足业务需求的自定义方面。

　　·开发Spring AOP Advice 很方便，可以借助代理类快速搭建Spring AOP 应用。

　　使用Spring AOP松散耦合

　　1、创建通知

　　为实现AOP，开发者需要开发AOP 通知(Advice)。AOP 通知（Advice） 包含了方面（Aspect）的逻辑。当创建一个Advice 对象的时候，你就编写了实现横切（cross-cutting）功能。 Spring 的连接点是用方法拦截器实现的，这就意味着你编写的Spring AOP 通知将在方法调用的不同点组入进程序中。由于在调用一个方法时有几个不同的时间点，Spring 可以在不同的时间点组入进程序。Spring AOP中，提供了四种通知的接口： MethodBeforeAdvice 用于在目标方法调用前触发；AfterReturningAdvice 用于在目标方法调用后触发；ThrowsAdvice 用于在目标方法抛出异常时触发；MethodInterceptor 用于实现 Around 通知（Advice），在目方法执行的前后触发。

　　如果要实现相应功能，则需要实现上述对应的接口。例如：实现Before 通知（Advice）需要实现方法 void before(Method method, Object[] args, Object target) ，实现 After 通知（Advice） 需要实现方法 void afterReturning (Method method, Object[] args, Object target)。

　　2、在Spring 中定义切入点

　　在不能明确调用方法的时候，通知就很不实用。切入点则可以决定特定的类，特定的方法是否匹配特定标准。如果某匹配，则通知将应用到此方法上。Spring 切入点允许用很灵活的方式将通知组织进我们的类中。Spring 中的切入点框架的核心是Pointcut接口，此接口允许我们定义组入通知中的类和方法。许多方面是通过一系列的通知和切入点组合来定义。

　　在Spring中，一个advisor就是一个方面的完整的模块化表示。Spring提供了PointcutAdvisor接口把通知和切入点组合成一个对象。Spring中很多内建的切入点都有对应的PointcutAdvisor，这使得你可以很方便在一个地方管理切入点和通知。Spring中的切入点分为两类：静态和动态。因为静态切入点的性能要优于动态切入点，所以优先考虑使用。Spring 为我们提供创建静态切入点很实用的类StaticMethodMatherPointcut。在这个类中，我们只需要关心setMappedName和setMappedNams方法。你可以使用具体的类名，也可以使用通配符。如：设置mappedName属性为set* 则匹配所有的set方法。Spring还提供了另通过正则表达式来创建静态切入点的实用类RegexpMethodPointcut。通过使用Perl样式的正则表达式来定义你感兴趣的方法。当切入点需要运行时参数值来执行通知时，这时就需要使用动态切入点。Spring提供了一个内建的动态切入点：ControlFlowPointcut，此切入点匹配基于当前线程的调用堆栈。我们可以在只有在当前线程执行的执行时找到特定的类和特定的方法才返回true。使用动态切入点有很大的性能损耗。大多数的切入点可以静态确定，我们很少有机会创建动态切入点。为了增加可切入点的可重用性，Spring 提供了切入点上的集合操作——交集和合并。

　　3、用ProxyFactoryBean创建AOP代理

　　ProxyFactoryBean，和其他Spring的 FactoryBean实现一样，引入一个间接的层次。如果你定义一个名字为myfactory的ProxyFactoryBean， 引用myfactory的对象所看到的不是ProxyFactoryBean 实例本身，而是由实现ProxyFactoryBean的类的 getObject()方法所创建的对象。这个方法将创建一个包装了目标对象 的AOP代理。使用ProxyFactoryBean或者其他IoC可知的类来创建AOP代理的最重要的优点之一是IoC可以管理通知和切入点。这是一个非常的强大的功能，能够实现其他AOP框架很难实现的特定的方法。例如，一个通知本身可以引用应用对象（除了目标对象， 它在任何AOP框架中都可以引用应用对象），这完全得益于依赖注入所提供的可插入性。通常，我们不需要ProxyFactoryBean的全部功能，因为我们常常只对一个方面感兴趣： 例如，事务管理。当我们仅仅对一个特定的方面感兴趣时，我们可以使用许多便利的工厂来创建AOP代理，如：TransactionProxyFactoryBean。

　　4、自动代理

　　在应用较小时，只有很少类需要被通知的时，ProxyFactoryBean 可以很好的工作。当有许多类需要通知的时，显示的创建每个代理就显得很繁琐。幸运的是Spring提供了是使用自动通过容器来创建代理。这时，就只需要配置一个Bean来做繁琐的工作。Spring提供了两个类实现自动代理：BeanNameAutoProxyCreator和DefaultAdvisorAutoProxyCreator。BeanNameAutoProxyCreator为匹配名字的Bean产生代理，它可以使用在将一个或者多个方面应用在命名相似的Bean中。自动代理框架假设代理将要暴露出什么接口。如果目标Bean没有实现任何接口，这时就会动态产生一个子类。而更强大的自动代理是DefaultAdvisorAutoProxyCreator，你所需要做的是在BeanFactory中包含它的配置。这个类的奇妙之处在于他使用实现了BeanPostProcessor接口。在Bean定义被加载倒Spring容器中后，DefaultAdvisorAutoProxyCreator将搜索上下文中的Advisor，最后它将Advisor应用到匹配Advisor切入点的Bean中。这个代理只对Advisor起作用，它需要通过Advisor来得到需要通知的Bean。元数据自动代理（MetaData AutoProxy）。元数据自动代理配置依赖于源代码属性而不是外部XML配置文件。这可以非常方便的使源代码和AOP元数据组织在同一个地方。元数据自动代理最常用的地方是用来声明事务。Spring提供了很强的框架来通过AOP框架来声明事务。这提供了在EJB使用声明式事务的相同功能。

　　结论

　　AOP 是面向对象编程的有力补充。通过方面就可以聚合在应用中行为形成可重用模块。

　　通过程序可以实现怎样和在什么地方来调用这些行为。这可以减少代码重复，并使你更加关注业务逻辑。Spring 提供了AOP框架来实现调用方法时加入方面。在AOP框架中可以很方便的使用预定义的静态切入点来定义被调用的类和方法。我们需要通过Spring提供的代理类来产生代理对象，可以使用ProxyFactoryBean也可以使用自动代理。Spring AOP 的编程方式模块化了横向关注点的实现，提供了一个更好更快的软件开发方式。在软件结构日益扩大，结构日益复杂的今天，Spring AOP 将会发挥越来越重要的作用。