构建 Spring 2 企业应用程序：第 4 章：Spring AOP 2.0

这个 bean 本身不受任何影响。事实上，messagePrinter bean 也不知道它被声明为一个方面。此标签本身不会在自动代理创建期间触发代理对象的创建。该标签仅声明一个可以包含零个或多个 XML 中的切点和通知/切点声明的方面。

接下来，我们将把 xml-aspect-context.xml 加载到一个测试用例中，以验证 tournamentMatchManager bean 是否已正确代理。清单 4-26 中的测试用例显示了 MessagePrintingXmlAspectIntegration Tests，它扩展了清单 4-6 中的 MessagePrintingAspectIntegrationTests。

清单 4-26. 用于验证 XML 方面是否按预期工作的测试用例

package com.apress.springbook.chapter04; 

public class MessagePrintingXmlAspectIntegrationTests extends 
MessagePrintingAspectIntegrationTests { 
protected String[] getConfigLocations() { 
  return new String[] { 
     "classpath:com/apress/springbook/chapter04/" + 
     "xml-aspect-context.xml" 
   }; 
  } 
} 

=== GOING TO CALL METHOD ON BEAN FROM CONTAINER === 
Attempting to start tennis match! 
=== FINISHED CALLING METHOD ON BEAN FROM CONTAINER === 
=== GOING TO CALL METHOD ON NEWLY CREATED OBJECT === 
=== FINISHED CALLING METHOD ON NEWLY CREATED OBJECT === 

XML 中的切点声明和重用

清单 4-27. 重用在 @AspectJ 风格方面中声明的切点

<?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: aop="http://www.springframework.org/schema/aop" 
       xsi: schemaLocation="http://www.springframework.org/schema/beans 
              http://www.springframework.org/schema/beans/spring-beans.xsd 
              http://www.springframework.org/schema/aop 
              http://www.springframework.org/schema/aop/spring-aop.xsd"> 

  <aop:config> 
    <aop:aspect ref="securityEnforcer"> 
      <aop:before method="denyAccessToAll" 
                 pointcut="com.apress.springbook.chapter04.aspects. --> 
      SystemPointcutsAspect.inServiceLayer()"/> 
</aop:aspect> 
</aop:config> 

  <bean id="securityEnforcer" 
    class="com.apress.springbook.chapter04.SecurityEnforcer"/> 
</beans> 

清单 4-28. 在 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: aop="http://www.springframework.org/schema/aop" 
       xsi: schemaLocation="http://www.springframework.org/schema/beans 
              http://www.springframework.org/schema/beans/spring-beans.xsd 
              http://www.springframework.org/schema/aop 
              http://www.springframework.org/schema/aop/spring-aop.xsd"> 

  <aop:config> 
    <aop:aspect ref="securityEnforcer"> 
      <aop:pointcut id="inServiceLayer" 
                expression="within(com.apress.springbook.chapter04..*)"/> 
      <aop:before method="denyAccessToAll" 
                pointcut-ref="inServiceLayer"/> 
    </aop:aspect> 
  </aop:config> 

  <bean id="securityEnforcer" 
    class="com.apress.springbook.chapter04.SecurityEnforcer"/> 
</beans> 

<aop:pointcut> 标签声明一个切点，并接受一个名称（id）和切点表达式（expression）。然后由 <aop:before> 标签（pointcut-ref）重用此切点。

清单 4-29 显示了一个声明在 <aop:config> 标签内的切点。此切点可以在此及其他 Spring XML 文件中的 <aop:aspect> 标签内重用。

清单 4-29. 在方面外部声明一个切点并在 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: aop="http://www.springframework.org/schema/aop" 
       xsi: schemaLocation="http://www.springframework.org/schema/beans 
              http://www.springframework.org/schema/beans/spring-beans.xsd 
              http://www.springframework.org/schema/aop 
              http://www.springframework.org /schema/aop/spring-aop.xsd"> 

  <aop:config> 
    <aop:pointcut id="inServiceLayer" 
expression="within(com.apress.springbook.chapter04..*)"/> 
<aop:aspect ref="securityEnforcer"> 
<aop:before method="denyAccessToAll" 
pointcut-ref="inServiceLayer"/> 
</aop:aspect> 
</aop:config> 

  <bean id="securityEnforcer" 
    class="com.apress.springbook.chapter04.SecurityEnforcer"/> 
</beans> 

XML 中的通知声明

现在我们将介绍如何在 XML 中声明每种不同的通知类型。稍后，在“绑定通知参数”部分，我们将重写我们用来解释如何绑定 @AspectJ 风格通知方法上的通知参数的方面，并显示等效的 XML，以便您可以轻松地进行比较。

清单 4-30 显示了一个前置通知 XML 声明的示例。清单 4-30. 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: aop="http://www.springframework.org/schema/aop" 
       xsi: schemaLocation="http://www.springframework.org/schema/beans 
              http://www.springframework.org/schema/beans/spring-beans.xsd 
              http://www.springframework.org/schema/aop 
              http://www.springframework.org /schema/aop/spring-aop.xsd"> 



  <aop:config> 
    <aop:aspect ref="messagePrinter"> 
<aop:before method="printMessageToInformMatchStarts" 
pointcut="execution(* startMatch(..))"/> 
</aop:aspect> 
</aop:config> 

  <bean id="messagePrinter" 
    class="com.apress.springbook.chapter04.MessagePrinter"/> 

  <bean id="tournamentMatchManager" 
    class="com.apress.springbook.chapter04.DefaultTournamentMatchManager"> 
    <!-- properties omitted --> 
  </bean> 
</beans> 

清单 4-31. 在 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: aop="http://www.springframework.org/schema/aop" 
       xsi: schemaLocation="http://www.springframework.org/schema/beans 
              http://www.springframework.org/schema/beans/spring-beans.xsd 
              http://www.springframework.org/schema/aop 
              http://www.springframework.org/schema/aop/spring-aop.xsd"> 

  <aop:config> 
    <aop:aspect ref="messagePrinter"> 
<aop:after-returning method="printMessageToInformMatchHasStarted" 
pointcut="execution(* startMatch(..))"/> 
</aop:aspect> 
</aop:config> 

  <bean id="messagePrinter" 
    class="com.apress.springbook.chapter04.MessagePrinter"/> 

  <bean id="tournamentMatchManager" 
    class="com.apress.springbook.chapter04.DefaultTournamentMatchManager"> 
<!-- properties omsitted --> 
</bean> 
</beans> 

清单 4-32. 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: aop="http://www.springframework.org/schema/aop" 
       xsi: schemaLocation="http://www.springframework.org/schema/beans 
              http://www.springframework.org/schema/beans/spring-beans.xsd 
              http://www.springframework.org/schema/aop 
              http://www.springframework.org /schema/aop/spring-aop.xsd"> 





  <aop:config> 
    <aop:aspect ref="messagePrinter"> 
<aop:after-throwing method="printMessageWhenMatchIdentifierIsNotFound" 
pointcut="execution(* startMatch(..) throws --> 
com.apress.springbook.chapter04.UnknownMatchException)"/> 
</aop:aspect> 
</aop:config> 

  <bean id="messagePrinter" 
    class="com.apress.springbook.chapter04.MessagePrinter"/> 

  <bean id="tournamentMatchManager" 
    class="com.apress.springbook.chapter04.DefaultTournamentMatchManager"> 
    <!-- properties omitted --> 
  </bean> 
</beans> 

<?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: aop="http://www.springframework.org/schema/aop" 
       xsi: schemaLocation="http://www.springframework.org/schema/beans 
              http://www.springframework.org/schema/beans/spring-beans.xsd 
              http://www.springframework.org/schema/aop 
              http://www.springframework.org /schema/aop/spring-aop.xsd"> 

  <aop:config> 
    <aop:aspect ref="messagePrinter"> 
<aop:after method="printMessageWhenStartMatchAttemptIsOver" 
pointcut="execution(* startMatch(..))"/> 
</aop:aspect> 
</aop:config> 

  <bean id="messagePrinter" 
    class="com.apress.springbook.chapter04.MessagePrinter"/> 

  <bean id="tournamentMatchManager" 
    class="com.apress.springbook.chapter04.DefaultTournamentMatchManager"> 
    <!-- properties omitted --> 
  </bean> 
</beans> 

清单 4-34. MessagePrinter 上的 printMessageWhenStartMatchAttemptIsOver() 方法

package com.apress.springbook.chapter04; 

public class MessagePrinter { 
  public (.*?) { 
      System.out.println("Tried to start a match and this attempt is now over!");    } 
} 

同样，因为后置（finally）通知 XML 声明与我们之前讨论的 @AspectJ 风格声明非常相似，所以没有意外。

最后但同样重要的是，环绕通知作为 XML 声明。您可能已经猜到，此通知类型要求在通知方法中声明一个 ProceedingJoinPoint 参数。这会将 MessagePrinter 类绑定到 AspectJ API。清单 4-35 显示了 XML 中的环绕通知声明。

清单 4-35. 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: aop="http://www.springframework.org/schema/aop" 
       xsi: schemaLocation="http://www.springframework.org/schema/beans 
              http://www.springframework.org/schema/beans/spring-beans.xsd 
              http://www.springframework.org/schema/aop 
              http://www.springframework.org /schema/aop/spring-aop.xsd"> 

  <aop:config> 
    <aop:aspect ref="messagePrinter"> 
<aop:around method="controlStartMatchMethodExecution" 
pointcut="execution(* startMatch(..))"/> 
</aop:aspect> 
</aop:config> 

  <bean id="messagePrinter" 
    class="com.apress.springbook.chapter04.MessagePrinter"/> 

  <bean id="tournamentMatchManager" 
    class="com.apress.springbook.chapter04.DefaultTournamentMatchManager"> 
    <!-- properties omitted --> 
  </bean> 
</beans> 

清单 4-36. MessagePrinter 上的 controlStartMatchMethodExecution() 方法

package com.apress.springbook.chapter04; 

import org.aspectj.lang.ProceedingJoinPoint; 

public class MessagePrinter { 
  public Object controlStartMatchMethodExecution(ProceedingJoinPoint pjp) 
    throws Throwable { 
  System.out.println("A match is about to be started!"); 
try { 
Object result = pjp.proceed(); 
System.out.println("The match has been started successfully!"); 
return result; 
} catch (Throwable t) { 
System.out.println("Oops, something went wrong while starting the match."); 
throw t; 
  } 
} 
} 

MessagePrinter 上的 controlStartMatchMethodExecution() 方法是拦截通知的一个经典示例。

XML 中的通知排序

• 在同一个 XML 方面中声明的、在一个连接点上执行的通知，按照它们在 XML 文件中的声明顺序进行排序。
• 如果您想控制不同 XML 方面中声明的通知的顺序，您必须在声明通知方法的类（如清单 4-24 中的 MessagePrinter 类）中实现 org.springframework.core.Ordered 接口。

通过实现 Ordered 接口，您还可以控制 XML 通知和 @AspectJ 风格通知在同一连接点上的顺序。

带有 AspectJ 切点的 Advisor

当您将 advisor 添加到 Spring 容器并配置自动代理创建时，其切点可以匹配容器中 bean 上的连接点；当匹配时，将创建代理对象。

考虑清单 4-37 中的示例。请注意，必须先定义 advisor，然后才能定义方面。

清单 4-37. 使用 <aop:advisor> 标签配置 PointcutAdvisor

<?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: aop="http://www.springframework.org/schema/aop" 
       xsi: schemaLocation="http://www.springframework.org/schema/beans 
              http://www.springframework.org/schema/beans/spring-beans.xsd 
              http://www.springframework.org/schema/aop 
              http://www.springframework.org /schema/aop/spring-aop.xsd"> 

  <aop:config> 
    <aop:advisor advice-ref="loggingAdvice" pointcut="execution(* startMatch(..))"/> 
</aop:config> 

  <bean id="loggingAdvice" 
    class="org.springframework.aop.interceptor.CustomizableTraceInterceptor"> 
<property name="enterMessage" 
value="Entering $[methodName] on $[targetClassShortName]"/> 
</bean> 

  <bean id="tournamentMatchManager" 
    class="com.apress.springbook.chapter04.DefaultTournamentMatchManager"> 
    <!-- properties omitted --> 
  </bean> 
</beans> 

自动代理创建将为 tournamentMatchManager bean 创建一个代理，因为其 startMatch() 方法与 advisor 的切点匹配。

advisor 参与自动代理创建，这意味着它们的通知对象可以与其他通知在同一连接点上一起执行。要设置 advisor 的顺序，您可以配置 order 属性，如清单 4-38 所示。

清单 4-38. 设置此 advisor 的通知顺序

<?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: aop="http://www.springframework.org/schema/aop" 
       xsi: schemaLocation="http://www.springframework.org/schema/beans 
              http://www.springframework.org/schema/beans/spring-beans.xsd 
              http://www.springframework.org/schema/aop 
              http://www.springframework.org /schema/aop/spring-aop.xsd"> 

  <aop:config> 
    <aop:advisor advice-ref="loggingAdvice" 
              order="20" 
              pointcut="execution(* startMatch(..))"/> 
</aop:config> 

  <bean id="loggingAdvice" 
    class="org.springframework.aop.interceptor.CustomizableTraceInterceptor"> 
<property name="enterMessage" 
              value="Entering $[methodName] on $[targetClassNameShort]"/> 
</bean> 

  <bean id="tournamentMatchManager" 
              class="com.apress.springbook.chapter04.DefaultTournamentMatchManager"> 
    <!-- properties omitted --> 
  </bean> 
</beans>

XML 中的代理类型选择

清单 4-39. 强制使用 CGLIB 代理对象

<?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: aop="http://www.springframework.org/schema/aop" 
       xsi: schemaLocation="http://www.springframework.org/schema/beans 
              http://www.springframework.org/schema/beans/spring-beans.xsd 
              http://www.springframework.org/schema/aop 
              http://www.springframework.org /schema/aop/spring-aop.xsd"> 

    <aop:config proxy-target-class="true"> 

  </aop:config> 

</beans> 

因此，既然您已经了解了配置 Spring AOP 的两种不同方法，让我们更详细地看看切点。

使用切点

• 特定类的所有方法
• 特定包中所有类的所有方法
• 特定包及其子包中所有类的所有方法
• 具有特定注解的所有方法
• 具有特定注解的类的所有方法
• 具有特定名称的所有方法
• 名称包含特定字符串的所有方法
• 具有特定参数类型的所有方法

• 切点指示符：我们已经使用了 execution() 和 within()。Spring AOP 支持更多指示符，您将在以下示例中看到。它们根据某个属性缩小连接点的选择范围。此列表中的其他构造与这些指示符结合使用。
• 布尔运算符：您可以组合切点指示符来缩小选择范围。支持 AND (&&) 和 OR (||) 运算符，以及 NOT 运算符 (!)。
• 类名：通常，您需要指定类名，例如将选择范围缩小到目标类型或方法参数类型。这些类名必须始终是完全限定的（包括完整的包名），即使对于 java.lang 包中的类也是如此。
• 可见性运算符：您可以将搜索范围缩小到 public 或 protected 方法。
• 通配符：通常，您会想要使用通配符运算符。支持的通配符运算符是星号 (*) 用于任何方法或类名或任何参数类型，以及双点 (..) 用于零个或多个参数。
• 方法名：可以是完整名称、名称的部分匹配或通配符（任何名称）。
• 注解：您还可以根据注解选择方法，如以下各节所述。

让我们从直接选择方法开始。

直接选择方法

按方法名称选择

清单 4-40 显示了一个选择所有 relax()、enjoy() 和 chillOut() 方法的切点。

清单 4-40. 选择一些愉快的练习

package com.apress.springbook.chapter04.aspects; 

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


@Aspect 
public class SystemPointcutsAspect { 
  @Pointcut("execution(* relax(..)) || execution(* enjoy(..)) || " + 
      "execution(* chillOut(..))") 
  public void goodTimes() {  } 
} 

您也可以在方法名称中使用通配符。清单 4-41 显示了一个选择所有名称以 do 开头的方法的切点。

清单 4-41. 选择所有名称以 do 开头的方法

package com.apress.springbook.chapter04.aspects; 

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


@Aspect 
public class SystemPointcutsAspect { 
  @Pointcut("execution(* do*(..))") 
  public void performAction() {  } 
} 

按方法名称选择是最基本切点标准之一。它们可以与其他标准结合使用，以缩小选择范围，确保只选择预期的那些方法。

缩小方法选择范围的一种强大方法是同时根据方法参数进行选择。

按参数类型选择

• 没有参数的所有方法
• 具有一个参数的所有方法，无论其类型如何
• 具有一个 java.lang.String 参数的所有方法
• 以 java.lang.String 作为第一个参数，以及零个或多个其他参数的所有方法
• 以 java.lang.String 作为第二个参数，以及零个或多个其他参数的所有方法

package com.apress.springbook.chapter04.aspects; 

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


@Aspect 
public class SystemPointcutsAspect { 
  @Pointcut("execution(* *())")   
  public void allMethodsWithoutArguments() {} 

  @Pointcut("execution(* *(*))")   
  public void allMethodsWithOneArgumentRegarlessOfType() {} 

  @Pointcut("execution(* *(java.lang.String))")   
  public void allMethodsWithOneArgumentOfTypeString() {} 

  @Pointcut("execution(* *(java.lang.String,..))")   
  public void  
  allMethodsWithFirstArgumentOfTypeStringAndZeroOrMoreOtherArguments() {} 
@Pointcut("execution(* *(*,java.lang.String,..))")   
  public void  
      allMethodsWithSecondArgumentOfTypeStringAndZeroOrMoreOtherArguments () {  } 
} 

清单 4-43. 根据实际参数值而不是参数声明选择方法

package com.apress.springbook.chapter04.aspects; 

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


@Aspect 
public class MessagePrintingAspect { 

  @Before("args(java.util.Hashtable)")   
  public void printWarningForUsageOfHashtable() { 
    System.out.println("Warning: java.util.Hashtable is passed as argument!"); 
  } 
} 

以下三个方法签名都将被此切点选择：

public java.util.List getUniqueValuesFromMap(java.util.Map map) { … } 

public Object getLowestKeyValueFromMap(java.util.Map map) { … } 

public String transformObjectToString(Object o) { … }

由于 Spring AOP 无法确定将哪个参数值传递给这些方法，因此这三个方法签名都将由清单 4-43 中的切点在自动代理创建期间匹配。Spring AOP 知道这些单参数方法中的任何一个都有可能被此切点匹配。但是，即使 Spring AOP 决定为实现这些方法中任何一种的 bean 创建代理对象，也不意味着通知将始终为这些方法执行。Spring AOP 将需要每次执行这些方法时进行匹配，以决定是否执行通知，具体取决于传递的参数值。此过程可能会产生创建比预期更多的代理对象的非预期副作用。

在 Spring AOP 中，代理创建相对廉价，并且对于单例 bean 来说不是问题。

对于原型 bean 来说，情况就不同了，因为每次通过依赖查找或依赖注入请求原型 bean 时都需要创建一个代理对象。如果您要创建许多原型对象，您应该意识到动态切点*可能*对 Spring 容器中的原型 bean 创建产生性能影响。

根据返回类型声明选择

execution(* startMatch(..)) 

此切点中的星号 (*) 匹配任何返回类型；返回类型和方法签名都是 execution() 切点指示符的必需字段。我们可以将此切点更改为仅匹配返回我们期望类型的 startMatch() 方法，如下所示：

execution(com.apress.springbook.chapter04.Match startMatch(..)) 

为什么我们要指定返回类型，而整个应用程序只有一个 startMatch() 方法，而且 * 输入更少？

编写切点时，您需要小心您将选择哪些连接点。作为意外副作用而选择的任何连接点都会产生开销。当应用程序增长时，许多小开销通常会变得很重要。

您还可以使用 void 关键字作为返回类型，以仅选择不返回任何内容的（无返回值）方法。

---

注意

根据返回类型声明来选择方法不需要动态切点，因为 Spring AOP 可以在自动代理创建时查看静态方法签名。

---

根据 throws 声明选择方法

要匹配异常类型，它必须在方法签名中声明。正如您可能已经知道的，Java 有两种异常类型：

运行时异常（Unchecked exceptions）：这些是无法恢复的异常，通常意味着应用程序在这些异常发生时无能为力。由于其不可恢复的性质，Java 不要求在方法签名中声明这些异常，也不要求应用程序代码捕获它们。与 java.lang.Error 和 java.lang.RuntimeException 类型兼容的异常是运行时异常。

已检查异常（Checked exceptions）：这些通常是可恢复的异常，意味着应用程序逻辑可以采取有意义的措施来响应它们的发生。这些异常必须在 try/catch 块中捕获，或者在方法签名中声明以传递给调用者。

与 java.lang.Error 和 java.lang.RuntimeException 不兼容的异常是已检查异常。

如果未在方法体中捕获，已检查异常必须在方法签名中声明；运行时异常可以声明，但这不是必需的。运行时异常有时会在方法签名中声明，以告知调用者它们可能会被抛出。但是，即使运行时异常在方法签名中声明，调用者也不需要捕获它们。

这让我们得出以下结论：

• 已检查异常通常在方法签名中声明。
• 运行时异常通常不在方法签名中声明。

由于切点只能匹配在其签名中声明了异常的方法，因此您通常只能匹配已检查异常，如列表 4-44 所示。

列表 4-44.匹配 java.io.IOException

package com.apress.springbook.chapter04.aspects; 

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


@Aspect 
public class MessagePrintingAspect { 

  @Before("execution(* *(..) throws java.lang.IOException)")   
  public void printWarningIOExceptionMayBeThrown() { 

    System.out.println("Warning: IOException may be thrown. Brace yourselves!"); 
  } 
} 

public String readFileToString(java.io.File file) throws java.io.IOException, java.lang.IllegalArgumentException { … } public void copy(java.io.InputStream in, java.io.OutputStream out) throws java.io.IOException, java.lang.IllegalStateException { … } 当我们在本章后面讨论绑定通知方法参数时，我们将研究如何响应实际由方法抛出的异常。

---

注意

根据 `throws` 声明选择方法不需要动态切点，因为 Spring AOP 可以在自动代理创建时查看静态方法签名。

---

通过类、包和继承选择方法

• 日志记录：您想确切地了解应用程序组件如何交互，或者您想衡量方法执行的性能。
• 审计：您有要求记录谁在执行一系列组件上的操作。
• 安全：您想在调用方法时强制执行用户角色，或者您想根据安全策略过滤返回值。
• 优化：您想了解用户如何使用您的领域逻辑，以便了解可以在哪里添加更多功能，或者如何改进性能、减少内存使用或减少常见操作的数据库访问。

这些要求中的每一个通常都基于通用属性（如包含类、包含包或继承层次结构）对大量方法产生影响。其中一些要求只能通过绑定通知方法参数来实现，我们将在本章后面讨论这一点。在这里，我们将重点介绍如何根据类、包和继承来选择方法。

按类选择

• 能够根据静态（非动态）类和方法信息确定匹配的切点。`execution()` 和 `within()` 切点指示符将只查看静态信息，非常适合在切点中缩小选择范围。
• 需要方法执行上下文来确定匹配的切点。需要方法执行的切点并非总是可以避免，但了解如何限制要代理的对象数量至仅限目标对象非常重要。

您已经熟悉 `execution()`，但我们还没有讨论如何在单个类中选择方法。`within()` 切点指示符也可以将选择范围缩小到特定类型的所有方法。以下是两个选择完全相同的连接点的切点：

execution(* com.apress.springbook.chapter04.DefaultTournamentMatchManager.*(..)) 
within(com.apress.springbook.chapter04.DefaultTournamentMatchManager) 

这些切点选择 DefaultTournamentMatchManager 类上的所有方法。它们使用静态信息，因此不需要方法执行的上下文。但是，有时您需要它，特别是在使用通知方法参数绑定时，我们稍后将讨论。我们已经讨论了 `args()` 切点指示符，它强制执行动态切点。

另外两个动态切点指示符是 `target()` 和 `this()`。`target()` 指示符将选择范围缩小到代理对象的实际目标对象。`this()` 指示符将选择范围缩小到代理对象本身。（有关 `target()` 和 `this()` 的更多详细信息，请参阅 Spring 2.0 参考手册的第 6 章。）

通过继承选择方法

execution(* com.apress.springbook.chapter04.TournamentMatchManager+.*(..)) 
within(com.apress.springbook.chapter04.TournamentMatchManager+) 

这些切点将选择所有与 TournamentMatchManager 接口类型兼容的对象。请注意使用 + 运算符来告诉 Spring AOP 考虑类层次结构。

选择包中所有类的方法

execution(* com.apress.springbook.chapter04.*.*(..)) 
within(com.apress.springbook.chapter04.*) 

如果您想包含所有子包，则需要额外添加一个点 (..)。将前面的切点与以下切点进行比较：

execution(*com.apress.springbook.chapter04..*.*(..)) 
within(com.apress.springbook.chapter04..*) 

在包级别缩小范围有助于您选择特定的方法。

通过注解选择方法

在这里，我们将使用审计的例子来演示如何选择带有注解的方法以及带有注解的类中的方法。在本例中，我们将使用列表 4-45 中显示的 `@Audit` 注解。

列表 4-45.`@Audit` 注解

package com.apress.springbook.chapter04; 

import java.lang.annotation.Retention; 
import java.lang.annotation.RetentionPolicy; 

@Retention(RetentionPolicy.RUNTIME) 
public @interface Audit { 
  } 

列表 4-46.使用 `@Audit` 注解标记需要保留审计信息的方法

package com.apress.springbook.chapter04; 

public class BusinessOperations { 
  @Audit   
  public void sensitiveOperation(long recordId) { …   } 
  } 

要存储的信息以及存储方式很可能在策略文档中定义，并且对于所有方法都是相同的。我们只标记了一个方法，现在可以用切面来实现保留策略。

按方法注解声明选择

我们将只选择声明了 `@Audit` 注解的方法，而让其他方法不受影响。这是一种很好的工作方式，因为我们可以确定不会有副作用。我们将实际的审计信息保存委托给 AuditInformationRetentionPolicy 接口，如列表 4-47 所示。

列表 4-47.AuditInformationRetentionPolicy 接口

package com.apress.springbook.chapter04; 

public interface AuditInformationRetentionPolicy { 
  public void retainMethodInvocationInformation( 
    String currentUser, String methodDescription, Object[] arguments); 
} 

不希望将我们切面的实现与特定的身份验证机制绑定。我们创建了 CurrentUserInformation 接口，如列表 4-48 所示。

列表 4-48.CurrentUserInformation 接口

package com.apress.springbook.chapter04; 

public interface CurrentUserInformation { 
  public String getUsername(); 
    } 

第一步是在 SystemPointcutsAspect 中添加一个切点，因为我们希望集中系统范围的切点，如列表 4-49 所示。

列表 4-49.添加系统范围的切点

package com.apress.springbook.chapter04.aspects; 

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


@Aspect 
public class SystemPointcutsAspect { 
  @Pointcut("@annotation(com.apress.springbook.chapter04.Audit)")   
  public void auditableMethods() {  }  
} 

请注意，我们不再选择特定的方法、类或包。如果需要，我们显然可以进一步缩小切点的选择范围。

列表 4-50 显示了 AuditInformationRetentionAspect，它负责捕获所有被标记为 `@Audit` 注解的方法的执行，并调用 AuditInformationRetentionPolicy 接口上的 retainMethodInvocationInformation()。

列表 4-50.AuditInformationRetentionAspect 负责为敏感操作保存审计信息

package com.apress.springbook.chapter04.aspects; 

import com.apress.springbook.chapter04.CurrentUserInformation; 
import com.apress.springbook.chapter04.AuditInformationRetentionPolicy; 
import org.aspectj.lang.annotation.Aspect; 
import org.aspectj.lang.annotation.Before; 
import org.aspectj.lang.JoinPoint; 


@Aspect 
public class AuditInformationRetentionAspect { 
  

private AuditInformationRetentionPolicy auditInformationRetentionPolicy; 
private CurrentUserInformation currentUserInformation;   
  public void setAuditInformationRetentionPolicy( 
  AuditInformationRetentionPolicy auditInformationRetentionPolicy 
) { 
   this.auditInformationRetentionPolicy = auditInformationRetentionPolicy; 
  } 

  public void setCurrentUserInformation 
   ( 
   CurrentUserInformation currentUserInformation 
   ) { 
      this.currentUserInformation = currentUserInformation; 
  } 
  
  public void init() { 
    if (this.auditInformationRetentionPolicy == null) { 
      throw new IllegalStateException("AuditInformationRetentionPolicy " + 
        "object is not set!"); 
    } 
    if (this.currentUserInformation == null) { 
      throw new IllegalStateException("CurrentUserInformation " + 
        "object is not set!"); 
    } 
  } 
  @Before("com.apress.springbook.chapter04.aspects." + 
  "SystemPointcutsAspect.auditableMethods()")   
    public void retainMethodInvocationInformation(JoinPoint joinPoint) { 
      String currentUser = this.currentUserInformation.getUsername(); 
      String methodDescription = joinPoint.getSignature().toLongString(); 
      Object[] arguments = joinPoint.getArgs(); 

      this.auditInformationRetentionPolicy.retainMethodInvocationInformation( 
      currentUser, methodDescription, arguments); 
    } 
} 

列表 4-50 中的切面使用 org.aspectj.lang.JoinPoint 对象来获取已执行方法的描述以及已传递的参数。

列表 4-51 显示了 BusinessOperations 类和 AuditInformationRetentionAspect 切面的 Spring XML 配置文件。

列表 4-51.配置可审计类和审计切面

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

  <bean class="com.apress.springbook.chapter04.aspects. --> 
AuditInformationRetentionAspect" 
  init-method="init"> 

  <property name="auditInformationRetentionPolicy" 
               ref="auditInformationRetentionPolicy"/> 
  <property name="currentUserInformation" ref="currentUserInformation"/> 
</bean> 

  <bean id="businessOperations" 
    class="com.apress.springbook.chapter04.BusinessOperations"> 
    <!-- properties omitted --> 
  </bean> 
</beans> 

按类注解声明选择

有时您还希望用注解标记整个类，为该类中的所有方法强制执行策略。当类的所有职责都需要强制执行策略（如审计）时，这是一种可行的方法。不需要这些策略的方法因此不应放在此类中。

虽然这是一个有趣的方法，但您需要考虑一个后果。如果您还记得，在 Spring AOP 中使用切面工作的要求之一是调用者使用代理对象，而不是目标对象。

考虑列表 4-52 中的 MoreBusinessOperations 类。

列表 4-52.MoreBusinessOperations 类

package com.apress.springbook.chapter04; 

@Audit 
public class MoreBusinessOperations { 
  public (.*?) { 
      // do some work 
     someOtherSensitiveOperation(recordId); 
} 
  
  public void someOtherSensitiveOperation(long recordId) { 
    // work with sensitive data 
  } 
} 

是否通过代理对象调用了 `someSensitiveOperation()` 方法并不重要。此方法调用同一对象上的另一个方法，因此该方法调用不会通过代理对象。这意味着 `someOtherSensitiveOperation()` 不会强制执行审计策略。虽然这听起来很严重，但我们需要考虑在执行 `someSensitiveOperation()` 时保存审计信息是否足以覆盖这两个方法调用。如果不足够，那么两个都需要审计信息保留的方法，一个被另一个调用，是否应该放在同一个类中？将这两个方法放在同一个类中可能会使该类承担过多的职责。

如果 `someOtherSensitiveOperation()` 方法始终需要保存审计信息，那么它可能应该移到一个单独的类中。然后可以将该类的对象注入到 MoreBusinessOperations 对象中，该对象随后可以调用注入对象上的 `someOtherSensitiveOperation()` 方法。

关于解决此类应用程序设计与 Spring AOP 等技术框架所施加的限制之间的冲突，没有硬性规定。我们建议您运用常识，并考虑类、方法和要强制执行的策略来找到解决方案。

要匹配声明了 `@Audit` 注解的类中的方法，我们需要更改 SystemPointcutsAspect 中的 auditableMethods() 切点，如列表 4-53 所示。

列表 4-53.也匹配声明了 `@Audit` 注解的类中的方法

package com.apress.springbook.chapter04.aspects; 

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


@Aspect 
public class SystemPointcutsAspect { 
  @Pointcut("@within(com.apress.springbook.chapter04.Audit)") 
  public void auditableMethods() {  } 
} 

现在我们已经涵盖了如何使用切点匹配 Java 5 注解，让我们来看看如何绑定通知。

绑定通知参数

让我们从本章开头示例中的切面开始，如列表 4-54 所示。

列表 4-54.在网球比赛开始时打印一条消息

package com.apress.springbook.chapter04.aspects; 

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


@Aspect 
public class MessagePrintingAspect { 
  @Before("execution(* startMatch(..))") 
  public void printMessageToInformMatchStarts() { 
      System.out.println("Attempting to start tennis match!"); 
  } 
} 

列表 4-54 中的 `printMessageToInformMatchStarts()` 通知方法没有参数。

让我们再次看看 TournamentMatchManager 接口及其 `startMatch()` 方法，如列表 4-55 所示。

列表 4-55.TournamentMatchManager 接口

package com.apress.springbook.chapter04; 

public interface TournamentMatchManager { 
  public Match startMatch(long matchId) throws 
    UnknownMatchException, MatchIsFinishedException, 
    MatchCannotBePlayedException, PreviousMatchesNotFinishedException; 
} 

列表 4-56.通过 JoinPoint 对象获取参数值

package com.apress.springbook.chapter04.aspects; 

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


@Aspect 
public class MessagePrintingAspect { 
  @Before("execution(* startMatch(..))") 
  public void printMessageToInformMatchStarts(JoinPoint jp) { 
  Long matchId = (Long)jp.getArgs()[0]; 
  System.out.println("Attempting to start tennis match with identifier " + 
      matchId + "!"); 
  } 
} 

所以我们现在有了比赛标识符，但是有一个问题：必须更改切点表达式以避免错误。当前的切点表达式将选择任何 startMatch() 方法，而不管其参数类型。我们需要更改切点以仅选择第一个参数类型为 long 的方法，如列表 4-57 所示，因为通知方法假定它存在。

列表 4-57.更改切点表达式以进一步缩小方法选择范围

package com.apress.springbook.chapter04.aspects; 

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

@Aspect public class MessagePrintingAspect { @Before("execution(* startMatch(long,..))") public void printMessageToInformMatchStarts(JoinPoint jp) { Long matchId = (Long)jp.getArgs()[0]; System.out.println("Attempting to start tennis match with identifier " + matchId + "!"); } } 这更好，但列表 4-57 仍可改进。Spring AOP 允许我们在 `printMessageToInformMatchStarts()` 通知方法中声明一个 long 参数，而不是必须使用 JoinPoint 对象，如下节所示。

Spring AOP 支持以下通知参数绑定：

• 绑定值，对所有通知类型均有效
• 绑定返回值，仅对 after returning 通知有效
• 绑定异常对象，仅对 after throwing 通知有效
• 绑定注解对象，对所有通知类型均有效

您需要将 Java 编译器配置为在 Java 类中包含调试信息，以使参数绑定能够正常工作。通常，IDE 中的编译器默认会这样配置。有关更多详细信息，请参阅 Spring 2.0 参考手册的第 6 章。

绑定方法参数值

对于示例，我们想将比赛标识符值绑定到 printMessageToInformMatchStarts() 通知方法的参数，因此我们首先需要向该方法添加一个参数。

但是，我们还需要使用 `args()` 切点指示符来指定我们想要绑定方法参数。我们已按列表 4-58 所示更改了 MessagePrintingAspect。

列表 4-58.将比赛标识符值绑定到通知方法

package com.apress.springbook.chapter04.aspects; 

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


@Aspect 
public class MessagePrintingAspect { 

  @Before("execution(* startMatch(..)) && args(matchId, ..)")   
  public void printMessageToInformMatchStarts(long matchId) { 
    System.out.println("Attempting to start tennis match with identifier " + 
      matchId + "!"); 
  } 
} 

列表 4-58 中的切点告诉 Spring AOP 将连接点的第一个参数值绑定到 `printMessageToInformMatchStarts()` 通知方法的唯一参数。当执行此通知方法时，其参数将包含传递给代理对象上 `startMatch()` 方法执行的值。

请注意列表 4-58 中的切点和通知方法：

• 我们保留了 `execution()` 切点指示符中的静态参数选择。请记住，`execution()` 使用静态方法签名信息，而 `args()` 需要动态切点。为了避免在自动代理创建时为太多可以匹配切点的 bean 创建代理对象，我们添加了尽可能多的静态条件。
• `printMessageToInformMatchStarts()` 通知方法无法更改比赛标识符的值。要更改参数值，必须使用 JoinPoint 对象。
• 向 `printMessageToInformMatchStarts()` 通知方法添加参数时，此参数必须由切点绑定，因此我们必须添加 `args()` 切点指示符。

当我们添加更多参数时，我们需要更改切点，以便这些额外的参数也能被绑定。`args()` 切点指示符中使用的名称必须与通知方法参数中的参数名称匹配。

要在 XML 中执行此操作，请将以下内容添加到您的配置文件中：

<aop:aspect ref="messagePrinter"> 
  <aop:before method="printMessageToInformMatchStarts" 
              arg-names="matchId" 
              pointcut="execution(* startMatch(..)) && args(matchId, ..)"/> 
</aop:aspect>

绑定返回值

列表 4-59.获取返回值

package com.apress.springbook.chapter04.aspects; 

import com.apress.springbook.chapter04.Match; 

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

import org.aspectj.lang.JoinPoint; 


@Aspect 
public class MessagePrintingAspect { 
  @AfterReturning( 
    value = "execution(com.apress.springbook.chapter04.Match" + 
        " startMatch(..))", 
    returning = "match" 
)   
  public void printMessageToInformMatchHasStarted(Match match) { 
    System.out.println("This match has been started: " + match); 
  } 
} 

绑定返回值是一种特殊的静态切点。Spring AOP 不需要进行任何运行时匹配，但它需要将返回值作为参数传递给 printMessageToInformMatchHasStarted() 通知方法。请注意，我们在 `execution()` 切点指示符中提供了返回类型作为一种安全措施，以便通知方法只为具有正确返回类型的 `startMatch()` 方法执行。

我们在列表 4-59 的 `@AfterReturning` 注解中指定了 returning 属性，以表明我们希望将返回值绑定到通知方法。传递给 returning 属性的值是我们想要绑定的参数名称。要在 XML 中执行此操作，请添加 returning 属性：

<aop:aspect ref="messagePrinter"> 
  <aop:after-returning method="printMessageToInformMatchHasStarted" 
                  returning="match" 
                  pointcut="execution(* startMatch(..))"/> 
</aop:aspect>

绑定异常

列表 4-60.获取 `startMatch()` 方法抛出的异常

package com.apress.springbook.chapter04.aspects; 

import com.apress.springbook.chapter04.UnknownMatchException; 

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

import org.aspectj.lang.JoinPoint; 


@Aspect 
public class MessagePrintingAspect { 
  @AfterThrowing( 
    value = "execution(* startMatch(..) throws " + 
      "com.apress.springbook.chapter04." + 
      "UnknownMatchException)", 
    throwing = "exception" 
  )   
  public void printMessageWhenMatchIdentifierIsNotFound( 
  UnknownMatchException exception) { 
    System.out.println("No match found for match identifier " + 
    exception.getInvalidMatchIdentifier() + "!"); 
  } 
} 

但是，如果 `startMatch()` 方法抛出其他异常类型会怎样？

除了 UnknownMatchException 之外，`startMatch()` 还声明了三种其他异常类型，并且还可以抛出任何运行时异常。

只有当抛出其唯一参数中声明的异常类型时，`printMessageWhenMatchIdentifierIsNotFound()` 通知方法才会执行；否则，通知根本不会执行。这使我们可以添加更多 @AfterThrowing 通知来处理特定的异常类型。我们不一定需要使用异常对象，但通过将其绑定到通知方法，Spring AOP 可以选择正确的通知。

但是，请注意，列表 4-60 中的切点不是动态切点。Spring AOP 将根据静态 `execution()` 切点指示符匹配连接点。当抛出异常时，Spring AOP 将根据绑定信息为每个通知决定是否需要执行。这意味着静态切点必须足够严格，以仅选择实际可能抛出异常的方法。不够严格的切点会在自动代理创建期间触发为过多 bean 创建代理对象。

绑定异常时，`@AfterThrowing` 注解上的 throwing 属性必须存在，并且其值应为通知方法中声明的异常参数的名称。

要在 XML 中使用异常进行绑定，您将执行以下操作：

<aop:aspect ref="messagePrinter"> 
  <aop:after-throwing method="printMessageWhenMatchIdentifierIsNotFound" 
                     throwing="exception" 
                     pointcut="execution(* startMatch(..) throws --> 
                     com.apress.springbook.chapter04.UnknownMatchException)"/> 
</aop:aspect>

绑定注解

我们将继续研究将注解对象绑定到来自两个位置的通知方法参数：

• 声明在方法上的注解
• 声明在类上的注解 在本节中，我们将扩展我们在本章前面介绍注解时使用的 @Audit 示例。首先，我们将为 `@Audit` 注解添加一个属性，如列表 4-61 所示。

列表 4-61.向 `@Audit` 注解添加属性

package com.apress.springbook.chapter04; 

import java.lang.annotation.Retention; 
import java.lang.annotation.RetentionPolicy; 

@Retention(RetentionPolicy.RUNTIME) 
public @interface Audit { 
  String value() default ""; 
} 

通过向 `@Audit` 注解添加值，我们可以传递特定信息，在保留审计信息时可以使用。接下来，我们将更改 SystemPointcutsAdvice 上的 auditableMethods() 切点声明以进行参数绑定，如列表 4-62 所示。

列表 4-62.更改 `auditableMethods()` 切点声明以进行参数绑定

package com.apress.springbook.chapter04.aspects; 

import com.apress.springbook.chapter04.Audit; 
import org.aspectj.lang.annotation.Aspect; 
import org.aspectj.lang.annotation.Pointcut; 


@Aspect 
public class SystemPointcutsAspect { 
  @Pointcut("@annotation(audit)") 
  public void auditableMethods(Audit audit) {  } 
} 

列表 4-63 显示了带有 `@Audit` 注解的 BusinessOperations 类。

列表 4-63.声明带有附加信息的 `@Audit` 注解

package com.apress.springbook.chapter04; 

public class BusinessOperations { 
  @Audit("top secret") 
  public void sensitiveOperation(long recordId) { …   } 
} 

列表 4-64.绑定声明在对象上的注解对象

package com.apress.springbook.chapter04.aspects; 

import com.apress.springbook.chapter04.Audit; 
import com.apress.springbook.chapter04.CurrentUserInformation; 
import com.apress.springbook.chapter04.AuditInformationRetentionPolicy; 

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

import org.aspectj.lang.JoinPoint; 

@Aspect 
public class AuditInformationRetentionAspect { 
  private AuditInformationRetentionPolicy auditInformationRetentionPolicy; 
  private CurrentUserInformation currentUserInformation;   

  public void setAuditInformationRetentionPolicy( 
    AuditInformationRetentionPolicy auditInformationRetentionPolicy) { 
    this.auditInformationRetentionPolicy = auditInformationRetentionPolicy; 
  } 
  
  public void setCurrentUserInformation( 
    CurrentUserInformation currentUserInformation) { 
    this.currentUserInformation = currentUserInformation; 
  } 
  
  public void init() { 
    if (this.auditInformationRetentionPolicy == null) { 
    throw new IllegalStateException("AuditInformationRetentionPolicy " + 
    "object is not set!"); 
  } 

  if (this.currentUserInformation == null) { 
    throw new IllegalStateException("CurrentUserInformation " + 
    "object is not set!"); 
  } 
} 

@Before("com.apress.springbook.chapter04.aspects." + 
    "SystemPointcutsAspect.auditableMethods(audit)")   
  public void retainMethodInvocationInformation(JoinPoint joinPoint, Audit audit) { 
    String currentUser = this.currentUserInformation.getUsername(); 
    String methodDescription = audit.value() + ":" + 
       joinPoint.getSignature().toLongString(); 
    Object[] arguments = joinPoint.getArgs(); 

    this.auditInformationRetentionPolicy.retainMethodInvocationInformation( 
      currentUser, methodDescription, arguments); 
  } 
} 

JoinPoint 参数由 Spring AOP 自动绑定，auditableMethods() 调用 @annotation() 来绑定 Audit 注解参数。

由于切点没有指定注解类型，Spring AOP 会决定 @annotation() 中的参数是通过名称引用的。这样，`retainMethodInvocationInformation()` 通知方法只针对声明了 `@Audit` 注解的连接点执行。

请注意，列表 4-64 中的切点没有重用另一个切点。切点的重用不支持将参数绑定到通知方法。

我们还可以使用 @within() 切点指示符将声明在类上的注解绑定到通知方法。再次考虑 MoreBusinessOperations 类，如列表 4-65 所示。

列表 4-65.MoreBusinessOperations 类现被classified 为绝密

package com.apress.springbook.chapter04; 

@Audit("top secret") 
public class MoreBusinessOperations { 
  public (.*?) { 
      // do some work 
    someOtherSensitiveOperation(recordId); 
} 
  
  public void someOtherSensitiveOperation(long recordId) { 
    // work with sensitive data 
  } 
} 

列表 4-66.SystemPointcutsAspect 选择类上的 `@Audit` 注解

package com.apress.springbook.chapter04.aspects; 

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


@Aspect 
public class SystemPointcutsAspect { 
  @Pointcut("@within(audit)") 
  public void auditableMethods(Audit audit) {  } 
} 

能够创建自己的注解，注解类和方法，并将注解对象绑定到通知方法参数，这是 Spring AOP 的一个非常有趣的功能。有关绑定通知参数以及其他 Spring AOP 主题的更多详细信息，请参阅 Spring 参考手册的第 6 章。

摘要

AspectJ 切面是丰富、细粒度且功能强大的构造，允许您更改和增强 Java 类的行为。本章涵盖了您在应用程序中开始使用新的 Spring AOP 功能和切面所需的所有内容。通过利用 @AspectJ 风格的注解，Spring 支持 Java 5，并通过利用 AOP XML Schema 支持旧版 Java。下一章将介绍 Spring 框架的数据访问。

本书的源代码可供读者在 http://www.apress.com/book/view/1590599187 获取。

Interface21 是一家私营的国际公司，由致力于构建、使用和培训世界上最流行的应用程序框架的顾问组成。Springframework.com 由 Interface21 Limited（一家私营公司）运营。带来 Spring 框架的开发者也提供培训、咨询和支持。Interface21 在欧洲和北美也有合作伙伴，与重视高质量服务的公司合作，这些公司拥有 Spring 经验，并与提供 .NET 服务的开发人员合作。Interface21 希望成为您企业开发的首选合作伙伴。

Seth Ladd 是一名软件工程师和专业的 Spring Framework 培训师和导师，专注于面向对象和可测试的 Web 应用程序。他 17 岁时就创办了自己的公司来构建网站，但现在喜欢拥有一份真正的工作。Seth 目前在 Camber Corporation 工作，为 NEC、罗切斯特理工学院、Brivo Systems 和 National Information Consortium 构建和部署了系统。他为服务器和远程连接的嵌入式设备架构和开发了 Java 和 C 语言的企业应用程序。他喜欢演讲和教学，并且是本地 Java 用户组和公司开发者会议的常客。Seth 非常感谢能与妻子一起在夏威夷凯卢阿生活和工作。

Bram Smeets 是一名 Java 架构师，拥有超过 8 年的企业 Java 应用程序开发经验。目前，Bram 是 JTeam (www.jteam.nl) 的技术总监，JTeam 是一家总部位于荷兰的 Java 软件开发公司，也是 SpringSource (www.springsource.com) 的高级顾问。他是 Ajax Experience 和 SpringOne 等技术焦点会议的常客。使用 GWT，Bram 在 JTeam 交付了多个成功的 RIA 项目。他还为多家公司提供了 Ajax 和 GWT 培训。