`
xinklabi
  • 浏览: 1587835 次
  • 性别: Icon_minigender_1
  • 来自: 吉林
文章分类
社区版块
存档分类
最新评论

使用TransactionTemplate 编程式控制事务

 
阅读更多

http://wzhw2008.iteye.com/blog/1687523

 

http://blog.csdn.net/zq9017197/article/details/6321391

 

spring可以支持编程式事务和声明式事务。

Spring使用事务管理器,每个不同平台的事务管理器都实现了接口:PlatformTransactionManager

此接口是事务管理的核心,提供了三个需要实现的函数:

 

[java] view plain copy
 
 print?
  1. commit(TransactionStatus status) ;     
  2. getTransaction(TransactionDefinition definition) ;     
  3. rollback(TransactionStatus status) ;  

 

如果我们使用的是JDBC来处理事务,那么这个事务管理器就是DataSourceTransactionManager。

通过Spring文档查找到这个类,发现其需要DataSource这个类。也就是只要实现了javax.sql.DataSource这个接口的类,都可以作为参数传入到DataSourceTransactionManager。

 然后,找到 包org.springframework.transaction.support中的 TransactionTemplate。

发现TransactionTemplate中有一个重要的方法:

 

[java] view plain copy
 
 print?
  1. execute(TransactionCallback action) ;  

 

就是利用这个方法,我们可以在这个方法中添加事务。

这个方法需要传入参数 TransactionCallback。

TransactionCallback,顾名思义,就是事务回调然后查到TransactionCallback。

发现这是一个接口(这也必须是接口,因为任务都是自己具体定义的)

里面只有一个方法:

 

[java] view plain copy
 
 print?
  1. doInTransaction(TransactionStatus status) ;   

 

很明显,就是在一个事务中需要做的事情都包括这这个方法中了。

而这个doInTransaction 又传入了一个参数,这次是 TransactionStatus,继续顾名思义,也就是事务状态。

查询下去,这个 TransactionStatus 还是一个接口。 看看这个接口定义了哪些服务(方法):

 

[java] view plain copy
 
 print?
  1. hasSavepoint() ;  
  2. isCompleted() ;    
  3. isNewTransaction() ;  
  4. 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

 

[java] view plain copy
 
 print?
  1. import javax.naming.Context;  
  2. import javax.naming.InitialContext;  
  3. import javax.naming.NamingException;  
  4. import javax.sql.DataSource;  
  5.   
  6. import org.apache.log4j.Logger;  
  7. import org.springframework.jdbc.core.JdbcTemplate;  
  8. import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate;  
  9. import org.springframework.jdbc.core.simple.SimpleJdbcTemplate;  
  10. import org.springframework.jdbc.datasource.DataSourceTransactionManager;  
  11. import org.springframework.transaction.PlatformTransactionManager;  
  12. import org.springframework.transaction.support.TransactionTemplate;  
  13.   
  14. public class TemplateUtils {  
  15.     private static Logger logger = Logger.getLogger(TemplateUtils.class);  
  16.     private static String oracleDS = "<a href="http://lib.csdn.net/base/17" class='replace_word' title="Java EE知识库" target='_blank' style='color:#df3434; font-weight:bold;'>Java</a>:OracleDS";  
  17.     private static DataSource dataSource = null;  
  18.   
  19.     static {  
  20.         try {  
  21.             Context context = new InitialContext();  
  22.             dataSource = (DataSource) context.lookup(oracleDS);  
  23.         } catch (NamingException e) {  
  24.             logger.info("查找数据源失败···", e);  
  25.         }  
  26.     }  
  27.   
  28.     public static TransactionTemplate getTransactionTemplate() {  
  29.         PlatformTransactionManager txManager = new DataSourceTransactionManager(  
  30.                 dataSource);  
  31.         return new TransactionTemplate(txManager);  
  32.     }  
  33.   
  34.     public static JdbcTemplate getJdbcTemplate() {  
  35.         return new JdbcTemplate(dataSource);  
  36.     }  
  37.   
  38.     public static NamedParameterJdbcTemplate getNamedParameterJdbcTemplate() {  
  39.         return new NamedParameterJdbcTemplate(dataSource);  
  40.     }  
  41.   
  42.     public static SimpleJdbcTemplate getSimpleJdbcTemplate() {  
  43.         return new SimpleJdbcTemplate(dataSource);  
  44.     }  
  45.   
  46. }  

 

 

Test

 

[java] view plain copy
 
 print?
  1. import javax.naming.Context;  
  2. import javax.naming.InitialContext;  
  3. import javax.sql.DataSource;  
  4.   
  5. import org.springframework.jdbc.core.JdbcTemplate;  
  6. import org.springframework.jdbc.datasource.DataSourceTransactionManager;  
  7. import org.springframework.transaction.PlatformTransactionManager;  
  8. import org.springframework.transaction.TransactionStatus;  
  9. import org.springframework.transaction.support.DefaultTransactionDefinition;  
  10. import org.springframework.transaction.support.TransactionCallback;  
  11. import org.springframework.transaction.support.TransactionCallbackWithoutResult;  
  12. import org.springframework.transaction.support.TransactionTemplate;  
  13.   
  14. @SuppressWarnings("all")  
  15. public class Test {  
  16.   
  17.     public void m1() throws Exception {  
  18.         TransactionTemplate transactionTemplate = TemplateUtils  
  19.                 .getTransactionTemplate();  
  20.         Object object = transactionTemplate.execute(new TransactionCallback() {  
  21.             public Object doInTransaction(TransactionStatus status) {  
  22.                 try {  
  23.                     // 数据库操作1  
  24.                     // 数据库操作2  
  25.                 } catch (Exception e) {  
  26.                     status.setRollbackOnly();  
  27.                     e.printStackTrace();  
  28.                 }  
  29.                 return null;  
  30.             }  
  31.         });  
  32.     }  
  33.   
  34.     public void m2() throws Exception {  
  35.         TransactionTemplate transactionTemplate = TemplateUtils  
  36.                 .getTransactionTemplate();  
  37.         transactionTemplate.execute(new TransactionCallbackWithoutResult() {  
  38.             protected void doInTransactionWithoutResult(TransactionStatus s) {  
  39.                 try {  
  40.                     // 数据库操作1  
  41.                     // 数据库操作2  
  42.                 } catch (Exception e) {  
  43.                     s.setRollbackOnly();  
  44.                     e.printStackTrace();  
  45.                 }  
  46.             }  
  47.         });  
  48.     }  
  49.   
  50.     public void m3() throws Exception {  
  51.         Context ctx = new InitialContext();  
  52.         DataSource ds = (DataSource) ctx.lookup("java:OracleDS");  
  53.         JdbcTemplate jt = new JdbcTemplate(ds);  
  54.         DefaultTransactionDefinition tf = new DefaultTransactionDefinition();  
  55.         PlatformTransactionManager tm = new DataSourceTransactionManager(ds);  
  56.         TransactionStatus ts = tm.getTransaction(tf);  
  57.         try {  
  58.             // 数据库操作1  
  59.             // 数据库操作2  
  60.             tm.commit(ts);  
  61.         } catch (Exception e) {  
  62.             tm.rollback(ts);  
  63.             e.printStackTrace();  
  64.         }  
  65.     }  
  66.   
  67. }  

 

 

JdbcUtils

 

 

[java] view plain copy
 
 print?
  1. import java.sql.CallableStatement;  
  2. import java.sql.Connection;  
  3. import java.sql.PreparedStatement;  
  4. import java.sql.ResultSet;  
  5. import java.sql.SQLException;  
  6. import java.sql.Savepoint;  
  7.   
  8. import javax.naming.Context;  
  9. import javax.naming.InitialContext;  
  10. import javax.naming.NamingException;  
  11. import javax.sql.DataSource;  
  12.   
  13. import org.apache.log4j.Logger;  
  14.   
  15. public class JdbcUtils {  
  16.     private static Logger logger = Logger.getLogger(JdbcUtils.class);  
  17.     private static String oracleDS = "java:OracleDS";  
  18.     private static DataSource dataSource = null;  
  19.   
  20.     static {  
  21.         try {  
  22.             Context context = new InitialContext();  
  23.             dataSource = (DataSource) context.lookup(oracleDS);  
  24.         } catch (NamingException e) {  
  25.             logger.info("查找数据源失败···", e);  
  26.         }  
  27.     }  
  28.   
  29.     public static Connection getConnection() {  
  30.         Connection conn = null;  
  31.         try {  
  32.             conn = dataSource.getConnection();  
  33.         } catch (SQLException e) {  
  34.             logger.info("获取数据库连接失败···", e);  
  35.         }  
  36.         return conn;  
  37.     }  
  38.   
  39.     public static void close(Connection conn) {  
  40.         if (conn != null) {  
  41.             try {  
  42.                 conn.close();  
  43.             } catch (SQLException e) {  
  44.                 logger.info("释放数据库连接失败···", e);  
  45.             }  
  46.         }  
  47.     }  
  48.   
  49.     public static void close(CallableStatement cs) {  
  50.         if (cs != null) {  
  51.             try {  
  52.                 cs.close();  
  53.             } catch (SQLException e) {  
  54.                 logger.info("关闭CallableStatement失败···", e);  
  55.             }  
  56.         }  
  57.     }  
  58.   
  59.     public static void close(PreparedStatement ps) {  
  60.         if (ps != null) {  
  61.             try {  
  62.                 ps.close();  
  63.             } catch (SQLException e) {  
  64.                 logger.info("关闭PreparedStatement失败···", e);  
  65.             }  
  66.         }  
  67.     }  
  68.   
  69.     public static void close(ResultSet rs) {  
  70.         if (rs != null) {  
  71.             try {  
  72.                 rs.close();  
  73.             } catch (SQLException e) {  
  74.                 logger.info("关闭ResultSet失败···", e);  
  75.             }  
  76.         }  
  77.     }  
  78.   
  79.     public static void setAutoCommit(Connection conn, boolean autoCommit) {  
  80.         if (conn != null) {  
  81.             try {  
  82.                 conn.setAutoCommit(autoCommit);  
  83.             } catch (SQLException e) {  
  84.                 logger.info("设置事务提交方式失败···", e);  
  85.             }  
  86.         }  
  87.     }  
  88.   
  89.     public static void commit(Connection conn) {  
  90.         if (conn != null) {  
  91.             try {  
  92.                 conn.commit();  
  93.             } catch (SQLException e) {  
  94.                 logger.info("提交事务失败···", e);  
  95.             }  
  96.         }  
  97.     }  
  98.   
  99.     public static void rollback(Connection conn) {  
  100.         if (conn != null) {  
  101.             try {  
  102.                 conn.rollback();  
  103.             } catch (SQLException e) {  
  104.                 logger.info("回滚事务失败···", e);  
  105.             }  
  106.         }  
  107.     }  
  108.   
  109.     public static void rollback(Connection conn, Savepoint sp) {  
  110.         if (conn != null) {  
  111.             try {  
  112.                 conn.rollback(sp);  
  113.             } catch (SQLException e) {  
  114.                 logger.info("回滚事务失败···", e);  
  115.             }  
  116.         }  
  117.     }  
  118.   
  119. }  
分享到:
评论

相关推荐

    spring编程式事务实现

    本篇文章将聚焦于编程式事务管理,特别是如何通过`TransactionTemplate`进行事务控制。 1. **Spring编程式事务管理**: 编程式事务管理允许开发者在代码中直接控制事务的开始、提交、回滚等操作。这种方式提供了更...

    spring编程式事务与声明式事务详解

    Spring 提供了多种方式来实现编程式事务管理,例如使用 TransactionTemplate 或者直接使用 PlatformTransactionManager。 声明式事务管理 声明式事务管理是指通过配置文件或注解来管理事务。 Spring 提供了多种...

    spring学习之八--Hibernate编程式事务

    在编程式事务管理中,我们通常会使用TransactionTemplate或者PlatformTransactionManager接口。TransactionTemplate是Spring提供的一个事务管理工具类,它简化了事务管理的代码,使得我们可以在不直接接触底层事务...

    spring_tx编程式事务代码

    编程式事务管理允许开发者通过代码来精确控制事务的边界,而`TransactionTemplate`就是Spring为编程式事务管理提供的一种便捷工具。 `TransactionTemplate`类是Spring框架的`org.springframework.transaction....

    全面分析 Spring 的编程式事务管理及声明式事务管理

    3. **TransactionTemplate**: Spring提供的一个工具类,简化了编程式事务管理的代码,使得我们可以专注于业务逻辑而不是事务控制。通过设置TransactionDefinition和执行execute方法,我们可以在一个回调函数中编写...

    spring 自定义事务管理器,编程式事务,声明式事务@Transactional使用

    本教程将深入探讨如何在Spring中实现自定义事务管理器、编程式事务处理以及声明式事务`@Transactional`的使用。 首先,让我们了解事务管理的基本概念。事务是一组数据库操作,这些操作要么全部执行,要么全部回滚,...

    全面分析_Spring_的编程式事务管理及声明式事务管理

    首先,编程式事务管理依赖于编程的方式显式地控制事务的开始、提交、回滚等操作。它通过实现 `PlatformTransactionManager` 接口的实例,如 `HibernateTransactionManager` 或 `DataSourceTransactionManager` 来...

    09-4编程式事务管理.rar

    本资料着重于“编程式事务管理”,这是一种通过代码直接控制事务开始、提交、回滚等操作的方式。 在Spring中,编程式事务管理通常使用PlatformTransactionManager接口实现,如DataSourceTransactionManager(适用于...

    spring声明事务,编程事务实现

    Spring 声明事务、编程事务实现 Spring 声明事务是指使用 Spring 框架来管理事务,实现事务控制。声明式事务管理是建立在 AOP 之上的,它的本质是对方法前后进行拦截,然后在目标方法开始之前创建或者加入一个事务...

    全面分析Spring的编程式事务管理与声明式事务管理.doc

    Spring 提供了多种方式来实现编程式事务管理,例如使用 TransactionTemplate、TransactionInterceptor 等。 六、声明式事务管理 声明式事务管理是指通过配置文件或注解的方式来管理事务的提交和回滚。 Spring ...

    跟我学Spring3(9.3)Spring的事务之编程式事

    声明式事务基于AOP(面向切面编程),通过在配置文件或注解中声明事务规则,而编程式事务则是通过编程的方式来控制事务的开始、提交、回滚等操作。 3. **编程式事务**:编程式事务通常通过TransactionTemplate或者...

    spring编程式和声明式事务管理

    编程式事务管理适合对事务有特殊需求或需要精细控制的场合,而声明式事务管理则更适合大部分常规情况,让代码更加整洁。在实际项目中,根据具体需求和团队习惯来选择合适的事务管理方式是非常重要的。

    spring+mybatis的编码式事务

    编码式事务,也称为编程式事务管理,是指在代码中显式地控制事务的开始、提交、回滚等操作。这种方式虽然灵活,但会增加代码的复杂性和维护难度。下面将详细阐述Spring+MyBatis中的编码式事务管理。 1. **Spring的...

    spring编程式事务与声明式事务详解[参照].pdf

    **声明式事务管理**则是基于AOP(面向切面编程)的,通过在XML配置文件或者使用Java注解(@Transactional)来声明哪些方法需要在事务中运行。这种方式使得事务管理与业务逻辑解耦,提高了代码的可读性和可维护性。...

    spring编程式事物

    编程式事务管理是指在代码中显式地控制事务的开始、提交、回滚等操作,而声明式事务管理则是通过配置或注解来定义事务边界,更加简洁且易于维护。 标题"spring编程式事物"主要关注的是编程式事务管理。这种方式允许...

    详解Spring学习之编程式事务管理

    详解Spring学习之编程式事务管理 Spring框架中提供了两种事务管理方式:编程式事务管理和声明式事务...我们讨论了编程式事务管理的定义、优点和缺点,并提供了一些示例代码来演示如何使用编程式事务管理来管理事务。

    使用Spring的事务模板

    事务模板(`TransactionTemplate`)是Spring提供的一种编程式事务管理工具,它简化了在非AOP环境中使用事务的代码。`TransactionTemplate`包装了`PlatformTransactionManager`,并提供了一种简单的API来执行事务内的...

    spring声明式事务处理demo

    编程式事务管理通常通过AOP(面向切面编程)的TransactionTemplate或PlatformTransactionManager接口直接在代码中控制事务,而声明式事务管理则是基于AOP的,通过配置XML或使用注解来定义事务边界。 1. **配置...

    spring事务操作试验

    声明式事务管理通过配置元数据(如XML或注解)来控制事务边界,而编程式事务管理则通过TransactionTemplate或PlatformTransactionManager接口直接在代码中管理事务。 在描述中提到的博客文章中,作者可能详细讲解了...

Global site tag (gtag.js) - Google Analytics