SPRINGER提交latex

转载

mob64ca1407d5aa 2024-12-03 13:15:03

文章标签 SPRINGER提交latex java bc spring 文章分类 架构后端开发

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

[java] view plain copy print ?

1. execute(TransactionCallback action) ;

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

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

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

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

里面只有一个方法：

[java] view plain copy print ?

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 = "java:OracleDS";  
17. private static DataSource dataSource = null;  
18.   
19. static {  
20. try {  
21. new InitialContext();  
22.             dataSource = (DataSource) context.lookup(oracleDS);  
23. catch (NamingException e) {  
24. "查找数据源失败···", e);  
25.         }  
26.     }  
27.   
28. public static TransactionTemplate getTransactionTemplate() {  
29. 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. 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. 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. new InitialContext();  
52. "java:OracleDS");  
53. new JdbcTemplate(ds);  
54. new DefaultTransactionDefinition();  
55. 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. new InitialContext();  
23.             dataSource = (DataSource) context.lookup(oracleDS);  
24. catch (NamingException e) {  
25. "查找数据源失败···", e);  
26.         }  
27.     }  
28.   
29. public static Connection getConnection() {  
30. null;  
31. try {  
32.             conn = dataSource.getConnection();  
33. catch (SQLException e) {  
34. "获取数据库连接失败···", 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. "释放数据库连接失败···", 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. "关闭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. "关闭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. "关闭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. "设置事务提交方式失败···", 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. "提交事务失败···", 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. "回滚事务失败···", 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. "回滚事务失败···", e);  
115.             }  
116.         }  
117.     }  
118.   
119. }

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。