Spring可以支持编程式事务和声明式事务。
Spring使用事务管理器,每个不同平台的事务管理器都实现了接口:PlatformTransactionManager
此接口是事务管理的核心,提供了三个需要实现的函数:
- commit(TransactionStatus status) ;
- getTransaction(TransactionDefinition definition) ;
- rollback(TransactionStatus status) ;
如果我们使用的是JDBC来处理事务,那么这个事务管理器就是DataSourceTransactionManager。
通过Spring文档查找到这个类,发现其需要DataSource这个类。也就是只要实现了javax.sql.DataSource这个接口的类,都可以作为参数传入到DataSourceTransactionManager。
然后,找到 包org.springframework.transaction.support中的 TransactionTemplate。
发现TransactionTemplate中有一个重要的方法:
- execute(TransactionCallback action) ;
就是利用这个方法,我们可以在这个方法中添加事务。
这个方法需要传入参数 TransactionCallback。
TransactionCallback,顾名思义,就是事务回调然后查到TransactionCallback。
发现这是一个接口(这也必须是接口,因为任务都是自己具体定义的)
里面只有一个方法:
- doInTransaction(TransactionStatus status) ;
很明显,就是在一个事务中需要做的事情都包括这这个方法中了。
而这个doInTransaction 又传入了一个参数,这次是 TransactionStatus,继续顾名思义,也就是事务状态。
查询下去,这个 TransactionStatus 还是一个接口。 看看这个接口定义了哪些服务(方法):
- hasSavepoint() ;
- isCompleted() ;
- isNewTransaction() ;
- setRollbackOnly() ;
当需要回滚的时候,需要在调用 setRoolbackOnly(); 就OK了。
好了,走了这么久,现在就来简单总结一下编程式事务管理。
首先: 因为我们使用的是特定的平台,所以,我们需要创建一个合适我们的平台事务管理PlateformTransactionManager。如果使用的是JDBC的话,就用DataSourceTransactionManager。注意需要传入一个DataSource,这样,平台才知道如何和数据库打交道。
第二: 为了使得平台事务管理器对我们来说是透明的,就需要使用 TransactionTemplate。使用TransactionTemplat需要传入一个 PlateformTransactionManager 进入,这样,我们就得到了一个 TransactionTemplate,而不用关心到底使用的是什么平台了。
第三: TransactionTemplate 的重要方法就是 execute 方法,此方法就是调用 TransactionCallback 进行处理。
也就是说,实际上我们需要处理的事情全部都是在 TransactionCallback 中编码的。
第四: 也就是 TransactionCallback 接口,我们可以定义一个类并实现此接口,然后作为 TransactionTemplate.execute 的参数。把需要完成的事情放到 doInTransaction中,并且传入一个 TransactionStatus 参数。此参数是来调用回滚的。
也就是说 ,PlateformTransactionManager 和 TransactionTemplate 只需在程序中定义一次,而TransactionCallback 和 TransactionStatus 就要针对不同的任务多次定义了。
这就是Spring的编程式事务管理。下面贴出例子代码:
TemplateUtils
- import javax.naming.Context;
- import javax.naming.InitialContext;
- import javax.naming.NamingException;
- import javax.sql.DataSource;
- import org.apache.log4j.Logger;
- import org.springframework.jdbc.core.JdbcTemplate;
- import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate;
- import org.springframework.jdbc.core.simple.SimpleJdbcTemplate;
- import org.springframework.jdbc.datasource.DataSourceTransactionManager;
- import org.springframework.transaction.PlatformTransactionManager;
- import org.springframework.transaction.support.TransactionTemplate;
- public class TemplateUtils {
- private static Logger logger = Logger.getLogger(TemplateUtils.class);
- private static String oracleDS = "java:OracleDS";
- private static DataSource dataSource = null;
- static {
- try {
- Context context = new InitialContext();
- dataSource = (DataSource) context.lookup(oracleDS);
- } catch (NamingException e) {
- logger.info("查找数据源失败···", e);
- }
- }
- public static TransactionTemplate getTransactionTemplate() {
- PlatformTransactionManager txManager = new DataSourceTransactionManager(
- dataSource);
- return new TransactionTemplate(txManager);
- }
- public static JdbcTemplate getJdbcTemplate() {
- return new JdbcTemplate(dataSource);
- }
- public static NamedParameterJdbcTemplate getNamedParameterJdbcTemplate() {
- return new NamedParameterJdbcTemplate(dataSource);
- }
- public static SimpleJdbcTemplate getSimpleJdbcTemplate() {
- return new SimpleJdbcTemplate(dataSource);
- }
- }
Test
- import javax.naming.Context;
- import javax.naming.InitialContext;
- import javax.sql.DataSource;
- import org.springframework.jdbc.core.JdbcTemplate;
- import org.springframework.jdbc.datasource.DataSourceTransactionManager;
- import org.springframework.transaction.PlatformTransactionManager;
- import org.springframework.transaction.TransactionStatus;
- import org.springframework.transaction.support.DefaultTransactionDefinition;
- import org.springframework.transaction.support.TransactionCallback;
- import org.springframework.transaction.support.TransactionCallbackWithoutResult;
- import org.springframework.transaction.support.TransactionTemplate;
- @SuppressWarnings("all")
- public class Test {
- public void m1() throws Exception {
- TransactionTemplate transactionTemplate = TemplateUtils
- .getTransactionTemplate();
- Object object = transactionTemplate.execute(new TransactionCallback() {
- public Object doInTransaction(TransactionStatus status) {
- try {
- // 数据库操作1
- // 数据库操作2
- } catch (Exception e) {
- status.setRollbackOnly();
- e.printStackTrace();
- }
- return null;
- }
- });
- }
- public void m2() throws Exception {
- TransactionTemplate transactionTemplate = TemplateUtils
- .getTransactionTemplate();
- transactionTemplate.execute(new TransactionCallbackWithoutResult() {
- protected void doInTransactionWithoutResult(TransactionStatus s) {
- try {
- // 数据库操作1
- // 数据库操作2
- } catch (Exception e) {
- s.setRollbackOnly();
- e.printStackTrace();
- }
- }
- });
- }
- public void m3() throws Exception {
- Context ctx = new InitialContext();
- DataSource ds = (DataSource) ctx.lookup("java:OracleDS");
- JdbcTemplate jt = new JdbcTemplate(ds);
- DefaultTransactionDefinition tf = new DefaultTransactionDefinition();
- PlatformTransactionManager tm = new DataSourceTransactionManager(ds);
- TransactionStatus ts = tm.getTransaction(tf);
- try {
- // 数据库操作1
- // 数据库操作2
- tm.commit(ts);
- } catch (Exception e) {
- tm.rollback(ts);
- e.printStackTrace();
- }
- }
- }
JdbcUtils
- import java.sql.CallableStatement;
- import java.sql.Connection;
- import java.sql.PreparedStatement;
- import java.sql.ResultSet;
- import java.sql.SQLException;
- import java.sql.Savepoint;
- import javax.naming.Context;
- import javax.naming.InitialContext;
- import javax.naming.NamingException;
- import javax.sql.DataSource;
- import org.apache.log4j.Logger;
- public class JdbcUtils {
- private static Logger logger = Logger.getLogger(JdbcUtils.class);
- private static String oracleDS = "java:OracleDS";
- private static DataSource dataSource = null;
- static {
- try {
- Context context = new InitialContext();
- dataSource = (DataSource) context.lookup(oracleDS);
- } catch (NamingException e) {
- logger.info("查找数据源失败···", e);
- }
- }
- public static Connection getConnection() {
- Connection conn = null;
- try {
- conn = dataSource.getConnection();
- } catch (SQLException e) {
- logger.info("获取数据库连接失败···", e);
- }
- return conn;
- }
- public static void close(Connection conn) {
- if (conn != null) {
- try {
- conn.close();
- } catch (SQLException e) {
- logger.info("释放数据库连接失败···", e);
- }
- }
- }
- public static void close(CallableStatement cs) {
- if (cs != null) {
- try {
- cs.close();
- } catch (SQLException e) {
- logger.info("关闭CallableStatement失败···", e);
- }
- }
- }
- public static void close(PreparedStatement ps) {
- if (ps != null) {
- try {
- ps.close();
- } catch (SQLException e) {
- logger.info("关闭PreparedStatement失败···", e);
- }
- }
- }
- public static void close(ResultSet rs) {
- if (rs != null) {
- try {
- rs.close();
- } catch (SQLException e) {
- logger.info("关闭ResultSet失败···", e);
- }
- }
- }
- public static void setAutoCommit(Connection conn, boolean autoCommit) {
- if (conn != null) {
- try {
- conn.setAutoCommit(autoCommit);
- } catch (SQLException e) {
- logger.info("设置事务提交方式失败···", e);
- }
- }
- }
- public static void commit(Connection conn) {
- if (conn != null) {
- try {
- conn.commit();
- } catch (SQLException e) {
- logger.info("提交事务失败···", e);
- }
- }
- }
- public static void rollback(Connection conn) {
- if (conn != null) {
- try {
- conn.rollback();
- } catch (SQLException e) {
- logger.info("回滚事务失败···", e);
- }
- }
- }
- public static void rollback(Connection conn, Savepoint sp) {
- if (conn != null) {
- try {
- conn.rollback(sp);
- } catch (SQLException e) {
- logger.info("回滚事务失败···", e);
- }
- }
- }
- }