TransactionManager

事务划分属性（NotSupported、Required、Supports、RequiresNew、Mandatory和Never）

这六种都是由容器托管事务 (CMT)的bean来支持的，但如果使用的是bean托管事务(BMT)，EJB规范所能提供的功能难道就只有通过UserTransaction接口启动和提交/回滚事务吗？显然，CMT模型好像更强大，比如，BMT不能使当前事务挂起然后恢复，这就意味着在BMT bean中无法仿真RequiresNew和NotSupported划分，至少是在使用UserTransaction接口时。

　　虽然EJB规范并没有解释为什么会存在以上所提到的不对称情况，但是在BMT模型中依然有一种用来使事务挂起然后恢复的合法方式。如果曾经研究过javax.transaction包的内容，您可能会注意到，与UserTransaction接口一起的还有一个TransactionManager接口，它看起来就像一个扩展的UserTransaction：同样的方法——begin()、commit()和rollback()，再加上suspend()和resume()。

　　如果能从EJB中得到一个TransactionManager实现，我们就可以实现编程式地使事务挂起然后恢复的目标。虽然J2EE 1.3和EJB 2.0规范都未提到TransactionManager的可用性，但它们也都没有明确表示禁止使用它。此外，对于CMT事务划分，容器是从内部使用Java Transaction API (JTA)，因此，我们几乎可以100%地肯定：TransactionManager是存在的，惟一的问题只是在代码中获得对它的引用。

　　在这篇文章中，我们将了解如何利用几个流行的容器来获得一个TransactionManager，以及如何用它来扩展bean托管事务的功能，使它们和容器托管事务一样强大。我们也将简述一些涉及使用这些高级功能的风险，在文章的结尾，我们还将探讨如何在流行的Spring框架中使用TransactionManager。
在各种J2EE服务器中获得TransactionManager的引用

　　J2EE和EJB规范没有描述任何获得TransactionManager引用的标准方法，每个J2EE容器供应商可以随意将其放置在任何地方，甚至不需提供任何机制，就可以从应用程序代码中对它进行访问。但在实践中，如今所有的容器都有获取它的机制。以下是一些如何从最流行的J2EE容器获得TransactionManager引用的例子。
抛出一个UserTransaction (WebLogic、Orion、OC4J)

　　任何一个兼容J2EE的容器都必须使UserTransaction对象在JNDI中的java:comp/UserTransaction下可用。因为UserTransaction接口是TransactionManager的子集，所以一些J2EE容器供应商选择为它们提供一种通用的实现。WebLogic 8、Orion 2和Oracle的OC4J EJB3预览版都是这种方法的例子。在这些容器中，只要从JNDI中获得一个UserTransaction对象，再把它转到TransactionManager，就可以获得对TransactionManager的引用。这可能是最简单的一种情况。

Java代码  

1. private TransactionManager getFromUserTransaction()   
2.         throws Exception {  
3.     InitialContext ctx = new InitialContext();  
4.     UserTransaction ut = (UserTransaction)  
5.         ctx.lookup("java:comp/UserTransaction");  
6.     if (ut instanceof TransactionManager) {  
7.         log("UserTransaction also TransactionManager");  
8.         return (TransactionManager)ut;  
9.     }  
10.     return null;  
11. }  

直接从JNDI中获取TransactionManager (JBoss、WebLogic)

　　在JBoss 3和WebLogic 8中，可从JNDI获取TransactionManager（虽然名称不一样），因此可以通过简单的查找而获得：

Java代码  

1. private TransactionManager getFromJNDI()   
2.         throws Exception {  
3.     InitialContext ctx = new InitialContext();  
4.     try {  
5.         // WebLogic  
6.         return (TransactionManager)  
7.             ctx.lookup("javax.transaction.TransactionManager");  
8.      }  
9.      catch (Exception e) {  }  
10.   
11.     try {  
12.         // JBoss  
13.         return (TransactionManager)  
14.             ctx.lookup("java:/TransactionManager");  
15.     }  
16.     catch (Exception e) { }  
17.     return null;  
18. }  

从一个定制的工厂获取TransactionManager (Websphere)

　　在WebSphere 4/5/6中，TransactionManager的引用要从工厂类中获取。但是，麻烦的是，工厂类的名称随WebSphere版本的不同而有所改变。

Java代码  

1. public TransactionManager getFromWebsphereFactory()   
2.         throws Exception {  
3.      try {  
4.         // WebSphere 5.1 or 6.0  
5.         return   
6.             com.ibm.ws.Transaction.TransactionManagerFactory  
7.                 .getTransactionManager();  
8.     }  
9.     catch (ClassNotFoundException ex) {}  
10.           
11.     try {  
12.         // WebSphere 5.0  
13.         return   
14.             com.ibm.ejs.jts.jta.TransactionManagerFactory  
15.                 .getTransactionManager();  
16.     }  
17.     catch (ClassNotFoundException ex) {}  
18.           
19.     try {  
20.         // WebSphere 4.0  
21.         com.ibm.ejs.jts.jta.JTSXA..getTransactionManager();  
22.     }  
23.     catch (ClassNotFoundException ex) { }  
24.   
25.     return null;  
26. }  

　　在WebLogic 7/8/9中，对TransactionManager的引用可以通过在Weblogic 7的TxHelper中定义的静态方法getTransactionManager()而获得。该类在WebLogic 8中被否决了，而用TransactionHelper取而代之。

Java代码  

1. public TransactionManager getFromWebLogicFactory()   
2.     throws Exception {  
3.      try {  
4.         // WebLogic 8/9  
5.         return   
6.             weblogic.transaction.TransactionHelper  
7.                 .getTransactionManager();  
8.     }  
9.     catch (ClassNotFoundException ex) {}  
10.           
11.     try {  
12.         // WebLogic 7  
13.         return   
14.             weblogic.transaction.TxHelper  
15.                 .getTransactionManager();  
16.     }  
17.     catch (ClassNotFoundException ex) {}  
18.           
19.     return null;  
20. }  

使用TransactionManager

　　一旦成功地获得TransactionManager引用，就可以用它来挂起和恢复事务，正如以下的示例代码所示。

...

Java代码  

1. // obtain UserTransaction object and start transaction  
2. InitialContext ctx = new InitialContext();  
3. UserTransaction userTransaction = (UserTransaction)  
4.     ctx.lookup("java:comp/UserTransaction");  
5.   
6. // start first transaction  
7. userTransaction.begin();  
8.               
9. // obtain TransactionManager   
10. // using one of the methods described above  
11. TransactionManager tm = getTransactionManager();  
12.   
13. // suspend transaction  
14. // suspend() returns reference to suspended  
15. // Transaction object which later should be passed  
16. // to resume()  
17. Transaction transaction = tm.suspend();  
18.                   
19. // here you can do something outside of transaction  
20. // or start new transaction,   
21. // do something and then commit or rollback  
22. userTransaction.begin();  
23.       
24. // commit subtransaction  
25. userTransaction.commit();  
26.   
27. // resume suspended transaction  
28. tm.resume(transaction);  
29.   
30. // commit first transaction  
31. userTransaction.commit();  
32. ...  

正如您所看到的，在TransactionManager接口的帮助下，可以对UserTransaction所提供的标准功能进行扩展，在BMT代码中实现与CMT bean相同的灵活性水平。

　　需要知道的是，当事务被挂起时，并不意味着事务的计时器停止了。换言之，如果把事务的超时设定为30秒，而事务已挂起了20秒并恢复了，那么该事务只剩10秒就要到达超时了。事务的挂起会解除事务与正在运行的线程之间的关联，然后resume()调用会再次将其关连，而不影响事务超时计时器。
已知问题

　　因为J2EE规范并不要求TransactionManager在J2EE容器中的可用性以及功能（虽然从底层的JTA基础架构中我们知道它应该是存在的），所以有些应用服务器中存在一些问题。例如，在WebLogic 7、8以及9（beta版）中有种特别奇怪的现象：假如一个事务被标记为回滚（通过调用UserTransaction.setRollbackOnly ()），然后被挂起，当被挂起的事务尝试恢复时，它将会出现如下的提示：

　　javax.transaction.InvalidTransactionException: Attempt to resume an inactive transaction

　　以下代码说明了该行为：

Java代码  

1. ...  
2. // obtain UserTransaction object and start transaction  
3. InitialContext ctx = new InitialContext();  
4. UserTransaction userTransaction = (UserTransaction)  
5.     ctx.lookup("java:comp/UserTransaction");  
6. userTransaction.begin();  
7.   
8. // mark for rollback  
9. userTransaction.setRollbackOnly();  
10.               
11. TransactionManager tm = getTransactionManager();  
12.   
13. // suspend transaction  
14. Transaction transaction = tm.suspend();  
15.                   
16. // resume suspended transaction  
17. // this call will fail with InvalidTransactionException  
18. //  in WebLogic  
19. tm.resume(transaction);  

...

　　幸运的是，对于该问题，有一个应急方案。WebLogic的TransactionManager实现连同标准的resume （Transaction transaction）方法，有一个可用于替代的forceResume方法。以下的代码展示了一种在WebLogic中运行代码时需要用到的模式。注意，在这种情况下，应该把对TransactionManager的引用转换到WebLogic的定制实现接口（WebLogic 7中的weblogic.transaction.TransactionManager或WebLogic 8以及更高版本中的weblogic.transaction.ClientTransactionManager）。

...
// obtain UserTransaction object and start transaction

Java代码  

1. InitialContext ctx = new InitialContext();  
2. UserTransaction userTransaction = (UserTransaction)  
3.     ctx.lookup("java:comp/UserTransaction");  
4. userTransaction.begin();  
5.   
6. // mark for rollback  
7. userTransaction.setRollbackOnly();  
8.               
9. TransactionManager tm = getTransactionManager();  
10.   
11. // suspend transaction  
12. Transaction transaction = tm.suspend();  
13.                   
14. // resume suspended transaction  
15. try {  
16.     // first try standard JTA call  
17.     tm.resume(transaction);  
18. }  
19. catch (InvalidTransactionException e) {  
20.     // standard method failed, try forceResume()  
21.     if (tm instanceof   
22.         weblogic.transaction.ClientTransactionManager) {  
23.         // WebLogic 8 and above  
24.         ((weblogic.transaction.ClientTransactionManager)tm)  
25.             .forceResume(transaction);  
26.     }      
27.     else if (tm instanceof   
28.         weblogic.transaction.TransactionManager) {  
29.         // WebLogic 7  
30.         ((weblogic.transaction.TransactionManager)tm)  
31.             .forceResume(transaction)  
32.     }  
33.     else {  
34.         // cannot resume  
35.         throw e;  
36.     }  
37. }  

...

TransactionManager在Spring Framework中的用法

　　在流行的Spring framework中，以上所描述的技术都被广泛地用于事务代理。应该注意的是，每次使用PROPAGATION_REQUIRES_NEW或PROPAGATION_NOT_SUPPORTED、事务属性以及JtaTransactionManager来配置Spring的TransactionProxyFactoryBean时， Spring就会用JTA的TransactionManager来挂起和恢复事务。Spring太智能了，但有时太智能了反而使我无法接受——甚至没有指定，它就会发现容器中的TransactionManager。例如，当在一个Spring应用程序上下文中定义 JtaTransactionManager时，就可以为UserTransaction提供一个JNDI名，而如果UserTransaction也实现了它，它就将“自动检测”TransactionManager。如上所示，这对WebLogic、Orion和Oracle OC4J都适用。

　　有时，这可能并不是我们所想要的，尤其是当您想要严格遵循J2EE/EJB规范，并确保跨所有J2EE容器的完全可移植性的时候。正如我们所看到的，有时候编程式的事务挂起和恢复可能存在一些问题。虽然Spring知道如何绕过这些问题，至少是对于上面所描述的问题，即，在Welogic中，在挂起之前将事务标记为回滚。在这种情况下，可以在配置JtaTransactionManager时把 autodetectTransactionManager属性设定为false。如果这么做了，那么任何使用 PROPAGATION_REQUIRES_NEW或PROPAGATION_NOT_SUPPORTED事务属性的尝试都会抛出 TransactionSuspensionNotSupportedException而失败。但PROPAGATIO-REQUIRED、 PROPAGATION-SUPPORTS、PROPAGATION-MANDATORY以及PROPAGATION-NEVER应该会正常运行。这对应于JTA Usertransaction所提供的功能，而且在任一个兼容J2EE的容器中都起作用。

　　以下是Spring应用程序上下文中的事务管理器定义，其中禁用了TransactionManager自动检测：

Xml代码  

1. <bean id="transactionManager" class=  
2. "org.springframework.transaction.jta.JtaTransactionManager">  
3.   <property name="userTransactionName">  
4.     <value>javax.transaction.UserTransaction</value>  
5.   </property>  
6.   <property name="autodetectTransactionManager">  
7.     <value>false</value>  
8.   </property>  
9. </bean>  

结束语

　　J2EE规范不要求对JIA TransactionManager接口的支持。但由于J2EE使用JTA作为它的底层事务基础架构，所以几乎所有的J2EE服务器都把它公开为 J2EE的扩展。存在一些已知的兼容性问题，而在某些情况下，可以用特定于容器的代码来绕过这些问题。但是，如果需要实现编程式事务挂起，则J2EE中的 TransactionManager是一个强大的特性。只需首先在所选择的J2EE服务器中检测一下它是否可用就可以了。