注意，文档还在不断修改中，建议直接看Wiki 上的最新版本。

1. 需要Spring 依赖注入的测试

   为了测试Spring管理下的Bean，可以自行构造BeanFactory，也可以继承于AbstractDependencyInjectionSpringContextTests，实现public String[] getConfigLocations()函数， 返回applicationContext文件路径的数组。

 protectedString[] getConfigLocations() {        returnnewString[]{"classpath*:spring/*.xml",  "classpath*:spring/test/*.xml"}; } 

  并显式写一些需要注入的变量的setter函数。

    tips1：此基类有一个applicationContext的成员变量，所以除了依靠setter注入外，还可以随时用applicationContext.getBean() 取出所需的bean。 

    tips2：注意此基类 默认是autowire by type的，所以如果context文件里有两个相同类型的Bean就会报错，可能需要在getConfigLocations()函数里，setAutowireMode(AUTOWIRE_BY_NAME);把它设回by name，或者取消setter函数，自行用applicationContext.getBean()来显式查找Bean。

2. Dao测试

AbstractTransactionalDataSourceSpringContextTests 继承于AbstractDependencyInjectionSpringContextTests，除了拥有上类的能力外，还管理了每个测试的事务，会在每个测试后默认回滚所有的操作。

深层解释：此类的实现其实依赖于Application Context中定义的 PlatformTransactionManager。由于使用了Autowrie by type，可以任意取名。

         另依赖于Application Context中定义的DataSource，同样可以任意取名。 

tips1：如果需要在测试后提交，需要setRollBack(false); 或者调用setComplete()

tips2：此基类还通过注入的DataSource创建了一个JDBCTemplate 变量，可以跑SQL帮忙核对Hibernate的结果，Spring将确保该查询在同一个事务内执行。为正常工作你需要告诉你的ORM工具'刷新'它的已改变内容，例如使用Hibernate Session 接口的 flush() 方法。

tips3：除了tips2以外，还有countRowsInTable(String tableName)，deleteFromTables(String[] names) ，executeSqlScript(String sqlResourcePath, boolean continueOnError)三个简便函数。

3. Controller测试

Controller测试一般要用MockObject 分离Service层，要copy WEB-INF/下的相关文件copy 到classpath，而且Controller不含太多的逻辑，所有测试controller有点吃力不讨好，建议直接用Selenium进行集成测试，见(Selenium测试概述)。

4.SpringSide里的测试

因为Spring默认的基类名字较长，SpringSide 在core 的org.springside.core.test 中重新继承了它们，并提供了默认读取所有按springside 文件存放规则存放的context 文件的getConfigLocations()函数。

默认读取所有context文件的getConfigLocations()函数对速度和测试的隔离化都有影响，可以在子类重新实现。不过自己重新一个个写相关context文件也好烦，而且其实在全lazy-load的情况下，速度也还可以接受。如何取舍要自己平衡了。

对于CRUD的测试，在helloworld示例里的变量名都作了泛化，可以快速copy到另一个测试里。

另外，留意resources/spring/test 下的文件，利用了Spring的PropertyOverrideConfigurer，新设定测试时的ApplicatonContext 里各个Bean的属性如指定测试用的DataSource，详细用法见Spring配置要点。

    <bean id="methodInvokingJobDetail"

        class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">

        <property name="targetObject"><ref bean="financeDAO"/></property>

        <property name="targetMethod"><value>confirmOrder</value></property>

    </bean>

    <bean id="cronTrigger" class="org.springframework.scheduling.quartz.CronTriggerBean">

        <property name="jobDetail">

            <ref bean="methodInvokingJobDetail"/>

        </property>

        <property name="cronExpression">

            <value>0 0 6,12,20 * * ?</value>

        </property>

    </bean>

    <bean class="org.springframework.scheduling.quartz.SchedulerFactoryBean">

        <property name="triggers">

            <list><ref local="cronTrigger"/></list>

        </property>

    </bean>

上面这段配置文件规定了在早上6点和晚上8点执行financeDAO对象的confirmOrder()方法.

附：cronExpression配置说明

Cron表达式的时间字段除允许设置数值外，还可使用一些特殊的字符，提供列表、范围、通配符等功能，细说如下：

●星号(*)：可用在所有字段中，表示对应时间域的每一个时刻，例如，*在分钟字段时，表示“每分钟”；

●问号（?）：该字符只在日期和星期字段中使用，它通常指定为“无意义的值”，相当于点位符；

●减号(-)：表达一个范围，如在小时字段中使用“10-12”，则表示从10到12点，即10,11,12；

●逗号(,)：表达一个列表值，如在星期字段中使用“MON,WED,FRI”，则表示星期一，星期三和星期五；

●斜杠(/)：x/y表达一个等步长序列，x为起始值，y为增量步长值。如在分钟字段中使用0/15，则表示为0,15,30和45秒，而5/15在分钟字段中表示5,20,35,50，你也可以使用*/y，它等同于0/y；

●L：该字符只在日期和星期字段中使用，代表“Last”的意思，但它在两个字段中意思不同。L在日期字段中，表示这个月份的最后一天，如一月的31号，非闰年二月的28号；如果L用在星期中，则表示星期六，等同于7。但是，如果L出现在星期字段里，而且在前面有一个数值X，则表示“这个月的最后X天”，例如，6L表示该月的最后星期五；

●W：该字符只能出现在日期字段里，是对前导日期的修饰，表示离该日期最近的工作日。例如15W表示离该月15号最近的工作日，如果该月15号是星期六，则匹配14号星期五；如果15日是星期日，则匹配16号星期一；如果15号是星期二，那结果就是15号星期二。但必须注意关联的匹配日期不能够跨月，如你指定1W，如果1号是星期六，结果匹配的是3号星期一，而非上个月最后的那天。W字符串只能指定单一日期，而不能指定日期范围；

●LW组合：在日期字段可以组合使用LW，它的意思是当月的最后一个工作日；

●井号(#)：该字符只能在星期字段中使用，表示当月某个工作日。如6#3表示当月的第三个星期五(6表示星期五，#3表示当前的第三个)，而4#5表示当月的第五个星期三，假设当月没有第五个星期三，忽略不触发；

● C：该字符只在日期和星期字段中使用，代表“Calendar”的意思。它的意思是计划所关联的日期，如果日期没有被关联，则相当于日历中所有日期。例如5C在日期字段中就相当于日历5日以后的第一天。1C在星期字段中相当于星期日后的第一天。Cron表达式对特殊字符的大小写不敏感，对代表星期的缩写英文大小写也不敏感。表2下面给出一些完整的Cron表示式的实例：

表2 Cron表示式示例

Spring 标记库介绍及用法：

最近这个段时间都是忙于学习 SpringFramework，那东东好样的，只是刚刚学完Struts，Hibernate，有来了这个，呵呵，，感觉挺累的。
“你怎么把这两个不相干的东西撤到一起？” ，确实是这样！ 无论从他们的设计，
实现，使用等方面他们是风马牛不相及， 但本人认为从理解的方面看他们有点类似。况且学习要从对比中学呀！这对初学者会有帮助于理解。
重要声明：本人都是用自己的语言写的，有专业术语不对还请大家指出。: - )
就说设计模式 Decorator,也就是装饰模式，这还不好理解？ 在原有的东西上进行装饰一下便是装饰了。既然是装饰，你要有主体呀（被修饰的东西），还要有装饰品。但是不管你装饰来装饰去，他的本质是不变的。 就象人带上了面具，但他还是人。墙上打上了油漆，但它还是墙呀。你也许觉得这是废话。 但理解这点很重要(这是跟策略模式Strategy的区别)，本人觉得这个是理解好 Decorator 模式很重要的一点。在开发中你经常要增强一个类的功能，或者是撤销一个类的某些功能，但是一个类给众多的功能进行装饰了以后，也许原来的类已经面目全非了，你往往会感到茫然，其实，你主要抓住他的主体，脑子里面时刻要知道你现在所作的工作就是为这个主体进行打扮的工作。
研究过Jive的都知道， 里面的 Filter 就是用了Decorator 设计模式，那么在这个设计里面，它的主体是什么？ ForumMessage ，无疑是 ForumMessage 。装饰品当然是Filter 了，所以我们在作这件事情的时候始终是以ForumMessage为核心的，Filter 进行装饰的时候，你千万不要忘记你现在是为ForumMessage而工作！有关于jive研究的文章，网上一大堆，现在看看一个比较简单的 Decorator:



//比如有一个抽象构件：
publicinterface Component {
void operation();
}
//一个具体构件：
publicclass ConcreteComponent implements Component {
publicvoid operation() {
//Write your code here
}
}
//一个抽象装饰：
publicclass Decorator implements Component {
private Component component; //引用
… …. …. …
//商业方法，委派给构件
publicvoid operation() {
component.operation();
}
}
//一个具体装饰：
publicclass ConcreteDecorator extends Decorator {
/**
* 商业方法
*/
publicvoid operation(){
//一些具体的装饰的代码
......
super.operation(); // 主体
//一些具体的装饰的代码
.......
}
}

　代碼:

								package onlyfun.caterpillar; 

publicinterface IHello { 
    public void hello(String name); 
    public void morning(String name); 
}

　　實作IHello介面的HelloSpeaker則如下：

　代碼:

								package onlyfun.caterpillar; 

public class HelloSpeaker implements IHello { 
    public void hello(String name) { 
        System.out.println("Hello, " + name); 
    } 

    public void morning(String name) { 
        System.out.println("Morning, " + name); 
    } 
}

　　我們希望在方法執行前後進行記錄的動作，在AOP中這需要Around類型的Advice，通常的，實作Around類型的策略是使用Interceptor。

　　Interceptor的一個例子是Servlet中的Filter機制，在Filter機制下，當請求來臨時，會被Filter先攔截並進行處理，之後傳給下一個Filter，最後才是真正處理請求的Servlet。實作AOP時所使用的Interceptor策略與Filter類似，所不同的是Filter被綁定於Servlet API，且只適用於請求階段。

　　您可以將一連串的Interceptor想成是堆疊結構，在Spring中，在真正執行某個方法前，會先插入Interceptor，每個Interceptor會執行自己的處理，然後再執行proceed，這將執行流程轉給下一個Interceptor，如果沒有下一個Interceptor了，就執行真正呼叫的方法，方法執行過後，再一層一層返回Interceptor堆疊，最後離開堆疊，如下圖，流程先是紅色，方法執行後的流程是藍色：

　代碼:

<-- --> interceptor1 <-- --> interceptor2 <-- --> ..... <-- --> Invoked method

　　Spring在實作Interceptor時，是實作org.aopalliance.intercept.MethodInterceptor，AOP Alliance（http://www.sourceforge.net/projects/aopalliance）的目標是制定AOP功能的標準介面，目前只提供一部份的子集合，子集包括了Interceptor，Spring實作MethodInterceptor，以求將來Interceptor的可移植性。

　　我們實作LogInterceptor如下：

　代碼:

								package onlyfun.caterpillar; 

import org.aopalliance.intercept.MethodInterceptor; 
import org.aopalliance.intercept.MethodInvocation; 
import java.util.logging.*; 

public class LogInterceptor implements MethodInterceptor { 
    private Logger logger = Logger.getLogger(this.getClass().getName()); 
    
   publicObject invoke(MethodInvocation methodInvocation) throws Throwable { 
        logger.log(Level.INFO, "method starts..." + methodInvocation.getMethod()); 
        try { 
          Object result = methodInvocation.proceed(); 
          return result; 
        } 
        finally { 
            logger.log(Level.INFO, "method ends..." + methodInvocation.getMethod() + "\n"); 
        }        
   } 
}

　　invoke()中的MethodInvocation參數包括了下一個Interceptor的資訊、被執行的方法、以及方法所需的參數，其返回值是被呼叫方法的返回值。

　　我們還需要一個代理物件，這可以使用org.springframework.aop.framework.ProxyFactoryBean，它需要知道代理的介面與物件，以及所要介入的Interceptor，如下：

　代碼:

<?xml version="1.0" encoding="UTF-8"?> 
<!DOCTYPE beans PUBLIC "-//SPRING/DTD BEAN/EN""http://www.springframework.org/dtd/spring-beans.dtd"> 
<beans> 
    <bean id="logInterceptor" class="onlyfun.caterpillar.LogInterceptor"/> 

    <bean id="helloSpeaker" class="onlyfun.caterpillar.HelloSpeaker"/> 
    
    <bean id="helloProxy" class="org.springframework.aop.framework.ProxyFactoryBean"> 
        <property name="proxyInterfaces"> 
            <value>onlyfun.caterpillar.IHello</value> 
        </property> 
        <property name="target"> 
            <ref bean="helloSpeaker"/> 
        </property> 
        <property name="interceptorNames"> 
            <list> 
                <value>logInterceptor</value> 
            </list> 
        </property> 
    </bean> 
</beans>

　　Interceptor執行的順序是interceptorNames中設定的順序，最後是target目標物件，使用下面的程式來測試一下：

　代碼:

								package onlyfun.caterpillar; 

import org.springframework.context.*; 
import org.springframework.context.support.*; 

public class SpringTest { 
   publicstatic void main(String[] args) { 
        ApplicationContext context = new FileSystemXmlApplicationContext("bean.xml"); 
        IHello helloProxy = (IHello) context.getBean("helloProxy"); 
        helloProxy.hello("Justin"); 
        helloProxy.morning("momor"); 
    } 
}

　　執行結果如下：

　代碼:

2004/11/26 上午 11:59:09 onlyfun.caterpillar.LogInterceptor invoke 
資訊: method starts...publicabstract void onlyfun.caterpillar.IHello.hello(java.lang.String) 
Hello, Justin 
2004/11/26 上午 11:59:09 onlyfun.caterpillar.LogInterceptor invoke 
資訊: method ends...publicabstract void onlyfun.caterpillar.IHello.hello(java.lang.String) 

2004/11/26 上午 11:59:09 onlyfun.caterpillar.LogInterceptor invoke 
資訊: method starts...publicabstract void onlyfun.caterpillar.IHello.morning(java.lang.String) 
Morning, momor 
2004/11/26 上午 11:59:09 onlyfun.caterpillar.LogInterceptor invoke 
資訊: method ends...publicabstract void onlyfun.caterpillar.IHello.morning(java.lang.String)

　　完成了第一個Spring AOP程式了，不過這當中還有許多細節可以說明，下一個主題再繼續。