最近再次拜读了spring的源码，对关于spring事物的应用部分加以整理,做如下笔记。如有不正确的地方，欢迎指正，谢谢。本文大致分为如下板块：

1. 数据库事物
   1.1 ACID
2. spring事物管理
   2.1 PlatformTransactionManager
   2.2 @Transactional
3. 事物管理器
   3.1 jdbc事物管理器
   3.2 hibernate事物管理器
   3.3 其它事物管理器
4. spring 事物的基本行为
   4.1 事物的传播行为
   4.1.1 PROPAGATION_REQUIRED
   4.1.2 PROPAGATION_SUPPORTS
   4.1.3 PROPAGATION_MANDATORY
   4.1.4 PROPAGATION_REQUIRES_NEW
   4.1.5 PROPAGATION_NOT_SUPPORTED
   4.1.6 PROPAGATION_NEVER
   4.1.7 PROPAGATION_NESTED
   4.2 事物的隔离级别
   4.2.1 数据库的隔离问题及级别
   4.2.1.1 隔离问题
   4.2.1.1 隔离级别
   4.2.2 Spirng 的事物隔离级别-Isolation
   4.3 事物的只读属性-readOnly
   4.4 事物的超时时间-timeout
   4.5 回滚规则-rollbackFor
   4.6 其它属性
   总结

1.数据库事物

数据库事物，指的是数据库执行的逻辑单元，这个逻辑单元遵从ACID原则，用这个原则来保证数据的一致性和完整性。反应到数据库上就是一组sql，要么全部执行成功，要么全部执行失败。例如下面sql：

--uid001账户余额增加100块
update user_account set account_balance=account_balance+100 where user_id='uid001';
--uid002账户余额减少100块
update user_account set account_balance=account_balance-100 where user_id='uid002';

1.1 ACID

2.spring事物管理

所谓的事物管理指的是“按照指定事物规则执行提交或者回滚操作”，而spring的事物管理，指的是spring对事物管理规则的抽象。具体来说就是spring不直接管理事物，而是为了不同的平台(如jdbc hibernate jpa 等)提供了不同的事物管理器 ，将具体的事物管理委托给相应的平台实现，spring并不关心具体事物管理的实现，从而为事物管理提供了通用编程模型。

2.1 PlatformTransactionManager

上述通用抽象反应到代码层面就是org.springframework.jdbc.datasource.PlatformTransactionManager 类。

/**
     * 根据不同的事物行为，获取当前事物，或者新建事物。
     * @param definition 事物定义信息，包含事物行为，隔离级别，超时时间等
     * @return org.springframework.transaction.TransactionStatus 代表当前或者新的事物的事物对象
     */
    TransactionStatus getTransaction(TransactionDefinition definition) throws TransactionException;

    /**
     * 就给定的事物状态提交事物。如果事物状态被标记为回滚，则回滚事物
     * @param status 当前事物对象
     */
    void commit(TransactionStatus status) throws TransactionException;

    /**
     * 回滚当前事物
     * @param status 当前事物对象
     */
    void rollback(TransactionStatus status) throws TransactionException;

2.2 @Transactional

spring 中使用事物分为两种，一种是声明式事物，一种是编程式事物。考虑到编程式事物基本很少使用，故下文以声明式事物来介绍spring的事物。而一般我们又比较常用@Transactional来实现事物声明。@Transactional 常用以下属性propagation，tionisolation，readOnly，rollbackFor，rollbackForClassName，noRollbackFor，noRollbackForClassName

3 事物管理器

spring 为不同的平台提供了不同的事物管理器。不同的事物管理器都继承自抽象类org.springframework.transaction.support.AbstractPlatformTransactionManager。该抽象类实现了org.springframework.jdbc.datasource.PlatformTransactionManager ，实现了事物管理器的骨架实现，通过继承该类，仅仅关心平台相关内容即可实现不同的事物管理器。

3.1 jdbc事物管理器

 <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
 </bean>

jdbc 事物管理器是通过javax.sql.DataSource.getConnection() 获取javax.sql.Connection,通过javax.sql.Connection来进行事物的提交和回滚。

    @Override
    protected void doCommit(DefaultTransactionStatus status) {
        DataSourceTransactionObject txObject = (DataSourceTransactionObject) status.getTransaction();
        Connection con = txObject.getConnectionHolder().getConnection();
        if (status.isDebug()) {
            logger.debug("Committing JDBC transaction on Connection [" + con + "]");
        }
        try {
            con.commit();
        }
        catch (SQLException ex) {
            throw new TransactionSystemException("Could not commit JDBC transaction", ex);
        }
    }

    @Override
    protected void doRollback(DefaultTransactionStatus status) {
        DataSourceTransactionObject txObject = (DataSourceTransactionObject) status.getTransaction();
        Connection con = txObject.getConnectionHolder().getConnection();
        if (status.isDebug()) {
            logger.debug("Rolling back JDBC transaction on Connection [" + con + "]");
        }
        try {
            con.rollback();
        }
        catch (SQLException ex) {
            throw new TransactionSystemException("Could not roll back JDBC transaction", ex);
        }
    }

3.2 hibernate事物管理器

    <bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
        <property name="sessionFactory" ref="sessionFactory" />
    </bean>

HibernateTransactionManager 是通过绑定org.hibernate.SessionFactory来实现的 ，通过sessionFactory来绑定org.hibernate.Transaction，提交或者回滚的时候调用org.hibernate.Transaction的commit或者rollback来操作。

3.3 其它spring事物管理器

除了上面介绍的两个常用的事物管理器之外，spring还提供了其它的事物管理器。如 org.springframework.orm.jpa，org.springframework.transaction.jta.JtaTransactionManager，org.springframework.jms.connection.JmsTransactionManager,org.springframework.transaction.jta.WebLogicJtaTransactionManager等。感兴趣的可以自行查看，在idea中查看PlatformTransactionManager实现类如下

image.png

4 spring 事物的基本行为

通过org.springframework.transaction.getTransaction(TransactionDefinition definition)

      /**
     * 根据不同的事物行为，获取当前事物，或者新建事物。
     * @param definition 事物定义信息，包含事物行为，隔离级别，超时时间等
     * @return org.springframework.transaction.TransactionStatus 代表当前或者新的事物的事物对象
     */
    TransactionStatus getTransaction(TransactionDefinition definition) throws TransactionException;

可以得知，事物的相关属性就定义在java.sql.Connection.TransactionDefinition类中。那么我们看看该类中分别定义了什么

   /**
     * 获取传播行为
     */
    int getPropagationBehavior();

    /**
     * 获取隔离级别
     */
    int getIsolationLevel();

    /**
     * 获取超时时间
     */
    int getTimeout();

    /**
     * 获取只读属性
     */
    boolean isReadOnly();

    /**
     * 获取事物的名称 默认为classname+"."+methodName
     */
    String getName();

4.1 事物的传播行为

所谓事物的传播行为，指的是被事物标记的方法（注解或者xml声明），之间进行嵌套调用时事物的传播规则。拿jdbc事物管理器来说，就是共用同一个jdbc connection，还是新建connection，还是抛异常。这个规则就叫做事物的传播行为。spring定义了如下传播行为：

4.1.1 PROPAGATION_REQUIRED

如果存在事物，则加入当前事物。如果不存在事物，则新建事物。默认传播行为。

  void methodA(){
        //doSomethingA()
        ((ServiceName)AopContext.currentProxy()).methodB();
    }

    @Transactional(propagation = Propagation.REQUIRED)
    void methodB(){
        //doSomethingB()
    }

methodB()被调用时不存在事物，则会新建一个事物。methodB 会以事物方式运行。相当于如下操作

void methodA(){
        //doSomethingA()
        Connection connection=null;
        try{
            connection=getConnection();
            //doSomethingB()
            connection.commit();
        }catch (RuntimeException e){
            connection.rollback();
        }finally {
            connection.close();
        }
    }

方法内调用之所以用类似 ((ServiceName)AopContext.currentProxy()).methodB()。是因为spring事物是基于aop实现，aop又是基于代理类实现。直接方法内调用是不会使用到增强类，也就不会调用到被代理类的增强方法。

4.1.2 PROPAGATION_SUPPORTS

支持事物，如果不存在事物则以非事物的状态运行。

@Transactional(propagation = Propagation.REQUIRED)
    void methodA(){
        //doSomethingA()
        ((ServiceName)AopContext.currentProxy()).methodB();
    }

    @Transactional(propagation = Propagation.SUPPORTS)
    void methodB(){
        //doSomethingB()
    }

调用methodA时，相当于如下：

void methodA(){
        Connection connection=null;
        try{
            connection=getConnection();
            //doSomethingA()
            //doSomethingB()
            connection.commit();
        }catch (RuntimeException e){
            connection.rollback();
        }finally {
            connection.close();
        }
    }

当单独调用methodB 时，methodB 以非事物的方式运行。

4.1.3 PROPAGATION_MANDATORY

必须存在事物，不存在则抛异常。

    @Transactional(propagation = Propagation.REQUIRED)
    void methodA(){
        //doSomethingA()
        ((ServiceName)AopContext.currentProxy()).methodB();
    }

    @Transactional(propagation = Propagation.MANDATORY)
    void methodB(){
        //doSomethingB()
    }

无论时调用methodA，还是单独调用methodB都会抛异常

// No existing transaction found -> check propagation behavior to find out how to proceed.
        if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_MANDATORY) {
            throw new IllegalTransactionStateException(
                    "No existing transaction found for transaction marked with propagation 'mandatory'");
        }

4.1.4 PROPAGATION_REQUIRES_NEW

无论当前是否存在事物，都新建事物。

@Transactional(propagation = Propagation.REQUIRED)
    void methodA(){
        ((ServiceName)AopContext.currentProxy()).methodB();
        //doSomethingA()
    }

    @Transactional(propagation = Propagation.REQUIRES_NEW)
    void methodB(){
        //doSomethingB()
        //successOrNot
    }

当methodA中的doSomethingA()发生异常回滚时，methodB可以正常提交。
相当于如下：

void methodA(){
        //当前连接
        Connection currentConnection=null;
        try{
            currentConnection=getConnection();
            //挂起当前事物
            suspend(currentConnection);
            Connection newConnection;
            try {
                //开启新事物
                 newConnection=getConnection();
                //doSomethingB()
                newConnection.commit();
            }catch (Exception e){
                newConnection.rollback(sa);
            }finally {
                newConnection.close();
            }
            //恢复当前事物
            resume(currentConnection);
            currentConnection.commit();
        }catch (RuntimeException e){
            currentConnection.rollback();
        }finally {
            currentConnection.close();
        }
    }

新建事物不受外部事物的影响，PROPAGATION_REQUIRES_NEW可以用在保证接口最近在读spring源码的时候，对spring事物又有了一点新的理解。遂加以整理如下笔记。如有不正确的地方，欢迎指正，谢谢。本文大致分为如下板块：

• 什么是数据库事物
• 什么是spring事物
• spring事物核心接口
• 不同的事物管理器
• 事物的传播行为
• 事物的隔离级别
• 事物工具类

1.什么是数据库事物

数据库事物，指的是数据库执行的逻辑单元，这个逻辑单元遵从ACID原则，用这个原则来保证数据的一致性和完整性。反应到数据库上就是一组sql，要么全部执行成功，要么全部执行失败。例如下面sql：

--uid001账户余额增加100块
update user_account set account_balance=account_balance+100 where user_id='uid001';
--uid002账户余额减少100块
update user_account set account_balance=account_balance-100 where user_id='uid002';

1.1 ACID

2.什么是spring事物管理

所谓的事物管理指的是“按照指定事物规则执行提交或者回滚操作”，而spring的事物管理，指的是spring对事物管理规则的抽象。具体来说就是spring不直接管理事物，而是为了不同的平台提供了不同的事物管理器 如jdbc hibernate jpa 等，将具体的事物管理委托给相应的持久化框架实现，spring并不关心具体事物管理的实现，具体的实现留给对应的平台来实现，从而为事物管理提供了通用编程模型。这个通用抽象反应到代码层面就是org.springframework.jdbc.datasource.PlatformTransactionManager 类。

/**
     * 根据不同的事物行为，获取当前事物，或者新建事物。
     * @param definition 事物定义信息，包含事物行为，隔离级别，超时时间等
     * @return org.springframework.transaction.TransactionStatus 代表当前或者新的事物的事物对象
     */
    TransactionStatus getTransaction(TransactionDefinition definition) throws TransactionException;

    /**
     * 就给定的事物状态提交事物。如果事物状态被标记为回滚，则回滚事物
     * @param status 当前事物对象
     */
    void commit(TransactionStatus status) throws TransactionException;

    /**
     * 回滚当前事物
     * @param status 当前事物对象
     */
    void rollback(TransactionStatus status) throws TransactionException;

3 事物管理器

spring 为不同的平台提供了不同的事物管理器。不同的事物管理器都继承自抽象类org.springframework.transaction.support.AbstractPlatformTransactionManager。该抽象类实现了org.springframework.jdbc.datasource.PlatformTransactionManager ，实现了事物管理器的骨架实现，通过继承该类，仅仅关心平台相关内容即可实现不同的事物管理器。

3.1 jdbc事物管理器

 <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
 </bean>

jdbc 事物管理器是通过javax.sql.DataSource.getConnection() 获取javax.sql.Connection,通过javax.sql.Connection来进行事物的提交和回滚。

    @Override
    protected void doCommit(DefaultTransactionStatus status) {
        DataSourceTransactionObject txObject = (DataSourceTransactionObject) status.getTransaction();
        Connection con = txObject.getConnectionHolder().getConnection();
        if (status.isDebug()) {
            logger.debug("Committing JDBC transaction on Connection [" + con + "]");
        }
        try {
            con.commit();
        }
        catch (SQLException ex) {
            throw new TransactionSystemException("Could not commit JDBC transaction", ex);
        }
    }

    @Override
    protected void doRollback(DefaultTransactionStatus status) {
        DataSourceTransactionObject txObject = (DataSourceTransactionObject) status.getTransaction();
        Connection con = txObject.getConnectionHolder().getConnection();
        if (status.isDebug()) {
            logger.debug("Rolling back JDBC transaction on Connection [" + con + "]");
        }
        try {
            con.rollback();
        }
        catch (SQLException ex) {
            throw new TransactionSystemException("Could not roll back JDBC transaction", ex);
        }
    }

3.2 hibernate事物管理器

    <bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
        <property name="sessionFactory" ref="sessionFactory" />
    </bean>

HibernateTransactionManager 是通过绑定org.hibernate.SessionFactory来实现的 ，通过sessionFactory来绑定org.hibernate.Transaction，提交或者回滚的时候调用org.hibernate.Transaction的commit或者rollback来操作。

@Override
    protected void doCommit(DefaultTransactionStatus status) {
        HibernateTransactionObject txObject = (HibernateTransactionObject) status.getTransaction();
        if (status.isDebug()) {
            logger.debug("Committing Hibernate transaction on Session [" +
                    txObject.getSessionHolder().getSession() + "]");
        }
        try {
            txObject.getSessionHolder().getTransaction().commit();
        }
        catch (org.hibernate.TransactionException ex) {
            // assumably from commit call to the underlying JDBC connection
            throw new TransactionSystemException("Could not commit Hibernate transaction", ex);
        }
        catch (HibernateException ex) {
            // assumably failed to flush changes to database
            throw convertHibernateAccessException(ex);
        }
    }

3.3 其它spring事物管理器

除了上面介绍的两个常用的事物管理器之外，spring还提供了其它的事物管理器。如 org.springframework.orm.jpa，org.springframework.transaction.jta.JtaTransactionManager，org.springframework.jms.connection.JmsTransactionManager,org.springframework.transaction.jta.WebLogicJtaTransactionManager等。感兴趣的可以自行查看，在idea中查看PlatformTransactionManager实现类如下

image.png

4 spring 事物的基本行为

通过org.springframework.transaction.getTransaction(TransactionDefinition definition)

      /**
     * 根据不同的事物行为，获取当前事物，或者新建事物。
     * @param definition 事物定义信息，包含事物行为，隔离级别，超时时间等
     * @return org.springframework.transaction.TransactionStatus 代表当前或者新的事物的事物对象
     */
    TransactionStatus getTransaction(TransactionDefinition definition) throws TransactionException;

可以得知，事物的相关属性就定义在java.sql.Connection.TransactionDefinition类中。那么我们看看该类中分别定义了什么

   /**
     * 获取传播行为
     */
    int getPropagationBehavior();

    /**
     * 获取隔离级别
     */
    int getIsolationLevel();

    /**
     * 获取超时时间
     */
    int getTimeout();

    /**
     * 获取只读属性
     */
    boolean isReadOnly();

    /**
     * 获取事物的名称 默认为classname+"."+methodName
     */
    String getName();

4.1 事物的传播行为-propagation

所谓事物的传播行为，指的是被事物标记的方法（注解或者xml声明），之间进行嵌套调用时事物的传播规则。拿jdbc事物管理器来说，就是共用同一个jdbc connection，还是新建connection，还是抛异常。这个规则就叫做事物的传播行为。spring定义了如下传播行为：

4.1.1 PROPAGATION_REQUIRED

如果存在事物，则加入当前事物。如果不存在事物，则新建事物。默认传播行为。

  void methodA(){
        //doSomethingA()
        ((ServiceName)AopContext.currentProxy()).methodB();
    }

    @Transactional(propagation = Propagation.REQUIRED)
    void methodB(){
        //doSomethingB()
    }

methodB()被调用时不存在事物，则会新建一个事物。methodB 会以事物方式运行。相当于如下操作

void methodA(){
        //doSomethingA()
        Connection connection=null;
        try{
            connection=getConnection();
            //doSomethingB()
            connection.commit();
        }catch (RuntimeException e){
            connection.rollback();
        }finally {
            connection.close();
        }
    }

方法内调用之所以用类似 ((ServiceName)AopContext.currentProxy()).methodB()。是因为spring事物是基于aop实现，aop又是基于代理类实现。直接方法内调用是不会使用到增强类，也就不会调用到被代理类的增强方法。

4.1.2 PROPAGATION_SUPPORTS

支持事物，如果不存在事物则以非事物的状态运行。

@Transactional(propagation = Propagation.REQUIRED)
    void methodA(){
        //doSomethingA()
        ((ServiceName)AopContext.currentProxy()).methodB();
    }

    @Transactional(propagation = Propagation.SUPPORTS)
    void methodB(){
        //doSomethingB()
    }

调用methodA时，相当于如下：

void methodA(){
        Connection connection=null;
        try{
            connection=getConnection();
            //doSomethingA()
            //doSomethingB()
            connection.commit();
        }catch (RuntimeException e){
            connection.rollback();
        }finally {
            connection.close();
        }
    }

当单独调用methodB 时，methodB 以非事物的方式运行。

4.1.3 PROPAGATION_MANDATORY

必须存在事物，不存在则抛异常。

   void methodA(){
        //doSomethingA()
        ((ServiceName)AopContext.currentProxy()).methodB();
    }

    @Transactional(propagation = Propagation.MANDATORY)
    void methodB(){
        //doSomethingB()
    }

无论时调用methodA，还是耽误调用methodB都会抛异常

// No existing transaction found -> check propagation behavior to find out how to proceed.
        if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_MANDATORY) {
            throw new IllegalTransactionStateException(
                    "No existing transaction found for transaction marked with propagation 'mandatory'");
        }

4.1.4 PROPAGATION_REQUIRES_NEW

无论当前是否存在事物，都新建事物。

@Transactional(propagation = Propagation.REQUIRED)
    void methodA(){
        ((ServiceName)AopContext.currentProxy()).methodB();
        //doSomethingA()
    }

    @Transactional(propagation = Propagation.REQUIRES_NEW)
    void methodB(){
        //doSomethingB()
        //successOrNot
    }

当methodA中的doSomethingA()发生异常回滚时，methodB可以正常提交。值得注意的是，PROPAGATION_REQUIRES_NEW 仅仅支持JtaTransactionManager作为事物管理器。

/**
     * Create a new transaction, suspending the current transaction if one exists.
     * Analogous to the EJB transaction attribute of the same name.
     * <p><b>NOTE:</b> Actual transaction suspension will not work out-of-the-box
     * on all transaction managers. This in particular applies to
     * {@link org.springframework.transaction.jta.JtaTransactionManager},
     * which requires the {@code javax.transaction.TransactionManager} to be
     * made available it to it (which is server-specific in standard Java EE).
     * <p>A {@code PROPAGATION_REQUIRES_NEW} scope always defines its own
     * transaction synchronizations. Existing synchronizations will be suspended
     * and resumed appropriately.
     * @see org.springframework.transaction.jta.JtaTransactionManager#setTransactionManager
     */
    int PROPAGATION_REQUIRES_NEW = 3;

相当于如下：

void methodA(){
        //当前连接
        Connection currentConnection=null;
        try{
            currentConnection=getConnection();
            //挂起当前事物
            suspend(currentConnection);
            Connection newConnection;
            try {
                //开启新事物
                 newConnection=getConnection();
                //doSomethingB()
                newConnection.commit();
            }catch (Exception e){
                newConnection.rollback(sa);
            }finally {
                newConnection.close();
            }
            //恢复当前事物
            resume(currentConnection);
            currentConnection.commit();
        }catch (RuntimeException e){
            currentConnection.rollback();
        }finally {
            currentConnection.close();
        }
    }

4.1.5 PROPAGATION_NOT_SUPPORTED

不支持事物，如果当前存在事物，则将当前事物挂起，已非事物的方式运行。同样，仅支持JtaTransactionManager做为事物管理器。

/**
     * Do not support a current transaction; rather always execute non-transactionally.
     * Analogous to the EJB transaction attribute of the same name.
     * <p><b>NOTE:</b> Actual transaction suspension will not work out-of-the-box
     * on all transaction managers. This in particular applies to
     * {@link org.springframework.transaction.jta.JtaTransactionManager},
     * which requires the {@code javax.transaction.TransactionManager} to be
     * made available it to it (which is server-specific in standard Java EE).
     * <p>Note that transaction synchronization is <i>not</i> available within a
     * {@code PROPAGATION_NOT_SUPPORTED} scope. Existing synchronizations
     * will be suspended and resumed appropriately.
     * @see org.springframework.transaction.jta.JtaTransactionManager#setTransactionManager
     */
    int PROPAGATION_NOT_SUPPORTED = 4;

4.1.6 PROPAGATION_NEVER

不支持事物，如果当前存在事物，则抛异常。

if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NEVER) {
            throw new IllegalTransactionStateException(
                    "Existing transaction found for transaction marked with propagation 'never'");
        }

4.1.7 PROPAGATION_NESTED

嵌套事物。如果当前存在事物，则以嵌套事物的方式运行。如果不存在事物，则以PROPAGATION_REQUIRED的方式运行。

@Transactional(propagation = Propagation.REQUIRED)
    void methodA(){
        //doSomethingA()
        ((ServiceName)AopContext.currentProxy()).methodB();
    }

    @Transactional(propagation = Propagation.NESTED)
    void methodB(){
        //doSomethingB()
        //successOrNot
    }

单独调用methodB 时，相当于 PROPAGATION_REQUIRED。

void method(){
        Connection connection=null;
        try{
            connection=getConnection();
            //doSomethingB()
            connection.commit();
        }catch (RuntimeException e){
            connection.rollback();
        }finally {
            connection.close();
        }
    }

当调用methodA时，则以嵌套事物的方式运行，methodB作为methodA的子事物，提交和回滚都会受methodA的事物的影响。

void methodA(){
        Connection currentConnection=null;
        Savepoint savepoint=null;
        try{
            currentConnection=getConnection();
            //doSomethingA();
            savepoint=currentConnection.setSavepoint(createSavePoint());
            try{
                //doSomethingB();
            }catch (RuntimeException e){
                currentConnection.rollback(savepoint);
            }finally {
                currentConnection.close();
            }
            currentConnection.commit();
        }catch (RuntimeException e){
            currentConnection.rollback();
        }finally {
            currentConnection.close();
        }
    }

值得注意的一点是,嵌套事物只支持DataSourceTransactionManager，或者部分JTA事物管理器。且要求jdbc 3.0驱动及以上，同时 jdk版本在1.4 以上

/**
     * Execute within a nested transaction if a current transaction exists,
     * behave like {@link #PROPAGATION_REQUIRED} else. There is no analogous
     * feature in EJB.
     * <p><b>NOTE:</b> Actual creation of a nested transaction will only work on
     * specific transaction managers. Out of the box, this only applies to the JDBC
     * {@link org.springframework.jdbc.datasource.DataSourceTransactionManager}
     * when working on a JDBC 3.0 driver. Some JTA providers might support
     * nested transactions as well.
     * @see org.springframework.jdbc.datasource.DataSourceTransactionManager
     */
    int PROPAGATION_NESTED = 6;

 /**
     * Creates a savepoint with the given name in the current transaction
     * and returns the new <code>Savepoint</code> object that represents it.
     *
     * <p> if setSavepoint is invoked outside of an active transaction, a transaction will be started at this newly created
     *savepoint.
     *
     * @param name a <code>String</code> containing the name of the savepoint
     * @return the new <code>Savepoint</code> object
     * @exception SQLException if a database access error occurs,
          * this method is called while participating in a distributed transaction,
     * this method is called on a closed connection
     *            or this <code>Connection</code> object is currently in
     *            auto-commit mode
     * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
     * this method
     * @see Savepoint
     * @since 1.4
     */
    Savepoint setSavepoint(String name) throws SQLException;

一般我们用PROPAGATION_NESTED来执行分支逻辑。

@Transactional(propagation = Propagation.REQUIRED)
    void methodA(){
        try{
            ((ServiceName)AopContext.currentProxy()).methodB();
        }catch (Exception e){
            //doSomethingC();
        }

    }

    @Transactional(propagation = Propagation.NESTED)
    void methodB(){
        //doSomethingB()
        //successOrNot
    }

当methodB执行失败的时候，则methodA 回滚到之前的保存点，然后执行catch块中的其它业务逻辑，就像methodB从未执行过一样。这也是PROPAGATION_NESTED最常用的用法，而PROPAGATION_REQUIRED和PROPAGATION_NEW都无法做到这一点。
大多数情况下，PROPAGATION_REQUIRED可以满足我们的绝大部分需求，所以它也应该是我们优先考虑的传播行为，同时其也是@Transactional 的默认传播行为

4.2 事物的隔离级别

事物的隔离级别，指的是并发情况下，事物之间的隔离度。不同的隔离级别，可以解决不同的隔离问题，也对应着不同的并发度，使用的时候，要结合实际情况，按需选择。

4.2.1 数据库的隔离问题及级别

4.2.1.1 隔离问题

4.2.1.2 隔离级别

4.2.2 Spirng 的事物隔离级别-isolation

spring的事物隔离级别也是依赖于底层的数据库隔离级别

以DataSourceTransactionManager为例，是通过设置Connection的TransactionIsolation属性来实现绑定不同的隔离级别的。

// Apply specific isolation level, if any.
        Integer previousIsolationLevel = null;
        if (definition != null && definition.getIsolationLevel() != TransactionDefinition.ISOLATION_DEFAULT) {
            if (logger.isDebugEnabled()) {
                logger.debug("Changing isolation level of JDBC Connection [" + con + "] to " +
                        definition.getIsolationLevel());
            }
            int currentIsolation = con.getTransactionIsolation();
            if (currentIsolation != definition.getIsolationLevel()) {
                previousIsolationLevel = currentIsolation;
                con.setTransactionIsolation(definition.getIsolationLevel());
            }
        }

4.3 事物的只读属性-readOnly

spring 事物的只读属性是通过设置，java.sql.Connection 的 readOnly 属性来实现的。当设置了只读属性后，数据库会对只读事物进行一些优化，如不启用回滚段，不启用回滚日志等。同时值得注意的是，设置了只读属性后，如果进行写操作会报错。

// Set read-only flag.
        if (definition != null && definition.isReadOnly()) {
            try {
                if (logger.isDebugEnabled()) {
                    logger.debug("Setting JDBC Connection [" + con + "] read-only");
                }
                con.setReadOnly(true);
            }

4.4 事物的超时时间-timeout

事物的超时指的是设置一个时间，当执行时间超过这个时间后，抛异常并回滚。是通过设置一个截至时间来实现的，值得注意的是，这个超时时间只有特定情况下才会生效，如dao层使用jdbcTemplete 执行sql

设置超时时间

int timeout = determineTimeout(definition);
            if (timeout != TransactionDefinition.TIMEOUT_DEFAULT) {
                txObject.getConnectionHolder().setTimeoutInSeconds(timeout);
            }
/**
     * Set the timeout for this object in seconds.
     * @param seconds number of seconds until expiration
     */
    public void setTimeoutInSeconds(int seconds) {
        setTimeoutInMillis(seconds * 1000L);
    }

    /**
     * Set the timeout for this object in milliseconds.
     * @param millis number of milliseconds until expiration
     */
    public void setTimeoutInMillis(long millis) {
        this.deadline = new Date(System.currentTimeMillis() + millis);
    }

检查超时时间

/**
     * Return the time to live for this object in seconds.
     * Rounds up eagerly, e.g. 9.00001 still to 10.
     * @return number of seconds until expiration
     * @throws TransactionTimedOutException if the deadline has already been reached
     */
    public int getTimeToLiveInSeconds() {
        double diff = ((double) getTimeToLiveInMillis()) / 1000;
        int secs = (int) Math.ceil(diff);
        checkTransactionTimeout(secs <= 0);
        return secs;
    }
/**
     * Set the transaction rollback-only if the deadline has been reached,
     * and throw a TransactionTimedOutException.
     */
    private void checkTransactionTimeout(boolean deadlineReached) throws TransactionTimedOutException {
        if (deadlineReached) {
            setRollbackOnly();
            throw new TransactionTimedOutException("Transaction timed out: deadline was " + this.deadline);
        }
    }

4.5 回滚规则-rollbackFor

回滚规则只得是spring 事物遇到哪种异常会回滚。默认只回滚RuntimeException和Error
源码如下

if (txInfo.transactionAttribute.rollbackOn(ex)) {
                try {
                    txInfo.getTransactionManager().rollback(txInfo.getTransactionStatus());
                }
                catch (TransactionSystemException ex2) {
                    logger.error("Application exception overridden by rollback exception", ex);
                    ex2.initApplicationException(ex);
                    throw ex2;
                }
                catch (RuntimeException ex2) {
                    logger.error("Application exception overridden by rollback exception", ex);
                    throw ex2;
                }
                catch (Error err) {
                    logger.error("Application exception overridden by rollback error", ex);
                    throw err;
                }
            }

@Override
    public boolean rollbackOn(Throwable ex) {
        return (ex instanceof RuntimeException || ex instanceof Error);
    }

当配置了rollbackFor 属性时，源码如下

@Override
    public boolean rollbackOn(Throwable ex) {
        if (logger.isTraceEnabled()) {
            logger.trace("Applying rules to determine whether transaction should rollback on " + ex);
        }

        RollbackRuleAttribute winner = null;
        int deepest = Integer.MAX_VALUE;

        if (this.rollbackRules != null) {
            for (RollbackRuleAttribute rule : this.rollbackRules) {
                int depth = rule.getDepth(ex);
                if (depth >= 0 && depth < deepest) {
                    deepest = depth;
                    winner = rule;
                }
            }
        }

        if (logger.isTraceEnabled()) {
            logger.trace("Winning rollback rule is: " + winner);
        }

        // User superclass behavior (rollback on unchecked) if no rule matches.
        if (winner == null) {
            logger.trace("No relevant rollback rule found: applying default rules");
            return super.rollbackOn(ex);
        }

        return !(winner instanceof NoRollbackRuleAttribute);
    }

public int getDepth(Throwable ex) {
        return getDepth(ex.getClass(), 0);
    }


    private int getDepth(Class<?> exceptionClass, int depth) {
        if (exceptionClass.getName().contains(this.exceptionName)) {
            // Found it!
            return depth;
        }
        // If we've gone as far as we can go and haven't found it...
        if (exceptionClass == Throwable.class) {
            return -1;
        }
        return getDepth(exceptionClass.getSuperclass(), depth + 1);
    }

可以看到，此时回滚的规则为当前异常类型在配置的异常类型里面。

4.6 其它属性

类似4.5的属性还有rollbackForClassName，noRollbackFor，noRollbackForClassName 。都是类似的作用，可以自行查看。

总结

任何场景下都应该根据合适的场景选择合适的方式，知其然还要只其所以然，才能在出先问题的时候，快读定位排查。后续我们将分析下spring的事物管理的源码，一起看下spring的事物究竟是怎么生效的。

下一篇-spring源码系列-容器之XmlBeanFactory

参考文章
http://www.jianshu.com
Spring 源码深度解析-郝佳