欧美性猛交XXXX免费看蜜桃,成人网18免费韩国,亚洲国产成人精品区综合,欧美日韩一区二区三区高清不卡,亚洲综合一区二区精品久久

首先讓我們從定義一些重要的AOP概念開(kāi)始。這些術(shù)語(yǔ)不是Spring特有的。 不幸的是，AOP術(shù)語(yǔ)并不是特別的直觀(guān)；如果Spring使用自己的術(shù)語(yǔ)，將會(huì )變得更加令人困惑。

通知的類(lèi)型：

環(huán)繞通知是最常用的一種通知類(lèi)型。大部分基于攔截的AOP框架，例如Nanning和JBoss4，都只提供環(huán)繞通知。

跟AspectJ一樣，Spring提供所有類(lèi)型的通知，我們推薦你使用盡量簡(jiǎn)單的通知類(lèi)型來(lái)實(shí)現需要的功能。 例如，如果你只是需要用一個(gè)方法的返回值來(lái)更新緩存，雖然使用環(huán)繞通知也能完成同樣的事情， 但是你最好使用After returning通知而不是環(huán)繞通知。 用最合適的通知類(lèi)型可以使得編程模型變得簡(jiǎn)單，并且能夠避免很多潛在的錯誤。 比如，你不需要調用 JoinPoint（用于A(yíng)round Advice）的 proceed() 方法，就不會(huì )有調用的問(wèn)題。

在Spring 2.0中，所有的通知參數都是靜態(tài)類(lèi)型，因此你可以使用合適的類(lèi)型（例如一個(gè)方法執行后的返回值類(lèi)型）作為通知的參數而不是使用一個(gè)對象數組。

切入點(diǎn)（pointcut）和連接點(diǎn)（join point）匹配的概念是AOP的關(guān)鍵，這使得AOP不同于其它僅僅提供攔截功能的舊技術(shù)。 切入點(diǎn)使得定位通知（advice）可獨立于OO層次。 例如，一個(gè)提供聲明式事務(wù)管理的around通知可以被應用到一組橫跨多個(gè)對象中的方法上（例如服務(wù)層的所有業(yè)務(wù)操作）。

Spring AOP用純Java實(shí)現。它不需要專(zhuān)門(mén)的編譯過(guò)程。Spring AOP不需要控制類(lèi)裝載器層次，因此它適用于J2EE web容器或應用服務(wù)器。

Spring目前僅支持使用方法調用作為連接點(diǎn)（join point）（在Spring bean上通知方法的執行）。 雖然可以在不影響到Spring AOP核心API的情況下加入對成員變量攔截器支持，但Spring并沒(méi)有實(shí)現成員變量攔截器。 如果你需要把對成員變量的訪(fǎng)問(wèn)和更新也作為通知的連接點(diǎn)，可以考慮其它語(yǔ)法的Java語(yǔ)言，例如AspectJ。

Spring實(shí)現AOP的方法跟其他的框架不同。Spring并不是要嘗試提供最完整的AOP實(shí)現（盡管Spring AOP有這個(gè)能力）， 相反的，它其實(shí)側重于提供一種AOP實(shí)現和Spring IoC容器的整合，用于幫助解決在企業(yè)級開(kāi)發(fā)中的常見(jiàn)問(wèn)題。

因此，Spring AOP通常都和Spring IoC容器一起使用。 Aspect使用普通的bean定義語(yǔ)法（盡管Spring提供了強大的“自動(dòng)代理（autoproxying）”功能）： 與其他AOP實(shí)現相比這是一個(gè)顯著(zhù)的區別。有些事使用Spring AOP是無(wú)法輕松或者高效的完成的，比如說(shuō)通知一個(gè)細粒度的對象。 這種時(shí)候，使用AspectJ是最好的選擇。不過(guò)經(jīng)驗告訴我們： 于大多數在J2EE應用中遇到的問(wèn)題，只要適合AOP來(lái)解決的，Spring AOP都沒(méi)有問(wèn)題，Spring AOP提供了一個(gè)非常好的解決方案。

Spring AOP從來(lái)沒(méi)有打算通過(guò)提供一種全面的AOP解決方案來(lái)取代AspectJ。 我們相信無(wú)論是基于代理（proxy-based ）的框架比如說(shuō)Spring亦或是full-blown的框架比如說(shuō)是AspectJ都是很有價(jià)值的，他們之間的關(guān)系應該是互補而不是競爭的關(guān)系。 Spring 2.0可以無(wú)縫的整合Spring AOP，IoC 和AspectJ，使得所有的AOP應用完全融入基于Spring的應用體系。 這樣的集成不會(huì )影響Spring AOP API或者AOP Alliance API；Spring AOP保留了向下兼容性。接下來(lái)的一章會(huì )詳細討論Spring AOP API。

Spring缺省使用J2SE 動(dòng)態(tài)代理（dynamic proxies）來(lái)作為AOP的代理。這樣任何接口都可以被代理。

Spring也支持使用CGLIB代理. 對于需要代理類(lèi)而不是代理接口的時(shí)候CGLIB代理是很有必要的。 如果一個(gè)業(yè)務(wù)對象并沒(méi)有實(shí)現一個(gè)接口，默認就會(huì )使用CGLIB。 作為面向接口編程的最佳實(shí)踐，業(yè)務(wù)對象通常都會(huì )實(shí)現一個(gè)或多個(gè)接口。但也有可能會(huì ) 強制使用CGLIB， 在這種情況（希望不常有）下，你可能需要通知一個(gè)沒(méi)有在接口中聲明的方法，或者需要傳入一個(gè)代理對象給方法作為具體類(lèi)型

為了在Spring配置中使用@AspectJ aspects，你必須首先啟用Spring對基于@AspectJ aspects的配置支持，自動(dòng)代理（autoproxying）基于通知是否來(lái)自這些切面。 自動(dòng)代理是指Spring會(huì )判斷一個(gè)bean是否使用了一個(gè)或多個(gè)切面通知，并據此自動(dòng)生成相應的代理以攔截其方法調用，并且確認通知是否如期進(jìn)行。

通過(guò)在你的Spring的配置中引入下列元素來(lái)啟用Spring對@AspectJ的支持：

<aop:aspectj-autoproxy/>

我們假使你正在使用 Appendix A, XML Schema-based configuration 所描述的schema支持。 關(guān)于如何在aop的命名空間中引入這些標簽，請參見(jiàn) Section A.2.6, “The aop schema”

如果你正在使用DTD，你仍舊可以通過(guò)在你的application context中添加如下定義來(lái)啟用@AspectJ支持：

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

你需要在你的應用程序的classpath中引入兩個(gè)AspectJ庫：aspectjweaver.jar 和 aspectjrt.jar。 這些庫可以在A(yíng)spectJ的安裝包（1.5.1或者之后的版本）中的 lib 目錄里找到，或者也可以在Spring依賴(lài)庫的 lib/aspectj 目錄下找到。

在啟用@AspectJ支持的情況下，在application context中定義的任意帶有一個(gè)@Aspect切面（擁有@Aspect注解）的bean都將被Spring自動(dòng)識別并用于配置在Spring AOP。 以下例子展示了為了完成一個(gè)不是非常有用的切面所需要的最小定義：

下面是在application context中的一個(gè)常見(jiàn)的bean定義，這個(gè)bean指向一個(gè)使用了 @Aspect 注解的bean類(lèi)：

<bean id="myAspect" class="org.xyz.NotVeryUsefulAspect"><!-- configure properties of aspect here as normal --></bean>

下面是 NotVeryUsefulAspect 類(lèi)定義，使用了 org.aspectj.lang.annotation.Aspect 注解。

package org.xyz;import org.aspectj.lang.annotation.Aspect;@Aspectpublic class NotVeryUsefulAspect {}

切面（用 @Aspect 注解的類(lèi)）和其他類(lèi)一樣有方法和字段定義。他們也可能包括切入點(diǎn)，通知和引入（inter-type）聲明。

回想一下，切入點(diǎn)決定了連接點(diǎn)關(guān)注的內容，使得我們可以控制通知什么時(shí)候執行。 Spring AOP 只支持 Spring bean 方法執行連接點(diǎn)。所以你可以把切入點(diǎn)看做是匹配 Spring bean 上方法的執行。 一個(gè)切入點(diǎn)聲明有兩個(gè)部分：一個(gè)包含名字和任意參數的簽名，還有一個(gè)切入點(diǎn)表達式，該表達式?jīng)Q定了我們關(guān)注那個(gè)方法的執行。 在 @AspectJ 注解風(fēng)格的 AOP 中，一個(gè)切入點(diǎn)簽名通過(guò)一個(gè)普通的方法定義來(lái)提供，并且切入點(diǎn)表達式使用 @Pointcut 注解來(lái)表示（作為切入點(diǎn)簽名的方法必須返回 void 類(lèi)型）。

用一個(gè)例子會(huì )幫助我們區分切入點(diǎn)簽名和切入點(diǎn)表達式之間的差別，下面的例子定義了一個(gè)切入點(diǎn)‘a(chǎn)nyOldTransfer‘， 這個(gè)切入點(diǎn)將匹配任何名為 "transfer" 的方法的執行：

@Pointcut("execution(* transfer(..))")// the pointcut expressionprivate void anyOldTransfer() {}// the pointcut signature

切入點(diǎn)表達式，也就是 @Pointcut 注解的值，是正規的AspectJ 5切入點(diǎn)表達式。 如果你想要更多了解AspectJ的 切入點(diǎn)語(yǔ)言，請參見(jiàn) AspectJ 編程指南（如果要了解基于Java 5的擴展請參閱 AspectJ 5 開(kāi)發(fā)手冊） 或者其他人寫(xiě)的關(guān)于A(yíng)spectJ的書(shū)，例如Colyer et. al.著(zhù)的《Eclipse AspectJ》或者Ramnivas Laddad著(zhù)的《AspectJ in Action》。

	@Pointcut("execution(public * *(..))")private void anyPublicOperation() {}@Pointcut("within(com.xyz.someapp.trading..*")private void inTrading() {}@Pointcut("anyPublicOperation() && inTrading()")private void tradingOperation() {}

package com.xyz.someapp;import org.aspectj.lang.annotation.Aspect;import org.aspectj.lang.annotation.Pointcut;@Aspectpublic class SystemArchitecture {/*** A join point is in the web layer if the method is defined* in a type in the com.xyz.someapp.web package or any sub-package* under that.*/@Pointcut("within(com.xyz.someapp.web..*)")public void inWebLayer() {}/*** A join point is in the service layer if the method is defined* in a type in the com.xyz.someapp.service package or any sub-package* under that.*/@Pointcut("within(com.xyz.someapp.service..*)")public void inServiceLayer() {}/*** A join point is in the data access layer if the method is defined* in a type in the com.xyz.someapp.dao package or any sub-package* under that.*/@Pointcut("within(com.xyz.someapp.dao..*)")public void inDataAccessLayer() {}/*** A business service is the execution of any method defined on a service* interface. This definition assumes that interfaces are placed in the* "service" package, and that implementation types are in sub-packages.** If you group service interfaces by functional area (for example,* in packages com.xyz.someapp.abc.service and com.xyz.def.service) then* the pointcut expression "execution(* com.xyz.someapp..service.*.*(..))"* could be used instead.*/@Pointcut("execution(* com.xyz.someapp.service.*.*(..))")public void businessService() {}/*** A data access operation is the execution of any method defined on a* dao interface. This definition assumes that interfaces are placed in the* "dao" package, and that implementation types are in sub-packages.*/@Pointcut("execution(* com.xyz.someapp.dao.*.*(..))")public void dataAccessOperation() {}}

<aop:config><aop:advisorpointcut="com.xyz.someapp.SystemArchitecture.businessService()"advice-ref="tx-advice"/></aop:config><tx:advice id="tx-advice"><tx:attributes><tx:method name="*" propagation="REQUIRED"/></tx:attributes></tx:advice>

execution(modifiers-pattern? ret-type-pattern declaring-type-pattern? name-pattern(param-pattern) throws-pattern?)

通知是跟一個(gè)切入點(diǎn)表達式關(guān)聯(lián)起來(lái)的，并且在切入點(diǎn)匹配的方法執行之前或者之后或者之前和之后運行。 切入點(diǎn)表達式可能是指向已命名的切入點(diǎn)的簡(jiǎn)單引用或者是一個(gè)已經(jīng)聲明過(guò)的切入點(diǎn)表達式。

import org.aspectj.lang.annotation.Aspect;import org.aspectj.lang.annotation.Before;@Aspectpublic class BeforeExample {@Before("com.xyz.myapp.SystemArchitecture.dataAccessOperation()")public void doAccessCheck() {// ...}}

import org.aspectj.lang.annotation.Aspect;import org.aspectj.lang.annotation.Before;@Aspectpublic class BeforeExample {@Before("execution(* com.xyz.myapp.dao.*.*(..))")public void doAccessCheck() {// ...}}

import org.aspectj.lang.annotation.Aspect;import org.aspectj.lang.annotation.AfterReturning;@Aspectpublic class AfterReturningExample {@AfterReturning("com.xyz.myapp.SystemArchitecture.dataAccessOperation()")public void doAccessCheck() {// ...}}

import org.aspectj.lang.annotation.Aspect;import org.aspectj.lang.annotation.AfterReturning;@Aspectpublic class AfterReturningExample {@AfterReturning(pointcut="com.xyz.myapp.SystemArchitecture.dataAccessOperation()",returning="retVal")public void doAccessCheck(Object retVal) {// ...}}

import org.aspectj.lang.annotation.Aspect;import org.aspectj.lang.annotation.AfterThrowing;@Aspectpublic class AfterThrowingExample {@AfterThrowing("com.xyz.myapp.SystemArchitecture.dataAccessOperation()")public void doRecoveryActions() {// ...}}

import org.aspectj.lang.annotation.Aspect;import org.aspectj.lang.annotation.AfterThrowing;@Aspectpublic class AfterThrowingExample {@AfterThrowing(pointcut="com.xyz.myapp.SystemArchitecture.dataAccessOperation()",throwing="ex")public void doRecoveryActions(DataAccessException ex) {// ...}}

import org.aspectj.lang.annotation.Aspect;import org.aspectj.lang.annotation.After;@Aspectpublic class AfterFinallyExample {@After("com.xyz.myapp.SystemArchitecture.dataAccessOperation()")public void doReleaseLock() {// ...}}

import org.aspectj.lang.annotation.Aspect;import org.aspectj.lang.annotation.Around;import org.aspectj.lang.ProceedingJoinPoint;@Aspectpublic class AroundExample {@Around("com.xyz.myapp.SystemArchitecture.businessService()")public Object doBasicProfiling(ProceedingJoinPoint pjp) throws Throwable {// start stopwatchObject retVal = pjp.proceed();// stop stopwatchreturn retVal;}}

@Before("com.xyz.myapp.SystemArchitecture.dataAccessOperation() &&" +"args(account,..)")public void validateAccount(Account account) {// ...}

@Pointcut("com.xyz.myapp.SystemArchitecture.dataAccessOperation() &&" +"args(account,..)")private void accountDataAccessOperation(Account account) {}@Before("accountDataAccessOperation(account)")public void validateAccount(Account account) {// ...}

@Retention(RetentionPolicy.RUNTIME)@Target(ElementType.METHOD)public @interface Auditable {AuditCode value();}

@Before("com.xyz.lib.Pointcuts.anyPublicMethod() && " +"@annotation(auditable)")public void audit(Auditable auditable) {AuditCode code = auditable.value();// ...}

@Around("execution(List<Account> find*(..)) &&" +"com.xyz.myapp.SystemArchitecture.inDataAccessLayer() && " +"args(accountHolderNamePattern)")public Object preProcessQueryPattern(ProceedingJoinPoint pjp, String accountHolderNamePattern)throws Throwable {String newPattern = preProcess(accountHolderNamePattern);return pjp.proceed(new Object[] {newPattern});}

@Aspectpublic class AspectWithMultipleAdviceDeclarations {@Pointcut("execution(* foo(..))")public void fooExecution() {}@Before("fooExecution()")public void doBeforeOne() {// ...}@Before("fooExecution()")public void doBeforeTwo() {// ...}@AfterReturning("fooExecution()")public void doAfterOne() {// ...}@AfterReturning("fooExecution()")public void doAfterTwo() {// ...}}

doBeforeOnedoBeforeTwofoodoAfterOnedoAfterTwo

引入（Introductions）（在A(yíng)spectJ中被稱(chēng)為inter-type聲明）使得一個(gè)切面可以定義被通知對象實(shí)現一個(gè)給定的接口，并且可以代表那些對象提供具體實(shí)現。

使用 @DeclareParents注解來(lái)定義引入。這個(gè)注解被用來(lái)定義匹配的類(lèi)型擁有一個(gè)新的父親。 比如，給定一個(gè)接口 UsageTracked，然后接口的具體實(shí)現 DefaultUsageTracked 類(lèi)， 接下來(lái)的切面聲明了所有的service接口的實(shí)現都實(shí)現了 UsageTracked 接口。（比如為了通過(guò)JMX輸出統計信息）。

@Aspectpublic 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();}}

實(shí)現的接口通過(guò)被注解的字段類(lèi)型來(lái)決定。@DeclareParents 注解的 value 屬性是一個(gè)AspectJ的類(lèi)型模式：- 任何匹配類(lèi)型的bean都會(huì )實(shí)現 UsageTracked 接口。 請注意，在上面的前置通知（before advice）的例子中，service beans 可以直接用作 UsageTracked 接口的實(shí)現。 如果需要編程式的來(lái)訪(fǎng)問(wèn)一個(gè)bean，你可以這樣寫(xiě)：

UsageTracked usageTracked = (UsageTracked) context.getBean("myService");

默認情況下，在application context中每一個(gè)切面都會(huì )有一個(gè)實(shí)例。 AspectJ 把這個(gè)叫做單個(gè)實(shí)例化模型（singleton instantiation model）。 也可以用其他的生命周期來(lái)定義切面：- Spring支持AspectJ的 perthis 和 pertarget 實(shí)例化模型 （現在還不支持percflow、percflowbelow 和 pertypewithin ）。

一個(gè)"perthis" 切面的定義：在 @Aspect 注解中指定perthis 子句。 讓我們先來(lái)看一個(gè)例子，然后解釋它是如何運作的：

@Aspect("perthis(com.xyz.myapp.SystemArchitecture.businessService())")public class MyAspect {private int someState;@Before(com.xyz.myapp.SystemArchitecture.businessService())public void recordServiceUsage() {// ...}}

這個(gè)perthis子句的效果是每個(gè)獨立的service對象執行時(shí)都會(huì )創(chuàng )建一個(gè)切面實(shí)例（切入點(diǎn)表達式所匹配的連接點(diǎn)上的每一個(gè)獨立的對象都會(huì )綁定到‘this‘上）。 service對象的每個(gè)方法在第一次執行的時(shí)候創(chuàng )建切面實(shí)例。切面在service對象失效的同時(shí)失效。 在切面實(shí)例被創(chuàng )建前，所有的通知都不會(huì )被執行，一旦切面對象創(chuàng )建完成，定義的通知將會(huì )在匹配的連接點(diǎn)上執行，但是只有當service對象是和切面關(guān)聯(lián)的才可以。 如果想要知道更多關(guān)于per-clauses的信息，請參閱 AspectJ 編程指南。

‘pertarget‘實(shí)例模型的跟“perthis”完全一樣，只不過(guò)是為每個(gè)匹配于連接點(diǎn)的獨立目標對象創(chuàng )建一個(gè)切面實(shí)例。

現在你已經(jīng)看到了每個(gè)獨立的部分是如何運作的了，是時(shí)候把他們放到一起做一些有用的事情了！

因為并發(fā)的問(wèn)題，有時(shí)候business services可能會(huì )失?。ɡ?，死鎖失?。?。如果重新嘗試一下，很有可能就會(huì )成功。 對于business services來(lái)說(shuō)，重試幾次是很正常的（Idempotent操作不需要用戶(hù)參與，否則會(huì )得出矛盾的結論） 我們可能需要透明的重試操作以避免讓客戶(hù)看見(jiàn) PessimisticLockingFailureException 例外被拋出。 很明顯，在一個(gè)橫切多層的情況下，這是非常有必要的，因此通過(guò)切面來(lái)實(shí)現是很理想的。

因為我們想要重試操作，我們會(huì )需要使用到環(huán)繞通知，這樣我們就可以多次調用proceed()方法。下面是簡(jiǎn)單的切面實(shí)現：

@Aspectpublic class ConcurrentOperationExecutor implements Ordered {private static final int DEFAULT_MAX_RETRIES = 2;private int maxRetries = DEFAULT_MAX_RETRIES;private int order = 1;public void setMaxRetries(int maxRetries) {this.maxRetries = maxRetries;}public int getOrder() {return this.order;}public void setOrder(int order) {this.order = order;}@Around("com.xyz.myapp.SystemArchitecture.businessService()")public Object doConcurrentOperation(ProceedingJoinPoint pjp) throws Throwable {int numAttempts = 0;PessimisticLockingFailureException lockFailureException;do {numAttempts++;try {return pjp.proceed();}catch(PessimisticLockingFailureException ex) {lockFailureException = ex;}}while(numAttempts <= this.maxRetries);throw lockFailureException;}}

請注意切面實(shí)現了 Ordered 接口，這樣我們就可以把切面的優(yōu)先級設定為高于事務(wù)通知（我們每次重試的時(shí)候都想要在一個(gè)全新的事務(wù)中進(jìn)行）。 maxRetries 和 order 屬性都可以在Spring中配置。 主要的動(dòng)作在 doConcurrentOperation 這個(gè)環(huán)繞通知中發(fā)生。 請注意這個(gè)時(shí)候我們所有的 businessService() 方法都會(huì )使用這個(gè)重試策略。 我們首先會(huì )嘗試處理，然后如果我們得到一個(gè) PessimisticLockingFailureException 意外，我們只需要簡(jiǎn)單的重試，直到我們耗盡所有預設的重試次數。

對應的Spring配置如下：

<aop:aspectj-autoproxy/><bean id="concurrentOperationExecutor"class="com.xyz.myapp.service.impl.ConcurrentOperationExecutor"><property name="maxRetries" value="3"/><property name="order" value="100"/></bean>

為了改進(jìn)切面，使之僅僅重試idempotent操作，我們可以定義一個(gè) Idempotent 注解：

@Retention(RetentionPolicy.RUNTIME)public @interface Idempotent {// marker annotation}

并且對service操作的實(shí)現進(jìn)行注解。 這樣如果你只希望改變切面使得idempotent的操作會(huì )嘗試多次，你只需要改寫(xiě)切入點(diǎn)表達式，這樣只有 @Idempotent 操作會(huì )匹配：

@Around("com.xyz.myapp.SystemArchitecture.businessService() && " +"@annotation(com.xyz.myapp.service.Idempotent)")public Object doConcurrentOperation(ProceedingJoinPoint pjp) throws Throwable {...}

有了schema的支持，切面就和常規的Java對象一樣被定義成application context中的一個(gè)bean。 對象的字段和方法提供了狀態(tài)和行為信息，XML文件則提供了切入點(diǎn)和通知信息。

切面使用<aop:aspect>來(lái)聲明，backing bean（支持bean）通過(guò) ref 屬性來(lái)引用：

<aop:config><aop:aspect id="myAspect" ref="aBean">...</aop:aspect></aop:config><bean id="aBean" class="...">...</bean>

切面的支持bean（上例中的"aBean"）可以象其他Spring bean一樣被容器管理配置以及依賴(lài)注入。

切入點(diǎn)可以在切面里面聲明，這種情況下切入點(diǎn)只在切面內部可見(jiàn)。切入點(diǎn)也可以直接在<aop:config>下定義，這樣就可以使多個(gè)切面和通知器共享該切入點(diǎn)。

一個(gè)描述service層中表示所有service執行的切入點(diǎn)可以如下定義：

<aop:config><aop:pointcut id="businessService"expression="execution(* com.xyz.myapp.service.*.*(..))"/></aop:config>

注意切入點(diǎn)表達式本身使用了 Section 6.2, “@AspectJ支持” 中描述的AspectJ 切入點(diǎn)表達式語(yǔ)言。 如果你在Java 5環(huán)境下使用基于schema的聲明風(fēng)格，可參考切入點(diǎn)表達式類(lèi)型中定義的命名式切入點(diǎn)，不過(guò)這在JDK1.4及以下版本中是不被支持的（因為依賴(lài)于Java 5中的AspectJ反射API）。 所以在JDK 1.5中，上面的切入點(diǎn)的另外一種定義形式如下：

<aop:config><aop:pointcut id="businessService"expression="com.xyz.myapp.SystemArchitecture.businessService()"/></aop:config>

假定你有 Section 6.2.3.3, “共享常見(jiàn)的切入點(diǎn)（pointcut）定義”中說(shuō)描述的 SystemArchitecture 切面。

在切面里面聲明一個(gè)切入點(diǎn)和聲明一個(gè)頂級的切入點(diǎn)非常類(lèi)似：

<aop:config><aop:aspect id="myAspect" ref="aBean"><aop:pointcut id="businessService"expression="execution(* com.xyz.myapp.service.*.*(..))"/>...</aop:aspect></aop:config>

當需要連接子表達式的時(shí)候，‘&‘在XML中用起來(lái)非常不方便，所以關(guān)鍵字‘a(chǎn)nd‘, ‘or‘ 和 ‘not‘可以分別用來(lái)代替‘&‘, ‘||‘ 和 ‘!‘。

注意這種方式定義的切入點(diǎn)通過(guò)XML id來(lái)查找，并且不能定義切入點(diǎn)參數。在基于schema的定義風(fēng)格中命名切入點(diǎn)支持較之@AspectJ風(fēng)格受到了很多的限制。

和@AspectJ風(fēng)格一樣，基于schema的風(fēng)格也支持5種通知類(lèi)型并且兩者具有同樣的語(yǔ)義。

<aop:aspect id="beforeExample" ref="aBean"><aop:beforepointcut-ref="dataAccessOperation"method="doAccessCheck"/>...</aop:aspect>

<aop:aspect id="beforeExample" ref="aBean"><aop:beforepointcut="execution(* com.xyz.myapp.dao.*.*(..))"method="doAccessCheck"/>...</aop:aspect>

<aop:aspect id="afterReturningExample" ref="aBean"><aop:after-returningpointcut-ref="dataAccessOperation"method="doAccessCheck"/>...</aop:aspect>

<aop:aspect id="afterReturningExample" ref="aBean"><aop:after-returningpointcut-ref="dataAccessOperation"returning="retVal"method="doAccessCheck"/>...</aop:aspect>

public void doAccessCheck(Object retVal) {...

<aop:aspect id="afterThrowingExample" ref="aBean"><aop:after-throwingpointcut-ref="dataAccessOperation"method="doRecoveryActions"/>...</aop:aspect>

<aop:aspect id="afterThrowingExample" ref="aBean"><aop:after-throwingpointcut-ref="dataAccessOperation"thowing="dataAccessEx"method="doRecoveryActions"/>...</aop:aspect>

public void doRecoveryActions(DataAccessException dataAccessEx) {...

<aop:aspect id="afterFinallyExample" ref="aBean"><aop:afterpointcut-ref="dataAccessOperation"method="doReleaseLock"/>...</aop:aspect>

<aop:aspect id="aroundExample" ref="aBean"><aop:aroundpointcut-ref="businessService"method="doBasicProfiling"/>...</aop:aspect>

public Object doBasicProfiling(ProceedingJoinPoint pjp) throws Throwable {// start stopwatchObject retVal = pjp.proceed();// stop stopwatchreturn retVal;}

<aop:beforepointcut="com.xyz.lib.Pointcuts.anyPublicMethod() and @annotation(auditable)"method="audit"arg-names="auditable"/>

package x.y.service;public interface FooService {Foo getFoo(String fooName, int age);}// the attendant implementation (defined in another file of course)public class DefaultFooService implements FooService {public Foo getFoo(String name, int age) {return new Foo(name, age);}}

package x.y;import org.aspectj.lang.ProceedingJoinPoint;import org.springframework.util.StopWatch;public class SimpleProfiler {public Object profile(ProceedingJoinPoint call, String name, int age) throws Throwable {StopWatch clock = new StopWatch("Profiling for ‘" + name + "‘ and ‘" + age + "‘");try {clock.start(call.toShortString());return call.proceed();} finally {clock.stop();System.out.println(clock.prettyPrint());}}}

<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-2.0.xsdhttp://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd"><!-- this is the object that will be proxied by Spring‘s AOP infrastructure --><bean id="fooService" class="x.y.service.DefaultFooService"/><!-- this is the actual advice itself --><bean id="profiler" class="x.y.SimpleProfiler"/><aop:config><aop:aspect ref="profiler"><aop:pointcut id="theExecutionOfSomeFooServiceMethod"expression="execution(* x.y.service.FooService.getFoo(String,int))and args(name, age)"/><aop:around pointcut-ref="theExecutionOfSomeFooServiceMethod"method="profile"/></aop:aspect></aop:config></beans>

import org.springframework.beans.factory.BeanFactory;import org.springframework.context.support.ClassPathXmlApplicationContext;import x.y.service.FooService;public final class Boot {public static void main(final String[] args) throws Exception {BeanFactory ctx = new ClassPathXmlApplicationContext("x/y/plain.xml");FooService foo = (FooService) ctx.getBean("fooService");foo.getFoo("Pengo", 12);}}

StopWatch ‘Profiling for ‘Pengo‘ and ‘12‘‘: running time (millis) = 0-----------------------------------------ms     %     Task name-----------------------------------------00000  ?  execution(getFoo)

Intrduction （在A(yíng)spectJ中成為inter-type聲明）允許一個(gè)切面聲明一個(gè)通知對象實(shí)現指定接口，并且提供了一個(gè)接口實(shí)現類(lèi)來(lái)代表這些對象。

在 aop:aspect 內部使用 aop:declare-parents 元素定義Introduction。 該元素用于用來(lái)聲明所匹配的類(lèi)型有了一個(gè)新的父類(lèi)型（所以有了這個(gè)名字）。 例如，給定接口 UsageTracked，以及這個(gè)接口的一個(gè)實(shí)現類(lèi) DefaultUsageTracked， 下面聲明的切面所有實(shí)現service接口的類(lèi)同時(shí)實(shí)現 UsageTracked 接口。（比如為了通過(guò)JMX暴露statistics。）

<aop:aspect id="usageTrackerAspect" ref="usageTracking"><aop:declare-parentstypes-matching="com.xzy.myapp.service.*+",implement-interface="UsageTracked"default-impl="com.xyz.myapp.service.tracking.DefaultUsageTracked"/><aop:beforepointcut="com.xyz.myapp.SystemArchitecture.businessService()and this(usageTracked)"method="recordUsage"/></aop:aspect>

usageTracking bean的支持類(lèi)可以包含下面的方法：

public void recordUsage(UsageTracked usageTracked) {usageTracked.incrementUseCount();}

欲實(shí)現的接口由 implement-interface 屬性來(lái)指定。 types-matching 屬性的值是一個(gè)AspectJ類(lèi)型模式：- 任何匹配類(lèi)型的bean會(huì )實(shí)現 UsageTracked 接口。 注意在Before通知的例子中，srevice bean可以用作 UsageTracked 接口的實(shí)現。 如果編程形式訪(fǎng)問(wèn)一個(gè)bean，你可以這樣來(lái)寫(xiě)：

UsageTracked usageTracked = (UsageTracked) context.getBean("myService");

Schema-defined切面僅支持一種實(shí)例化模型就是singlton模型。其他的實(shí)例化模型或許在未來(lái)版本中將得到支持。

"advisors"這個(gè)概念來(lái)自Spring1.2對AOP的支持，在A(yíng)spectJ中是沒(méi)有等價(jià)的概念。 advisor就像一個(gè)小的自包含的切面，這個(gè)切面只有一個(gè)通知。 切面自身通過(guò)一個(gè)bean表示，并且必須實(shí)現一個(gè)通知接口， 在 Section 7.3.2, “Spring里的通知類(lèi)型” 中我們會(huì )討論相應的接口。Advisors可以很好的利用AspectJ切入點(diǎn)表達式。

Spring 2.0 通過(guò) <aop:advisor> 元素來(lái)支持advisor 概念。 你將會(huì )發(fā)現它大多數情況下會(huì )和transactional advice一起使用，transactional advice在Spring 2.0中有自己的命名空間。格式如下：

<aop:config><aop:pointcut id="businessService"expression="execution(* com.xyz.myapp.service.*.*(..))"/><aop:advisorpointcut-ref="businessService"advice-ref="tx-advice"/></aop:config><tx:advice id="tx-advice"><tx:attributes><tx:method name="*" propagation="REQUIRED"/></tx:attributes></tx:advice>

和在上面使用的 pointcut-ref 屬性一樣，你還可以使用 pointcut 屬性來(lái)定義一個(gè)內聯(lián)的切入點(diǎn)表達式。

為了定義一個(gè)advisord的優(yōu)先級以便讓通知可以有序，使用 order 屬性來(lái)定義 advisor的值 Ordered 。

讓我們來(lái)看看在 Section 6.2.7, “例子” 提過(guò)并發(fā)鎖失敗重試的例子，如果使用schema對這個(gè)例子進(jìn)行重寫(xiě)是什么效果。

因為并發(fā)鎖的關(guān)系，有時(shí)候business services可能會(huì )失?。ɡ?，死鎖失?。?。 如果重新嘗試一下，很有可能就會(huì )成功。對于business services來(lái)說(shuō)，重試幾次是很正常的（Idempotent操作不需要用戶(hù)參與，否則會(huì )得出矛盾的結論） 我們可能需要透明的重試操作以避免讓客戶(hù)看見(jiàn) PessimisticLockingFailureException 例外被拋出。 很明顯，在一個(gè)橫切多層的情況下，這是非常有必要的，因此通過(guò)切面來(lái)實(shí)現是很理想的。

因為我們想要重試操作，我們會(huì )需要使用到環(huán)繞通知，這樣我們就可以多次調用proceed()方法。 下面是簡(jiǎn)單的切面實(shí)現（只是一個(gè)schema支持的普通Java 類(lèi)）：

public class ConcurrentOperationExecutor implements Ordered {private static final int DEFAULT_MAX_RETRIES = 2;private int maxRetries = DEFAULT_MAX_RETRIES;private int order = 1;public void setMaxRetries(int maxRetries) {this.maxRetries = maxRetries;}public int getOrder() {return this.order;}public void setOrder(int order) {this.order = order;}public Object doConcurrentOperation(ProceedingJoinPoint pjp) throws Throwable {int numAttempts = 0;PessimisticLockingFailureException lockFailureException;do {numAttempts++;try {return pjp.proceed();}catch(PessimisticLockingFailureException ex) {lockFailureException = ex;}}while(numAttempts <= this.maxRetries);throw lockFailureException;}}

請注意切面實(shí)現了 Ordered 接口，這樣我們就可以把切面的優(yōu)先級設定為高于事務(wù)通知（我們每次重試的時(shí)候都想要在一個(gè)全新的事務(wù)中進(jìn)行）。 maxRetries 和 order 屬性都可以在Spring中配置。 主要的動(dòng)作在 doConcurrentOperation 這個(gè)環(huán)繞通知中發(fā)生。 請注意這個(gè)時(shí)候我們所有的 businessService() 方法都會(huì )使用這個(gè)重試策略。 我們首先會(huì )嘗試處理，然后如果我們得到一個(gè) PessimisticLockingFailureException 異常，我們只需要簡(jiǎn)單的重試，直到我們耗盡所有預設的重試次數。

對應的Spring配置如下：

<aop:config><aop:aspect id="concurrentOperationRetry" ref="concurrentOperationExecutor"><aop:pointcut id="idempotentOperation"expression="execution(* com.xyz.myapp.service.*.*(..))"/><aop:aroundpointcut-ref="idempotentOperation"method="doConcurrentOperation"/></aop:aspect></aop:config><bean id="concurrentOperationExecutor"class="com.xyz.myapp.service.impl.ConcurrentOperationExecutor"><property name="maxRetries" value="3"/><property name="order" value="100"/></bean>

請注意我們現在假設所有的bussiness services都是idempotent。如果不是這樣，我們可以改寫(xiě)切面，加上 Idempotent 注解，讓它只調用idempotent：

@Retention(RetentionPolicy.RUNTIME)public @interface Idempotent {// marker annotation}

并且對service操作的實(shí)現進(jìn)行注解。這樣如果你只希望改變切面使得idempotent的操作會(huì )嘗試多次，你只需要改寫(xiě)切入點(diǎn)表達式，這樣只有 @Idempotent 操作會(huì )匹配：

  <aop:pointcut id="idempotentOperation"expression="execution(* com.xyz.myapp.service.*.*(..)) and@annotation(com.xyz.myapp.service.Idempotent)"/>

做能起作用的最簡(jiǎn)單的事。Spring AOP比完全使用AspectJ更加簡(jiǎn)單，因為它不需要引入AspectJ的編譯器／織入器到你開(kāi)發(fā)和構建過(guò)程中。 如果你僅僅需要在Spring bean上通知執行操作，那么Spring AOP是合適的選擇。如果你需要通知domain對象或其它沒(méi)有在Spring容器中 管理的任意對象，那么你需要使用AspectJ。如果你想通知除了簡(jiǎn)單的方法執行之外的連接點(diǎn)（如：調用連接點(diǎn)、字段get或set的連接點(diǎn)等等）， 也需要使用AspectJ。

當使用AspectJ時(shí)，你可以選擇使用AspectJ語(yǔ)言（也稱(chēng)為“代碼風(fēng)格”）或@AspectJ注解風(fēng)格。 如果切面在你的設計中扮演一個(gè)很大的角色，并且你能在Eclipse中使用AspectJ Development Tools (AJDT)， 那么首選AspectJ語(yǔ)言 :- 因為該語(yǔ)言專(zhuān)門(mén)被設計用來(lái)編寫(xiě)切面，所以會(huì )更清晰、更簡(jiǎn)單。如果你沒(méi)有使用 Eclipse，或者在你的應用中只有很少的切面并沒(méi)有作為一個(gè)主要的角色，你或許應該考慮使用@AspectJ風(fēng)格 并在你的IDE中附加一個(gè)普通的Java編輯器，并且在你的構建腳本中增加切面織入（鏈接）的段落。

如果你選擇使用Spring AOP，那么你可以選擇@AspectJ或者XML風(fēng)格?？偟膩?lái)說(shuō)，如果你使用Java 5， 我們建議使用@AspectJ風(fēng)格。顯然如果你不是運行在Java 5上，XML風(fēng)格是最佳選擇。XML和@AspectJ 之間權衡的細節將在下面進(jìn)行討論。

XML風(fēng)格對現有的Spring用戶(hù)來(lái)說(shuō)更加習慣。它可以使用在任何Java級別中（參考連接點(diǎn)表達式內部的命名連接點(diǎn)，雖然它也需要Java 5） 并且通過(guò)純粹的POJO來(lái)支持。當使用AOP作為工具來(lái)配置企業(yè)服務(wù)時(shí)（一個(gè)好的例子是當你認為連接點(diǎn)表達式是你的配置中的一部分時(shí)， 你可能想單獨更改它）XML會(huì )是一個(gè)很好的選擇。對于XML風(fēng)格，從你的配置中可以清晰的表明在系統中存在那些切面。

XML風(fēng)格有兩個(gè)缺點(diǎn)。第一是它不能完全將需求實(shí)現的地方封裝到一個(gè)位置。DRY原則中說(shuō)系統中的每一項知識都必須具有單一、無(wú)歧義、權威的表示。 當使用XML風(fēng)格時(shí)，如何實(shí)現一個(gè)需求的知識被分割到支撐類(lèi)的聲明中以及XML配置文件中。當使用@AspectJ風(fēng)格時(shí)就只有一個(gè)單獨的模塊 -切面- 信息被封裝了起來(lái)。 第二是XML風(fēng)格同@AspectJ風(fēng)格所能表達的內容相比有更多的限制：僅僅支持"singleton"切面實(shí)例模型，并且不能在XML中組合命名連接點(diǎn)的聲明。 例如，在@AspectJ風(fēng)格中我們可以編寫(xiě)如下的內容：

  @Pointcut(execution(* get*()))public void propertyAccess() {}@Pointcut(execution(org.xyz.Account+ *(..))public void operationReturningAnAccount() {}@Pointcut(propertyAccess() && operationReturningAnAccount())public void accountPropertyAccess() {}

在XML風(fēng)格中能聲明開(kāi)頭的兩個(gè)連接點(diǎn)：

  <aop:pointcut id="propertyAccess"expression="execution(* get*())"/><aop:pointcut id="operationReturningAnAccount"expression="execution(org.xyz.Account+ *(..))"/>

但是不能通過(guò)組合這些來(lái)定義accountPropertyAccess連接點(diǎn)

@AspectJ風(fēng)格支持其它的實(shí)例模型以及更豐富的連接點(diǎn)組合。它具有將將切面保持為一個(gè)模塊單元的優(yōu)點(diǎn)。 還有一個(gè)優(yōu)點(diǎn)就是@AspectJ切面能被Spring AOP和AspectJ兩者都理解 - 所以如果稍后你認為你需要AspectJ 的能力去實(shí)現附加的需求，那么你非常容易轉移到基于A(yíng)spectJ的途徑?？偠灾?，我們更喜歡@AspectJ風(fēng)格只要你有切面 去做超出簡(jiǎn)單的“配置”企業(yè)服務(wù)之外的事情。

Spring容器對application context中定義的bean進(jìn)行實(shí)例化和配置。 同樣也可以通過(guò)bean factory來(lái)為一個(gè)已經(jīng)存在且已經(jīng)定義為spring bean的對象應用所包含的配置信息。 spring-aspects.jar中包含了一個(gè)annotation-driven的切面，提供了能為任何對象進(jìn)行依賴(lài)注入的能力。 這樣的支持旨在為 脫離容器管理 創(chuàng )建的對象進(jìn)行依賴(lài)注入。 Domain object經(jīng)常處于這樣的情形：它們可能是通過(guò) new 操作符創(chuàng )建的對象， 也可能是ORM工具查詢(xún)數據庫的返回結果對象。

包 org.springframework.orm.hibernate.support 中的類(lèi) DependencyInjectionInterceptorFactoryBean 可以讓Spring為Hibernate創(chuàng )建并且配置prototype類(lèi)型的domain object（使用自動(dòng)裝配或者確切命名的bean原型定義）。 當然，攔截器不支持配置你編程方式創(chuàng )建的對象而非檢索數據庫返回的對象。 其他framework也會(huì )提供類(lèi)似的技術(shù)。仍是那句話(huà)，Be Pragramatic選擇能滿(mǎn)足你需求的方法中最簡(jiǎn)單的那個(gè)。 請注意前面提及的類(lèi) 沒(méi)有 隨Spring發(fā)行包一起發(fā)布。 如果你希望使用該類(lèi)，需要從Spring CVS Respository上下載并且自行編譯。 你可以在Spring CVS respository下的 ‘sandbox‘ 目錄下找到該文件。

@Configurable 注解標記了一個(gè)類(lèi)可以通過(guò)Spring-driven方式來(lái)配置。 在最簡(jiǎn)單的情況下，我們只把它當作標記注解：

package com.xyz.myapp.domain;import org.springframework.beans.factory.annotation.Configurable;@Configurablepublic class Account {...}

當只是簡(jiǎn)單地作為一個(gè)標記接口來(lái)使用的時(shí)候，Spring將采用和該已注解的類(lèi)型（比如Account類(lèi)）全名 （com.xyz.myapp.domain.Account）一致的bean原型定義來(lái)配置一個(gè)新實(shí)例。 由于一個(gè)bean默認的名字就是它的全名，所以一個(gè)比較方便的辦法就是省略定義中的id屬性：

<bean class="com.xyz.myapp.domain.Account" scope="prototype"><property name="fundsTransferService" ref="fundsTransferService"/>...</bean>

如果你希望明確的指定bean原型定義的名字，你可以在注解中直接定義：

package com.xyz.myapp.domain;import org.springframework.beans.factory.annotation.Configurable;@Configurable("account")public class Account {...}

Spring會(huì )查找名字為"account"的bean定義，并使用它作為原型定義來(lái)配置一個(gè)新的Account對象。

你也可以使用自動(dòng)裝配來(lái)避免手工指定原型定義的名字。 只要設置 @Configurable 注解中的autowire屬性就可以讓Spring來(lái)自動(dòng)裝配了： @Configurable(autowire=Autowire.BY_TYPE) 或者 @Configurable(autowire=Autowire.BY_NAME，這樣就可以按類(lèi)型或者按名字自動(dòng)裝配了。

最后，你可以設置 dependencyCheck 屬性，通過(guò)設置，Spring對新創(chuàng )建和配置的對象的對象引用進(jìn)行校驗 （例如：@Configurable(autowire=Autowire.BY_NAME,dependencyCheck=true) ）。 如果這個(gè)屬性被設為true，Spring會(huì )在配置結束后校驗除了primitives和collections類(lèi)型的所有的屬性是否都被賦值了。

僅僅使用注解并沒(méi)有做任何事情。但當注解存在時(shí)，spring-aspects.jar中的 AnnotationBeanConfigurerAspect 就起作用了。 實(shí)質(zhì)上切面做了這些：當初始化一個(gè)有 @Configurable 注解的新對象時(shí)，Spring按照注解中的屬性來(lái)配置這個(gè)新創(chuàng )建的對象。 要實(shí)現上述的操作，已注解的類(lèi)型必須由AspectJ weaver來(lái)織入 - 你可以使用一個(gè) build-time ant/maven任務(wù)來(lái)完成 （參見(jiàn)AspectJ Development Environment Guide） 或者使用load-time weaving（參見(jiàn) Section 6.8.4, “在Spring應用中使用AspectJ Load-time weaving（LTW）”）。

類(lèi) AnnotationBeanConfigurerAspect 本身也需要Spring來(lái)配置（獲得bean factory的引用，使用bean factory配置新的對象）。 為此Spring AOP命名空間定義了一個(gè)非常方便的標簽。如下所示，可以很簡(jiǎn)單的在application context配置文件包含這個(gè)標簽中。

<aop:spring-configured/>

如果你使用DTD代替Schema，對應的定義如下：

<beanclass="org.springframework.beans.factory.aspectj.AnnotationBeanConfigurerAspect"factory-method="aspectOf"/>

在切面配置完成 之前 創(chuàng )建的@Configurable對象實(shí)例會(huì )導致在log中留下一個(gè)warning，并且任何對于該對象的配置都不會(huì )生效。 舉一個(gè)例子，一個(gè)Spring管理配置的bean在被Spring初始化的時(shí)候創(chuàng )建了一個(gè)domain object。 對于這樣的情況，你需要定義bean屬性中的"depends-on"屬性來(lái)手動(dòng)指定該bean依賴(lài)于configuration切面。

<bean id="myService"class="com.xzy.myapp.service.MyService"depends-on="org.springframework.beans.factory.aspectj.AnnotationBeanConfigurerAspect">...</bean>

除了 @Configurable 支持，spring-aspects.jar包含了一個(gè)AspectJ切面可以用來(lái)為那些使用了 @Transactional annotation 的類(lèi)型和方法驅動(dòng)Spring事務(wù)管理（參見(jiàn) Chapter 9, 事務(wù)管理）。 提供這個(gè)的主要目的是有些用戶(hù)希望脫離Spring容器使用Spring的事務(wù)管理。

解析@Transactional annotations的切面是AnnotationTransactionAspect。 當使用這個(gè)切面時(shí)，你必須注解這個(gè)實(shí)現類(lèi)（和/或這個(gè)類(lèi)中的方法），而不是這個(gè)類(lèi)實(shí)現的接口（如果有）。 AspectJ允許在接口上注解的Java規則 不被繼承。

類(lèi)之上的一個(gè)@Transactional注解為該類(lèi)中任何public操作的執行指定了默認的事務(wù)語(yǔ)義。

類(lèi)內部方法上的一個(gè)@Transactional注解會(huì )覆蓋類(lèi)注解（如果存在）所給定的默認的事務(wù)語(yǔ)義。 具有public、protected和default修飾符的方法都可以被注解。直接注解protected和default方法是讓這個(gè)操作的執行 獲得事務(wù)劃分的唯一途徑。

對于A(yíng)spectJ程序員，希望使用Spring管理配置和事務(wù)管理支持，不過(guò)他們不想（或者不能）使用注解，spring-aspects.jar也包含了一些抽象切面供你繼承來(lái)提供你自己的切入點(diǎn)定義。 參見(jiàn) AbstractBeanConfigurerAspect 和 AbstractTransactionAspect 的Javadoc獲取更多信息。 作為一個(gè)例子，下面的代碼片斷展示了如何編寫(xiě)一個(gè)切面，然后通過(guò)bean原型定義中和類(lèi)全名匹配的來(lái)配置domian object中所有的實(shí)例：

public aspect DomainObjectConfiguration extends AbstractBeanConfigurerAspect {public DomainObjectConfiguration() {setBeanWiringInfoResolver(new ClassNameBeanWiringInfoResolver());}// the creation of a new bean (any object in the domain model)protected pointcut beanCreation(Object beanInstance) :initialization(new(..)) &&SystemArchitecture.inDomainModel() &&this(beanInstance);}

當在Spring application中使用AspectJ的時(shí)候，很自然的會(huì )想到用Spring來(lái)管理這些切面。 AspectJ runtime自身負責切面的創(chuàng )建，這意味著(zhù)通過(guò)Spring來(lái)管理AspectJ 創(chuàng )建切面依賴(lài)于切面所使用的AspectJ instantiation model(per-clause)。

大多數AspectJ切面都是 singleton 切面。 管理這些切面非常容易，和通常一樣創(chuàng )建一個(gè)bean定義引用該切面類(lèi)型就可以了，并且在bean定義中包含 ‘factory-method="aspectOf"‘ 這個(gè)屬性。 這確保Spring從AspectJ獲取切面實(shí)例而不是嘗試自己去創(chuàng )建該實(shí)例。示例如下：

<bean id="profiler" class="com.xyz.profiler.Profiler"factory-method="aspectOf"><property name="profilingStrategy" ref="jamonProfilingStrategy"/></bean>

對于non-singleton的切面，最簡(jiǎn)單的配置管理方法是定義一個(gè)bean原型定義并且使用@Configurable支持，這樣就可以在切面被AspectJ runtime創(chuàng )建后管理它們。

如果你希望一些@AspectJ切面使用AspectJ來(lái)織入（例如使用load-time織入domain object） 和另一些@AspectJ切面使用Spring AOP，而這些切面都是由Spring來(lái)管理的，那你就需要告訴Spring AOP @AspectJ自動(dòng)代理支持那些切面需要被自動(dòng)代理。 你可以通過(guò)在 <aop:aspectj-autoproxy> 聲明中使用一個(gè)或多個(gè) <include/>。 每一個(gè)指定了一種命名格式，只有bean命名至少符合其中一種情況下才會(huì )使用Spring AOP自動(dòng)代理配置：

<aop:aspectj-autoproxy><include name="thisBean"/><include name="thatBean"/></aop:aspectj-autoproxy>

Load-time weaving（LTW）指的是在虛擬機載入字節碼文件時(shí)動(dòng)態(tài)織入AspectJ切面。 關(guān)于LTW的詳細信息，請查看 LTW section of the AspectJ Development Environment Guide。 在這里我們重點(diǎn)來(lái)看一下Java 5環(huán)境下Spring應用如何配置LTW。

LTW需要定義一個(gè) aop.xml，并將其置于META-INF目錄。 AspectJ會(huì )自動(dòng)查找所有可見(jiàn)的classpath下的META-INF/aop.xml文件，并且通過(guò)定義內容的合集來(lái)配置自身。

一個(gè)基本的META-INF/aop.xml文件應該如下所示：

<!DOCTYPE aspectj PUBLIC"-//AspectJ//DTD//EN"	"http://www.eclipse.org/aspectj/dtd/aspectj.dtd"><aspectj><weaver><include within="com.xyz.myapp..*"/></weaver></aspectj>

‘<include/>‘的內容告訴AspectJ那些類(lèi)型需要被納入織入過(guò)程。使用包名前綴并加上"..*"（表示該子包中的所有類(lèi)型）是一個(gè)不錯的默認設定。 使用include元素是非常重要的，不然AspectJ會(huì )查找每一個(gè)應用里面用到的類(lèi)型（包括Spring的庫和其它許多相關(guān)庫）。通常你并不希望織入這些類(lèi)型并且不愿意承擔AspectJ嘗試去匹配的開(kāi)銷(xiāo)。

希望在日志中記錄LTW的活動(dòng)，請添加如下選項：

<!DOCTYPE aspectj PUBLIC"-//AspectJ//DTD//EN"    "http://www.eclipse.org/aspectj/dtd/aspectj.dtd"><aspectj><weaveroptions="-showWeaveInfo-XmessageHandlerClass:org.springframework.aop.aspectj.AspectJWeaverMessageHandler"><include within="com.xyz.myapp..*"/></weaver></aspectj>

最后，如果希望精確的控制使用哪些切面，可以使用 aspects。 默認情況下所有定義的切面都將被織入（spring-aspects.jar包含了META-INF/aop.xml，定義了配置管理和事務(wù)管理切面）。 如果你在使用spring-aspects.jar，但是只希望使用配制管理切面而不需要事務(wù)管理的話(huà)，你可以像下面那樣定義：

<!DOCTYPE aspectj PUBLIC"-//AspectJ//DTD//EN"	"http://www.eclipse.org/aspectj/dtd/aspectj.dtd"><aspectj><aspects><include within="org.springframework.beans.factory.aspectj.AnnotationBeanConfigurerAspect"/></aspects><weaveroptions="-showWeaveInfo -XmessageHandlerClass:org.springframework.aop.aspectj.AspectJWeaverMessageHandler"><include within="com.xyz.myapp..*"/></weaver></aspectj>

在Java 5平臺下，LTW可以通過(guò)虛擬機的參數來(lái)啟用。

-javaagent:<path-to-ajlibs>/aspectjweaver.jar