Spring AOP支持在切入点表达式中使用如下的AspectJ切入点指示符：

另外,Spring AOP还提供了一个名为'bean'的PCD。这个PCD允许你限定匹配连接点到一个特定名称的Spring bean，或者到一个特定名称Spring bean的集合（当使用通配符时）。'bean' PCD具有下列的格式:

bean（idOrNameOfBean）

'idOrNameOfBean'标记可以是任何Spring bean的名字：限定通配符使用'*'来提供，如果你为Spring bean制定一些命名约定，你可以非常容易地编写一个'bean' PCD表达式将它们选出来。和其它连接点指示符一样，'bean' PCD也支持&&, ||和 !逻辑操作符。

	Note
	请注意'bean' PCD仅仅 被Spring AOP支持而不是AspectJ. 这是Spring对AspectJ中定义的标准PCD的一个特定扩展。 'bean' PCD不仅仅可以在类型级别（被限制在基于织入AOP上）上操作而还可以在实例级别（基于Spring bean的概念）上操作。

切入点表达式可以使用'&', '||' 和 '!'来组合。还可以通过名字来指向切入点表达式。以下的例子展示了三种切入点表达式： anyPublicOperation（在一个方法执行连接点代表了任意public方法的执行时匹配）；inTrading（在一个代表了在交易模块中的任意的方法执行时匹配）和 tradingOperation（在一个代表了在交易模块中的任意的公共方法执行时匹配）。

@Pointcut（"execution（public * *（..））"）
private void anyPublicOperation（） {}

@Pointcut（"within（com.xyz.someapp.trading..*"）
private void inTrading（） {}

@Pointcut（"anyPublicOperation（） && inTrading（）"）
private void tradingOperation（） {}
        

如上所示，用更少的命名组件来构建更加复杂的切入点表达式是一种最佳实践。当用名字来指定切入点时使用的是常见的Java成员可视性访问规则。（比如说，你可以在同一类型中访问私有的切入点，在继承关系中访问受保护的切入点，可以在任意地方访问公共切入点）。成员可视性访问规则不影响到切入点的匹配。

当开发企业级应用的时候，你通常会想要从几个切面来引用模块化的应用和特定操作的集合。我们推荐定义一个“SystemArchitecture”切面来捕捉通用的切入点表达式。一个典型的通用切面看起来可能像下面这样：

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.
   *
   * Alternatively, you can write the expression using the 'bean'
   * PCD, like so "bean（*Service）". （This assumes that you have
   * named your Spring service beans in a consistent fashion.）
   */
  @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（） {}

}

示例中的切入点定义了一个你可以在任何需要切入点表达式的地方可引用的切面。比如，为了使service层事务化，你可以写成：

<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>

我们将在Section 6.3, “基于Schema的AOP支持”中讨论 <aop:config>和<aop:advisor>标签。在Chapter 9, 事务管理中讨论事务标签。

Spring AOP 用户可能会经常使用 execution切入点指示符。执行表达式的格式如下：

execution（modifiers-pattern? ret-type-pattern declaring-type-pattern? name-pattern（param-pattern）
          throws-pattern?）

除了返回类型模式（上面代码片断中的ret-type-pattern），名字模式和参数模式以外， 所有的部分都是可选的。返回类型模式决定了方法的返回类型必须依次匹配一个连接点。 你会使用的最频繁的返回类型模式是*，它代表了匹配任意的返回类型。 一个全限定的类型名将只会匹配返回给定类型的方法。名字模式匹配的是方法名。 你可以使用*通配符作为所有或者部分命名模式。 参数模式稍微有点复杂：()匹配了一个不接受任何参数的方法， 而(..)匹配了一个接受任意数量参数的方法（零或者更多）。 模式(*)匹配了一个接受一个任何类型的参数的方法。 模式(*,String)匹配了一个接受两个参数的方法，第一个可以是任意类型， 第二个则必须是String类型。更多的信息请参阅AspectJ编程指南中 语言语义的部分。

下面给出一些通用切入点表达式的例子。

一个切面里使用 @Before 注解声明前置通知：

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（） {
    // ...
  }

}

如果使用一个in-place 的切入点表达式，我们可以把上面的例子换个写法：

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（） {
    // ...
  }

}

返回后通知通常在一个匹配的方法返回的时候执行。使用 @AfterReturning 注解来声明：

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（） {
    // ...
  }

}

有时候你需要在通知体内得到返回的值。你可以使用@AfterReturning 接口的形式来绑定返回值：

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） {
    // ...
  }
  
}

在 returning属性中使用的名字必须对应于通知方法内的一个参数名。 当一个方法执行返回后，返回值作为相应的参数值传入通知方法。 一个returning子句也限制了只能匹配到返回指定类型值的方法。 （在本例子中，返回值是Object类，也就是说返回任意类型都会匹配）

请注意当使用后置通知时不允许返回一个完全不同的引用。

抛出异常通知在一个方法抛出异常后执行。使用@AfterThrowing注解来声明：

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（） {
    // ...
  }

}

你通常会想要限制通知只在某种特殊的异常被抛出的时候匹配，你还希望可以在通知体内得到被抛出的异常。 使用throwing属性不仅可以限制匹配的异常类型（如果你不想限制，请使用 Throwable作为异常类型），还可以将抛出的异常绑定到通知的一个参数上。

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） {
    // ...
  }

}

在throwing属性中使用的名字必须与通知方法内的一个参数对应。 当一个方法因抛出一个异常而中止后，这个异常将会作为那个对应的参数送至通知方法。 throwing 子句也限制了只能匹配到抛出指定异常类型的方法 （上面的示例为DataAccessException）。

不论一个方法是如何结束的，最终通知都会运行。使用@After 注解来声明。最终通知必须准备处理正常返回和异常返回两种情况。通常用它来释放资源。

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（） {
    // ...
  }

}

最后一种通知是环绕通知。环绕通知在一个方法执行之前和之后执行。它使得通知有机会 在一个方法执行之前和执行之后运行。而且它可以决定这个方法在什么时候执行，如何执行，甚至是否执行。 环绕通知经常在某线程安全的环境下，你需要在一个方法执行之前和之后共享某种状态的时候使用。 请尽量使用最简单的满足你需求的通知。（比如如果简单的前置通知也可以适用的情况下不要使用环绕通知）。

环绕通知使用@Around注解来声明。通知的第一个参数必须是 ProceedingJoinPoint类型。在通知体内，调用 ProceedingJoinPoint的proceed()方法会导致 后台的连接点方法执行。proceed 方法也可能会被调用并且传入一个 Object[]对象-该数组中的值将被作为方法执行时的参数。

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;
  }

}

方法的调用者得到的返回值就是环绕通知返回的值。 例如：一个简单的缓存切面，如果缓存中有值，就返回该值，否则调用proceed()方法。 请注意proceed可能在通知体内部被调用一次，许多次，或者根本不被调用，所有这些都是合法的。

Spring 2.0 提供了完整的通知类型 - 这意味着你可以在通知签名中声明所需的参数， （就像我们在前面看到的后置和异常通知一样）而不总是使用Object[]。 我们将会看到如何使得参数和其他上下文值对通知体可用。 首先让我们看以下如何编写普通的通知以找出正在被通知的方法。

@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}）;
}        

如果有多个通知想要在同一连接点运行会发生什么？Spring AOP遵循跟AspectJ一样的优先规则来确定通知执行的顺序。 在“进入”连接点的情况下，最高优先级的通知会先执行（所以给定的两个前置通知中，优先级高的那个会先执行）。 在“退出”连接点的情况下，最高优先级的通知会最后执行。（所以给定的两个后置通知中， 优先级高的那个会第二个执行）。

当定义在不同的切面里的两个通知都需要在一个相同的连接点中运行， 那么除非你指定，否则执行的顺序是未知的。你可以通过指定优先级来控制执行顺序。 在标准的Spring方法中可以在切面类中实现org.springframework.core.Ordered 接口或者用Order注解做到这一点。在两个切面中， Ordered.getValue()方法返回值（或者注解值）较低的那个有更高的优先级。

当定义在相同的切面里的两个通知都需要在一个相同的连接点中运行， 执行的顺序是未知的（因为这里没有方法通过反射javac编译的类来获取声明顺序）。 考虑在每个切面类中按连接点压缩这些通知方法到一个通知方法，或者重构通知的片段到各自的切面类中 - 它能在切面级别进行排序。

前置通知在匹配方法执行前运行。在<aop:aspect>中使用<aop:before> 元素来声明它。

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

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

这里dataAccessOperation是一个顶级（<aop:config>）切入点的id。 　　　　而要定义内置切入点，需将pointcut-ref属性替换为pointcut属性：

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

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

正如我们在@AspectJ风格章节中讨论过的，使用命名切入点能够明显的提高代码的可读性。

Method属性标识了提供通知主体的方法（doAccessCheck）。 这个方法必须定义在包含通知的切面元素所引用的bean中。在一个数据访问操作执行之前 （一个方法执行由切入点表达式所匹配的连接点），切面中的"doAccessCheck"会被调用。

后置通知在匹配的方法完全执行后运行。和前置通知一样，可以在<aop:aspect> 里面声明它。例如：

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

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

和@AspectJ风格一样，通知主体可以得到返回值。使用returning属性来指定传递返回值的参数名：

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

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

doAccessCheck方法必须声明一个名字叫 retVal 的参数。 参数的类型依照@AfterReturning所描述的方法强制匹配。例如，方法签名可以这样声明：

public void doAccessCheck（Object retVal） {...

异常通知在匹配方法抛出异常退出时执行。在<aop:aspect>中使用 after-throwing元素来声明：

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

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

和@AspectJ风格一样，通知主体可以得到抛出的异常。使用throwing属性来指定传递异常的参数名：

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

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

doRecoveryActions方法必须声明一个名字为dataAccessEx的参数。 参数的类型依照@AfterThrowing所描述的方法强制匹配。例如：方法签名可以如下这般声明：

public void doRecoveryActions（DataAccessException dataAccessEx） {...

最终通知无论如何都会在匹配方法退出后执行。使用after元素来声明它：

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

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

环绕通知是最后一种通知类型。环绕通知在匹配方法运行期的“周围”执行。 它有机会在目标方法的前面和后面执行，并决定什么时候运行，怎么运行，甚至是否运行。 环绕通知经常在需要在一个方法执行前后共享状态信息，并且是在线程安全的情况下使用 （启动和停止一个计时器就是一个例子）。注意选择能满足你需求的最简单的通知类型； 如果简单的前置通知能做的事情就绝对不要使用环绕通知。

Around通知使用aop:around元素来声明。通知方法的第一个参数的类型必须是 ProceedingJoinPoint类型。在通知的主体中，调用 ProceedingJoinPoint的proceed()方法来执行真正的方法。 proceed方法也可能会被调用并且传入一个Object[]对象 - 该数组将作为方法执行时候的参数。参见Section 6.2.4.5, “环绕通知”中调用具有 Object[]的proceed方法。

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

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

doBasicProfiling通知的实现和@AspectJ中的例子完全一样（当然要去掉注解）：

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

Schema-based声明风格和@AspectJ一样，支持多种类型的通知：通过通知方法参数名字来匹配切入点参数。 参见Section 6.2.4.6, “通知参数（Advice parameters）”获取详细信息。如果你希望显式指定通知方法的参数名 （而不是依靠先前提及的侦测策略），可以通过通知元素的arg-names属性来实现，它的处理和 在Section 6.2.4.6.3, “确定参数名”中所描述的对通知注解中"argNames"属性的处理方式一样。 示例如下：

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

arg-names属性接受由逗号分割的参数名列表。

下面是个稍微复杂的基于XSD的例子，它展示了关联了多个强类型参数的环绕通知的使用。

package x.y.service;

public interface FooService {

   Foo getFoo（String fooName, int age）;
}

public class DefaultFooService implements FooService {

   public Foo getFoo（String name, int age） {
      return new Foo（name, age）;
   }
}

接下来看切面。注意profile（..）方法接受多个强类型参数， 首先连接点在方法调用时执行，这个参数指明profile（..）会被用作 环绕通知：

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（））;
      }
   }
}

最后这里是使得上面的通知针对一个特定连接点而执行所必需的XML配置：

<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.5.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.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）

当同一个切入点（执行方法）上有多个通知需要执行时，执行顺序的规则如 Section 6.2.4.7, “通知顺序”所述。切面的优先级通过给切面的支持bean增加 Order注解或者使切面的支持bean实现 Ordered接口来决定。 　　

提供@Configurable支持的一个目的就是使得domain object的单元测试 可以独立进行，不需要通过硬编码查找各种倚赖关系。如果@Configurable 类型没有通过AspectJ织入，则在单元测试过程中注解不会起到任何作用， 测试中你可以简单的为对象的mock或者stub属性赋值，并且和正常情况一样去使用该对象。 如果@Configurable类型通过AspectJ织入， 我们依然可以脱离容器进行单元测试，不过每次创建一个新的@Configurable 对象时都会看到一个warning，标示该对象没有被Spring配置。

AnnotationBeanConfigurerAspect通过一个AspectJ singleton切面来实现对 @Configurable的支持。一个singleton切面的作用域和一个 静态变量的作用域是一样的，那就是说，对于每一个classloader有一个切面来定义类型。 这就意味着如果你在一个classloader层次结构中定义了多个application context的时候就需要考虑 在哪里定义<aop:spring-configured/> bean和在哪个classpath下 放置spring-aspects.jar。

考虑一下典型的Spring web项目，一般都是由一个父application context定义大部分business service和 所需要的其他资源，然后每一个servlet拥有一个子application context定义。所有这些context共存于 同一个classloader体系下，因此AnnotationBeanConfigurerAspect仅保持 一个对context的引用。在这样的情况下，我们推荐在父application context中定义 <aop:spring-configured/> bean：这里所定义的service可能是 你希望注入domain object的。这样做的结果是你不能为子application context中 使用@Configurable的domain object配置bean引用（可能你也根本就不希望那么做！）。

当在一个容器中部署多个web-app的时候，请确保每一个web-application使用自己的classloader 来加载spring-aspects.jar中的类（例如将spring-aspects.jar放在WEB-INF/lib目录下）。 如果spring-aspects.jar被放在了容器的classpath下（因此也被父classloader加载），则所有的 web application将共享一个aspect实例，这可能并不是你所想要的。

假设你是一个应用开人员，被指派诊断一个系统的若干性能问题。与其拿出性能分析工具， 我们不如开启一个简单的分析切面，使我们能很快地得到一些性能指标，这样我们就能马上 针对特定区域使用一些较细粒度的分析工具。

这就是一个分析切面。没什么特别的，只是一个快餐式的基于时间的模拟分析器， 使用类@AspectJ风格的切面声明。

package foo;
                    
                    import org.aspectj.lang.ProceedingJoinPoint;
                    import org.aspectj.lang.annotation.Aspect;
                    import org.aspectj.lang.annotation.Around;
                    import org.aspectj.lang.annotation.Pointcut;
                    import org.springframework.util.StopWatch;
                    import org.springframework.core.annotation.Order;
                    
                    @Aspect
                    public class ProfilingAspect {
                    
                    @Around("methodsToBeProfiled()")
                    public Object profile(ProceedingJoinPoint pjp) throws Throwable {
                    StopWatch sw = new StopWatch(getClass().getSimpleName());
                    try {
                    sw.start(pjp.getSignature().getName());
                    return pjp.proceed();
                    } finally {
                    sw.stop();
                    System.out.println(sw.prettyPrint());
                    }
                    }
                    
                    @Pointcut("execution(public * foo..*.*(..))")
                    public void methodsToBeProfiled(){}
                    }
                

我们还需要创建一个“META-INF/aop.xml”文件，以告知AspectJ weaver 我们要把ProfilingAspect织入到类中。这个文件惯例，即在Java classpath中 出现一个文件称作“META-INF/aop.xml”是标准的AspectJ。

<!DOCTYPE aspectj PUBLIC
                    "-//AspectJ//DTD//EN" "http://www.eclipse.org/aspectj/dtd/aspectj.dtd">
                    <aspectj>
                    
                    <weaver>
                    
                    <!-- only weave classes in our application-specific packages -->
                    <include within="foo.*"/>
                    
                    </weaver>
                    
                    <aspects>
                    
                    <!-- weave in just this aspect -->        
                    <aspect name="foo.ProfilingAspect"/>
                    
                    </aspects>
                    
                </aspectj>

现在来看Spring特定的配置部分。我们需要配置一个LoadTimeWeaver （稍后会有解释，暂时不多深究）。当将一个或多个“META-INF/aop.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"
                    xmlns:context="http://www.springframework.org/schema/context"
                    xsi:schemaLocation="
                    http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
                    http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd">
                    
                    <!-- a service object; we will be profiling it's methods -->
                    <bean id="entitlementCalculationService"
                    class="foo.StubEntitlementCalculationService"/>
                    
                    <!-- this switches on the load-time weaving -->
                    <context:load-time-weaver/>
                    
                </beans>

现在万事俱备 - 切面，META-INF/aop.xml文件，以及Spring的配置 - 让我们创建一个带有main(..)方法的简单驱动类来演示LTW的作用吧。

package foo;
                    
                    import org.springframework.context.support.ClassPathXmlApplicationContext;
                    
                    public final class Main {
                    
                    public static void main(String[] args) {
                    
                    ApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml", Main.class);
                    
                    EntitlementCalculationService entitlementCalculationService
                    = (EntitlementCalculationService) ctx.getBean("entitlementCalculationService");
                    
                    // the profiling aspect is 'woven' around this method execution
                    entitlementCalculationService.calculateEntitlement();
                    }
                }

最后还有一件事要做。此节之前的介绍说过可以有选择性的基于Spring的 per-ClassLoader来启动LTW，而且的确如此。不过，对此例来说， 我们将使用Java代理（由Spring提供）来启动LTW。这个就是用以运行上面Main 类的命令行语句：

java -javaagent:C:/projects/foo/lib/global/spring-agent.jar foo.Main

-javaagent是一个Java 5+标记，用来指定和激活 使JVM上的程序运行的代理。Spring框架装载了一个InstrumentationSavingAgent 代理，在上面的例子中被作为了-javaagent参数的值打包在 spring-agent.jar中。

Main程序运行的输出如下所示。（我已经在 calculateEntitlement()的实现中插入了Thread.sleep(..) 语句，以免让模拟分析器获取0毫秒 - 这里的01234毫秒并非是AOP引入的系统开销。）

Calculating entitlement
                    
                    StopWatch 'ProfilingAspect': running time (millis) = 1234
                    ------ ----- ----------------------------
                    ms     %     Task name
                    ------ ----- ----------------------------
                01234  100%  calculateEntitlement

因为这个LTW使用成熟的AspectJ，我们并不局限于通知Spring beans的方法；接下来这个稍有变化的 Main程序将生成同样的结果。

package foo;
                    
                    import org.springframework.context.support.ClassPathXmlApplicationContext;
                    
                    public final class Main {
                    
                    public static void main(String[] args) {
                    
                    new ClassPathXmlApplicationContext("beans.xml", Main.class);
                    
                    EntitlementCalculationService entitlementCalculationService =
                    new StubEntitlementCalculationService();
                    
                    // the profiling aspect will be 'woven' around this method execution
                    entitlementCalculationService.calculateEntitlement();
                    }
                }

注意以上程序我们只是引导了Spring容器，然后完全在Spring上下文之外创建了一个 StubEntitlementCalculationService的实例...分析通知仍然得到织入。

上面的例子虽然简单了些，但Spring中基本的LTW支持都已介绍完了， 此节余下内容将对使用这些配置和用法背后的理由作详细解释。

	Note
	类ProfilingAspect在此例中虽然基本但是颇为有用。这是一个很好的开发时切面的例子，开发者可以在开发过程中使用它（废话）， 然后也能从已部署到UAT或者生产环境的应用中轻易的脱离。

你在LTW中使用的切面必须是AspectJ切面。你可以使用AspectJ语言或者类@AspectJ风格来编写你的切面。 后一种方式当然只能在Java 5+中使用，但它说明了你的切面可以同时对AspectJ和Spring AOP切面有效。 此外，编译后的切面类需要被注册到classpath下。

AspectJ LTW的基础设施是用一个或多个位于Java classpath上的（可以是直接的文件形式， 也可以是更典型的jar包形式）META-INF/aop.xml文件配置起来的。

有关文件的结构和内容都在AspectJ的参考文档中有详细介绍，有兴趣的读者 请参考这些资源。（很庆幸这一节比较简短，但aop.xml文件 是100% AspectJ的 - 没有任何使用Spring特定的信息或语义，因此我也没有什么可贡献的。 与其重写这些已由AspectJ开发者提供的令人满意的章节，我不如领你到这里。）

你至少需要以下类库来让Spring框架支持AspectJ LTW：

如果你正在使用 由Spring提供的代理来激活检测（instrumentation）功能，你会需要：

Spring LTW功能的关键组件是LoadTimeWeaver接口 （在org.springframework.instrument.classloading包中）， 以及Spring分发包中大量的实现。LoadTimeWeaver的实现负责 在运行时把一个或多个java.lang.instrument.ClassFileTransformers类添加到 ClassLoader中，这能产生各种各样有趣的应用，LTW切面恰好便是其中之一。

	Tip
	如果你对运行时类文件变换的思想还不熟悉，推荐你在继续之前阅读 java.lang.instrument包的Javadoc API文档。 这其实并不难-反而有些恼人-因为有用的文件并不多...关键的接口和类都将会在此节呈现给你。

用XML为ApplicationContext配置一个 LoadTimeWeaver简单得只需要添加一行。 （请注意几乎肯定你需要使用ApplicationContext作为你的 Spring容器 - 一般来说只有BeanFactory是不够的， 因为LTW功能需要用到BeanFactoryPostProcessors。）

当要使用Spring框架的LTW功能时，你需要配置一个LoadTimeWeaver， 一般可以用<context:load-time-weaver/>元素来完成。 下面为一个有效的使用默认设置的<context:load-time-weaver/>定义。

<?xml version="1.0" encoding="UTF-8"?>
                    <beans xmlns="http://www.springframework.org/schema/beans"
                    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
                    xmlns:context="http://www.springframework.org/schema/context"
                    xsi:schemaLocation="
                    http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
                    http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd">
                    
                    <context:load-time-weaver/>
                    
                </beans>

上面<context:load-time-weaver/> bean的定义会自动为你定义和注册若干 特定LTW的基础设施beans，比如一个LoadTimeWeaver 和一个AspectJWeavingEnabler。请注意 <context:load-time-weaver/>是怎样在context 命名空间下被定义的；还要注意被引用的XML Schema文件只在Spring 2.5或更高版本中才可用。

上面的配置为你定义并注册了一个默认的LoadTimeWeaver bean。 默认的LoadTimeWeaver是一个 DefaultContextLoadTimeWeaver类，它更倾向于去装饰一个能自动检测的LoadTimeWeaver类：LoadTimeWeaver 的确切类型会根据你的运行时环境“自动检测”出来（概述如下表）。

请注意当使用DefaultContextLoadTimeWeaver时只有 LoadTimeWeavers实现类能进行自动检测： 当然，你也可以通过指定将类的完全限定名作为<context:load-time-weaver/> 元素中weaver-class属性的值 来指定究竟想使用哪个LoadTimeWeaver的实现。如下例：

<?xml version="1.0" encoding="UTF-8"?>
                    <beans xmlns="http://www.springframework.org/schema/beans"
                    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
                    xmlns:context="http://www.springframework.org/schema/context"
                    xsi:schemaLocation="
                    http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
                    http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd">
                    
                    <context:load-time-weaver
                    weaver-class="org.springframework.instrument.classloading.ReflectiveLoadTimeWeaver"/>
                    
                </beans>

在<context:load-time-weaver/>元素上定义和注册的 LoadTimeWeaver接口可以在Spring容器中以 loadTimeWeaver名字找到。 记住LoadTimeWeaver接口只是作为Spring LTW基础设施的一个机制 用来添加一个或多个ClassFileTransformers的。 ClassFileTransformer类实际是利用 ClassPreProcessorAgentAdapter类（包含在 org.aspectj.weaver.loadtime中）来进行LTW的。 有关ClassPreProcessorAgentAdapter的细节请参见 类级别的javadoc，织入实际怎样生效的具体内容已经超出本节讨论范围。

让我们来讨论<context:load-time-weaver/>的最后一个属性： aspectj-weaving。 这是一个简单的LTW开关，就这么简单。 它可以接受如下所述的三种值，如果不显示设置此属性则其默认值为autodetect

这最后一节包括所有你在诸如应用服务器和web容器中使用Spring的LTW功能时需要的额外设置和配置。

<Context path="/myWebApp" docBase="/my/webApp/location">
                        <Loader loaderClass="org.springframework.instrument.classloading.tomcat.TomcatInstrumentableClassLoader"
                        useSystemClassLoaderAsParent="false"/>
                        </Context>