随笔 - 100  文章 - 50  trackbacks - 0
<2024年12月>
日一二三四五六
24252627282930
1234567
891011121314
15161718192021
22232425262728
2930311234

常用链接

留言簿(3)

随笔分类

随笔档案

文章分类

文章档案

收藏夹

我收藏的一些文章!

搜索

  •  

最新评论

阅读排行榜

评论排行榜

Spring的事务管理入门：编程式事务管理(TransactionTemplate)

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

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

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

  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中有一个重要的方法：

  1. execute(TransactionCallback action) ;  

 

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

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

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

发现这是一个接口（这也必须是接口，因为任务都是自己具体定义的）

里面只有一个方法：

  1. doInTransaction(TransactionStatus status) ;   

 

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

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

查询下去，这个 TransactionStatus 还是一个接口。 看看这个接口定义了哪些服务（方法）：

  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

  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

  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

  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. }  

 

posted on 2016-06-16 09:55 fly 阅读(1137) 评论(0)  编辑  收藏 所属分类: java学习

只有注册用户登录后才能发表评论。
网站导航:
 
Copyright ©2024 fly Powered by: 博客园 模板提供：沪江博客