对TransactionTemplate进行封装，使用程序调用更加简单

<!-- DB2 dataSource-->
	<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
		<property name="driverClassName" value="${jdbc.driver}" />
		<property name="url" value="${jdbc.url}" />
		<property name="username" value="${jdbc.username}" />
		<property name="password" value="${jdbc.password}" />
	</bean>

	<!-- 定义事务管理器 -->
	<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<property name="dataSource" ref="dataSource" />
	</bean>
	
	<!-- 编程式事务模板,Spring的编程式事务可以通过TransactionTemplate的execute(TransactionCallback<T> action)方法来完成 -->
	<bean id="transactionTemplate" class="org.springframework.transaction.support.TransactionTemplate">
		<property name="transactionManager" ref="transactionManager" />
	</bean>

	<!-- jdbcTemplate -->
	 <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
		<property name="dataSource" ref="dataSource"/>
	</bean>
	
	<!-- TransactionTemplateFz -->
	 <bean id="transactionTemplateFz" class="com.suning.sel.eps.main.service.TransactionTemplateFz">
	</bean>
	
	<context:annotation-config />

import org.springframework.transaction.TransactionDefinition;

/**
 * 事务特性进行封装<br>
 * 〈功能详细描述〉
 * 
 * @see [相关类/方法]（可选）
 * @since [产品/模块版本] （可选）
 */
public class TransactionDefinitionFz {

    /**
     * 事务的传播行为:默认是TransactionDefinition.PROPAGATION_REQUIRED
     */
    private int propagationBehavior = TransactionDefinition.PROPAGATION_REQUIRED;

    /**
     * 事务的隔离级别:默认是ISOLATION_DEFAULT:使用的是底层数据库的默认的隔离级别,也可使用默认值TransactionDefinition.ISOLATION_DEFAULT
     */
    private int isolationLevel = TransactionDefinition.ISOLATION_DEFAULT;

    /**
     * 是否可读:默认是false
     */
    private boolean readOnly = false;

    /**
     * 事务的超时时间:默认使用的是数据库底层的默认的事务的超时时间,也可使用默认值TransactionDefinition.TIMEOUT_DEFAULT
     */
    private int timeout = TransactionDefinition.TIMEOUT_DEFAULT;

    public int getPropagationBehavior() {
        return propagationBehavior;
    }

    public void setPropagationBehavior(int propagationBehavior) {
        this.propagationBehavior = propagationBehavior;
    }

    public int getIsolationLevel() {
        return isolationLevel;
    }

    public void setIsolationLevel(int isolationLevel) {
        this.isolationLevel = isolationLevel;
    }

    public boolean isReadOnly() {
        return readOnly;
    }

    public void setReadOnly(boolean readOnly) {
        this.readOnly = readOnly;
    }

    public int getTimeout() {
        return timeout;
    }

    public void setTimeout(int timeout) {
        this.timeout = timeout;
    }

}

/**
 * 对TransactionTemplate进行封装，使用程序调用更加简单<br>
 * 〈功能详细描述〉
 * 
 * @see [相关类/方法]（可选）
 * @since [产品/模块版本] （可选）
 */
public class TransactionTemplateFz {
    @Autowired
    private TransactionTemplate transactionTemplate;

    /**
     * 
     * 使用默认的事务的相关特性进行编程事务管理 <br>
     * 〈功能详细描述〉
     * 
     * @param action
     * @return
     * @see [相关类/方法](可选)
     * @since [产品/模块版本](可选)
     */
    public <T> T execute(final TransactionCallbackFz<T> action) {
        return transactionTemplate.execute(new TransactionCallback<T>() {
            @Override
            public T doInTransaction(TransactionStatus status) {
                return action.doInTransaction();
            }
        });
    }

    public <T> T execute(final TransactionCallbackFz<T> action, TransactionDefinitionFz transactionDefinitionFz) {
        if (transactionDefinitionFz != null) {
            // 设置事务的传播行为,默认是PROPAGATION_REQUIRED,也可使用默认值
            transactionTemplate.setPropagationBehavior(transactionDefinitionFz.getPropagationBehavior());
            // 设置事务的隔离级别,默认是ISOLATION_DEFAULT:使用的是底层数据库的默认的隔离级别,也可使用默认值
            transactionTemplate.setIsolationLevel(transactionDefinitionFz.getIsolationLevel());
            // 设置是否只读，默认是false,也可使用默认值
            transactionTemplate.setReadOnly(transactionDefinitionFz.isReadOnly());
            // 默认使用的是数据库底层的默认的事务的超时时间,也可使用默认值
            transactionTemplate.setTimeout(transactionDefinitionFz.getTimeout());
        }

        return transactionTemplate.execute(new TransactionCallback<T>() {
            @Override
            public T doInTransaction(TransactionStatus status) {
                return action.doInTransaction();
            }
        });
    }
}

/**
 * 回调接口，在使用编程事务管理时使用回调接口传入相关的DB操作<br>
 * 〈功能详细描述〉
 * 
 * @see [相关类/方法]（可选）
 * @since [产品/模块版本] （可选）
 */
public interface TransactionCallbackFz<T> {
    T doInTransaction();
}

import java.util.List;
import java.util.Map;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.testng.AbstractTestNGSpringContextTests;
import org.springframework.transaction.TransactionDefinition;
import org.testng.annotations.Test;

/**
 * 〈一句话功能简述〉<br>
 * 〈功能详细描述〉
 * 
 * @see [相关类/方法]（可选）
 * @since [产品/模块版本] （可选）
 */
@ContextConfiguration(locations = { "file:src/main/webapp/WEB-INF/applicationContext.xml" })
public class TestTransactionTemplateFz extends AbstractTestNGSpringContextTests {
    // AbstractTestNGSpringContextTests方法执行完不会回滚,
    // AbstractTransactionalTestNGSpringContextTests在每个方法执行结束之后会把事务回滚，这样每次修改、新增、删除操作都可以执行多次

    @Autowired
    private JdbcTemplate jdbcTemplate;

    @Autowired
    private TransactionTemplateFz transactionTemplatefz;

    /**
     * 
     * 直接使用TransactionTemplate进行编程式事务管理 <br>
     * 〈功能详细描述〉
      * 
     * @see [相关类/方法](可选)
     * @since [产品/模块版本](可选)
     */
    @Test
    public void testTransactionTemplateFz() {
        TransactionDefinitionFz definition = new TransactionDefinitionFz();
        definition.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
        definition.setIsolationLevel(TransactionDefinition.ISOLATION_READ_COMMITTED);
        definition.setReadOnly(true);
        definition.setTimeout(3000);

        List<Map<String, Object>> userList = transactionTemplatefz.execute(
                new TransactionCallbackFz<List<Map<String, Object>>>() {
                    @Override
                    public List<Map<String, Object>> doInTransaction() {
                        return jdbcTemplate.queryForList("select * from sym_t_user");
                    }

                }, definition);
        System.out.println(userList);
    }
}