分类： Java
2008-01-18 14:19:07
<---- 接1续 ---->
接着我们重点再回头看一下createTransactionIfNecessary方法里的这一句：
txInfo.newTransactionStatus(this.transactionManager.getTransaction(txAttr));
接着我们就应该去看看这个getTransaction方法了，假设我们是使用hibernate3，其他类似。看getTransaction之前我们来看一下这两类和一个接口：
接口PlatformTransactionManager
抽象类public abstract class AbstractPlatformTransactionManager implements PlatformTransactionManager
类public class HibernateTransactionManager extends AbstractPlatformTransactionManager，很明显，这里有一个方法模板模式。
那我们看一下AbstractPlatformTransactionManager中得getTransaction方法：
代码
1. public final TransactionStatus getTransaction(TransactionDefinition definition) throws TransactionException {
2. Object transaction = doGetTransaction();//抽象方法，也需要子类实现,这个方法同样很重要
3.
4. // Cache debug flag to avoid repeated checks.
5. boolean debugEnabled = logger.isDebugEnabled();
6. if (debugEnabled) {
7. logger.debug("Using transaction object [" + transaction + "]");
8. }
9.
10. if (definition == null) {
11. // Use defaults if no transaction definition given.
12. definition = new DefaultTransactionDefinition();
13. }
14.
15. if (isExistingTransaction(transaction)) {
16. // Existing transaction found -> check propagation behavior to find out how to behave.
17. return handleExistingTransaction(definition, transaction, debugEnabled);
18. }
19.
20. // Check definition settings for new transaction.
21. if (definition.getTimeout() < TransactionDefinition.TIMEOUT_DEFAULT) {
22. throw new InvalidTimeoutException("Invalid transaction timeout", definition.getTimeout());
23. }
24.
25. // No existing transaction found -> check propagation behavior to find out how to behave.
26. if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_MANDATORY) {
27. throw new IllegalTransactionStateException(
28. "Transaction propagation 'mandatory' but no existing transaction found");
29. }
30. else if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRED ||
31. definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRES_NEW ||
32. definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NESTED) {
33. if (debugEnabled) {
34. logger.debug("Creating new transaction with name [" + definition.getName() + "]");
35. }
36. doBegin(transaction, definition);
37. boolean newSynchronization = (this.transactionSynchronization != SYNCHRONIZATION_NEVER);
38. return newTransactionStatus(definition, transaction, true, newSynchronization, debugEnabled, null);
39. }
40. else {
41. // Create "empty" transaction: no actual transaction, but potentially synchronization.
42. boolean newSynchronization = (this.transactionSynchronization == SYNCHRONIZATION_ALWAYS);
43. return newTransactionStatus(definition, null, false, newSynchronization, debugEnabled, null);
44. }
45. }
上面的代码很多地方都有解释，所以很好理解，这段代码的关键部分在doBegin(transaction,definition)这里（这是一个抽象方法，子类必须实现这个方法，具体依赖于抽象，这个是对方法模板模式的一个概括。），前面讲到我们假设是使用hibernate，那么就看看HibernateTransactionManager这个类吧，doBegin里的参数1，transaction其实是HibernateTransactionObject的一个实例，这个实例里主要存放的就是sessionholder，sessionholder里存放的就是开始事务的session和transaction对象,如果之前没有sessionholder存放到线程中，那么这个HibernateTransactionObject的实例的属性其实是空的，这一点可以在doBegin方法的实现中看出来
代码
1. protected void doBegin(Object transaction, TransactionDefinition definition) {
2. if (getDataSource() != null && TransactionSynchronizationManager.hasResource(getDataSource())) {
3. throw new IllegalTransactionStateException(
4. "Pre-bound JDBC Connection found - HibernateTransactionManager does not support " +
5. "running within DataSourceTransactionManager if told to manage the DataSource itself. " +
6. "It is recommended to use a single HibernateTransactionManager for all transactions " +
7. "on a single DataSource, no matter whether Hibernate or JDBC access.");
8. }
9.
10. Session session = null;
11.
12. try {
13. HibernateTransactionObject txObject = (HibernateTransactionObject) transaction;
14. if (txObject.getSessionHolder() == null) {
15. Interceptor entityInterceptor = getEntityInterceptor();
16. Session newSession = (entityInterceptor != null ?
17. getSessionFactory().openSession(entityInterceptor) : getSessionFactory().openSession());
18. if (logger.isDebugEnabled()) {
19. logger.debug("Opened new Session [" + newSession + "] for Hibernate transaction");
20. }
21. txObject.setSessionHolder(new SessionHolder(newSession), true);
22. }//我们看到，如果传进来的transaction中并没有存放sessionholder，那么就新建一个session，放到新的sessionholder中，再放到HibernateTransactionObject的实例中去,顺便说一下，这个变量的名字取得真是差，虽然是Juergen Hoeller写的，也要批一下，搞得别人会以为是Transaction的实例
23. txObject.getSessionHolder().setSynchronizedWithTransaction(true);
24. session = txObject.getSessionHolder().getSession();
25.
26. Connection con = session.connection();
27. Integer previousIsolationLevel = DataSourceUtils.prepareConnectionForTransaction(con, definition);
28. txObject.setPreviousIsolationLevel(previousIsolationLevel);
29.
30. if (definition.isReadOnly() && txObject.isNewSessionHolder()) {
31. // Just set to NEVER in case of a new Session for this transaction.
32. session.setFlushMode(FlushMode.NEVER);
33. }//如果是只读事务，并且sessionholder是新建的，那么就设置hibernate的flushmode为never
34.
35. if (!definition.isReadOnly() && !txObject.isNewSessionHolder()) {
36. // We need AUTO or COMMIT for a non-read-only transaction.
37. FlushMode flushMode = session.getFlushMode();
38. if (FlushMode.NEVER.equals(flushMode)) {
39. session.setFlushMode(FlushMode.AUTO); //如果session的flushmode是nerver，就设置为auto，因为如果事务定义成非readonly，那么这个session一定是可以flush的
40. txObject.getSessionHolder().setPreviousFlushMode(flushMode);
41. }
42. }
43.
44. // Add the Hibernate transaction to the session holder.
45. txObject.getSessionHolder().setTransaction(session.beginTransaction())；//开始一个事务，并把这个事务对象放到sessionholder中，随后这个sessionholder会通过threadlocal放到线程中，以供在commit时使用
46.
47. // Register transaction timeout.
48. if (definition.getTimeout() != TransactionDefinition.TIMEOUT_DEFAULT) {
49. txObject.getSessionHolder().setTimeoutInSeconds(definition.getTimeout());//设置超时时间,如果其超时时间为-1，则不进行设置，如果不是-1，那么超时时间是这样设置的new Date(System.currentTimeMillis() + millis*1000);既程序员在配置文件中指定的其实是秒数
50. }
51.
52. // Register the Hibernate Session's JDBC Connection for the DataSource, if set.
53. if (getDataSource() != null) {
54. ConnectionHolder conHolder = new ConnectionHolder(con);
55. if (definition.getTimeout() != TransactionDefinition.TIMEOUT_DEFAULT) {
56. conHolder.setTimeoutInSeconds(definition.getTimeout());
57. }
58. if (logger.isDebugEnabled()) {
59. logger.debug("Exposing Hibernate transaction as JDBC transaction [" + con + "]");
60. }
61. TransactionSynchronizationManager.bindResource(getDataSource(), conHolder);
62. txObject.setConnectionHolder(conHolder);
63. }
64.
65. // Bind the session holder to the thread.
66. if (txObject.isNewSessionHolder()) {
67. TransactionSynchronizationManager.bindResource(getSessionFactory(), txObject.getSessionHolder());//如果是新的sessionholder则绑定到线程。这样在进入方法栈中的下一个方法时就能得到整个sessionholder了，connectionholder亦是如此
68. }
69. } catch (Exception ex) {
70. SessionFactoryUtils.releaseSession(session, getSessionFactory());//如果抛出异常就释放这个session,这个操作还会在后面出现
71. throw new CannotCreateTransactionException("Could not open Hibernate Session for transaction", ex);
72. }
73. }
通过以上对代码的注释可以知道，如果给service设置声明式事务管理，假设事务传播途径为required，然后一个service调用另一个service时，他们其实是共用一个session，原则是没有就创建，有就不创建，并返回之前已创建的session和transaction。也就是说spring通过threadlocal把session和对应的transaction放到线程之中，保证了在整个方法栈的任何一个地方都能得到同一个session和transaction。
所以如果你的方法在事务体之内，那么你只要通过hibernatesupportdao或者hibernatetemplate来得到session的话，那这个session一定是开始事务的那个session，这个得到session的主要方法在SessionFactoryUtils里，我们来看一下
（这里还有一个小细节，public abstract class SessionFactoryUtils ，Juergen Hoeller在写工具类的时候为了不能让其有实例使用的是abstract，而我们一般的做法是final类加private的构造方法，看上去不怎么雅观,看看源代码还是能学习到不少写代码的技巧的,这里还有一个插曲，上次feiing还说java为什么不能弄成final和abstract同时存在呢，这样就可以确保既不会有实例产生，也不能继承了，呵呵）
在SessionFactoryUtils的doGetSession里写到，如果当前线程有绑定session，则返回这个session，如果没有绑定session，则看是否允许创建（既allowCreate这个参数是true还是false，这个参数将会在很多地方设计到，比如说hibernatetemplate和hibernatedaosupport里都有），如果不允许创建就抛出一个原始的hibernateException，举个例子，如果你没有给某个service方法配置声明式事务管理，而却要在这个service所调用的dao里得到当前得session，这样就会抛这个错了：
代码
1. if (method.getName().equals("getCurrentSession")) {
2. // Handle getCurrentSession method: return transactional Session, if any.
3. try {
4. return SessionFactoryUtils.doGetSession((SessionFactory) proxy, false);
5. //最后一个参数是false，说明这个方法不能返回一个新的session，没有就抛异常
6. } catch (IllegalStateException ex) {
7. throw new HibernateException(ex.getMessage());
8. }
9. }
到这里事务开始部分基本就结束了。
按正常流程，那么接下来就是方法结束commit的问题了。Commit放到下一篇文章里说吧，我会把大家正确得观点不断得加到贴中，使本贴得质量不断提高，共同进步吧，使劲的拍吧。俺写文章得水平是不行的，希望大家也多提提写文章技巧方面的意见。
<----- 未完 ----->
