原贴地址：http://book.csdn.net/bookfiles/111/1001113463.shtml

一.AOP概念

介绍完 IoC 之后，我们来介绍另外一个重要的概念： AOP(Aspect Oriented Programming) ，也就是面向方面编程的技术。 AOP 基于 IoC 基础，是对 OOP 的有益补充。

AOP 将应用系统分为两部分，核心业务逻辑 （ Core business concerns ）及横向的通用逻辑， 也就是所谓的方面 Crosscutting enterprise concerns ，例如，所有大中型应用都要涉及到的持久化管理（ Persistent ）、事务管理（ Transaction Management ）、安全管理（ Security ）、 日志管理（ Logging ）和调试管理（ Debugging ）等。

AOP 正在成为软件开发的下一个光环。使用 AOP ，你可以将处理 aspect 的代码注入主程序，通常主程序的主要目的并不在于处理这些 aspect 。 AOP 可以防止代码混乱。

Spring framework 是很有前途的 AOP 技术。作为一种非侵略性的、轻型的 AOP framework ，你无需使用预编译器或其他的元标签，便可以在 Java 程序中使用它。这意味着开发团队里只需一人要对付 AOP framework ，其他人还是像往常一样编程。

6.3.1  A OP 概念

让我们从定义一些重要的 AOP 概念开始。

— 方面（ Aspect ）：一个关注点的模块化，这个关注点实现可能另外横切多个对象。事务管理是 J2EE 应用中一个很好的横切关注点例子。方面用 Spring 的 Advisor 或拦截器实现。

— 连接点（ Joinpoint ）：程序执行过程中明确的点，如方法的调用或特定的异常被抛出。

— 通知（ Advice ）：在特定的连接点， AOP 框架执行的动作。各种类型的通知包括“ around ”、“ before ”和“ throws ”通知。通知类型将在下面讨论。许多 AOP 框架包括 Spring 都是以拦截器做通知模型，维护一个“围绕”连接点的拦截器链。

— 切入点（ Pointcut ）：指定一个通知将被引发的一系列连接点的集合。 AOP 框架必须允许开发者指定切入点，例如，使用正则表达式。

— 引入（ Introduction ）：添加方法或字段到被通知的类。 Spring 允许引入新的接口到任何被通知的对象。例如，你可以使用一个引入使任何对象实现 IsModified 接口，来简化缓存。

— 目标对象（ Target Object ）：包含连接点的对象，也被称作被通知或被代理对象。

— AOP 代理（ AOP Proxy ）： AOP 框架创建的对象，包含通知。在 Spring 中， AOP 代理可以是 JDK 动态代理或 CGLIB 代理。

— 编织（ Weaving ）：组装方面来创建一个被通知对象。这可以在编译时完成（例如使用 AspectJ 编译器），也可以在运行时完成。 Spring 和其他纯 Java AOP 框架一样，在运行时完成织入。

各种通知类型包括：

—   Around 通知：包围一个连接点的通知，如方法调用。这是最强大的通知。 Aroud 通知在方法调用前后完成自定义的行为，它们负责选择继续执行连接点或通过返回它们自己的返回值或抛出异常来短路执行。

—   Before 通知：在一个连接点之前执行的通知，但这个通知不能阻止连接点前的执行（除非它抛出一个异常）。

—   Throws 通知：在方法抛出异常时执行的通知。 Spring 提供强制类型的 Throws 通知，因此你可以书写代码捕获感兴趣的异常（和它的子类），不需要从 Throwable 或 Exception 强制类型转换。

—   After returning 通知：在连接点正常完成后执行的通知，例如，一个方法正常返回，没有抛出异常。

Around 通知是最通用的通知类型。大部分基于拦截的 AOP 框架（如 Nanning 和 Jboss 4 ） 只提供 Around 通知。

如同 AspectJ ， Spring 提供所有类型的通知，我们推荐你使用最为合适的通知类型来实现需要的行为。例如，如果只是需要用一个方法的返回值来更新缓存，你最好实现一个 after returning 通知，而不是 around 通知，虽然 around 通知也能完成同样的事情。使用最合适的通知类型使编程模型变得简单，并能减少潜在错误。例如，你不需要调用在 around 通知中所需使用的 MethodInvocation 的 proceed() 方法，因此就调用失败。

切入点的概念是 AOP 的关键，它使 AOP 区别于其他使用拦截的技术。切入点使通知独立于 OO 的层次选定目标。例如，提供声明式事务管理的 around 通知可以被应用到跨越多个对象的一组方法上。 因此切入点构成了 AOP 的结构要素。

下面让我们实现一个 Spring AOP 的例子。在这个例子中，我们将实现一个 before advice ，这意味着 advice 的代码在被调用的 public 方法开始前被执行。以下是这个 before advice 的实现代码。

package com.ascenttech.springaop.test;
import java.lang.reflect.Method;
import org.springframework.aop.MethodBeforeAdvice;

public class TestBeforeAdvice implements MethodBeforeAdvice {
   public void before(Method m, Object[] args, Object target)  throws Throwable {
     System.out.println("Hello world! (by " + this.getClass().getName()  + ")");
    }
}

接口 MethodBeforeAdvice 只有一个方法 before 需要实现，它定义了 advice 的实现。 before 方法共用 3 个参数，它们提供了相当丰富的信息。参数 Method m 是 advice 开始后执行的方法，方法名称可以用作判断是否执行代码的条件。 Object[] args 是传给被调用的 public 方法的参数数组。当需要记日志时，参数 args 和被执行方法的名称都是非常有用的信息。你也可以改变传给 m 的参数，但要小心使用这个功能；编写最初主程序的程序员并不知道主程序可能会和传入参数的发生冲突。 Object target 是执行方法 m 对象的引用。

在下面的 BeanImpl 类中，每个 public 方法调用前，都会执行 advice ，代码如下。

package com.ascenttech.springaop.test;
public class BeanImpl implements Bean {

 public void theMethod() {
     System.out.println(this.getClass().getName()   + "." + new Exception().getStackTrace()  [0].getMethodName   ()  +  "()"  +  "says HELLO!");    
 }
}

类 BeanImpl 实现了下面的接口 Bean ，代码如下。

package com.ascenttech.springaop.test;
public interface Bean {
 public void theMethod();
}

虽然不是必须使用接口，但面向接口而不是面向实现编程是良好的编程实践， Spring 也鼓励这样做。

pointcut 和 advice 通过配置文件来实现，因此，接下来你只需编写主方法的 Java 代码，代码如下。

package com.ascenttech.springaop.test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;

public class Main {
 public static void main(String[] args) {

  //Read the configuration file
  ApplicationContext ctx = new FileSystemXmlApplicationContext("springconfig.xml");

  //Instantiate an object
  Bean x = (Bean) ctx.getBean("bean");

  //Execute the public method of the bean (the test)
  x.theMethod();
 }
}

我们从读入和处理配置文件开始，接下来马上要创建它。这个配置文件将作为粘合程序不同部分的“胶水”。读入和处理配置文件后，我们会得到一个创建工厂 ctx ，任何一个 Spring 管理的对象都必须通过这个工厂来创建。对象通过工厂创建后便可正常使用。

仅仅用配置文件便可把程序的每一部分组装起来，代码如下。

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework. org/dtd/spring-beans.dtd">
<beans>
 <!--CONFIG-->
 <bean id="bean" class="org.springframework.aop.framework.ProxyFactoryBean">
    <property name="proxyInterfaces">
         <value>com.ascenttech.springaop.test.Bean</value>
     </property>

  <property name="target">
      <ref local="beanTarget"/>
  </property>

  <property name="interceptorNames">
   <list>
    <value>theAdvisor</value>
   </list>
  </property>

 </bean> 

 <!--CLASS--> 
 <bean id="beanTarget" class="com.ascenttech.springaop.test.BeanImpl"/>
 <!--ADVISOR-->
 <!--Note: An advisor assembles pointcut and advice-->

 <bean id="theAdvisor" class="org.springframework.aop.support.RegexpMethod PointcutAdvisor">
  <property name="advice">
      <ref local="theBeforeAdvice"/>
  </property>

  <property name="pattern">
       <value>com\.ascenttech\.springaop\.test\.Bean\.theMethod</value>
  </property>

 </bean>
 <!--ADVICE-->

 <bean id="theBeforeAdvice" class="com.ascenttech.springaop.test.TestBefore Advice"/>
</beans>

4 个 bean 定义的次序并不重要。我们现在有了一个 advice 、一个包含了正则表达式 pointcut 的 advisor 、一个主程序类和一个配置好的接口，通过工厂 ctx ，这个接口返回自己本身实现的一个引用。

BeanImpl 和 TestBeforeAdvice 都是直接配置。我们用一个惟一的 ID 创建一个 bean 元素，并指定了一个实现类，这就是全部的工作。

advisor 通过 Spring framework 提供的一个 RegexMethodPointcutAdvisor 类来实现。我们用 advisor 的第一个属性来指定它所需的 advice-bean ，第二个属性则用正则表达式定义了 pointcut ，确保良好的性能和易读性。

最后配置的是 bean ，它可以通过一个工厂来创建。 bean 的定义看起来比实际上要复杂。 bean 是 ProxyFactoryBean 的一个实现，它是 Spring framework 的一部分。这个 bean 的行为通过以下的 3 个属性来定义。

— 属性 proxyInterface 定义了接口类。

— 属性 target 指向本地配置的一个 bean ，这个 bean 返回一个接口的实现。

— 属性 interceptorNames 是惟一允许定义一个值列表的属性，这个列表包含所有需要在 beanTarget 上执行的 advisor 。注意， advisor 列表的次序是非常重要的。

二.Spring的切入点,通知，advisor

让我们看看 Spring 如何处理切入点这个重要的概念。

1 ．概念

Spring 的切入点模型能够使切入点独立于通知类型被重用。 同样的切入点有可能接受不同的通知。

org.springframework.aop.Pointcut 接口是重要的接口，用来指定通知到特定的类和方法目标，完整的接口定义如下。

public interface Pointcut {
    ClassFilter getClassFilter();
    MethodMatcher getMethodMatcher();
}

将 Pointcut 接口分成两个部分有利于重用类和方法的匹配部分，并且组合细粒度的操作（如和另一个方法匹配器执行一个“并”的操作）。

ClassFilter 接口被用来将切入点限制到一个给定的目标类的集合。如果 matches() 永远返回 true ，所有的目标类都将被匹配。

public interface ClassFilter {
   boolean matches(Class clazz);
}

MethodMatcher 接口通常更加重要，完整的接口如下。

public interface MethodMatcher {
    boolean matches(Method m, Class targetClass);
    boolean isRuntime();
    boolean matches(Method m, Class targetClass, Object[] args);
}

matches(Method, Class) 方法被用来测试这个切入点是否匹配目标类的给定方法。这个测试可以在 AOP 代理创建的时候执行，避免在所有方法调用时都需要进行测试。如果 2 个参数的匹配方法对某个方法返回 true ，并且 MethodMatcher 的 isRuntime() 也返回 true ，那么 3 个参数的匹配方法将在每次方法调用的时候被调用。这使切入点能够在目标通知被执行之前立即查看传递给方法调用的参数。

大部分 MethodMatcher 都是静态的，意味着 isRuntime() 方法返回 false 。这种情况下， 3 个参数的匹配方法永远不会被调用。

如果可能，尽量使切入点是静态的，使当 AOP 代理被创建时， AOP 框架能够缓存切入点的测试结果。

2 ．切入点的运算

Spring 支持的切入点的运算有并和交。

并表示只要任何一个切入点匹配的方法。交表示两个切入点都要匹配的方法。并通常比较有用。

切入点可以用 org.springframework.aop.support.Pointcuts 类的静态方法来组合，或者使用同一个包中的 ComposablePointcut 类。

3 ．实用切入点实现

Spring 提供几个实用的切入点实现，一些可以直接使用，另一些需要子类化来实现应用相关的切入点。

（ 1 ）静态切入点

静态切入点只基于方法和目标类，而不考虑方法的参数。静态切入点足够满足大多数情况的使用。 Spring 可以只在方法第一次被调用的时候计算静态切入点，不需要在每次方法调用的时候计算。

让我们看一下 Spring 提供的一些静态切入点的实现。

— 正则表达式切入点

一个很显然的指定静态切入点的方法是正则表达式。除了 Spring 以外，其他的 AOP 框架也实现了这一点。 org.springframework.aop.support.RegexpMethodPointcut 是一个通用的正则表达式切入点，它使用 Perl 5 的正则表达式的语法。

使用这个类你可以定义一个模式的列表。如果任何一个匹配，那个切入点将被计算成 true （所以，结果相当于是这些切入点的并集）。

用法如下。

<bean id="settersAndAbsquatulatePointcut" 
    class="org.springframework.aop.support.RegexpMethodPointcut">

    <property name="patterns">
        <list>
            <value>.*get.*</value>
            <value>.*absquatulate</value>
        </list>
    </property>
</bean>

RegexpMethodPointcut 一个实用子类， RegexpMethodPointcutAdvisor 允许我们同时引用一个通知（通知可以是拦截器、 before 通知、 throws 通知等）。这简化了 bean 的装配，因为一个 bean 可以同时当作切入点和通知，如下所示。

<bean id="settersAndAbsquatulateAdvisor" 
    class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">

    <property name="interceptor">
        <ref local="beanNameOfAopAllianceInterceptor"/>
    </property>

    <property name="patterns">
        <list>
            <value>.*get.*</value>
            <value>.*absquatulate</value>
        </list>
    </property>

</bean>

RegexpMethodPointcutAdvisor 可以用于任何通知类型。 RegexpMethodPointcut 类需要 Jakarta ORO 正则表达式包。

— 属性驱动的切入点

一类重要的静态切入点是元数据驱动的切入点。它使用元数据属性的值，典型地，使用源代码级元数据。

（ 2 ）动态切入点

动态切入点的演算代价比静态切入点高得多。它们不仅考虑静态信息，还要考虑方法的参数。这意味着它们必须在每次方法调用的时候都被计算，并且不能缓存结果，因为参数是变化的。

— 控制流切入点

Spring 的控制流切入点概念上和 AspectJ 的 cflow 切入点一致，虽然没有其那么强大（当前没有办法指定一个切入点在另一个切入点后执行）。一个控制流切入点匹配当前的调用栈。例如，连接点被 com.mycompany.web 包或者 SomeCaller 类中一个方法调用的时候，触发该切入点。控制流切入点的实现类是 org.springframework.aop.support.ControlFlowPointcut 。

4 ．切入点超类

Spring 提供非常实用的切入点的超类帮助你实现你自己的切入点。

因为静态切入点非常实用，你很可能子类化 StaticMethodMatcherPointcut ，如下所示。 这只需要实现一个抽象方法（虽然可以改写其他的方法来自定义行为）。

class TestStaticPointcut extends StaticMethodMatcherPointcut {

    public boolean matches(Method m, Class targetClass) {
        // return true if custom criteria match
    }

}

当然也有动态切入点的超类。

Spring 1.0 RC2 或以上版本，自定义切入点可以用于任何类型的通知。

5 ．自定义切入点

因为 Spring 中的切入点是 Java 类，而不是语言特性（如 AspectJ ），因此可以定义自定义切入点，无论静态还是动态。但是，没有直接支持用 AspectJ 语法书写的复杂的切入点表达式。不过， Spring 的自定义切入点也可以任意的复杂。

现在让我们看看 Spring AOP 是如何处理通知的。

1 ．通知的生命周期

Spring 的通知可以跨越多个被通知对象共享，或者每个被通知对象有自己的通知。这分别对应 per-class 或 per-instance 通知。

Per-class 通知使用最为广泛。它适合于通用的通知，如事务 adisor 。它们不依赖被代理的对象的状态，也不添加新的状态。它们仅仅作用于方法和方法的参数。

Per-instance 通知适合于导入，来支持混入（ mixin ）。在这种情况下，通知添加状态到被代理的对象。

可以在同一个 AOP 代理中混合使用共享和 per-instance 通知。

2 ． Spring 中通知类型

Spring 提供几种现成的通知类型并可扩展提供任意的通知类型。让我们看看基本概念和标准的通知类型。

（ 1 ） Interception around advice

Spring 中最基本的通知类型是 interception around advice 。

Spring 使用方法拦截器的 around 通知是和 AOP 联盟接口兼容的。实现 around 通知的类需要实现接口 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() 方法的调用。这个调用会应用到目标连接点的拦截器链中的每一个拦截器。大部分拦截器会调用这个方法，并返回它的返回值。但是，一个 MethodInterceptor ，和任何 around 通知一样，可以返回不同的值或者抛出一个异常，而不调用 proceed 方法。但是，没有好的原因你要这么做。

MethodInterceptor 提供了和其他 AOP 联盟的兼容实现的交互能力。这一节下面要讨论的其他的通知类型实现了 AOP 公共的概念，但是以 Spring 特定的方式。虽然使用特定通知类型有很多优点，但如果你需要在其他的 AOP 框架中使用，请坚持使用 MethodInterceptor around 通知类型。注意，目前切入点不能和其他框架交互操作，并且 AOP 联盟目前也没有定义切入点接口。

2 ） Before 通知

Before 通知 是一种简单的通知类型。 这个通知不需要一个 MethodInvocation 对象，因为它只在进入一个方法前被调用。

Before 通知的主要优点是它不需要调用 proceed() 方法，因此没有无意中忘掉继续执行拦截器链的可能性。

MethodBeforeAdvice 接口如下所示（ Spring 的 API 设计允许成员变量的 Before 通知，虽然一般的对象都可以应用成员变量拦截，但 Spring 有可能永远不会实现它）。

public interface MethodBeforeAdvice extends BeforeAdvice {
    void before(Method m, Object[] args, Object target) throws Throwable;
}

注意，返回类型是 void 。 Before 通知可以在连接点执行之前插入自定义的行为，但是不能改变返回值。如果一个 Before 通知抛出一个异常，这将中断拦截器链的进一步执行。这个异常将沿着拦截器链后退着向上传播。如果这个异常是 unchecked 的，或者出现在被调用的方法的签名中，它将会被直接传递给客户代码；否则，它将被 AOP 代理包装到一个 unchecked 的异常里。

下面是 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; 
    }

}

Before 通知可以被用于任何类型的切入点。

（ 3 ） Throws 通知

如果连接点抛出异常， Throws 通知 在连接点返回后被调用。 Spring 提供强类型的 Throws 通知。注意，这意味着 org.springframework.aop.ThrowsAdvice 接口不包含任何方法，它是一个标记接口，标识给定的对象实现了一个或多个强类型的 Throws 通知方法。这些方法形式如下。

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

只有最后一个参数是必需的。这样从 1 个参数到 4 个参数，依赖于通知是否对方法和方法的参数感兴趣。下面是 Throws 通知的例子。

如果抛出 RemoteException 异常（包括子类），这个通知会被调用。

public  class RemoteThrowsAdvice implements ThrowsAdvice {

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

如果抛出 ServletException 异常，下面的通知会被调用。和上面的通知不一样，它声明了 4 个参数，所以它可以访问被调用的方法、方法的参数和目标对象。

public static class ServletThrowsAdviceWithArguments implements ThrowsAdvice {

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

最后一个例子演示了如何在一个类中使用两个方法来同时处理 RemoteException 和 ServletException 异常。任意个数的 throws 方法可以被组合在一个类中。

public static class CombinedThrowsAdvice implements ThrowsAdvice {

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

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

}

Throws 通知可被用于任何类型的切入点。

（ 4 ） After Returning 通知

Spring 中的 After Returning 通知必须实现 org.springframework.aop.AfterReturningAdvice 接口，如下所示。

public interface AfterReturningAdvice extends Advice {
    void afterReturning(Object returnValue, Method m, Object[] args, Object target)  throws Throwable;

}

After Returning 通知可以访问返回值（不能改变）、被调用的方法、方法的参数和目标对象。

下面的 After Returning 通知统计所有成功的没有抛出异常的方法调用。

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

这方法不改变执行路径。如果它抛出一个异常，这个异常而不是返回值将被沿着拦截器链向上抛出。

After returning 通知可被用于任何类型的切入点。

（ 5 ） Introduction 通知

Spring 将 Introduction 通知看作一种特殊类型的拦截通知。

Introduction 需要实现 IntroductionAdvisor 和 IntroductionInterceptor 接口。

public interface IntroductionInterceptor extends MethodInterceptor {
    boolean implementsInterface(Class intf);
}

继承自 AOP 联盟 MethodInterceptor 接口的 invoke() 方法必须实现导入，也就是说，如果被调用的方法是在导入的接口中，导入拦截器负责处理这个方法调用，它不能调用 proceed() 方法。

Introduction 通知不能被用于任何切入点，因为它只能作用于类层次上，而不是方法。你可以只用 InterceptionIntroductionAdvisor 来实现导入通知，它有下面的方法。

public interface InterceptionIntroductionAdvisor extends InterceptionAdvisor {

    ClassFilter getClassFilter();
    IntroductionInterceptor getIntroductionInterceptor();
    Class[] getInterfaces();
}

这里没有 MethodMatcher ，因此也没有和导入通知关联的切入点，只有类过滤是合乎逻辑的。

getInterfaces() 方法返回 advisor 导入的接口。

让我们看看一个来自 Spring 测试套件中的简单例子。我们假设想要导入下面的接口到一个或者多个对象中。

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

在这个例子中，我们想要能够将被通知对象类型转换为 Lockable ，不管它们的类型，并且调用 lock 和 unlock 方法。如果我们调用 lock() 方法，我们希望所有 setter 方法抛出 LockedException 异常。这样我们能添加一个方面使对象 不可变，而它们不需要知道这一点，这是一个很好的 AOP 例子。

首先，我们需要一个做大量转化的 IntroductionInterceptor 。在这里，我们继承 org.spring framework.aop.support.DelegatingIntroductionInterceptor 实用类。我们可以直接实现 Introduction Interceptor 接口，但是，大多数情况下， DelegatingIntroductionInterceptor 是最合适的。

DelegatingIntroductionInterceptor 的设计是将导入委托到真正实现导入接口的接口，隐藏完成这些工作的拦截器。委托可以使用构造方法参数设置到任何对象中，默认的委托就是自己（当无参数的构造方法被使用时）。这样，在下面的例子里，委托是 DelegatingIntroduction Interceptor 的子类 LockMixin 。给定一个委托（默认是自身）的 DelegatingIntroductionIntercepto r 实例寻找被这个委托（而不是 IntroductionInterceptor ）实现的所有接口，并支持它们中任何一个导入。子类如 LockMixin 也可能调用 suppressInterflace (Class intf) 方法隐藏不应暴露的接口。然而，不管 IntroductionInterceptor 准备支持多少接口， IntroductionAdvisor 将控制哪个接口将被实际暴露。一个导入的接口将隐藏目标的同一个接口的所有实现。

这样， LockMixin 继承 DelegatingIntroductionInterceptor 并自己实现 Lockable 。父类自动选择支持导入的 Lockable ，所以我们不需要指定它。用这种方法我们可以导入任意数量的接口。

注意 locked 实例变量的使用，这有效地添加了额外的状态到目标对象。

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 就足够了，如果是导入的方法， DelegatingIntroductionInterceptor 实现会调用委托方法，否则继续沿着连接点处理。在现在的情况下，我们需要添加一个检查：在上锁状态下不能调用 setter 方法。

所需的导入 advisor 是很简单的。只有保存一个独立的 LockMixin 实例，并指定导入的接口，在这里就是 Lockable 。一个稍微复杂一点例子可能需要一个导入拦截器（可以定义成 prototype ）的引用：在这种情况下， LockMixin 没有相关配置，所以我们简单地使用 new 来创建它。

public class LockMixinAdvisor extends DefaultIntroductionAdvisor {

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

我们可以非常简单地使用这个 advisor ，它不需要任何配置（但是，有一点是必要的，就是不可能在没有 IntroductionAdvisor 的情况下使用 IntroductionInterceptor ）。和导入一样，通常 advisor 必须是针对每个实例的，并且是有状态的。我们会有不同的 LockMixinAdvisor 每个被通知对象，会有不同的 LockMixin 。 advisor 组成了被通知对象的状态的一部分。

和其他 advisor 一样，我们可以使用 Advised.addAdvisor() 方法以编程地方式使用这种 advisor ，或者在 XML 中配置（推荐这种方式）。下面将讨论所有代理创建，包括“自动代理创建者”，选择代理创建以正确地处理导入和有状态的混入。

在 Spring 中，一个 advisor 就是一个 aspect 的完整的模块化表示。一般地，一个 advisor 包括通知和切入点。

撇开导入这种特殊情况，任何 advisor 可被用于任何通知。 org.springframework.aop. support.DefaultPointcutAdvisor 是最通用的 advisor 类。例如，它可以和 MethodInterceptor 、 BeforeAdvice 或 ThrowsAdvice 一起使用。

Spring 中可以将 advisor 和通知混合在一个 AOP 代理中。例如，你可以在一个代理配置中使用一个对 Around 通知、 Throws 通知和 Before 通知的拦截： Spring 将自动创建必要的拦截器链。


三.用ProxyFactoryBean创建AOP代理

如果你在为你的业务对象使用 Spring 的 IoC 容器（例如， ApplicationContext 或 BeanFactory ），你应该会或者你愿意会使用 Spring 的 AOP FactoryBean （记住， factory bean 引入了一个间接层，它能创建不同类型的对象）。

在 spring 中创建 AOP proxy 的基本途径是使用 org.springframework.aop.framework. ProxyFactoryBean 。这样可以对 pointcut 和 advice 做精确控制。但是，如果你不需要这种控制，那些简单的选择可能更适合你。

1 ．基本概要

ProxyFactoryBean 和其他 Spring 的 FactoryBean 实现一样，引入一个间接的层次。如果你定义一个名字为 foo 的 ProxyFactoryBean ，引用 foo 的对象所看到的不是 ProxyFactoryBean 实例本身，而是由实现 ProxyFactoryBean 的类的 getObject() 方法所创建的对象。这个方法将创建一个包装了目标对象的 AOP 代理。

使用 ProxyFactoryBean 或者其他 IoC 可知的类来创建 AOP 代理的最重要的优点之一是 IoC 可以管理通知和切入点。这是一个非常的强大的功能，能够实现其他 AOP 框架很难实现的特定的方法。例如，一个通知本身可以引用应用对象（除了目标对象，它在任何 AOP 框架中都可以引用应用对象），这完全得益于依赖注入所提供的可插入性。

2 ． JavaBean 的属性

类似于 Spring 提供的绝大部分 FactoryBean 实现一样， ProxyFactoryBean 也是一个 javabean ，我们可以利用它的属性来指定你将要代理的目标，指定是否使用 CGLIB 。

一些关键属性来自 org.springframework.aop.framework.ProxyConfig ，它是所有 AOP 代理工厂的父类。这些关键属性包括：

—   proxyTargetClass ：如果我们应该代理目标类，而不是接口，这个属性的值为 true 。如果这是 true ，我们需要使用 CGLIB 。

—   optimize ：是否使用强优化来创建代理。不要使用这个设置，除非你了解相关的 AOP 代理是如何处理优化的。目前这只对 CGLIB 代理有效，对 JDK 动态代理无效（默认）。

—   frozen ：是否禁止通知的改变，一旦代理工厂已经配置。默认是 false 。

—   exposeProxy ：当前代理是否要暴露在 ThreadLocal 中，以便它可以被目标对象访问（它可以通过 MethodInvocation 得到，不需要 ThreadLocal ）。如果一个目标需要获得它的代理，并且 exposeProxy 的值是 ture ，可以使用 AopContext.currentProxy() 方法。

—   AopProxyFactory ：所使用的 AopProxyFactory 具体实现。这个参数提供了一条途径来定义是否使用动态代理、 CGLIB 还是其他代理策略。默认实现将适当地选择动态代理或 CGLIB 。一般不需要使用这个属性；它的意图是允许 Spring 1.1 使用另外新的代理类型。

其他 ProxyFactoryBean 特定的属性包括：

—   proxyInterfaces ：接口名称的字符串数组。如果这个没有提供， CGLIB 代理将被用于目标类。

—   interceptorNames: Advisor 、 interceptor 或其他被应用的通知名称的字符串数组。顺序是很重要的。这里的名称是当前工厂中 bean 的名称，包括来自祖先工厂的 bean 的名称。

—   Singleton ：工厂是否返回一个单独的对象，无论 getObject() 被调用多少次。许多 FactoryBean 的实现提供这个方法，默认值是 true 。如果你想要使用有状态的通知，（例如，用于有状态的 mixin ）将这个值设为 false ，使用 prototype 通知。

3 ．代理接口

让我们来看一个简单的 ProxyFactoryBean 的实际例子。这个例子涉及到一个将被代理的目标 bean ，在这个例子里，这个 bean 被定义为“ personTarget ”；一个 advisor 和一个 interceptor 来提供 advice ；一个 AOP 代理 bean 定义，该 bean 指定目标对象（这里是 personTarget bean ），代理接口和使用的 advice 。

<bean id="personTarget" class="com.mycompany.PersonImpl">
    <property name="name"><value>Tony</value></property>
    <property name="age"><value>51</value></property>
</bean>

<bean id="myAdvisor" class="com.mycompany.MyAdvisor">
    <property name="someProperty"><value>Custom string property value </value> </property>
</bean>

<bean id="debugInterceptor" class="org.springframework.aop.interceptor. NopInterceptor"> </bean>

<bean id="person"      class="org.springframework.aop.framework.ProxyFactoryBean">
    <property name="proxyInterfaces"><value>com.mycompany.Person</value></property>
    <property name="target"><ref local="personTarget"/></property>
    <property name="interceptorNames">
        <list>
            <value>myAdvisor</value>
            <value>debugInterceptor</value>
        </list>
    </property>
</bean>

请注意， person bean 的 interceptorNames 属性提供一个 String 列表，列出的是该 ProxyFactoryBean 使用的，在当前 bean 工厂定义的 interceptor 或者 advisor 的名字（ advisor 、 interceptor 、 before 、 after returning 和 throws advice 对象皆可）。 Advisor 在该列表中的次序很重要。

你也许会对该列表为什么不采用 bean 的引用存有疑问。原因就在于如果 ProxyFactory Bean 的 singleton 属性被设置为 false ，那么 bean 工厂必须能返回多个独立的代理实例。如果有任何一个 advisor 本身是 prototype 的，那么它就需要返回独立的实例，也就是有必要从 bean 工厂获取 advisor 的不同实例， bean 的引用在这里显然是不够的。

上面定义的“ person ” bean 定义可以作为 Person 接口的实现来使用，如下所示。

Person person = (Person) factory.getBean("person");

在同一个 IoC 的上下文中，其他的 bean 可以依赖于 Person 接口，就像依赖于一个普通的 java 对象一样。

<bean id="personUser" class="com.mycompany.PersonUser">
    <property name="person"><ref local="person" /></property>
</bean>

在这个例子里， PersonUser 类暴露了一个类型为 Person 的属性。只要是在用到该属性的地方， AOP 代理都能透明地替代一个真实的 Person 实现。但是，这个类可能是一个动态代理类。也就是有可能把它类型转换为一个 Advised 接口（该接口在下面的章节中论述）。

4 ．代理类

如果你需要代理的是类，而不是一个或多个接口，又该怎么办呢 ?

想象一下我们上面的例子，如果没有 Person 接口，我们需要通知一个叫 Person 的类，而且该类没有实现任何业务接口。在这种情况下，你可以配置 Spring 使用 CGLIB 代理，而不是动态 代理。你只要在上面的 ProxyFactoryBean 定义中把它的 proxyTargetClass 属性改成 true 就可以。

只要你愿意，即使在有接口的情况下，你也可以强迫 Spring 使用 CGLIB 代理。

CGLIB 代理是通过在运行期产生目标类的子类来进行工作的。 Spring 可以配置这个生成的子类，来代理原始目标类的方法调用。这个子类是用 Decorator 设计模式置入到 advice 中的。

CGLIB 代理对于用户来说应该是透明的。然而，还有以下一些因素需要考虑。

（ 1 ） Final 方法不能被通知，因为不能被重写。

（ 2 ）你需要在你的 classpath 中包括 CGLIB 的二进制代码，而动态代理对任何 JDK 都是可用的。

（ 3 ） CGLIB 和动态代理在性能上有微小的区别，对 Spring 1.0 来说，后者稍快。另外，以后可能会有变化。在这种情况下，性能不是决定性因素。