Spring对声明式事务管理的支持是通过它的AOP框架实现的。这样做是非常自然的，因为事务是系统级的，凌驾于应用的主要功能之上的。

    在Spring里，事务属性是对事务策略如何应用到方法的描述。这个描述包括：传播行为、隔离级别、只读提示、事务超时间隔
    传播行为：
    PROPAGATION_MANDATORY:表示该方法必须运行在一个事务中。如果当前事务不存在，将抛出一个异常。
    PROPAGATION_NESTED:表示如果当前已经存在一个事务，则该方法应当运行在一个嵌套的事务中。被嵌套的事务可以从当前事务中单独的提交或回滚。如果当前事务不存在，那么它看起来和PROPAGATION_REQUIRED没有两样。
    PROPAGATION_NEVER:表示当前的方法不应该运行在一个事务上下文中。如果当前存在一个事务，则会抛出一个异常。
    PROPAGATION_NOT_SUPPORTED:表示该方法不应在事务中运行。如果一个现有的事务正在运行中，它将在该方法的运行期间被挂起。
    PROPAGATION_REQUIRED:表示当前方法必须运行在一个事务中。如果一个现有的事务正在运行中，该方法将运行在这个事务中。否则的话，要开始一个新的事务。
    PROPAGATION_REQUIRES_NEW:表示当前方法必须运行在它自己的事务里。它将启动一个新的事务。如果有事务运行的话，将在这个方法运行期间被挂起。
    PROPAGATION_SUPPORTS:表示当前方法不需要事务处理环境，但如果有一个事务已经在运行的话，这个方法也可以在这个事务里运行。

   传播规则回答了一个问题：就是新的事务是否要被启动或是被挂起，或者方法是否要在事务环境中运行。

   隔离级别：在一个典型的应用中，多个事务并发运行，经常会操作同一个数据来完成它们的任务。并发，虽然是必须的，但会导致下面问题：
1、脏读：脏读发生在一个事务读取了被另一个事务改写但还未提交的数据时。如果这些改变在稍后被回滚，那么第一个事务读取的数据就是无效的。
2、不可重复读：不可重复读发生在一个事务执行相同的查询2次或2次以上，但每一次查询结果都不同时。这通常是由于另一个并发事务在2次查询之间更新了数据。
3、幻读：幻读和不可重复读相似。当一个事务读取几行纪录后，另一个并发事务插入一些记录，幻读就发生了。隔离级别有如下几个：
ISOLATION_DEFAULT:使用后端数据库默认的隔离级别
ISOLATION_READ_UNCOMMITTED:允许你读取还未提交的改变了的数据，可能导致脏读、幻读、不可重复读
ISOLATION_READ_COMMITTED:允许在并发事务已经提交后读取。可防止脏读，但幻读和不可重复读仍可能发生。
ISOLATION_REPEATABLE_READ:对相同字段的多次读取的结果是一致的，除非数据被事务本身改变。可防止脏读和不可重复读，但幻读仍可能发生。
ISOLATION_SERIALIZABLE:完全服从ACID的隔离级别，确保不发生脏读、不可重复读和幻读。这在所有隔离级别中也是最慢的。

    只读：如果一个事务只对后端是据库执行读操作，数据库就可能利用事务只读的特性，使用某些优化措施。通过声明一个事务为只读，你就给了后端数据库一个机会，来应用那些它认为合适的优化措施。因为只读的优化措施是在事务启动时由后端数据库实施的，所以，只有将那些具有可能启动新事务的传播行为的方法的事务标记成只读才有意义(PROPAGATION_REQUIRED,PROPAGATION_REQUIRES_NEW和PROPAGATION_NESTED) TransactionProxyFactoryBean参照一个方法的事务属性，决定如何在那个方法上执行事务策略。

<?xml version="1.0" encoding="UTF-8"?>
<beans
    xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd">
    <bean id="dataSource" class="org.springframework.jndi.JndiObjectFactoryBean">
        <property name="jndiName">
            <value>java:comp/env/jdbc/myDatasource</value>
        </property>
    </bean>
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource">
            <ref bean="dataSource"/>
        </property>
    </bean>
    <!-- 这个对象有一个值为courseService的id.当应用从应用上下文里请求一个courseService时，它将得到一个被
    TransactionProxyFactoryBean包裹的实例。 -->
    <bean id="courseService" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
        <!-- 代理所实现的接口 -->
        <property name="proxyInterfaces">
            <list>
                <value>
                    com.springinaction.training.service.CourseService
                </value>
            </list>
        </property>
        <!-- 被代理的对象 -->
        <property name="target">
            <ref bean="courseServiceTarget"/>
        </property>
        <!-- 事务管理器 -->
        <property name="transactionManager">
            <ref bean="transactionManager"/>
        </property>
        <!-- 事务的属性源 -->
        <property name="transactionAttributeSource">
            <ref bean="transactionAttributeSource"/>
        </property>
    </bean>
    <!-- 要知道尽管可以改变MatchAlwaysTransactionAttributeSource的事务属性参数，但它总是返回相同的事务属性，而
    不关心参与交易的哪一个方法。当你有一个相对简单的应用，把同样的事务策略应用到所有方法都没问题时，使用MatchAlwaysT
    ransactionAttributeSource就相当好。但是，在那些更为复杂的应用中，你很可能需要对不同的方法应用不同的事务策略。在那样
    情况下，你需要在应用何种策略的问题上做更多精确的控制。 -->
    <bean id="transactionAttributeSource" class="org.springframework.transaction.interceptor.MatchAlwaysTransactionAttributeSource">
        <property name="transactionAttribute">
            <ref bean="myTransactionAttribute"/>
        </property>
    </bean>
    <!-- 定义事务策略 -->
    <bean id="myTransactionAttribute" class="org.springframework.transaction.interceptor.DefaultTransactionAttribute">
        <!-- 传播行为 -->
        <property name="propagationBehaviorName">
            <value>PROPAGATION_REQUIRES_NEW</value>
        </property>
        <!-- 隔离级别 -->
        <property name="isolationLevelName">
            <value>ISOLATION_REPEATABLE_READ</value>
        </property>
    </bean>
</beans>

除了将transactionAttributeSource对象织入到TransactionProxyFactoryBean的transactionAttributeSource属性中外，还有一种简单的方法。发展到现在，TransactionProxyFactoryBean也有一个transactionAttributes属性为transactionProperties.

<?xml version="1.0" encoding="UTF-8"?>
<beans
    xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd">
    <bean id="dataSource" class="org.springframework.jndi.JndiObjectFactoryBean">
        <property name="jndiName">
            <value>java:comp/env/jdbc/myDatasource</value>
        </property>
    </bean>
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource">
            <ref bean="dataSource"/>
        </property>
    </bean>
    <!-- 这个对象有一个值为courseService的id.当应用从应用上下文里请求一个courseService时，它将得到一个被
    TransactionProxyFactoryBean包裹的实例。 -->
    <bean id="courseService" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
        <!-- 代理所实现的接口 -->
        <property name="proxyInterfaces">
            <list>
                <value>
                    com.springinaction.training.service.CourseService
                </value>
            </list>
        </property>
        <!-- 被代理的对象 -->
        <property name="target">
            <ref bean="courseServiceTarget"/>
        </property>
        <!-- 事务管理器 -->
        <property name="transactionManager">
            <ref bean="transactionManager"/>
        </property>
        <!-- 事务的属性源 -->
        <property name="transactionAttributeSource">
            <ref bean="transactionAttributeSource"/>
        </property>
    </bean>
    <!-- NameMatchTransactionAttributeSource的properties属性把方法名映射到事务属性描述器上。注意CourseException
    用一个负号标记。异常可以用负号或正号标记，当负号异常抛出时，将触发回滚;相反的，正号异常表示事务仍可提交，即使这个异常抛出 -->
    <bean id="transactionAttributeSource" class="org.springframework.transaction.interceptor.NameMatchTransactionAttributeSource">
        <property name="properties">
            <props>
                <prop key="enrollStudentInCourse">
                    PROPAGATION_REQUIRES_NEW,ISOLATION_REPEATABLE_READ,readOnly,
                    -CourseException
                </prop>
                <!-- 还可以使用通配符 -->
                <prop key="get*">
                    PROPAGATION_SUPPORTS
                </prop>
            </props>
        </property>
    </bean>
</beans>

package com.testproject.spring.datasource;

import java.sql.CallableStatement;
import java.sql.SQLException;

import org.springframework.jdbc.core.CallableStatementCallback;
import org.springframework.jdbc.core.JdbcTemplate;
/**//*
 * 为了让JdbcTemplate工作，它所需要的，只是一个DataSource实例。
 */
public class StudentDaoImpl implements StudentDao {
    private JdbcTemplate jdbcTemplate;
    
    public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }
    /** *//**
     * 调用存储过程，通过CallableStatementCallback来实现
     */
    public void archiveStudentData(){
        CallableStatementCallback cb = new CallableStatementCallback(){
            public Object doInCallableStatement(CallableStatement cs)throws SQLException{
                cs.execute();
                return null;
            }
        };
        jdbcTemplate.execute("{ARCHIVE_STUDENTS}",cb);
    }
}

把操作创建成对象：

插入：

package com.testproject.spring.datasource;

import java.sql.Types;

import javax.sql.DataSource;

import org.springframework.jdbc.core.SqlParameter;
import org.springframework.jdbc.object.SqlUpdate;
/** *//**
 * Spring提供了一种真正把数据库操作建模成对象的方法，这样就在的代码和直接JDBC之间又加了一个绝缘层。
 * 首先，这些数据库操作对象是线程安全的，意味着对于每个数据库操作，你只需创建一个实例。
 * 其次，任何数据库操作对象必须在运行前先编译一下，这样就让对象知道什么时候可以预备statement,以便在稍后能执行它们。
 * 使用：
 * private InsertPerson insertPerson;
 * public int insertPerson(Person person){
 *     return insertPerson.insert(person);
 * }
 *
 */
public class InsertPerson extends SqlUpdate {
    public InsertPerson(DataSource ds){
        //首先要给sqlUpdate提供一个DataSource,用来创建JdbcTemplate
        setDataSource(ds);
        setSql("insert into person(id,firstName,lastName) values(?,?,?)");
        //其次，我们需要为statement中的每个参数调用这个方法，顺序也是很重要的
        declareParameter(new SqlParameter(Types.NUMERIC));
        declareParameter(new SqlParameter(Types.VARCHAR));
        declareParameter(new SqlParameter(Types.VARCHAR));
        //最后编译它，每个数据库操作对象必须在它被使用之前编译好。
        compile();
    }
    public int insert(Person person){
        Object[] params = new Object[]{
                person.getId(),
                person.getFirstName(),
                person.getLastName()
        };
        return update(params);
    }
}

查询：

package com.testproject.spring.datasource;

import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Types;

import javax.sql.DataSource;

import org.springframework.jdbc.core.SqlParameter;
import org.springframework.jdbc.object.MappingSqlQuery;

/** *//**
 * 使用：
 * private PersonByIdQuery personByIdQuery;
 * public person getPerson(Integer id){
 *     Object[] params = new Object[]{id};
 *  return (Person)personByIdQuery.execute(params).get(0);
 * }
 *
 */
public class PersonByIdQuery extends MappingSqlQuery {
    
    public PersonByIdQuery(DataSource ds){
        super(ds,"select id,first_name,last_name from person where id=?");
        declareParameter(new SqlParameter("id",Types.INTEGER));
        compile();
    }
    
    protected Object mapRow(ResultSet rs, int rowNumber) throws SQLException {
        Person person = new Person();
        person.setId((Integer)rs.getObject("id"));
        person.setFirstName(rs.getString("first_name"));
        person.setLastName(rs.getString("last_name"));
        return person;
    }

}