我的漫漫程序之旅

Spring AOP 支持在切入點表達式中使用如下的AspectJ切入點指定者：

切入點表達式可以使用using '&&', '||' 和 '!'來合并.還可以通過名字來指向切入點表達式。 以下的例子展示了三種切入點表達式： anyPublicOperation（在一個方法執(zhí)行連接點代表了任意public方法的執(zhí)行時匹配）； inTrading（在一個代表了在交易模塊中的任意的方法執(zhí)行時匹配） 和 tradingOperation（在一個代表了在交易模塊中的任意的公共方法執(zhí)行時匹配）。

@Pointcut("execution(public * *(..))")

    private void anyPublicOperation() {}



    @Pointcut("within(com.xyz.someapp.trading..*")

    private void inTrading() {}



    @Pointcut("anyPublicOperation() && inTrading()")

    private void tradingOperation() {}

就上所示的，從更小的命名組件來構建更加復雜的切入點表達式是一種最佳實踐。 當用名字來指定切入點時使用的是常見的Java成員可視性訪問規(guī)則。 （比如說，你可以在同一類型中訪問私有的切入點，在繼承關系中訪問受保護的切入點，可以在任意地方訪問公共切入點。 成員可視性訪問規(guī)則不影響到切入點的 匹配。

當開發(fā)企業(yè)級應用的時候，你通常會想要從幾個切面來參考模塊化的應用和特定操作的集合。 我們推薦定義一個“SystemArchitecture”切面來捕捉常見的切入點表達式。一個典型的切面可能看起來像下面這樣：

package com.xyz.someapp;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;

@Aspect
public 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() {}

}

示例中的切入點定義一個你可以在任何需要切入點表達式的地方可引用的切面。比如，為了使service層事務化，你可以寫：

<aop:config>
  <aop:advisor
      pointcut="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>

在 Section 6.3, “Schema-based AOP support” 中討論 <aop:config> 和 <aop:advisor>標簽。 在 Chapter 9, 事務管理 中討論事務標簽。

Spring AOP 用戶可能會經常使用 execution pointcut designator。執(zhí)行表達式的格式如下：

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

除了返回類型模式，名字模式和參數(shù)模式以外，所有的部分都是可選的。 返回類型模式決定了方法的返回類型必須依次匹配一個連接點。 你會使用的最頻繁的返回類型模式是 *，它代表了匹配任意的返回類型。 一個全稱限定的類型名將只會匹配返回給定類型的方法。名字模式匹配的是方法名。 你可以使用 * 通配符作為所有或者部分命名模式。 參數(shù)模式稍微有點復雜：() 匹配了一個不接受任何參數(shù)的方法， 而 (..) 匹配了一個接受任意數(shù)量參數(shù)的方法（零或者更多）。 模式 (*) 匹配了一個接受一個任何類型的參數(shù)的方法。 模式 (*,String) 匹配了一個接受兩個參數(shù)的方法，第一個可以是任意類型，第二個則必須是String類型。 請參見AspectJ編程指南的 Language Semantics 部分。

下面給出一些常見切入點表達式的例子。

通知是跟一個切入點表達式關聯(lián)起來的，并且在切入點匹配的方法執(zhí)行之前或者之后或者之前和之后運行。 切入點表達式可能是指向已命名的切入點的簡單引用或者是一個已經聲明過的切入點表達式。

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() {
// ...
}
}

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() {
// ...
}
}

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) {
// ...
}
}

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() {
// ...
}
}

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) {
// ...
}
}

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() {
// ...
}
}

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

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

@Aspect
public 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() {
//..
}
}

doBeforeOne
doBeforeTwo
foo
doAfterOne
doAfterTwo

引入（Introductions）（在AspectJ中被稱為inter-type聲明）使得一個切面可以定義被通知對象實現(xiàn)一個給定的接口，并且可以代表那些對象提供具體實現(xiàn)。

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

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

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

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

默認情況下，在application context中每一個切面都會有一個實例。 AspectJ 把這個叫做單個實例化模型（singleton instantiation model）。 也可以用其他的生命周期來定義切面：- Spring支持AspectJ的 perthis 和 pertarget 實例化模型 （現(xiàn)在還不支持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對象執(zhí)行時都會創(chuàng)建一個切面實例（切入點表達式所匹配的連接點上的每一個獨立的對象都會綁定到'this'上）。 service對象的每個方法在第一次執(zhí)行的時候創(chuàng)建切面實例。切面在service對象失效的同時失效。 在切面實例被創(chuàng)建前，所有的通知都不會被執(zhí)行，一旦切面對象創(chuàng)建完成，定義的通知將會在匹配的連接點上執(zhí)行，但是只有當service對象是和切面關聯(lián)的才可以。 如果想要知道更多關于per-clauses的信息，請參閱 AspectJ 編程指南。

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

現(xiàn)在你已經看到了每個獨立的部分是如何運作的了，是時候把他們放到一起做一些有用的事情了！

因為樂觀鎖的關系，有時候business services可能會失敗（有人甚至在一開始運行事務的時候就失敗了）。如果重新嘗試一下，很有可能就會成功。 對于business services來說，重試幾次是很正常的（Idempotent操作不需要用戶參與，否則會得出矛盾的結論） 我們可能需要透明的重試操作以避免讓客戶看見 OptimisticLockingFailureException 例外被拋出。 很明顯，在一個橫切多層的情況下，這是非常有必要的，因此通過切面來實現(xiàn)是很理想的。

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

@Aspect
public class OptimisticOperationExecutor 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 doOptimisticOperation(ProceedingJoinPoint pjp) throws Throwable {
int numAttempts = 0;
OptimisticLockingFailureException lockFailureException;
do {
numAttempts++;
try {
return pjp.proceed();
}
catch(OptimisticLockingFailureException ex) {
lockFailureException = ex;
}
}
while(numAttempts <= this.maxRetries);
throw lockFailureException;
}
}

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

對應的Spring配置如下：

<aop:aspectj-autoproxy/>

<bean id="optimisticOperationExecutor"

class="com.xyz.myapp.service.impl.OptimisticOperationExecutor">

<property name="maxRetries" value="3"/>

<property name="order" value="100"/>

</bean>

為了改進切面，使之僅僅重試idempotent操作，我們可以定義一個 Idempotent 注解：

@Retention(RetentionPolicy.RUNTIME)

public @interface Idempotent {

// marker annotation

}

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

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

如果你無法使用Java 5，或者你比較喜歡使用XML格式，Spring2.0也提供了使用新的"aop"命名空間來定義一個切面。 和使用@AspectJ風格完全一樣，切入點表達式和通知類型同樣得到了支持，因此在這一節(jié)中我們將著重介紹新的 語法 和回顧前面我們所討論的如何寫一個切入點表達式和通知參數(shù)的綁定等等（Section 6.2, “@AspectJ支持”)。

使用本章所介紹的aop命名空間標簽（aop namespace tag），你需要引入Appendix A, XML Schema-based configuration中提及的spring-aop schema。 參見Section A.2.6, “The aop schema”。

在Spring的配置文件中，所有的切面和通知器都必須定義在 <aop:config> 元素內部。 一個application context可以包含多個 <aop:config>。 一個 <aop:config> 可以包含pointcut，advisor和aspect元素，并且三者必須按照這樣的順序進行聲明。

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

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

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

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

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

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

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

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

public void doAccessCheck(Object retVal) {...

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

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

public void doRecoveryActions(DataAccessException dataAccessEx) {...

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

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

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

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

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

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

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

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

public class OptimisticOperationExecutor 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 doOptimisticOperation(ProceedingJoinPoint pjp) throws Throwable {
int numAttempts = 0;
OptimisticLockingFailureException lockFailureException;
do {
numAttempts++;
try {
return pjp.proceed();
}
catch(OptimisticLockingFailureException ex) {
lockFailureException = ex;
}
}
while(numAttempts <= this.maxRetries);
throw lockFailureException;
}
}

<aop:config>
<aop:aspect id="optimisticOperationRetry" ref="optimisticOperationExecutor">
<aop:pointcut id="idempotentOperation"
expression="execution(* com.xyz.myapp.service.*.*(..))"/>
<aop:around
pointcut-ref="idempotentOperation"
method="doOptimisticOperation"/>
</aop:aspect>
</aop:config>
<bean id="optimisticOperationExecutor"
class="com.xyz.myapp.service.impl.OptimisticOperationExecutor">
<property name="maxRetries" value="3"/>
<property name="order" value="100"/>
</bean>

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

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

我們完全可以混合使用以下幾種風格的切面定義：使用自動代理的@AspectJ 風格的切面，schema-defined <aop:aspect> 的切面，和用 <aop:advisor> 聲明的advisor，甚至是使用Spring 1.2風格的代理和攔截器。 由于以上幾種風格的切面定義的都使用了相同的底層機制，因此可以很好的共存。

Spring AOP部分使用JDK動態(tài)代理或者CGLIB來為目標對象創(chuàng)建代理。（建議盡量使用JDK的動態(tài)代理）

如果被代理的目標對象實現(xiàn)了至少一個接口，則會使用JDK動態(tài)代理。所有該目標類型實現(xiàn)的接口都將被代理。若該目標對象沒有實現(xiàn)任何接口，則創(chuàng)建一個CGLIB代理。

如果你希望強制使用CGLIB代理，（例如：希望代理目標對象的所有方法，而不只是實現(xiàn)自接口的方法）那也可以。但是需要考慮以下問題:

強制使用CGLIB代理需要將 <aop:config> 的 proxy-target-class 屬性設為true:

<aop:config proxy-target-class="true">
...
</aop:config>

請注意這個屬性的設置僅對 每一個<aop-config/> 有效； 你可能有多個 <aop-config/>，其中有的強制使用CGLIB代理，有的沒有。

當需要使用CGLIB代理和@AspectJ自動代理支持，請按照如下的方式設置 <aop:aspectj-autoproxy> 的 proxy-target-class 屬性：

<aop:aspectj-autoproxy proxy-target-class="true"/>

除了在配置文件中使用 <aop:config> 或者 <aop:aspectj-autoproxy> 來聲明切面。 同樣可以通過編程方式來創(chuàng)建代理通知（advise）目標對象。關于Spring AOP API的詳細介紹，請參看下一章。這里我們重點介紹自動創(chuàng)建代理。

類 org.springframework.aop.aspectj.annotation.AspectJProxyFactory 可以為@AspectJ切面的目標對象創(chuàng)建一個代理。該類的基本用法非常簡單，示例如下。請參看Javadoc獲取更詳細的信息。

// create a factory that can generate a proxy for the given target object
AspectJProxyFactory factory = new AspectJProxyFactory(targetObject);
// add an aspect, the class must be an @AspectJ aspect
// you can call this as many times as you need with different aspects
factory.addAspect(SecurityManager.class);
// you can also add existing aspect instances, the type of the object
// supplied must be an @AspectJ aspect
factory.addAspect(usageTracker);
// now get the proxy object...
MyInterfaceType proxy = factory.getProxy();

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

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

@Configurable 注解標記了一個類可以通過Spring-driven方式來配置。 在最簡單的情況下，我們只把它當作標記注解：

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

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

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

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

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

Spring會查找名字為"account"的bean定義，并使用它作為原型定義來配置一個新的Account對象。

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

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

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

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

<aop:spring-configured/>

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

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

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

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

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

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

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的時候，很自然的會想到用Spring來管理這些切面。 AspectJ runtime自身負責切面的創(chuàng)建，這意味著通過Spring來管理AspectJ 創(chuàng)建切面依賴于切面所使用的AspectJ instantiation model(per-clause)。

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

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

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

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

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

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

LTW需要定義一個 aop.xml，并將其置于META-INF目錄。 AspectJ會自動查找所有可見的classpath下的META-INF/aop.xml文件，并且通過定義內容的合集來配置自身。

一個基本的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那些類型需要被納入織入過程。使用包名前綴并加上"..*"（表示該子包中的所有類型）是一個不錯的默認設定。 使用include元素是非常重要的，不然AspectJ會查找每一個應用里面用到的類型（包括Spring的庫和其它許多相關庫）。通常你并不希望織入這些類型并且不愿意承擔AspectJ嘗試去匹配的開銷。

希望在日志中記錄LTW的活動，請?zhí)砑尤缦逻x項：

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

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

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

<weaver

options="-showWeaveInfo,-XmessageHandlerClass:org.springframework.aop.aspectj.AspectJWeaverMessageHandler">

<include within="com.xyz.myapp..*"/>

</weaver>

</aspectj>

在Java 5平臺下，LTW可以通過虛擬機的參數(shù)來啟用。

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