Spring 中的TransactionTemplate

Spring提供的TransactionTemplate 能够以编程的方式实现事务控制，是无状态而且线程安全的

public class TransactionTemplate extends DefaultTransactionDefinition
        implements TransactionOperations, InitializingBean {

    protected final Log logger = LogFactory.getLog(getClass());
        //PlatformTransactionManager用来执行事务的提交和回滚操作。 
    private PlatformTransactionManager transactionManager;

    public TransactionTemplate() {
    }

    public TransactionTemplate(PlatformTransactionManager transactionManager) {
        this.transactionManager = transactionManager;
    }

    public TransactionTemplate(PlatformTransactionManager transactionManager, TransactionDefinition transactionDefinition) {
        super(transactionDefinition);
        this.transactionManager = transactionManager;
    }
       //依赖注入
    public void setTransactionManager(PlatformTransactionManager transactionManager) {
        this.transactionManager = transactionManager;
    }
    public PlatformTransactionManager getTransactionManager() {
        return this.transactionManager;
    }

    @Override
    //执行完毕后调用
    public void afterPropertiesSet() {
           //如果transactionManager 为空抛异常
        if (this.transactionManager == null) {
            throw new IllegalArgumentException("Property 'transactionManager' is required");
        }
    }
    @Override
    //进行事务处理的骨架代码，指明了事务处理的顺序
    public <T> T execute(TransactionCallback<T> action) throws TransactionException {
        if (this.transactionManager instanceof CallbackPreferringPlatformTransactionManager) {
            return ((CallbackPreferringPlatformTransactionManager) this.transactionManager).execute(this, action);
        }
        else {
                 //获取事务状态
            TransactionStatus status = this.transactionManager.getTransaction(this);
            T result;
            try {
                  //在doInTransaction（）进行各种数据库操作
                result = action.doInTransaction(status);
            }
            catch (RuntimeException ex) {
                rollbackOnException(status, ex);
                throw ex;
            }
            catch (Error err) {
                rollbackOnException(status, err);
                throw err;
            }
            catch (Throwable ex) {
                rollbackOnException(status, ex);
                throw new UndeclaredThrowableException(ex, "TransactionCallback threw undeclared checked exception");
            }
            //没有异常就操作成功，提交
            this.transactionManager.commit(status);
            //返回执行doInTransaction（）方法后的返回值
            return result;
        }
    }

    //事务处理回调时调用
    private void rollbackOnException(TransactionStatus status, Throwable ex) throws TransactionException {
        logger.debug("Initiating transaction rollback on application exception", ex);
        try {
            this.transactionManager.rollback(status);
        }
        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;
        }
    }

}

execute（）方法内的TransactionCallback参数是个接口，在这个接口内定义了doInTransaction（）方法，这样的模版代码，所以我们只要实现了TransactionCallback接口，并且在doInTransaction（）方法里编写具体进行的事务处理的代码就可以了，创建TransactionTemplate 的实例需要提供一个PlatformTransactionManager的实例，比如

TransactionTemplate transactionTemplate=new TransactionTemplate();
transactionTemplate.setTransactionManager(platformTransactionManager);

        transactionTemplate.execute(new TransactionCallback<String>() {

            @Override
            public String doInTransaction(TransactionStatus status) {
                //数据库操作1
                //数据库操作2
                return "success";
            }
        });

---

<?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.xsd">
<!-- 设定dataSource -->
<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
   <!-- 使用SQL server数据库 -->
   <property name="driverClassName">
      <value>com.microsoft.jdbc.sqlserver.SQLServerDriver</value>
   </property>
   <!-- 设定URL -->
   <property name="url">
      <value>jdbc:microsoft:sqlserver://localhost:1433/mydatabase</value>
   </property>
   <!-- 设定用户名 -->
   <property name="name">
     <value>root</value>
   </property>
    <property name="msg">
     <value>123</value>
   </property>
</bean>

<!-- 设定transactionManager -->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
  <property name="dataSource">
    <ref bean="dataSource"/>
  </property>
</bean>
<bean id="helloDAO" class="transaction.HelloDAO">
  <property name="dataSource">
    <ref bean="dataSource"/>
  </property>
  <property name="transactionManager">
    <ref bean="transactionManager"/>
  </property>
</bean>

</beans>

HelloDAO类

public class HelloDAO {
    private DataSource dataSource;
    private PlatformTransactionManager transactionManager;
    //通过依赖注入来完成管理
    public DataSource getDataSource() {
        return dataSource;
    }
    public void setDataSource(DataSource dataSource) {
        this.dataSource = dataSource;
    }
    public PlatformTransactionManager getTransactionManager() {
        return transactionManager;
    }
    public void setTransactionManager(PlatformTransactionManager transactionManager) {
        this.transactionManager = transactionManager;
    }

    //该方法进行事务处理
    public int create(String msg){
        DefaultTransactionDefinition def=new DefaultTransactionDefinition();
//      TransactionTemplate transactionTemplate=new TransactionTemplate(transactionManager);
        TransactionStatus status=transactionManager.getTransaction(def);
        try {
            //使用JdbcTemplate往数据库里新增数据
            JdbcTemplate jdbcTemplate=new JdbcTemplate(dataSource);
            jdbcTemplate.update("INSERT INTO hello VALUES(1,'gf','HELLO')");

        } catch (Exception e) {
            transactionManager.rollback(status);
            throw e;
        }finally{
            transactionManager.commit(status);
        }

        return 0;
    }
}

1、使用Spring预定义的DefaultTransactionDefinition ，然后通过TransactionManager的getTransaction（）方法首先声明事务开始
2、如果有异常发生，则使用TransactionManager的rollback（）方法进行事务回滚
3、如果成功，则执行TransactionManager的commit（）方法进行事务提交