讓我們從定義一些重要的AOP概念開(kāi)始。這些術(shù)語(yǔ)不是Spring特有的。不幸的是，Spring的術(shù)語(yǔ) 不是特別地直觀。而且，如果Spring使用自己的術(shù)語(yǔ)，這將使人更加迷惑。

各種通知類型包括:

Around通知是最通用的通知類型。大部分基于攔截的AOP框架，如Nanning和JBoss4，只提供 Around通知。

如同AspectJ，Spring提供所有類型的通知，我們推薦你使用最為合適的通知類型來(lái)實(shí)現(xiàn)需 要的行為。例如，如果只是需要用一個(gè)方法的返回值來(lái)更新緩存，你最好實(shí)現(xiàn)一個(gè)after returning 通知而不是around通知，雖然around通知也能完成同樣的事情。使用最合適的通知類型使編程模型變 得簡(jiǎn)單，并能減少潛在錯(cuò)誤。例如你不需要調(diào)用在around通知中所需使用的的MethodInvocation的 proceed() 方法，因此就調(diào)用失敗。

切入點(diǎn)的概念是AOP的關(guān)鍵，使AOP區(qū)別于其它使用攔截的技術(shù)。切入點(diǎn)使通知獨(dú)立于OO的 層次選定目標(biāo)。例如，提供聲明式事務(wù)管理的around通知可以被應(yīng)用到跨越多個(gè)對(duì)象的一組方法上。 因此切入點(diǎn)構(gòu)成了AOP的結(jié)構(gòu)要素。

Spring AOP用純Java實(shí)現(xiàn)。它不需要特別的編譯過(guò)程。Spring AOP不需要控制類裝載器層次， 因此適用于J2EE web容器或應(yīng)用服務(wù)器。

Spring目前支持?jǐn)r截方法調(diào)用。成員變量攔截器沒(méi)有實(shí)現(xiàn)，雖然加入成員變量攔截器支持并不破壞 Spring AOP核心API。

Spring提供代表切入點(diǎn)或各種通知類型的類。Spring使用術(shù)語(yǔ) advisor 來(lái) 表示代表方面的對(duì)象，它包含一個(gè)通知和一個(gè)指定特定連接點(diǎn)的切入點(diǎn)。

各種通知類型有 MethodInterceptor (來(lái)自AOP聯(lián)盟的攔截器API)和定義在 org.springframework.aop 包中的 通知接口。所有通知必須實(shí)現(xiàn) org.aopalliance.aop.Advice 標(biāo)簽接口。 取出就可使用的通知有 MethodInterceptor 、 ThrowsAdvice 、 BeforeAdvice 和 AfterReturningAdvice 。我們將在下面詳細(xì)討論這些通知類型。

Spring實(shí)現(xiàn)了 AOP聯(lián)盟 的攔截器接口( http://www.sourceforge.net/projects/aopalliance ). Around通知必須實(shí)現(xiàn)AOP聯(lián)盟的 org.aopalliance.intercept.MethodInterceptor 接口。這個(gè)接口的實(shí)現(xiàn)可以運(yùn)行在Spring或其他AOP聯(lián)盟兼容的實(shí)現(xiàn)中。目前JAC實(shí)現(xiàn)了AOP聯(lián)盟的接 口，Nanning和Dynaop可能在2004年早期實(shí)現(xiàn)。

Spring默認(rèn)使用JDK 動(dòng)態(tài)代理 實(shí)現(xiàn)AOP代理。這使得任何接口或 接口的集合能夠被代理。

Spring也可以是CGLIB代理。這可以代理類，而不是接口。如果業(yè)務(wù)對(duì)象沒(méi)有實(shí)現(xiàn)一個(gè)接口， CGLIB被默認(rèn)使用。但是作為一 針對(duì)接口編程而不是類編程 良好實(shí)踐，業(yè)務(wù)對(duì)象 通常實(shí)現(xiàn)一個(gè)或多個(gè)業(yè)務(wù)接口。

也可以強(qiáng)制使用CGLIB：我們將在下面討論，并且會(huì)解釋為什么你會(huì)要這么做。

Spring的切入點(diǎn)模型能夠使切入點(diǎn)獨(dú)立于通知類型被重用。 同樣的切入點(diǎn)有可能接受不同的 通知。

org.springframework.aop.Pointcut 接口是重要的接口， 用來(lái)指定通知到特定的類和方法目標(biāo)。完整的接口定義如下:

          public interface Pointcut {

    ClassFilter getClassFilter();

    MethodMatcher getMethodMatcher();

}
        

將 Pointcut 接口分成兩個(gè)部分有利于重用類和方法的匹配部分，并且組合細(xì)粒度的 操作（如和另一個(gè)方法匹配器執(zhí)行一個(gè)”并“的操作）。

ClassFilter 接口被用來(lái)將切入點(diǎn)限制到一個(gè)給定的目標(biāo)類的集合。 如果 matches() 永遠(yuǎn)返回true，所有的目標(biāo)類都將被匹配。

          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) 方法被用來(lái)測(cè)試這個(gè)切入點(diǎn)是否匹 配目標(biāo)類的給定方法。這個(gè)測(cè)試可以在AOP代理創(chuàng)建的時(shí)候執(zhí)行，避免在所有方法調(diào)用時(shí)都需要進(jìn)行 測(cè)試。如果2個(gè)參數(shù)的匹配方法對(duì)某個(gè)方法返回true，并且MethodMatcher的 isRuntime() 也返回true，那么3個(gè)參數(shù)的匹配方法將在每次方法調(diào)用的時(shí)候被調(diào)用。這使 切入點(diǎn)能夠在目標(biāo)通知被執(zhí)行之前立即查看傳遞給方法調(diào)用的參數(shù)。

大部分MethodMatcher都是靜態(tài)的，意味著 isRuntime() 方法 返回false。這種情況下3個(gè)參數(shù)的匹配方法永遠(yuǎn)不會(huì)被調(diào)用。

Spring支持的切入點(diǎn)的運(yùn)算有: 值得注意的是 并 和 交 。

并表示只要任何一個(gè)切入點(diǎn)匹配的方法。

交表示兩個(gè)切入點(diǎn)都要匹配的方法。

并通常比較有用。

切入點(diǎn)可以用 org.springframework.aop.support.Pointcuts 類的靜態(tài)方法來(lái)組合，或者使用同一個(gè)包中的 ComposablePointcut 類。

Spring提供幾個(gè)實(shí)用的切入點(diǎn)實(shí)現(xiàn)。一些可以直接使用。另一些需要子類化來(lái)實(shí)現(xiàn)應(yīng)用相 關(guān)的切入點(diǎn)。

              <bean id="settersAndAbsquatulatePointcut" 
    class="org.springframework.aop.support.RegexpMethodPointcut">
    <property name="patterns">
        <list>
            <value>.*get.*</value>
            <value>.*absquatulate</value>
        </list>
    </property>
</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>
            

Spring提供非常實(shí)用的切入點(diǎn)的超類幫助你實(shí)現(xiàn)你自己的切入點(diǎn)。

因?yàn)殪o態(tài)切入點(diǎn)非常實(shí)用，你很可能子類化StaticMethodMatcherPointcut，如下所示。 這只需要實(shí)現(xiàn)一個(gè)抽象方法（雖然可以改寫(xiě)其它的方法來(lái)自定義行為）。

          class TestStaticPointcut extends StaticMethodMatcherPointcut {

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

當(dāng)然也有動(dòng)態(tài)切入點(diǎn)的超類。

Spring 1.0 RC2或以上版本，自定義切入點(diǎn)可以用于任何類型的通知。

因?yàn)镾pring中的切入點(diǎn)是Java類，而不是語(yǔ)言特性（如AspectJ），因此可以定義自定義切入點(diǎn)， 無(wú)論靜態(tài)還是動(dòng)態(tài)。但是，沒(méi)有直接支持用AspectJ語(yǔ)法書(shū)寫(xiě)的復(fù)雜的切入點(diǎn)表達(dá)式。不過(guò)， Spring的自定義切入點(diǎn)也可以任意的復(fù)雜。

Spring的通知可以跨越多個(gè)被通知對(duì)象共享，或者每個(gè)被通知對(duì)象有自己的通知。這分別對(duì)應(yīng) per-class 或 per-instance 通知。

Per-class通知使用最為廣泛。它適合于通用的通知，如事務(wù)adisor。它們不依賴被代理 的對(duì)象的狀態(tài)，也不添加新的狀態(tài)。它們僅僅作用于方法和方法的參數(shù)。

Per-instance通知適合于導(dǎo)入，來(lái)支持混入（mixin）。在這種情況下，通知添加狀態(tài)到 被代理的對(duì)象。

可以在同一個(gè)AOP代理中混合使用共享和per-instance通知。

Spring提供幾種現(xiàn)成的通知類型并可擴(kuò)展提供任意的通知類型。讓我們看看基本概念和 標(biāo)準(zhǔn)的通知類型。

            public interface MethodInterceptor extends Interceptor {
  
    Object invoke(MethodInvocation invocation) throws Throwable;
}
          

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

            public interface MethodBeforeAdvice extends BeforeAdvice {

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

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

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

            public  class RemoteThrowsAdvice implements ThrowsAdvice {

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

            public static class ServletThrowsAdviceWithArguments implements ThrowsAdvice {

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

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

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

            public interface IntroductionInterceptor extends MethodInterceptor {

    boolean implementsInterface(Class intf);
}
          

            public interface InterceptionIntroductionAdvisor extends InterceptionAdvisor {

    ClassFilter getClassFilter();

    IntroductionInterceptor getIntroductionInterceptor();

    Class[] getInterfaces();
}
          

            public interface Lockable {
    void lock();
    void unlock();
    boolean 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);
    }

}
          

            public class LockMixinAdvisor extends DefaultIntroductionAdvisor {

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

ProxyFactoryBean ，和其他Spring的 FactoryBean 實(shí)現(xiàn)一樣，引入一個(gè)間接的層次。如果你 定義一個(gè)名字為 foo 的 ProxyFactoryBean ， 引用 foo 的對(duì)象所看到的不是 ProxyFactoryBean 實(shí)例本身，而是由實(shí)現(xiàn) ProxyFactoryBean 的類的 getObject() 方法所創(chuàng)建的對(duì)象。這個(gè)方法將創(chuàng)建一個(gè)包裝了目標(biāo)對(duì)象 的AOP代理。

使用 ProxyFactoryBean 或者其他IoC可知的類來(lái)創(chuàng)建AOP代理 的最重要的優(yōu)點(diǎn)之一是IoC可以管理通知和切入點(diǎn)。這是一個(gè)非常的強(qiáng)大的功能，能夠?qū)?現(xiàn)其他AOP框架很難實(shí)現(xiàn)的特定的方法。例如，一個(gè)通知本身可以引用應(yīng)用對(duì)象（除了目標(biāo)對(duì)象， 它在任何AOP框架中都可以引用應(yīng)用對(duì)象），這完全得益于依賴注入所提供的可插入性。

類似于Spring提供的絕大部分FactoryBean實(shí)現(xiàn)一樣， ProxyFactoryBean 也是一個(gè)javabean，我們可以利用它的屬性來(lái):

一些關(guān)鍵屬性來(lái)自 org.springframework.aop.framework.ProxyConfig ：它是所有AOP代理工廠的父類。這些關(guān)鍵屬性包括：

其他 ProxyFactoryBean 特定的屬性包括：

讓我們來(lái)看一個(gè)簡(jiǎn)單的ProxyFactoryBean的實(shí)際例子。這個(gè)例子涉及到 :

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

請(qǐng)注意:person bean的 interceptorNames 屬性提供一個(gè)String列表， 列出的是該P(yáng)roxyFactoryBean使用的,在當(dāng)前bean工廠定義的interceptor或者advisor的 名字(advisor,interceptor,before,after returning,和throws advice 對(duì)象皆可)。 Advisor在該列表中的次序很重要。

上面定義的“person”bean定義可以作為Person接口的實(shí)現(xiàn)來(lái)使用，如下所示:

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

在同一個(gè)IoC的上下文中，其他的bean可以依賴于Person接口，就象依賴于一個(gè)普通的java對(duì)象一樣。

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

在這個(gè)例子里， PersonUser 類暴露了一個(gè)類型為Person的屬性。 只要是在用到該屬性的地方，AOP代理都能透明的替代一個(gè)真實(shí)的Person實(shí)現(xiàn)。 但是，這個(gè)類可能是一個(gè)動(dòng)態(tài)代理類。也就是有可能把它類型轉(zhuǎn)換為一個(gè) Advised 接口 (該接口在下面的章節(jié)中論述) 。

如果你需要代理的是類，而不是一個(gè)或多個(gè)接口，又該怎么辦呢?

想象一下我們上面的例子，如果沒(méi)有 Person 接口， 我們需要通知一個(gè)叫 Person 的類， 而且該類沒(méi)有實(shí)現(xiàn)任何業(yè)務(wù)接口。在這種情況下，你可以配置Spring使用CGLIB代理， 而不是動(dòng)態(tài)代理。你只要在上面的 ProxyFactoryBean 定義中把 它的 proxyTargetClass 屬性改成true就行了。

只要你愿意，即使在有接口的情況下，你也可以強(qiáng)迫Spring使用CGLIB代理。

CGLIB代理是通過(guò)在運(yùn)行期產(chǎn)生目標(biāo)類的子類來(lái)進(jìn)行工作的。 Spring可以配置這個(gè)生成的子類，來(lái)代理原始目標(biāo)類的方法調(diào)用。這個(gè)子類是用 Decorator 設(shè)計(jì)模式置入到advice中的。

CGLIB代理對(duì)于用戶來(lái)說(shuō)應(yīng)該是透明的。然而，還有以下一些因素需要考慮：

CGLIB和動(dòng)態(tài)代理在性能上有微小的區(qū)別，對(duì)Spring 1.0來(lái)說(shuō)，后者稍快。 另外,以后可能會(huì)有變化。在這種情況下性能不是決定性因素

用Spring提供的 jPetStore 的示例應(yīng)用 演示了TransactionProxyFactoryBean的使用方式。

TransactionProxyFactoryBean 是 ProxyConfig 的子類， 因此基本配置信息是和 ProxyFactoryBean 共享的。 (見(jiàn)上面 ProxyConfig 的屬性列表。)

下面的代碼來(lái)自于JPetStore application，演示了 ProxyFactoryBean 是如何工作的。 跟ProxyFactoryBean一樣，存在一個(gè)目標(biāo)bean的定義。 類的依賴關(guān)系定義在代理工廠bean定義中（petStore），而不是普通Java對(duì)象（petStoreTarget）。

TransactionProxyFactoryBean 需要設(shè)置一個(gè) target 屬性， 還需要設(shè)置“ transactionAttributes ”， “ transactionAttributes ”用來(lái)指定需要事務(wù)化 處理的方法，還有要求的傳播方式和其他設(shè)置:

          <bean id="petStoreTarget" class="org.springframework.samples.jpetstore.domain.logic.PetStoreImpl">
    <property name="accountDao"><ref bean="accountDao"/></property>
    <!-- Other dependencies omitted -->
</bean>

<bean id="petStore" 
    class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
    <property name="transactionManager"><ref bean="transactionManager"/></property>
    <property name="target"><ref local="petStoreTarget"/></property>
    <property name="transactionAttributes">
        <props>
            <prop key="insert*">PROPAGATION_REQUIRED</prop>
            <prop key="update*">PROPAGATION_REQUIRED</prop>
            <prop key="*">PROPAGATION_REQUIRED,readOnly</prop>
        </props>
    </property>
</bean>
        

TransactionProxyFactoryBean 自動(dòng)創(chuàng)建一個(gè)事務(wù)advisor， 該advisor包括一個(gè)基于事務(wù)屬性的切入點(diǎn)。因此只有事務(wù)性的方法被通知。

TransactionProxyFactoryBean 使用preInterceptors和 postInterceptors屬性指定“pre”和“post”通知。它們將攔截器，通知和Advisor數(shù)組放置 在事務(wù)攔截器前后的攔截器鏈中。使用XML格式的bean定義中的<list>元素定義，就 象下面一樣：

          <property name="preInterceptors">
    <list>
        <ref local="authorizationInterceptor"/>
        <ref local="notificationBeforeAdvice"/>
    </list>
</property>
<property name="postInterceptors">
    <list>
        <ref local="myAdvisor"/>
    </list>
</property>
        

這些屬性可以加到上面的“petStore”的bean定義里。一個(gè)通用用法是將事務(wù)和聲明式 安全組合在一起使用：一個(gè)和EJB提供的類似的方法。

因?yàn)槭褂们皵r截器和后攔截器時(shí)，用的是真正的實(shí)例引用，而不象在 ProxyFactoryBean 中用的bean的名字，因此它們只能用于共享實(shí)例的通知。 因此它們不能用在有狀態(tài)的通知中：例如，在mixin中。這和TransactionProxyFactoryBean的要求是 一致的。如果你需要更復(fù)雜的，可以定制的AOP，你可以考慮使用普通的 ProxyFactoryBean ， 或者是自動(dòng)代理生成器（參考下面）。

TransactionProxyFactoryBean 依賴于由它的 transactionManager 屬性指定的 TransactionManager 。 這種事務(wù)管理方式是可插拔的，基于JTA，JDBC或者其他事務(wù)管理策略皆可。 這與Spring的事務(wù)抽象層有關(guān)，而不在于AOP本身。我們將在下一章中討論事務(wù)機(jī)制。

其它有一些專門(mén)的代理用于創(chuàng)建EJB代理，使得EJB的“業(yè)務(wù)方法”的接口可以被調(diào)用代碼直接使用。 調(diào)用代碼并不需要進(jìn)行JNDI查找或使用EJB的創(chuàng)建方法：這是在可讀性和架構(gòu)靈活性方面的重大提高。

進(jìn)一步請(qǐng)參考本手冊(cè)內(nèi)的Spring的EJB業(yè)務(wù)。

org.springframework.aop.framework.autoproxy 包提供了下列標(biāo)準(zhǔn)自動(dòng)代理生成器。

            <bean id="jdkBeanNameProxyCreator" 
    class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">
    <property name="beanNames"><value>jdk*,onlyJdk</value></property>
    <property name="interceptorNames">
        <list>
            <value>myInterceptor</value>
        </list>
    </property>
</bean>
          

            <bean id="autoProxyCreator"
    class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator">
</bean>

<bean id="txAdvisor"
    autowire="constructor"
    class="org.springframework.transaction.interceptor.TransactionAttributeSourceAdvisor">
    <property name="order"><value>1</value></property>
</bean>

<bean id="customAdvisor"
    class="com.mycompany.MyAdvisor">
</bean>

<bean id="businessObject1"
    class="com.mycompany.BusinessObject1">
    <!-- Properties omitted -->
</bean>

<bean id="businessObject2"
    class="com.mycompany.BusinessObject2">
</bean>
          

一種特別重要的自動(dòng)代理類型是由元數(shù)據(jù)驅(qū)動(dòng)的。這和.NET的 ServicedComponents 編程框架 非常類似。它沒(méi)有象EJB那樣使用XML部署描述，事務(wù)管理和其它企業(yè)級(jí)業(yè)務(wù)的配置都是定義在源代碼級(jí)的屬性上。

在這種情況下，你可以使用 DefaultAdvisorAutoProxyCreator ，以及可以讀取元數(shù)據(jù)屬性的 Advisor。元數(shù)據(jù)細(xì)節(jié)定義在候選advisor的切入點(diǎn)部分，而不是自動(dòng)代理創(chuàng)建類本身。

這是 DefaultAdvisorAutoProxyCreator 的一種特殊情況，但是它本身而言是值得考慮的。 （可以讀取元數(shù)據(jù)的代碼處于advisor的切入點(diǎn)中，而不是AOP框架本身。）

jPetStore示例應(yīng)用的 /attributes 目錄演示了屬性驅(qū)動(dòng)的自動(dòng)代理的使用。在這個(gè)例子中， 沒(méi)有必要使用 TransactionProxyFactoryBean 。僅僅在業(yè)務(wù)對(duì)象上定義業(yè)務(wù)屬性就足夠了，因?yàn)?使用了可知元數(shù)據(jù)的切入點(diǎn)。bean定義在 /WEB-INF/declarativeServices.xml 中，包括下 面的代碼。注意這是通用的，可以在jPetStore以外的地方使用：

          <bean id="autoproxy" 
    class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator">
</bean>

<bean id="transactionAttributeSource"
    class="org.springframework.transaction.interceptor.AttributesTransactionAttributeSource"
    autowire="constructor">
</bean>

<bean id="transactionInterceptor"
    class="org.springframework.transaction.interceptor.TransactionInterceptor"
    autowire="byType">
</bean>

<bean id="transactionAdvisor"
    class="org.springframework.transaction.interceptor.TransactionAttributeSourceAdvisor"
    autowire="constructor" >
</bean>

<bean id="attributes"
    class="org.springframework.metadata.commons.CommonsAttributes"
/>
        

DefaultAdvisorAutoProxyCreator bean定義－－在這種情況下稱作“advisor”，但是名字 無(wú)關(guān)緊要－－會(huì)在當(dāng)前的應(yīng)用上午中選擇所有符合的切入點(diǎn)。在這個(gè)例子中，類型為 TransactionAttributeSourceAdvisor 的“transactionAdvisor”bean定義將會(huì)應(yīng)用于包含事務(wù)屬性 的類或方法。TransactionAttributeSourceAdvisor通過(guò)構(gòu)造函數(shù)依賴于TransactionInterceptor。這個(gè)例子通過(guò)自動(dòng) 裝配來(lái)解析它。 AttributesTransactionAttributeSource 依賴于 org.springframework.metadata.Attributes 接口的一個(gè)實(shí)現(xiàn)。在這段代碼中，“attributes” bean使用Jakarta Commons Attributes API來(lái)獲取屬性信息。（應(yīng)用代碼必須使用Commons Attributes編譯任務(wù)編譯。）

這里定義的 TransactionInterceptor 依賴于一個(gè) PlatformTransactionManager 定義，它并沒(méi)有被包括在這個(gè)通用的文件中（雖然應(yīng)該是這樣）， 這是因?yàn)樗呛蛻?yīng)用的事務(wù)需求相關(guān)的（一般地，是想這個(gè)例子中的JTA，或者Hibernate，JDO 或JDBC）：

          <bean id="transactionManager" 
    class="org.springframework.transaction.jta.JtaTransactionManager"/>
        

這個(gè)機(jī)制具有可擴(kuò)展性。它可以基于定制的屬性來(lái)使用自動(dòng)代理。你需要：

這些advisor可能對(duì)每個(gè)被通知類都是唯一的（例如，maxin）。它們僅僅需要被定義成 prototype bean，而不是singleton bean。例如，Spring的測(cè)試套件中的 LockMixin 引入攔截器可以和一個(gè)屬性驅(qū)動(dòng)切入點(diǎn)一起來(lái)定位一個(gè)maxin，就象這里演示的。我們使用JavaBean配置的 普通的 DefaultPointcutAdvisor ：

          <bean id="lockMixin"
    class="org.springframework.aop.LockMixin"
    singleton="false"
/>

<bean id="lockableAdvisor"
    class="org.springframework.aop.support.DefaultPointcutAdvisor"
    singleton="false"
>
    <property name="pointcut">
        <ref local="myAttributeAwarePointcut"/>
    </property>
    <property name="advice">
        <ref local="lockMixin"/>
    </property>
</bean>

<bean id="anyBean" class="anyclass" ...
        

如果知道屬性的切入點(diǎn)符合 anyBean 或者其它bean定義中的任何方法，這個(gè)maxin 將被應(yīng)用。注意， lockMixin 和 lockableAdvisor 定義都是 prototype的。 myAttributeAwarePointcut 切入點(diǎn)可以被定義成singleton，因?yàn)樗粸?不同的被通知對(duì)象保存狀態(tài)。

org.springframework.aop.target.HotSwappableTargetSource 允許切換一個(gè)AOP代理的目標(biāo)，而調(diào)用者維持對(duì)它的引用。

修改目標(biāo)源的目標(biāo)會(huì)立即起作用。并且 HotSwappableTargetSource 是線程安全的。

你可以通過(guò) HotSwappableTargetSource 的 swap() 方法 來(lái)改變目標(biāo)，就象下面一樣：

          HotSwappableTargetSource swapper = 
    (HotSwappableTargetSource) beanFactory.getBean("swapper");
Object oldTarget = swapper.swap(newTarget);
        

所需的XML定義如下：

          <bean id="initialTarget" class="mycompany.OldTarget">
</bean>

<bean id="swapper" 
    class="org.springframework.aop.target.HotSwappableTargetSource">
    <constructor-arg><ref local="initialTarget"/></constructor-arg>
</bean>

<bean id="swappable" 
    class="org.springframework.aop.framework.ProxyFactoryBean"
>
    <property name="targetSource">
        <ref local="swapper"/>
    </property>
</bean>
        

上面的 swap() 調(diào)用會(huì)修改swappable這個(gè)bean的目標(biāo)。持有對(duì)這個(gè)bean應(yīng)用的客戶端 將不會(huì)知道這個(gè)變化，但會(huì)立刻轉(zhuǎn)為使用新的目標(biāo)對(duì)象。

雖然這個(gè)例子沒(méi)有添加任何通知－－使用 TargetSource 也沒(méi)必要添加通知－－ 當(dāng)然任何 TargetSource 都可以和任何一種通知一起使用。

使用支持池的目標(biāo)源提供了一種和無(wú)狀態(tài)的session EJB類似的編程模式，在無(wú)狀態(tài)的session EJB中，維護(hù)了 一個(gè)相同實(shí)例的池，提供從池中獲取可用對(duì)象的方法。

Spring的池和SLSB的池之間的重要區(qū)別在于Spring的池可以被應(yīng)用到任何普通Java對(duì)象。就象Spring的通用 的做法，這個(gè)業(yè)務(wù)也可以以非侵入的方式被應(yīng)用。

Spring直接支持Jakarta Commons Pool 1.1，它是一種非常高效的池實(shí)現(xiàn)。使用這個(gè)功能，你需要在你的應(yīng)用的 classpath中添加commons-pool的Jar文件。也可以直接繼承 org.springframework.aop.target.AbstractPoolingTargetSource 來(lái)支持其它池API。

下面是一個(gè)配置的例子：

          <bean id="businessObjectTarget" class="com.mycompany.MyBusinessObject" 
    singleton="false">
    ... properties omitted
</bean>

<bean id="poolTargetSource" 
    class="org.springframework.aop.target.CommonsPoolTargetSource">
    <property name="targetBeanName"><value>businessObject</value></property>
    <property name="maxSize"><value>25</value></property>
</bean>

<bean id="businessObject" 
    class="org.springframework.aop.framework.ProxyFactoryBean"
>
    <property name="targetSource"><ref local="poolTargetSource"/></property>
    <property name="interceptorNames"><value>myInterceptor</value></property>
</bean>
        

注意例子中的目標(biāo)對(duì)象“businessObjectTarget” 必須 是prototype。這樣在 PoolingTargetSource 的實(shí)現(xiàn)在擴(kuò)大池容量的時(shí)候可以創(chuàng)建目標(biāo)的新實(shí)例。關(guān)于這些屬性的 信息可以參考 AbstractPoolingTargetSource 和子類的Javadoc。maxSize是最基本的屬性， 被保證總是存在。

在這種情況下，名字為“myInterceptor”的攔截器需要定義在同一個(gè)IoC上下文中。但是，并不一定需要 指定攔截器也用池。如果你僅需要池，并且沒(méi)有其它通知，可以根本不設(shè)置屬性interceptorNames。

也可以配置Spring以便可以將任何池化的對(duì)象轉(zhuǎn)換類型為 org.springframework.aop.target.PoolingConfig 接口。通過(guò)這個(gè)接口的一個(gè)引入，可以得到 配置信息和池的當(dāng)前大小。你需要這樣定義一個(gè)advisor：

          <bean id="poolConfigAdvisor" 
    class="org.springframework.beans.factory.config.MethodInvokingFactoryBean">
    <property name="target"><ref local="poolTargetSource" /></property>
    <property name="targetMethod"><value>getPoolingConfigMixin</value></property>
</bean>
        

通過(guò)調(diào)用 AbstractPoolingTargetSource 類上的方法，可以得到這個(gè)advisor， 因此使用MethodInvokingFactoryBean。這個(gè)advisor的名字（“poolConfigAdvisor”）必須在暴露池化對(duì)象的 This advisor is obtained by calling a convenience method on the ProxyFactoryBean中的攔截器名字列表中。

這個(gè)類型轉(zhuǎn)換就象下面：

          PoolingConfig conf = (PoolingConfig) beanFactory.getBean("businessObject");
System.out.println("Max pool size is " + conf.getMaxSize());
        

簡(jiǎn)單的池也可以使用自動(dòng)代理。任何自動(dòng)代理生成器都可以設(shè)置TargetSources。

設(shè)置“prototype”目標(biāo)源和支持池的目標(biāo)源類似。在每次方法調(diào)用的時(shí)候都會(huì)創(chuàng)建一個(gè)新的目標(biāo)實(shí)例。 雖然在現(xiàn)代JVM中創(chuàng)建對(duì)象的代價(jià)不是很高，但是裝配新對(duì)象的代價(jià)可能更高（為了maz滿足它的IoC依賴關(guān)系）。 因此沒(méi)有好的理由不應(yīng)該使用這個(gè)方法。

為了這么做，你可以修改上面的的 poolTargetSource 定義，就向下面一樣。 （為了清晰起見(jiàn)，我修改了名字。）

          <bean id="prototypeTargetSource" 
    class="org.springframework.aop.target.PrototypeTargetSource">
    <property name="targetBeanName"><value>businessObject</value></property>
</bean>
        

只有一個(gè)屬性：目標(biāo)bean的名字。在TargetSource實(shí)現(xiàn)中使用繼承是為了保證命名的一致性。就象支持池的 目標(biāo)源一樣，目標(biāo)bean必須是一個(gè)prototype的bean定義。