Spring AOP 中的通知

2010-08-29 16:54:18|  分类： IOC/AOP |  标签：通知  annotation  aspectj  lang  import   |字号大中小 订阅

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

---

1. 前置通知（@Before）

一个切面里使用 @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（） {

    // ...

  }

}

---

2. 后置通知（After returning advice）

返回后通知通常在一个匹配的方法返回的时候执行。使用 @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类，也就是说返回任意类型都会匹配） 

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

---

3. 异常通知（After throwing advice）

抛出异常通知在一个方法抛出异常后执行。使用@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）。

---

4. 最终通知（After (finally) advice）

不论一个方法是如何结束的，最终通知都会运行。使用@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（） {

    // ...

  }

}

---

5. 环绕通知

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

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

当传入一个Object[]对象的时候，处理的方法与通过AspectJ编译器处理环绕通知略有不同。 对于使用传统AspectJ语言写的环绕通知来说，传入参数的数量必须和传递给环绕通知的参数数量匹配 （不是后台的连接点接受的参数数量），并且特定顺序的传入参数代替了将要绑定给连接点的原始值 （如果你看不懂不用担心）。Spring采用的方法更加简单并且能更好匹配它基于代理（proxy-based）的执行语法， 如果你使用AspectJ的编译器和编织器来编译为Spring而写的@AspectJ切面和处理参数，你只需要知道这一区别即可。 有一种方法可以让你写出100%兼容Spring AOP和AspectJ的表达式，我们将会在后续的通知参数的章节中讨论它。

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[]。 我们将会看到如何使得参数和其他上下文值对通知体可用。 首先让我们看以下如何编写普通的通知以找出正在被通知的方法。

1. 访问当前的连接点

任何通知方法可以将第一个参数定义为org.aspectj.lang.JoinPoint类型 （环绕通知需要定义第一个参数为ProceedingJoinPoint类型， 它是 JoinPoint 的一个子类）。JoinPoint 接口提供了一系列有用的方法，比如 getArgs()（返回方法参数）、 getThis()（返回代理对象）、getTarget()（返回目标）、 getSignature()（返回正在被通知的方法相关信息）和 toString() （打印出正在被通知的方法的有用信息）。详细的内容请参考JavaDoc。 

2

. 

传递参数给通知

我们已经看到了如何绑定返回值或者异常（使用后置通知和异常通知）。为了可以在通知体内访问参数， 你可以使用args来绑定。如果在一个args表达式中应该使用类型名字的地方 使用一个参数名字，那么当通知执行的时候对应的参数值将会被传递进来。用一个例子应该会使它变得清晰。 假使你想要通知以一个Account对象作为第一个参数的DAO操作的执行， 你想要在通知体内也能访问account对象，可以编写如下的代码： 

@Before（"com.xyz.myapp.SystemArchitecture.dataAccessOperation（） &&" + 

        "args（account,..）"）

public void validateAccount（Account account） {

  // ...

}

切入点表达式的 args(account,..) 部分有两个目的：首先它保证了 只会匹配那些接受至少一个参数的方法的执行，而且传入的参数必须是Account类型的实例， 其次它使得在通知体内可以通过account 参数访问实际的Account对象。 

另外一个办法是定义一个切入点，这个切入点在匹配某个连接点的时候“提供”了 Account对象的值，然后直接从通知中访问那个命名切入点。看起来和下面的示例一样： 

@Pointcut（"com.xyz.myapp.SystemArchitecture.dataAccessOperation（） &&" + 

          "args（account,..）"）

private void accountDataAccessOperation（Account account） {}

@Before（"accountDataAccessOperation（account）"）

public void validateAccount（Account account） {

  // ...

}

有兴趣的读者请参阅 AspectJ 编程指南了解更详细的内容。

代理对象（this）、目标对象（target） 和注解（@within, @target, @annotation, @args）都可以用一种类似的格式来绑定。 以下的例子展示了如何使用 @Auditable注解来匹配方法执行，并提取Audit代码。 

首先是@Auditable注解的定义：

@Retention（RetentionPolicy.RUNTIME）

@Target（ElementType.METHOD）

public @interface Auditable {

AuditCode value（）;

}

然后是匹配@Auditable方法执行的通知：

@Before（"com.xyz.lib.Pointcuts.anyPublicMethod（） && " + 

        "@annotation（auditable）"）

public void audit（Auditable auditable） {

  AuditCode code = auditable.value（）;

  // ...

}

3

. 

确定参数名

绑定在通知上的参数依赖切入点表达式的匹配名，并借此在（通知和切入点）的方法签名中声明参数名。 参数名无法 通过Java反射来获取，所以Spring AOP使用如下的策略来确定参数名字： 

如果参数名字已经被用户明确指定，则使用指定的参数名： 通知和切入点注解有一个额外的"argNames"属性，该属性用来指定所注解的方法的参数名 - 这些参数名在运行时是可以 访问的。例子如下：

@Before（

   value="com.xyz.lib.Pointcuts.anyPublicMethod（） && target（bean） && @annotation（auditable）",

   argNames="bean,auditable"）

public void audit（Object bean, Auditable auditable） {

  AuditCode code = auditable.value（）;

  // ... use code and bean

}

如果第一个参数是JoinPoint， ProceedingJoinPoint， 或者JoinPoint.StaticPart类型， 你可以在“argNames”属性的值中省去参数的名字。例如，如果你修改前面的通知来获取连接点对象， "argNames"属性就不必包含它：

@Before（

   value="com.xyz.lib.Pointcuts.anyPublicMethod（） && target（bean） && @annotation（auditable）",

   argNames="bean,auditable"）

public void audit（JoinPoint jp, Object bean, Auditable auditable） {

  AuditCode code = auditable.value（）;

  // ... use code, bean, and jp

}

对于第一个JoinPoint， ProceedingJoinPoint，和 JoinPoint.StaticPart类型的参数特殊处理特别适合 没有集合其它连接上下文的通知。在这种情部下，你可以简单的省略“argNames”属性。 例如，下面的通知不需要声明“argNames”属性：

@Before（

   "com.xyz.lib.Pointcuts.anyPublicMethod（）"）

public void audit（JoinPoint jp） {

  // ... use jp

}

使用'argNames'属性有一点笨拙，所以如果'argNames' 属性没有被指定，Spring AOP将查看类的debug信息并尝试从本地的变量表确定参数名。只要类编译时有debug信息， （最少要有'-g:vars'）这个信息将会出现。打开这个标志编译的结果是： （1）你的代码稍微容易理解（反向工程）， （2）class文件的大小稍微有些大（通常不重要）， （3）你的编译器将不会应用优化去移除未使用的本地变量。换句话说，打开这个标志创建时你应当不会遇到困难。

如果一个@AspectJ切面已经被AspectJ编译器（ajc）编译过，即使没有debug信息， 也不需要添加argNames参数，因为编译器会保留必需的信息。 

如果不加上必要的debug信息来编译的话，Spring AOP将会尝试推断绑定变量到参数的配对。 （例如，要是只有一个变量被绑定到切入点表达式，通知方法只接受一个参数， 配对是显而易见的）。 如果变量的绑定不明确，将会抛出一个AmbiguousBindingException异常。 

如果以上所有策略都失败了，将会抛出一个IllegalArgumentException异常。

4

. 

处理参数

我们之前提过我们将会讨论如何编写一个带参数的的proceed()调用， 使得在Spring AOP和AspectJ中都能正常工作。解决方法是仅仅确保通知签名按顺序绑定方法参数。例如：

@Around（"execution（List<Account> find*（..）） &&" +
        "com.xyz.myapp.SystemArchitecture.inDataAccessLayer（） && " +
        "args（accountHolderNamePattern）"）		
public Object preProcessQueryPattern（ProceedingJoinPoint pjp, Object accountHolderNamePattern）
throws Throwable {;
  return pjp.proceed（new Object[] {


accountHolderNamePattern











}）;




}        

大多数情况下你都会这样绑定（就像上面的例子那样）。

 

 

---

---

 

 

---

通知顺序

 

 

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

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

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

 

 

---

---

 

 

---

引入（Introduction）

 

 

引入（在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接口。请注意，在上面的前置通知的例子中，service beans 可以直接用作UsageTracked接口的实现。如果需要编程式的来访问一个bean， 你可以这样写：

UsageTracked usageTracked = （UsageTracked） context.getBean（"myService"）;

切面实例化模型
默认情况下，在application context中每一个切面都会有一个实例。AspectJ把这个叫做单例化模型。 
也可以用其他的生命周期来定义切面：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对象是和切面关联的才可以。 
请参阅 AspectJ 编程指南了解更多关于per-clauses的信息。 
'pertarget'实例模型的跟“perthis”完全一样，只不过是为每个匹配于连接点