首先让我们从定义一些重要的AOP概念开始。这些术语不是Spring特有的。 不幸的是，AOP术语并不是特别的直观；如果Spring使用自己的术语，将会变得更加令人困惑。

通知的类型：

环绕通知是最常用的一种通知类型。大部分基于拦截的AOP框架，例如Nanning和JBoss4，都只提供环绕通知。

跟AspectJ一样，Spring提供所有类型的通知，我们推荐你使用尽量简单的通知类型来实现需要的功能。 例如，如果你只是需要用一个方法的返回值来更新缓存，虽然使用环绕通知也能完成同样的事情， 但是你最好使用After returning通知而不是环绕通知。 用最合适的通知类型可以使得编程模型变得简单，并且能够避免很多潜在的错误。 比如，你不需要调用 JoinPoint（用于Around Advice）的 proceed() 方法，就不会有调用的问题。

在Spring 2.0中，所有的通知参数都是静态类型，因此你可以使用合适的类型（例如一个方法执行后的返回值类型）作为通知的参数而不是使用一个对象数组。

切入点（pointcut）和连接点（join point）匹配的概念是AOP的关键，这使得AOP不同于其它仅仅提供拦截功能的旧技术。 切入点使得定位通知（advice）可独立于OO层次。 例如，一个提供声明式事务管理的around通知可以被应用到一组横跨多个对象中的方法上（例如服务层的所有业务操作）。

Spring AOP用纯Java实现。它不需要专门的编译过程。Spring AOP不需要控制类装载器层次，因此它适用于J2EE web容器或应用服务器。

Spring目前仅支持使用方法调用作为连接点（join point）（在Spring bean上通知方法的执行）。 虽然可以在不影响到Spring AOP核心API的情况下加入对成员变量拦截器支持，但Spring并没有实现成员变量拦截器。 如果你需要把对成员变量的访问和更新也作为通知的连接点，可以考虑其它语法的Java语言，例如AspectJ。

Spring实现AOP的方法跟其他的框架不同。Spring并不是要尝试提供最完整的AOP实现（尽管Spring AOP有这个能力）， 相反的，它其实侧重于提供一种AOP实现和Spring IoC容器的整合，用于帮助解决在企业级开发中的常见问题。

因此，Spring AOP通常都和Spring IoC容器一起使用。 Aspect使用普通的bean定义语法（尽管Spring提供了强大的“自动代理（autoproxying）”功能）： 与其他AOP实现相比这是一个显著的区别。有些事使用Spring AOP是无法轻松或者高效的完成的，比如说通知一个细粒度的对象。 这种时候，使用AspectJ是最好的选择。不过经验告诉我们： 于大多数在J2EE应用中遇到的问题，只要适合AOP来解决的，Spring AOP都没有问题，Spring AOP提供了一个非常好的解决方案。

Spring AOP从来没有打算通过提供一种全面的AOP解决方案来取代AspectJ。 我们相信无论是基于代理（proxy-based ）的框架比如说Spring亦或是full-blown的框架比如说是AspectJ都是很有价值的，他们之间的关系应该是互补而不是竞争的关系。 Spring 2.0可以无缝的整合Spring AOP，IoC 和AspectJ，使得所有的AOP应用完全融入基于Spring的应用体系。 这样的集成不会影响Spring AOP API或者AOP Alliance API；Spring AOP保留了向下兼容性。接下来的一章会详细讨论Spring AOP API。

Spring缺省使用J2SE 动态代理（dynamic proxies）来作为AOP的代理。这样任何接口都可以被代理。

Spring也支持使用CGLIB代理. 对于需要代理类而不是代理接口的时候CGLIB代理是很有必要的。 如果一个业务对象并没有实现一个接口，默认就会使用CGLIB。 作为面向接口编程的最佳实践，业务对象通常都会实现一个或多个接口。但也有可能会 强制使用CGLIB， 在这种情况（希望不常有）下，你可能需要通知一个没有在接口中声明的方法，或者需要传入一个代理对象给方法作为具体类型

为了在Spring配置中使用@AspectJ aspects，你必须首先启用Spring对基于@AspectJ aspects的配置支持，自动代理（autoproxying）基于通知是否来自这些切面。 自动代理是指Spring会判断一个bean是否使用了一个或多个切面通知，并据此自动生成相应的代理以拦截其方法调用，并且确认通知是否如期进行。

通过在你的Spring的配置中引入下列元素来启用Spring对@AspectJ的支持：

<aop:aspectj-autoproxy/>

我们假使你正在使用 Appendix A, XML Schema-based configuration 所描述的schema支持。 关于如何在aop的命名空间中引入这些标签，请参见 Section A.2.6, “The aop schema”

如果你正在使用DTD，你仍旧可以通过在你的application context中添加如下定义来启用@AspectJ支持：

<bean class="org.springframework.aop.aspectj.annotation.AnnotationAwareAspectJAutoProxyCreator" />

你需要在你的应用程序的classpath中引入两个AspectJ库：aspectjweaver.jar 和 aspectjrt.jar。 这些库可以在AspectJ的安装包（1.5.1或者之后的版本）中的 lib 目录里找到，或者也可以在Spring依赖库的 lib/aspectj 目录下找到。

在启用@AspectJ支持的情况下，在application context中定义的任意带有一个@Aspect切面（拥有@Aspect注解）的bean都将被Spring自动识别并用于配置在Spring AOP。 以下例子展示了为了完成一个不是非常有用的切面所需要的最小定义：

下面是在application context中的一个常见的bean定义，这个bean指向一个使用了 @Aspect 注解的bean类：

<bean id="myAspect" class="org.xyz.NotVeryUsefulAspect">
   <!-- configure properties of aspect here as normal -->
</bean>

下面是 NotVeryUsefulAspect 类定义，使用了 org.aspectj.lang.annotation.Aspect 注解。

package org.xyz;
import org.aspectj.lang.annotation.Aspect;

@Aspect
public class NotVeryUsefulAspect {

}

切面（用 @Aspect 注解的类）和其他类一样有方法和字段定义。他们也可能包括切入点，通知和引入（inter-type）声明。

回想一下，切入点决定了连接点关注的内容，使得我们可以控制通知什么时候执行。 Spring AOP 只支持 Spring bean 方法执行连接点。所以你可以把切入点看做是匹配 Spring bean 上方法的执行。 一个切入点声明有两个部分：一个包含名字和任意参数的签名，还有一个切入点表达式，该表达式决定了我们关注那个方法的执行。 在 @AspectJ 注解风格的 AOP 中，一个切入点签名通过一个普通的方法定义来提供，并且切入点表达式使用 @Pointcut 注解来表示（作为切入点签名的方法必须返回 void 类型）。

用一个例子会帮助我们区分切入点签名和切入点表达式之间的差别，下面的例子定义了一个切入点'anyOldTransfer'， 这个切入点将匹配任何名为 "transfer" 的方法的执行：

@Pointcut("execution(* transfer(..))")// the pointcut expression
private void anyOldTransfer() {}// the pointcut signature

切入点表达式，也就是 @Pointcut 注解的值，是正规的AspectJ 5切入点表达式。 如果你想要更多了解AspectJ的 切入点语言，请参见 AspectJ 编程指南（如果要了解基于Java 5的扩展请参阅 AspectJ 5 开发手册） 或者其他人写的关于AspectJ的书，例如Colyer et. al.著的《Eclipse AspectJ》或者Ramnivas Laddad著的《AspectJ in Action》。

	@Pointcut("execution(public * *(..))")
	private void anyPublicOperation() {}

	@Pointcut("within(com.xyz.someapp.trading..*")
	private void inTrading() {}

	@Pointcut("anyPublicOperation() && inTrading()")
	private void tradingOperation() {}

package com.xyz.someapp;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;

@Aspect
public class SystemArchitecture {

  /**
   * A join point is in the web layer if the method is defined
   * in a type in the com.xyz.someapp.web package or any sub-package
   * under that.
   */
  @Pointcut("within(com.xyz.someapp.web..*)")
  public void inWebLayer() {}

  /**
   * A join point is in the service layer if the method is defined
   * in a type in the com.xyz.someapp.service package or any sub-package
   * under that.
   */
  @Pointcut("within(com.xyz.someapp.service..*)")
  public void inServiceLayer() {}

  /**
   * A join point is in the data access layer if the method is defined
   * in a type in the com.xyz.someapp.dao package or any sub-package
   * under that.
   */
  @Pointcut("within(com.xyz.someapp.dao..*)")
  public void inDataAccessLayer() {}

  /**
   * A business service is the execution of any method defined on a service
   * interface. This definition assumes that interfaces are placed in the
   * "service" package, and that implementation types are in sub-packages.
   * 
   * If you group service interfaces by functional area (for example, 
   * in packages com.xyz.someapp.abc.service and com.xyz.def.service) then
   * the pointcut expression "execution(* com.xyz.someapp..service.*.*(..))"
   * could be used instead.
   */
  @Pointcut("execution(* com.xyz.someapp.service.*.*(..))")
  public void businessService() {}
  
  /**
   * A data access operation is the execution of any method defined on a 
   * dao interface. This definition assumes that interfaces are placed in the
   * "dao" package, and that implementation types are in sub-packages.
   */
  @Pointcut("execution(* com.xyz.someapp.dao.*.*(..))")
  public void dataAccessOperation() {}

}

<aop:config>
  <aop:advisor
	  pointcut="com.xyz.someapp.SystemArchitecture.businessService()"
	  advice-ref="tx-advice"/>
</aop:config>

<tx:advice id="tx-advice">
<tx:attributes>
	<tx:method name="*" propagation="REQUIRED"/>
  </tx:attributes>
</tx:advice>

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

通知是跟一个切入点表达式关联起来的，并且在切入点匹配的方法执行之前或者之后或者之前和之后运行。 切入点表达式可能是指向已命名的切入点的简单引用或者是一个已经声明过的切入点表达式。

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;

@Aspect
public class BeforeExample {

  @Before("com.xyz.myapp.SystemArchitecture.dataAccessOperation()")
  public void doAccessCheck() {
	// ...
  }

}

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;

@Aspect
public class BeforeExample {

  @Before("execution(* com.xyz.myapp.dao.*.*(..))")
  public void doAccessCheck() {
	// ...
  }

}

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.AfterReturning;

@Aspect
public class AfterReturningExample {

  @AfterReturning("com.xyz.myapp.SystemArchitecture.dataAccessOperation()")
  public void doAccessCheck() {
	// ...
  }

}

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.AfterReturning;

@Aspect
public class AfterReturningExample {

  @AfterReturning(
	pointcut="com.xyz.myapp.SystemArchitecture.dataAccessOperation()",
	returning="retVal")
  public void doAccessCheck(Object retVal) {
	// ...
  }

}

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.AfterThrowing;

@Aspect
public class AfterThrowingExample {

  @AfterThrowing("com.xyz.myapp.SystemArchitecture.dataAccessOperation()")
  public void doRecoveryActions() {
	// ...
  }

}

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.AfterThrowing;

@Aspect
public class AfterThrowingExample {

  @AfterThrowing(
	pointcut="com.xyz.myapp.SystemArchitecture.dataAccessOperation()",
	throwing="ex")
  public void doRecoveryActions(DataAccessException ex) {
	// ...
  }

}

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.After;

@Aspect
public class AfterFinallyExample {

  @After("com.xyz.myapp.SystemArchitecture.dataAccessOperation()")
  public void doReleaseLock() {
	// ...
  }

}

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.ProceedingJoinPoint;

@Aspect
public class AroundExample {

  @Around("com.xyz.myapp.SystemArchitecture.businessService()")
  public Object doBasicProfiling(ProceedingJoinPoint pjp) throws Throwable {
	// start stopwatch
	Object retVal = pjp.proceed();
	// stop stopwatch
	return retVal;
  }

}

@Before("com.xyz.myapp.SystemArchitecture.dataAccessOperation() &&" + 
        "args(account,..)")
public void validateAccount(Account account) {
  // ...
}

@Pointcut("com.xyz.myapp.SystemArchitecture.dataAccessOperation() &&" + 
          "args(account,..)")
private void accountDataAccessOperation(Account account) {}

@Before("accountDataAccessOperation(account)")
public void validateAccount(Account account) {
  // ...
}

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface Auditable {
	AuditCode value();
}

@Before("com.xyz.lib.Pointcuts.anyPublicMethod() && " + 
        "@annotation(auditable)")
public void audit(Auditable auditable) {
  AuditCode code = auditable.value();
  // ...
}

@Around("execution(List<Account> find*(..)) &&" +
		"com.xyz.myapp.SystemArchitecture.inDataAccessLayer() && " +
		"args(accountHolderNamePattern)")
public Object preProcessQueryPattern(ProceedingJoinPoint pjp, String accountHolderNamePattern)
throws Throwable {
  String newPattern = preProcess(accountHolderNamePattern);
  return pjp.proceed(new Object[] {newPattern});
}

@Aspect
public class AspectWithMultipleAdviceDeclarations {

  @Pointcut("execution(* foo(..))")
  public void fooExecution() {}
  
  @Before("fooExecution()")
  public void doBeforeOne() {
    // ...
  }
  
  @Before("fooExecution()")
  public void doBeforeTwo() {
    // ...
  }
  
  @AfterReturning("fooExecution()")
  public void doAfterOne() {
    // ...
  }

  @AfterReturning("fooExecution()")
  public void doAfterTwo() {
    // ...
  }

}

doBeforeOne
doBeforeTwo
foo
doAfterOne
doAfterTwo

引入（Introductions）（在AspectJ中被称为inter-type声明）使得一个切面可以定义被通知对象实现一个给定的接口，并且可以代表那些对象提供具体实现。

使用 @DeclareParents注解来定义引入。这个注解被用来定义匹配的类型拥有一个新的父亲。 比如，给定一个接口 UsageTracked，然后接口的具体实现 DefaultUsageTracked 类， 接下来的切面声明了所有的service接口的实现都实现了 UsageTracked 接口。（比如为了通过JMX输出统计信息）。

@Aspect
public class UsageTracking {

  @DeclareParents(value="com.xzy.myapp.service.*+",
				  defaultImpl=DefaultUsageTracked.class)
  public static UsageTracked mixin;

  @Before("com.xyz.myapp.SystemArchitecture.businessService() &&" +
		  "this(usageTracked)")
  public void recordUsage(UsageTracked usageTracked) {
	usageTracked.incrementUseCount();
  }

}

实现的接口通过被注解的字段类型来决定。@DeclareParents 注解的 value 属性是一个AspectJ的类型模式：- 任何匹配类型的bean都会实现 UsageTracked 接口。 请注意，在上面的前置通知（before advice）的例子中，service beans 可以直接用作 UsageTracked 接口的实现。 如果需要编程式的来访问一个bean，你可以这样写：

UsageTracked usageTracked = (UsageTracked) context.getBean("myService");

默认情况下，在application context中每一个切面都会有一个实例。 AspectJ 把这个叫做单个实例化模型（singleton instantiation model）。 也可以用其他的生命周期来定义切面：- Spring支持AspectJ的 perthis 和 pertarget 实例化模型 （现在还不支持percflow、percflowbelow 和 pertypewithin ）。

一个"perthis" 切面的定义：在 @Aspect 注解中指定perthis 子句。 让我们先来看一个例子，然后解释它是如何运作的：

@Aspect("perthis(com.xyz.myapp.SystemArchitecture.businessService())")
public class MyAspect {

  private int someState;

  @Before(com.xyz.myapp.SystemArchitecture.businessService())
  public void recordServiceUsage() {
	// ...
  }

}

这个perthis子句的效果是每个独立的service对象执行时都会创建一个切面实例（切入点表达式所匹配的连接点上的每一个独立的对象都会绑定到'this'上）。 service对象的每个方法在第一次执行的时候创建切面实例。切面在service对象失效的同时失效。 在切面实例被创建前，所有的通知都不会被执行，一旦切面对象创建完成，定义的通知将会在匹配的连接点上执行，但是只有当service对象是和切面关联的才可以。 如果想要知道更多关于per-clauses的信息，请参阅 AspectJ 编程指南。

'pertarget'实例模型的跟“perthis”完全一样，只不过是为每个匹配于连接点的独立目标对象创建一个切面实例。

现在你已经看到了每个独立的部分是如何运作的了，是时候把他们放到一起做一些有用的事情了！

因为并发的问题，有时候business services可能会失败（例如，死锁失败）。如果重新尝试一下，很有可能就会成功。 对于business services来说，重试几次是很正常的（Idempotent操作不需要用户参与，否则会得出矛盾的结论） 我们可能需要透明的重试操作以避免让客户看见 PessimisticLockingFailureException 例外被抛出。 很明显，在一个横切多层的情况下，这是非常有必要的，因此通过切面来实现是很理想的。

因为我们想要重试操作，我们会需要使用到环绕通知，这样我们就可以多次调用proceed()方法。下面是简单的切面实现：

@Aspect
public class ConcurrentOperationExecutor implements Ordered {
   
   private static final int DEFAULT_MAX_RETRIES = 2;

   private int maxRetries = DEFAULT_MAX_RETRIES;
   private int order = 1;

   public void setMaxRetries(int maxRetries) {
      this.maxRetries = maxRetries;
   }
   
   public int getOrder() {
      return this.order;
   }
   
   public void setOrder(int order) {
      this.order = order;
   }
   
   @Around("com.xyz.myapp.SystemArchitecture.businessService()")
   public Object doConcurrentOperation(ProceedingJoinPoint pjp) throws Throwable { 
      int numAttempts = 0;
      PessimisticLockingFailureException lockFailureException;
      do {
         numAttempts++;
         try { 
            return pjp.proceed();
         }
         catch(PessimisticLockingFailureException ex) {
            lockFailureException = ex;
         }
      }
      while(numAttempts <= this.maxRetries);
      throw lockFailureException;
   }

}

请注意切面实现了 Ordered 接口，这样我们就可以把切面的优先级设定为高于事务通知（我们每次重试的时候都想要在一个全新的事务中进行）。 maxRetries 和 order 属性都可以在Spring中配置。 主要的动作在 doConcurrentOperation 这个环绕通知中发生。 请注意这个时候我们所有的 businessService() 方法都会使用这个重试策略。 我们首先会尝试处理，然后如果我们得到一个 PessimisticLockingFailureException 意外，我们只需要简单的重试，直到我们耗尽所有预设的重试次数。

对应的Spring配置如下：

<aop:aspectj-autoproxy/>

<bean id="concurrentOperationExecutor"
  class="com.xyz.myapp.service.impl.ConcurrentOperationExecutor">
     <property name="maxRetries" value="3"/>
     <property name="order" value="100"/>  
</bean>

为了改进切面，使之仅仅重试idempotent操作，我们可以定义一个 Idempotent 注解：

@Retention(RetentionPolicy.RUNTIME)
public @interface Idempotent {
  // marker annotation
}

并且对service操作的实现进行注解。 这样如果你只希望改变切面使得idempotent的操作会尝试多次，你只需要改写切入点表达式，这样只有 @Idempotent 操作会匹配：

@Around("com.xyz.myapp.SystemArchitecture.businessService() && " +
		"@annotation(com.xyz.myapp.service.Idempotent)")
public Object doConcurrentOperation(ProceedingJoinPoint pjp) throws Throwable { 
  ...
}

有了schema的支持，切面就和常规的Java对象一样被定义成application context中的一个bean。 对象的字段和方法提供了状态和行为信息，XML文件则提供了切入点和通知信息。

切面使用<aop:aspect>来声明，backing bean（支持bean）通过 ref 属性来引用：

<aop:config>
  <aop:aspect id="myAspect" ref="aBean">
	...
  </aop:aspect>
</aop:config>

<bean id="aBean" class="...">
  ...
</bean>

切面的支持bean（上例中的"aBean"）可以象其他Spring bean一样被容器管理配置以及依赖注入。

切入点可以在切面里面声明，这种情况下切入点只在切面内部可见。切入点也可以直接在<aop:config>下定义，这样就可以使多个切面和通知器共享该切入点。

一个描述service层中表示所有service执行的切入点可以如下定义：

<aop:config>

  <aop:pointcut id="businessService"
		expression="execution(* com.xyz.myapp.service.*.*(..))"/>

</aop:config>

注意切入点表达式本身使用了 Section 6.2, “@AspectJ支持” 中描述的AspectJ 切入点表达式语言。 如果你在Java 5环境下使用基于schema的声明风格，可参考切入点表达式类型中定义的命名式切入点，不过这在JDK1.4及以下版本中是不被支持的（因为依赖于Java 5中的AspectJ反射API）。 所以在JDK 1.5中，上面的切入点的另外一种定义形式如下：

<aop:config>

  <aop:pointcut id="businessService"
		expression="com.xyz.myapp.SystemArchitecture.businessService()"/>

</aop:config>

假定你有 Section 6.2.3.3, “共享常见的切入点（pointcut）定义”中说描述的 SystemArchitecture 切面。

在切面里面声明一个切入点和声明一个顶级的切入点非常类似：

<aop:config>

  <aop:aspect id="myAspect" ref="aBean">
	<aop:pointcut id="businessService"
		  expression="execution(* com.xyz.myapp.service.*.*(..))"/>
	...
  </aop:aspect>
</aop:config>

当需要连接子表达式的时候，'&'在XML中用起来非常不方便，所以关键字'and', 'or' 和 'not'可以分别用来代替'&', '||' 和 '!'。

注意这种方式定义的切入点通过XML id来查找，并且不能定义切入点参数。在基于schema的定义风格中命名切入点支持较之@AspectJ风格受到了很多的限制。

和@AspectJ风格一样，基于schema的风格也支持5种通知类型并且两者具有同样的语义。

<aop:aspect id="beforeExample" ref="aBean">

	<aop:before
	  pointcut-ref="dataAccessOperation"
	  method="doAccessCheck"/>
	...
</aop:aspect>

<aop:aspect id="beforeExample" ref="aBean">

	<aop:before
	  pointcut="execution(* com.xyz.myapp.dao.*.*(..))"
	  method="doAccessCheck"/>
	...
</aop:aspect>

<aop:aspect id="afterReturningExample" ref="aBean">

	<aop:after-returning
	  pointcut-ref="dataAccessOperation"
	  method="doAccessCheck"/>

	...

</aop:aspect>

<aop:aspect id="afterReturningExample" ref="aBean">

	<aop:after-returning
	  pointcut-ref="dataAccessOperation"
	  returning="retVal"
	  method="doAccessCheck"/>

	...

</aop:aspect>

public void doAccessCheck(Object retVal) {...

<aop:aspect id="afterThrowingExample" ref="aBean">

	<aop:after-throwing
	  pointcut-ref="dataAccessOperation"
	  method="doRecoveryActions"/>

	...

</aop:aspect>

<aop:aspect id="afterThrowingExample" ref="aBean">

	<aop:after-throwing
	  pointcut-ref="dataAccessOperation"
	  thowing="dataAccessEx"
	  method="doRecoveryActions"/>

	...

</aop:aspect>

public void doRecoveryActions(DataAccessException dataAccessEx) {...

<aop:aspect id="afterFinallyExample" ref="aBean">

	<aop:after
	  pointcut-ref="dataAccessOperation"
	  method="doReleaseLock"/>

	...

</aop:aspect>

<aop:aspect id="aroundExample" ref="aBean">

	<aop:around
	  pointcut-ref="businessService"
	  method="doBasicProfiling"/>

	...

</aop:aspect>

public Object doBasicProfiling(ProceedingJoinPoint pjp) throws Throwable {
    // start stopwatch
    Object retVal = pjp.proceed();
    // stop stopwatch
    return retVal;
}

<aop:before
  pointcut="com.xyz.lib.Pointcuts.anyPublicMethod() and @annotation(auditable)"
  method="audit"
  arg-names="auditable"/>

package x.y.service;

public interface FooService {

   Foo getFoo(String fooName, int age);
}

// the attendant implementation (defined in another file of course)

public class DefaultFooService implements FooService {

   public Foo getFoo(String name, int age) {
      return new Foo(name, age);
   }
}

package x.y;

import org.aspectj.lang.ProceedingJoinPoint;
import org.springframework.util.StopWatch;

public class SimpleProfiler {

   public Object profile(ProceedingJoinPoint call, String name, int age) throws Throwable {
      StopWatch clock = new StopWatch(
            "Profiling for '" + name + "' and '" + age + "'");
      try {
         clock.start(call.toShortString());
         return call.proceed();
      } finally {
         clock.stop();
         System.out.println(clock.prettyPrint());
      }
   }
}

<beans xmlns="http://www.springframework.org/schema/beans"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xmlns:aop="http://www.springframework.org/schema/aop"
      xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd">

   <!-- this is the object that will be proxied by Spring's AOP infrastructure -->
   <bean id="fooService" class="x.y.service.DefaultFooService"/>

   <!-- this is the actual advice itself -->
   <bean id="profiler" class="x.y.SimpleProfiler"/>

   <aop:config>
      <aop:aspect ref="profiler">

         <aop:pointcut id="theExecutionOfSomeFooServiceMethod"
                    expression="execution(* x.y.service.FooService.getFoo(String,int))
                    and args(name, age)"/>

         <aop:around pointcut-ref="theExecutionOfSomeFooServiceMethod"
                  method="profile"/>

      </aop:aspect>
   </aop:config>

</beans>

import org.springframework.beans.factory.BeanFactory;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import x.y.service.FooService;

public final class Boot {

   public static void main(final String[] args) throws Exception {
      BeanFactory ctx = new ClassPathXmlApplicationContext("x/y/plain.xml");
      FooService foo = (FooService) ctx.getBean("fooService");
      foo.getFoo("Pengo", 12);
   }
}

StopWatch 'Profiling for 'Pengo' and '12'': running time (millis) = 0
-----------------------------------------
ms     %     Task name
-----------------------------------------
00000  ?  execution(getFoo)

Intrduction （在AspectJ中成为inter-type声明）允许一个切面声明一个通知对象实现指定接口，并且提供了一个接口实现类来代表这些对象。

在 aop:aspect 内部使用 aop:declare-parents 元素定义Introduction。 该元素用于用来声明所匹配的类型有了一个新的父类型（所以有了这个名字）。 例如，给定接口 UsageTracked， 以及这个接口的一个实现类 DefaultUsageTracked， 下面声明的切面所有实现service接口的类同时实现 UsageTracked 接口。（比如为了通过JMX暴露statistics。）

<aop:aspect id="usageTrackerAspect" ref="usageTracking">

  <aop:declare-parents
	  types-matching="com.xzy.myapp.service.*+",
	  implement-interface="UsageTracked"
	  default-impl="com.xyz.myapp.service.tracking.DefaultUsageTracked"/>

  <aop:before
	pointcut="com.xyz.myapp.SystemArchitecture.businessService()
			  and this(usageTracked)"
	method="recordUsage"/>

</aop:aspect>

usageTracking bean的支持类可以包含下面的方法：

public void recordUsage(UsageTracked usageTracked) {
    usageTracked.incrementUseCount();
}

欲实现的接口由 implement-interface 属性来指定。 types-matching 属性的值是一个AspectJ类型模式：- 任何匹配类型的bean会实现 UsageTracked 接口。 注意在Before通知的例子中，srevice bean可以用作 UsageTracked 接口的实现。 如果编程形式访问一个bean，你可以这样来写：

UsageTracked usageTracked = (UsageTracked) context.getBean("myService");

Schema-defined切面仅支持一种实例化模型就是singlton模型。其他的实例化模型或许在未来版本中将得到支持。

"advisors"这个概念来自Spring1.2对AOP的支持，在AspectJ中是没有等价的概念。 advisor就像一个小的自包含的切面，这个切面只有一个通知。 切面自身通过一个bean表示，并且必须实现一个通知接口， 在 Section 7.3.2, “Spring里的通知类型” 中我们会讨论相应的接口。Advisors可以很好的利用AspectJ切入点表达式。

Spring 2.0 通过 <aop:advisor> 元素来支持advisor 概念。 你将会发现它大多数情况下会和transactional advice一起使用，transactional advice在Spring 2.0中有自己的命名空间。格式如下：

<aop:config>

  <aop:pointcut id="businessService"
		expression="execution(* com.xyz.myapp.service.*.*(..))"/>

  <aop:advisor
	  pointcut-ref="businessService"
	  advice-ref="tx-advice"/>

</aop:config>

<tx:advice id="tx-advice">
<tx:attributes>
	<tx:method name="*" propagation="REQUIRED"/>
  </tx:attributes>
</tx:advice>

和在上面使用的 pointcut-ref 属性一样，你还可以使用 pointcut 属性来定义一个内联的切入点表达式。

为了定义一个advisord的优先级以便让通知可以有序，使用 order 属性来定义 advisor的值 Ordered 。

让我们来看看在 Section 6.2.7, “例子” 提过并发锁失败重试的例子，如果使用schema对这个例子进行重写是什么效果。

因为并发锁的关系，有时候business services可能会失败（例如，死锁失败）。 如果重新尝试一下，很有可能就会成功。对于business services来说，重试几次是很正常的（Idempotent操作不需要用户参与，否则会得出矛盾的结论） 我们可能需要透明的重试操作以避免让客户看见 PessimisticLockingFailureException 例外被抛出。 很明显，在一个横切多层的情况下，这是非常有必要的，因此通过切面来实现是很理想的。

因为我们想要重试操作，我们会需要使用到环绕通知，这样我们就可以多次调用proceed()方法。 下面是简单的切面实现（只是一个schema支持的普通Java 类）：

public class ConcurrentOperationExecutor implements Ordered {
   
   private static final int DEFAULT_MAX_RETRIES = 2;

   private int maxRetries = DEFAULT_MAX_RETRIES;
   private int order = 1;

   public void setMaxRetries(int maxRetries) {
      this.maxRetries = maxRetries;
   }
   
   public int getOrder() {
      return this.order;
   }
   
   public void setOrder(int order) {
      this.order = order;
   }
   
   public Object doConcurrentOperation(ProceedingJoinPoint pjp) throws Throwable { 
      int numAttempts = 0;
      PessimisticLockingFailureException lockFailureException;
      do {
         numAttempts++;
         try { 
            return pjp.proceed();
         }
         catch(PessimisticLockingFailureException ex) {
            lockFailureException = ex;
         }
      }
      while(numAttempts <= this.maxRetries);
      throw lockFailureException;
   }

}

请注意切面实现了 Ordered 接口，这样我们就可以把切面的优先级设定为高于事务通知（我们每次重试的时候都想要在一个全新的事务中进行）。 maxRetries 和 order 属性都可以在Spring中配置。 主要的动作在 doConcurrentOperation 这个环绕通知中发生。 请注意这个时候我们所有的 businessService() 方法都会使用这个重试策略。 我们首先会尝试处理，然后如果我们得到一个 PessimisticLockingFailureException 异常，我们只需要简单的重试，直到我们耗尽所有预设的重试次数。

对应的Spring配置如下：

<aop:config>

  <aop:aspect id="concurrentOperationRetry" ref="concurrentOperationExecutor">

    <aop:pointcut id="idempotentOperation"
        expression="execution(* com.xyz.myapp.service.*.*(..))"/>
       
    <aop:around
       pointcut-ref="idempotentOperation"
       method="doConcurrentOperation"/>
  
  </aop:aspect>

</aop:config>

<bean id="concurrentOperationExecutor"
  class="com.xyz.myapp.service.impl.ConcurrentOperationExecutor">
     <property name="maxRetries" value="3"/>
     <property name="order" value="100"/>  
</bean>

请注意我们现在假设所有的bussiness services都是idempotent。如果不是这样，我们可以改写切面，加上 Idempotent 注解，让它只调用idempotent：

@Retention(RetentionPolicy.RUNTIME)
public @interface Idempotent {
  // marker annotation
}

并且对service操作的实现进行注解。这样如果你只希望改变切面使得idempotent的操作会尝试多次，你只需要改写切入点表达式，这样只有 @Idempotent 操作会匹配：

  <aop:pointcut id="idempotentOperation"
		expression="execution(* com.xyz.myapp.service.*.*(..)) and
					@annotation(com.xyz.myapp.service.Idempotent)"/>

做能起作用的最简单的事。Spring AOP比完全使用AspectJ更加简单，因为它不需要引入AspectJ的编译器／织入器到你开发和构建过程中。 如果你仅仅需要在Spring bean上通知执行操作，那么Spring AOP是合适的选择。如果你需要通知domain对象或其它没有在Spring容器中 管理的任意对象，那么你需要使用AspectJ。如果你想通知除了简单的方法执行之外的连接点（如：调用连接点、字段get或set的连接点等等）， 也需要使用AspectJ。

当使用AspectJ时，你可以选择使用AspectJ语言（也称为“代码风格”）或@AspectJ注解风格。 如果切面在你的设计中扮演一个很大的角色，并且你能在Eclipse中使用AspectJ Development Tools (AJDT)， 那么首选AspectJ语言 :- 因为该语言专门被设计用来编写切面，所以会更清晰、更简单。如果你没有使用 Eclipse，或者在你的应用中只有很少的切面并没有作为一个主要的角色，你或许应该考虑使用@AspectJ风格 并在你的IDE中附加一个普通的Java编辑器，并且在你的构建脚本中增加切面织入（链接）的段落。

如果你选择使用Spring AOP，那么你可以选择@AspectJ或者XML风格。总的来说，如果你使用Java 5， 我们建议使用@AspectJ风格。显然如果你不是运行在Java 5上，XML风格是最佳选择。XML和@AspectJ 之间权衡的细节将在下面进行讨论。

XML风格对现有的Spring用户来说更加习惯。它可以使用在任何Java级别中（参考连接点表达式内部的命名连接点，虽然它也需要Java 5） 并且通过纯粹的POJO来支持。当使用AOP作为工具来配置企业服务时（一个好的例子是当你认为连接点表达式是你的配置中的一部分时， 你可能想单独更改它）XML会是一个很好的选择。对于XML风格，从你的配置中可以清晰的表明在系统中存在那些切面。

XML风格有两个缺点。第一是它不能完全将需求实现的地方封装到一个位置。DRY原则中说系统中的每一项知识都必须具有单一、无歧义、权威的表示。 当使用XML风格时，如何实现一个需求的知识被分割到支撑类的声明中以及XML配置文件中。当使用@AspectJ风格时就只有一个单独的模块 -切面- 信息被封装了起来。 第二是XML风格同@AspectJ风格所能表达的内容相比有更多的限制：仅仅支持"singleton"切面实例模型，并且不能在XML中组合命名连接点的声明。 例如，在@AspectJ风格中我们可以编写如下的内容：

  @Pointcut(execution(* get*()))
  public void propertyAccess() {}

  @Pointcut(execution(org.xyz.Account+ *(..))
  public void operationReturningAnAccount() {}

  @Pointcut(propertyAccess() && operationReturningAnAccount())
  public void accountPropertyAccess() {}

在XML风格中能声明开头的两个连接点：

  <aop:pointcut id="propertyAccess" 
      expression="execution(* get*())"/>

  <aop:pointcut id="operationReturningAnAccount" 
      expression="execution(org.xyz.Account+ *(..))"/>

但是不能通过组合这些来定义accountPropertyAccess连接点

@AspectJ风格支持其它的实例模型以及更丰富的连接点组合。它具有将将切面保持为一个模块单元的优点。 还有一个优点就是@AspectJ切面能被Spring AOP和AspectJ两者都理解 - 所以如果稍后你认为你需要AspectJ 的能力去实现附加的需求，那么你非常容易转移到基于AspectJ的途径。总而言之，我们更喜欢@AspectJ风格只要你有切面 去做超出简单的“配置”企业服务之外的事情。

Spring容器对application context中定义的bean进行实例化和配置。 同样也可以通过bean factory来为一个已经存在且已经定义为spring bean的对象应用所包含的配置信息。 spring-aspects.jar中包含了一个annotation-driven的切面，提供了能为任何对象进行依赖注入的能力。 这样的支持旨在为 脱离容器管理 创建的对象进行依赖注入。 Domain object经常处于这样的情形：它们可能是通过 new 操作符创建的对象， 也可能是ORM工具查询数据库的返回结果对象。

包 org.springframework.orm.hibernate.support 中的类 DependencyInjectionInterceptorFactoryBean 可以让Spring为Hibernate创建并且配置prototype类型的domain object（使用自动装配或者确切命名的bean原型定义）。 当然，拦截器不支持配置你编程方式创建的对象而非检索数据库返回的对象。 其他framework也会提供类似的技术。仍是那句话，Be Pragramatic选择能满足你需求的方法中最简单的那个。 请注意前面提及的类 没有 随Spring发行包一起发布。 如果你希望使用该类，需要从Spring CVS Respository上下载并且自行编译。 你可以在Spring CVS respository下的 'sandbox' 目录下找到该文件。

@Configurable 注解标记了一个类可以通过Spring-driven方式来配置。 在最简单的情况下，我们只把它当作标记注解：

package com.xyz.myapp.domain;

import org.springframework.beans.factory.annotation.Configurable;

@Configurable
public class Account {
   ...

}

当只是简单地作为一个标记接口来使用的时候，Spring将采用和该已注解的类型（比如Account类）全名 （com.xyz.myapp.domain.Account）一致的bean原型定义来配置一个新实例。 由于一个bean默认的名字就是它的全名，所以一个比较方便的办法就是省略定义中的id属性：

<bean class="com.xyz.myapp.domain.Account" scope="prototype">
  <property name="fundsTransferService" ref="fundsTransferService"/>
  ...
</bean>

如果你希望明确的指定bean原型定义的名字，你可以在注解中直接定义：

package com.xyz.myapp.domain;

import org.springframework.beans.factory.annotation.Configurable;

@Configurable("account")
public class Account {

   ...

}

Spring会查找名字为"account"的bean定义，并使用它作为原型定义来配置一个新的Account对象。

你也可以使用自动装配来避免手工指定原型定义的名字。 只要设置 @Configurable 注解中的autowire属性就可以让Spring来自动装配了： @Configurable(autowire=Autowire.BY_TYPE) 或者 @Configurable(autowire=Autowire.BY_NAME，这样就可以按类型或者按名字自动装配了。

最后，你可以设置 dependencyCheck 属性，通过设置，Spring对新创建和配置的对象的对象引用进行校验 （例如：@Configurable(autowire=Autowire.BY_NAME,dependencyCheck=true) ）。 如果这个属性被设为true，Spring会在配置结束后校验除了primitives和collections类型的所有的属性是否都被赋值了。

仅仅使用注解并没有做任何事情。但当注解存在时，spring-aspects.jar中的 AnnotationBeanConfigurerAspect 就起作用了。 实质上切面做了这些：当初始化一个有 @Configurable 注解的新对象时，Spring按照注解中的属性来配置这个新创建的对象。 要实现上述的操作，已注解的类型必须由AspectJ weaver来织入 - 你可以使用一个 build-time ant/maven任务来完成 （参见AspectJ Development Environment Guide） 或者使用load-time weaving（参见 Section 6.8.4, “在Spring应用中使用AspectJ Load-time weaving（LTW）”）。

类 AnnotationBeanConfigurerAspect 本身也需要Spring来配置（获得bean factory的引用，使用bean factory配置新的对象）。 为此Spring AOP命名空间定义了一个非常方便的标签。如下所示，可以很简单的在application context配置文件包含这个标签中。

<aop:spring-configured/>

如果你使用DTD代替Schema，对应的定义如下：

<bean
  class="org.springframework.beans.factory.aspectj.AnnotationBeanConfigurerAspect"
  factory-method="aspectOf"/>

在切面配置完成 之前 创建的@Configurable对象实例会导致在log中留下一个warning，并且任何对于该对象的配置都不会生效。 举一个例子，一个Spring管理配置的bean在被Spring初始化的时候创建了一个domain object。 对于这样的情况，你需要定义bean属性中的"depends-on"属性来手动指定该bean依赖于configuration切面。

<bean id="myService"
  class="com.xzy.myapp.service.MyService"
  depends-on="org.springframework.beans.factory.aspectj.AnnotationBeanConfigurerAspect">

  ...

</bean>

除了 @Configurable 支持，spring-aspects.jar包含了一个AspectJ切面可以用来为那些使用了 @Transactional annotation 的类型和方法驱动Spring事务管理（参见 Chapter 9, 事务管理）。 提供这个的主要目的是有些用户希望脱离Spring容器使用Spring的事务管理。

解析@Transactional annotations的切面是AnnotationTransactionAspect。 当使用这个切面时，你必须注解这个实现类（和/或这个类中的方法），而不是这个类实现的接口（如果有）。 AspectJ允许在接口上注解的Java规则 不被继承。

类之上的一个@Transactional注解为该类中任何public操作的执行指定了默认的事务语义。

类内部方法上的一个@Transactional注解会覆盖类注解（如果存在）所给定的默认的事务语义。 具有public、protected和default修饰符的方法都可以被注解。直接注解protected和default方法是让这个操作的执行 获得事务划分的唯一途径。

对于AspectJ程序员，希望使用Spring管理配置和事务管理支持，不过他们不想（或者不能）使用注解，spring-aspects.jar也包含了一些抽象切面供你继承来提供你自己的切入点定义。 参见 AbstractBeanConfigurerAspect 和 AbstractTransactionAspect 的Javadoc获取更多信息。 作为一个例子，下面的代码片断展示了如何编写一个切面，然后通过bean原型定义中和类全名匹配的来配置domian object中所有的实例：

public aspect DomainObjectConfiguration extends AbstractBeanConfigurerAspect {

  public DomainObjectConfiguration() {
    setBeanWiringInfoResolver(new ClassNameBeanWiringInfoResolver());
  }

  // the creation of a new bean (any object in the domain model)
  protected pointcut beanCreation(Object beanInstance) :
    initialization(new(..)) &&
    SystemArchitecture.inDomainModel() && 
    this(beanInstance);
		   		   
}

当在Spring application中使用AspectJ的时候，很自然的会想到用Spring来管理这些切面。 AspectJ runtime自身负责切面的创建，这意味着通过Spring来管理AspectJ 创建切面依赖于切面所使用的AspectJ instantiation model(per-clause)。

大多数AspectJ切面都是 singleton 切面。 管理这些切面非常容易，和通常一样创建一个bean定义引用该切面类型就可以了，并且在bean定义中包含 'factory-method="aspectOf"' 这个属性。 这确保Spring从AspectJ获取切面实例而不是尝试自己去创建该实例。示例如下：

<bean id="profiler" class="com.xyz.profiler.Profiler"
	  factory-method="aspectOf">
  <property name="profilingStrategy" ref="jamonProfilingStrategy"/>
</bean>

对于non-singleton的切面，最简单的配置管理方法是定义一个bean原型定义并且使用@Configurable支持，这样就可以在切面被AspectJ runtime创建后管理它们。

如果你希望一些@AspectJ切面使用AspectJ来织入（例如使用load-time织入domain object） 和另一些@AspectJ切面使用Spring AOP，而这些切面都是由Spring来管理的，那你就需要告诉Spring AOP @AspectJ自动代理支持那些切面需要被自动代理。 你可以通过在 <aop:aspectj-autoproxy> 声明中使用一个或多个 <include/>。 每一个指定了一种命名格式，只有bean命名至少符合其中一种情况下才会使用Spring AOP自动代理配置：

<aop:aspectj-autoproxy>
  <include name="thisBean"/>
  <include name="thatBean"/>
</aop:aspectj-autoproxy>

Load-time weaving（LTW）指的是在虚拟机载入字节码文件时动态织入AspectJ切面。 关于LTW的详细信息，请查看 LTW section of the AspectJ Development Environment Guide。 在这里我们重点来看一下Java 5环境下Spring应用如何配置LTW。

LTW需要定义一个 aop.xml，并将其置于META-INF目录。 AspectJ会自动查找所有可见的classpath下的META-INF/aop.xml文件，并且通过定义内容的合集来配置自身。

一个基本的META-INF/aop.xml文件应该如下所示：

<!DOCTYPE aspectj PUBLIC
  "-//AspectJ//DTD//EN"	"http://www.eclipse.org/aspectj/dtd/aspectj.dtd">

<aspectj>
   <weaver>
	 <include within="com.xyz.myapp..*"/>
   </weaver>
</aspectj>

'<include/>'的内容告诉AspectJ那些类型需要被纳入织入过程。使用包名前缀并加上"..*"（表示该子包中的所有类型）是一个不错的默认设定。 使用include元素是非常重要的，不然AspectJ会查找每一个应用里面用到的类型（包括Spring的库和其它许多相关库）。通常你并不希望织入这些类型并且不愿意承担AspectJ尝试去匹配的开销。

希望在日志中记录LTW的活动，请添加如下选项：

<!DOCTYPE aspectj PUBLIC    
  "-//AspectJ//DTD//EN"    "http://www.eclipse.org/aspectj/dtd/aspectj.dtd">    

<aspectj>    
   <weaver 
	 options="-showWeaveInfo
              -XmessageHandlerClass:org.springframework.aop.aspectj.AspectJWeaverMessageHandler">
	 <include within="com.xyz.myapp..*"/>
   </weaver>
</aspectj>

最后，如果希望精确的控制使用哪些切面，可以使用 aspects。 默认情况下所有定义的切面都将被织入（spring-aspects.jar包含了META-INF/aop.xml，定义了配置管理和事务管理切面）。 如果你在使用spring-aspects.jar，但是只希望使用配制管理切面而不需要事务管理的话，你可以像下面那样定义：

<!DOCTYPE aspectj PUBLIC
  "-//AspectJ//DTD//EN"	"http://www.eclipse.org/aspectj/dtd/aspectj.dtd">

<aspectj>
   <aspects>
	  <include within="org.springframework.beans.factory.aspectj.AnnotationBeanConfigurerAspect"/>
   </aspects>
   <weaver
    options="-showWeaveInfo -XmessageHandlerClass:org.springframework.aop.aspectj.AspectJWeaverMessageHandler">
    <include within="com.xyz.myapp..*"/>
   </weaver>
</aspectj>

在Java 5平台下，LTW可以通过虚拟机的参数来启用。

-javaagent:<path-to-ajlibs>/aspectjweaver.jar