- 浏览: 45960 次
- 性别:
- 来自: 深圳
-
最新评论
接着我们重点再回头看一下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放到下一篇文章里说吧，我会把大家正确得观点不断得加到贴中，使本贴得质量不断提高，共同进步吧，使劲的拍吧。俺写文章得水平是不行的，希望大家也多提提写文章技巧方面的意见。
发表评论
-
Spring与Struts整合3种方式实例
2009-11-04 23:35 1079Spring与Struts整合3种方式实例 Sprin ... -
解惑 spring 嵌套事务
2009-10-26 14:58 1262在所有使用 spring 的应用中, 声明式事务管理可能是使用 ... -
Spring声明式事务管理源码解读(4)
2009-10-26 14:55 1028还有一点需要说明的是，AService的方法在执行之前创建的t ... -
Spring声明式事务管理源码解读(3)
2009-10-26 14:55 760上次说到spring声明式事 ... -
Spring声明式事务管理源码解读(1)
2009-10-26 14:43 778/***作者：张荣华(ahuaxuan ... -
在Spring中如何使用加密外部属性文件
2009-10-19 12:40 1063在Spring的开发中， ... -
Spring 配置Spring数据源
2009-10-19 11:17 805不管通过何种持久化 ...
相关推荐
Spring源代码解析(六)：Spring声明式事务处理.doc
Spring声明式事务配置管理方法
spring声明式事务实例 可复制修改使用。。。。。。。。。。
Spring框架的声明式事务管理是Java开发中的核心特性，它为高效且可靠的数据操作提供了强大支持。Spring通过@Transactional注解以及底层的AOP和代理机制实现了声明式事务。这个机制允许开发者通过简单的注解就能控制...
spring声明式事务管理异常处理的测试
spring声明式事务处理demo。myeclipse工程
Java高级编程 实验报告 spring 声明事务 实验目的 掌握spring 声明式事务管理配置 实验环境 本实验采用本实验采用的eclipse或者 Myeclpse开发工具。Spring 4.0以上 Jdk1.7以上、oracle/mysql。
示例代码 博文链接：https://awaken2012.iteye.com/blog/1728283
Spring源代码解析(六）：Spring声明式事务处理 Spring源代码解析（七）：Spring AOP中对拦截器调用的实现 Spring源代码解析（八）：Spring驱动Hibernate的实现 Spring源代码解析（九）：Spring Acegi框架鉴权的实现 ...
spring声明式事务管理+jdbc+连接池 包内为代码，下载可直接执行。 一直用s2sh,感觉hibernate不好用，所以写了一个spring声明式事务管理+jdbc+连接池。
Spring 声明式事务和Spring 编程式事务
使用@Transactional注解时，可以通过参数配置事务详情： 5.2.2 基于Annotation方式的声明式事务 * * * * * * * * 声明式事务管理 如何实现Spring的声明式事务管理？ 5.2 声明式事务管理 Spring的声明式事务管理可以...
1．掌握Myeclipse的使用。 2．掌握spring框架和hibernate框架的使用。 3. 掌握整合spring和hibernate的持久化操作编程 4．掌握基于AOP的声明式事务编程...3.配置WEB-INF/applicationContext.xml提供基于AOP的声明式事务
1. 基于Aspectj实现动态数据源...6. 实现事务内切换数据源(支持原生Spring声明式事务哟，仅此一家)，并支持多数据源事务回滚(有了它除了跨服务的事务你需要考虑分布式事务，其他都不需要，极大的减少了系统的复杂程度)
spring声明式事务管理_入门
spring声明式事务管理+jdbc+连接池.zip
Spring 的事务管理是 Spring 框架中一个比较重要的知识点，该知识点本身并不复杂，只是由于其比较灵活，导致初学者很难把握。本教程从基础知识开始，详细分析了 Spring 事务管理的使用方法，为读者理清思路。
本代码使用H2内存数据库演示spring事务使用，包括编程式事务，声明式事务@Transactional使用，自定义事务事务注解实现自定义事务管理器
Spring的声明式事务管理是采用AOP（Aspect-Oriented Programming，面向切面编程）实现的。在编程式事务管理中，各事务处理代码实际上是相似的，这就造成了代码重复；而且编程式事务管理会造成事务管理代码和被管理的...