6.2. Spring的通知API

现在我们可以研究SpringAOP如何处理通知。

6.2.1.通知生命周期

每个通知都是一个Spring bean。通知议实例可以在所有对象之间共享，也可以对每个对象都是唯一的。这就是所说的per-class（每个类）或 per-instance（每个实例）通知。
per-class通知最常用。它适用于一般的通知，如事务顾问。这些不依赖于代理对象的状态或添加新状态，他们只根据方法和论点行事。
per-instance 通知都适用于introductions(介绍)，以支持混合。在这种情况下，通知将状态添加到代理对象。
您可以在同一个AOP代理中混合使用共享和per-instance通知。

6.2.2.Spring通知类型

Spring提供了几种通知类型，并且可以扩展以支持任意通知类型。本节介绍基本概念和标准建议类型。
环绕拦截通知
Spring最基本的通知类型是围绕拦截通知。

Spring与AOP 联盟接口兼容，以获取使用方法的周边拦截通知。实现MethodInterceptor和实现环绕通知的类还应实现以下接口：

public interface MethodInterceptor extends Interceptor {

    Object invoke(MethodInvocation invocation) throws Throwable;
}

invoke() 方法的MethodInvocation 参数公开了被调用的方法、目标连接点、AOP代理以及该方法的参数。invoke()方法应返回调用的结果：连接点的返回值。

下面的示例显示了一个简单的MethodInterceptor 实现：

public class DebugInterceptor implements MethodInterceptor {

    public Object invoke(MethodInvocation invocation) throws Throwable {
        System.out.println("Before: invocation=[" + invocation + "]");
        Object rval = invocation.proceed();
        System.out.println("Invocation returned");
        return rval;
    }
}

注意对MethodInvocation的proceed()方法的调用。这将沿着拦截器链向连接点前进。大多数拦截器调用此方法并返回其返回值。但是，与任何around通知一样，MethodIntercetor可以返回不同的值或引发异常，而不是调用proceed方法。但是，如果没有充分的理由，你不想这样做。

MethodIntercetor实现提供与其他AOP联盟兼容的AOP实现的互操作性。本节其余部分讨论的其他通知类型是以特定于Spring的方式实现了常见的AOP概念。虽然在使用最具体的通知类型方面有一个优势，但是如果您可能希望在另一个AOP框架中运行该切面，那么请坚持使用围绕通知的MethodInterceptor。注意，切入点目前在框架之间不可互操作，AOP联盟目前没有定义切入点接口。

前置通知
更简单的通知类型是befor通知。这不需要MethodInvocation对象，因为它只在进入方法之前被调用。

before通知的主要优点是不需要调用proceed()方法，因此，不可能无意中未能沿着拦截器链继续。
下面的列表显示了 MethodBeforeAdvice 接口：

public interface MethodBeforeAdvice extends BeforeAdvice {

    void before(Method m, Object[] args, Object target) throws Throwable;
}

（Spring的API设计将允许在通知之前提供字段，尽管通常的对象适用于字段拦截，Spring不太可能实现它。）
请注意，返回类型为void。before advice可以在连接点执行之前插入自定义行为，但不能更改返回值。如果before通知抛出异常，它将中止拦截器链的进一步执行。异常向上传播到拦截器链。如果它未选中或在被调用方法的签名上，则直接传递给客户端。否则，AOP代理会将其包装在未选中的异常中。
下面的示例显示了Spring中的一个before通知，它对所有方法调用进行计数：

public class CountingBeforeAdvice implements MethodBeforeAdvice {

    private int count;

    public void before(Method m, Object[] args, Object target) throws Throwable {
        ++count;
    }

    public int getCount() {
        return count;
    }
}

前置通知可能使用任何切点

抛出异常后通知
如果连接点引发异常，则调用throws通知。Spring提供throws通知类型。注意，这意味着org.springframework.aop.ThrowsAdvice 接口不包含任何方法。它是一个标记接口，标识给定对象实现一个或多个类型化的throw通知方法。应采用以下形式：

afterThrowing([Method, args, target], subclassOfThrowable)

只需要最后一个参数。方法签名可以有一个或四个参数，这取决于advice方法对方法和参数是否感兴趣。下面的两个列表显示了属于throws通知示例的类。
如果抛出了RemoteException（包括子类），将调用以下通知：

public class RemoteThrowsAdvice implements ThrowsAdvice {

    public void afterThrowing(RemoteException ex) throws Throwable {
        // Do something with remote exception
    }
}

与前面的通知不同，下一个示例声明了四个参数，这样它就可以访问被调用的方法、方法参数和目标对象。如果抛出servletexception，将调用以下通知：

public class ServletThrowsAdviceWithArguments implements ThrowsAdvice {

    public void afterThrowing(Method m, Object[] args, Object target, ServletException ex) {
        // Do something with all arguments
    }
}

最后一个示例说明了这两个方法如何在处理RemoteException和ServletException的单个类中使用。可以在单个类中可以组合任意数量的throw通知方法。下面的列表显示了最后一个示例：

public static class CombinedThrowsAdvice implements ThrowsAdvice {

    public void afterThrowing(RemoteException ex) throws Throwable {
        // 针对RemoteException做一些事
    }

    public void afterThrowing(Method m, Object[] args, Object target, ServletException ex) {
        // 针对所有参数的情况，做一些事
    }
}

如果throws 通知方法本身引发异常，它将重写原始异常（即，它将更改引发给用户的异常）。重写异常通常是RuntimeException，它与任何方法签名都兼容。但是，如果throw 通知方法抛出一个特定的异常，它必须与目标方法的声明异常匹配，因此在某种程度上与特定的目标方法签名耦合。不要抛出与目标方法的签名不兼容的未声明的已检查异常！
throws通知可以与任何切入点一起使用。

*返回后通知
在Spring中返回后通知，必须实现org.springframework.aop.AfterReturningAdvice接口，如下所示：

public interface AfterReturningAdvice extends Advice {

    void afterReturning(Object returnValue, Method m, Object[] args, Object target)
            throws Throwable;
}

返回后的通知可以访问返回值（但不能修改）、调用的方法、方法的参数和目标。
返回通知后，以下内容将统计所有未引发异常的方法调用：

public class CountingAfterReturningAdvice implements AfterReturningAdvice {

    private int count;

    public void afterReturning(Object returnValue, Method m, Object[] args, Object target)
            throws Throwable {
        ++count;
    }

    public int getCount() {
        return count;
    }
}

此通知不会更改执行路径。如果它抛出一个异常，它将被抛出拦截器链而不是返回值。
返回后，通知可以与任何切入点一起使用。
Introduction通知
Spring将Introduction通知视为一种特殊的拦截通知。
Introduction需要一个Introduction顾问和一个实现以下接口的Introduction拦截器：

public interface IntroductionInterceptor extends MethodInterceptor {

    boolean implementsInterface(Class intf);
}

从MethodIntercetor接口继承的invoke() 方法必须实现introduction。也就是说，如果被调用的方法在introduction接口上，则introduction拦截器负责处理方法调用-它不能调用proceed()。
Introduction通知不能与任何切入点一起使用，因为它只适用于类，而不是方法级别。您只能将Introduction通知与Introduction顾问一起使用，其方法如下：

public interface IntroductionAdvisor extends Advisor, IntroductionInfo {

    ClassFilter getClassFilter();

    void validateInterfaces() throws IllegalArgumentException;
}

public interface IntroductionInfo {

    Class[] getInterfaces();
}

没有MethodMatcher，因此没有与Introduction通知相关联的切入点。只有类筛选是合乎逻辑的。
getInterfaces()方法返回此顾问引入的接口。
validateInterfaces()方法在内部用于查看所引入的接口是否可以由配置的IntroductionInterceptor实现。
考虑一下Spring测试套件中的一个示例，假设我们要将以下接口引入一个或多个对象：

public interface Lockable {
    void lock();
    void unlock();
    boolean locked();
}

无论其类型如何，我们希望能够将通知的对象强制转换为可锁定的对象，并调用锁定和解锁方法。如果调用lock() 方法，我们希望所有setter方法都抛出LockedException。因此，我们可以添加一个切面，使对象在不了解它的情况下保持不变：AOP的一个很好的例子。
首先，我们需要一个 IntroductionInterceptor来完成提升。在本例中，我们扩展了org.springframework.aop.support.DelegatingIntroductionInterceptor类。我们可以直接实现IntroductionInterceptor，但对于大多数情况，使用委托IntroductionInterceptor是最好的。
DelegingIntroductionInterceptor设计用于将introduction 委托给所introduced接口的实际实现，从而隐藏使用拦截来完成此操作。可以使用构造函数参数将委托设置为任何对象。因此，在下一个示例中，delegate是DelegatingIntroductionInterceptor的 LockMixin子类。对于delegate ，DelegatingIntroductionInterceptor 实例查找它实现的所有接口（而不是IntroductionInterceptor），并支持针对其中任何一个进行介绍。LockMixin等子类可以调用suppressInterface(Class intf) 法来抑制不应公开的接口。然而，不管一个IntroductionInterceptor准备支持多少个接口，IntroductionAdvisor都使用控制哪些接口实际上是公开的。引入的接口隐藏了目标对同一接口的任何实现。
因此，lockmixin扩展了委托DelegatingIntroductionInterceptor 并实现Lockable。超类会自动选取可锁定的，可以支持引入，所以我们不需要指定它。我们可以用这种方式引入任意数量的接口。
注意使用锁定的实例变量。这有效地为目标对象中保存的状态添加了额外的状态。
下面的示例显示了LockMixin类的示例：

public class LockMixin extends DelegatingIntroductionInterceptor implements Lockable {

    private boolean locked;

    public void lock() {
        this.locked = true;
    }

    public void unlock() {
        this.locked = false;
    }

    public boolean locked() {
        return this.locked;
    }

    public Object invoke(MethodInvocation invocation) throws Throwable {
        if (locked() && invocation.getMethod().getName().indexOf("set") == 0) {
            throw new LockedException();
        }
        return super.invoke(invocation);
    }

}

通常，您不需要重写 invoke() 方法。DelegatingIntroductionInterceptor实现通常就足够了。在本例中，我们需要添加一个检查：如果处于锁定模式，则不能调用setter方法。

所需的introduction只需要保存一个不同的LockMixin实例并指定 introduced的接口（在本例中， Lockable）。一个更复杂的例子可能会引用介绍拦截器（将被定义为原型）。在这种情况下，没有与LockMixin相关的配置，因此我们使用new创建它。下面的示例显示了我们的LockMixinAdvisor 类：

public class LockMixinAdvisor extends DefaultIntroductionAdvisor {

    public LockMixinAdvisor() {
        super(new LockMixin(), Lockable.class);
    }
}

我们可以非常简单地应用这个顾问，因为它不需要配置。（然而，在没有介绍顾问的情况下，不可能使用介绍拦截器。）与通常的 introductions一样，顾问必须是有状态的。对于每个建议的对象，我们需要一个不同的LockMixinAdvisor实例，因此需要LockMixin。顾问是被通知对象状态的一部分。
我们可以通过在XML配置中使用Advised.addAdvisor() 方法或（推荐的方法）以编程方式应用此Advisor，就像任何其他Advisor一样。下面讨论的所有代理创建选项，包括“auto-proxy creators”，正确处理introductions 和有状态的混合。