Spring @Transactional 如何开启事务

最新推荐文章于 2024-07-23 13:38:50 发布
最新推荐文章于 2024-07-23 13:38:50 发布
阅读量4.7k 收藏
点赞数
分类专栏： s2s3h4(s2sh) 文章标签： s2s3h4 spring3 hibernate4 struts2
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wzygis/article/details/28611775
版权
Spring @Transactional 如何开启事务

java.lang.Object

  org.springframework.transaction.support.TransactionSynchronizationManager

public abstract class TransactionSynchronizationManager

extends Object

Central helper that manages resourcesand transaction synchronizations per thread.

为每个线程管理资源和事务的中心helper


 hibernate.current_session_context_class=org.springframework.orm.hibernate4.SpringSessionContext时,

@Transactional,Spring的事务管理器HibernateTransactionManager.doBegin()方法开启的Session和事务 就是绑定到TransactionSynchronizationManager的上下文(ThreadLocal的Map)中的..


 SpringSessionContext.currentSesssion()方法就是在TransactionSynchronizationManager的上下文中查找的..


上文回顾:

现在对于hibernate.current_session_context_class= org.springframework.orm.hibernate4.SpringSessionContext时的getCurrentSession()就很清楚了:

 

 

1:@Transactional声明的方法执行时,Spring的TransactionManager会自动Open Sesion,自动开启事务,并且将此Sesion绑定到SpringSessionContext(实际上是TransactionSynchronizationManager的ThreadLocal的Map)中..

 

2:SessionFactory.getCurrentSession()方法执行时,调用SpringSessionContext.currentSession()从TransactionSynchronizationManager的上下文中查找 当前的Session

 

3:找到后返回当前的Session,找不到,则返回HibernateException("NoSessionfound for current thread")

 

 

上述第一点是未验证的,现在我们来分析一下源代码:


Public UserService
{
   @Transactional
   public void addUser(User user) throwsException
   {
      Session session =sessionFactory.getCurrentSession();
    
      session.save(user);
   }
}

//当然,声明式事务管理实质也是用AOP实现的,此时取得的一个Proxy..
UserService userService = (UserService) beanFactory.getBean("userService");
             
User user = new User();
user.setName("Mark");
             
userService.addUser(user);  //在执行这一句时,应该是调用Proxy来开启一个事务,并绑定到某个上下文中,我们跟进去看看

先进入到JdkDynamicAopProxyimplements.invoke()方法

然后到ReflectiveMethodInvocation. proceed(),这里调用TransactionInterceptor.invoke(this)方法: 

典型的拦截器模式:

1:按需开启事务

2:递归执行下一个拦截器 或 执行代理目标方法

3:提交事务

public class TransactionInterceptor extends TransactionAspectSupport implements MethodInterceptor,Serializable {
 
    public Object invoke(final MethodInvocationinvocation) throws Throwable {
                                                                                                                                                  .......
              //就在这一句开启事务
              TransactionInfotxInfo = createTransactionIfNecessary(tm, txAttr,joinpointIdentification);
              ......
              retVal= invocation.proceed();   //执行下一个拦截器 或 执行代理目标的方法
              ......                                                                                                                              //提交事务                       
              commitTransactionAfterReturning(txInfo);                                                                     
              return retVal;
              .......
    } 
}

进入createTransactionIfNecessary(tm,txAttr, joinpointIdentification), 其中的tm.getTransaction(txAttr);    //这一句应该是取得事务的,跟进去

 

……………………………………….

AbstractPlatformTransactionManager.getTransaction()方法:

如果当前有事务,取出并根据事务传播行为的配置去处理,如果当前没有事务,调用doBegin开启一个新事务

public abstract classAbstractPlatformTransactionManager implementsPlatformTransactionManager, Serializable {
 ......
   public final TransactionStatus getTransaction(TransactionDefinitiondefinition) throws TransactionException {
              //这里是取得当前已绑定到TransactionSynchronizationManager的上下文的事务,主要为事务传播行为而设
              Object transaction =doGetTransaction();
              ........
              //如果事务已存在,根据事务传播行为来处理,
              if(isExistingTransaction(transaction)) {
                     // Existingtransaction found -> check propagation behavior to find out how to behave.
                     return handleExistingTransaction(definition, transaction, debugEnabled);
              }
              ......
              //这里最关键,开启一个新的事务,并放进TransactionSynchronizationManager的上下文中,并绑定到当前线程)
              doBegin(transaction,definition);
              return status;
              .......
       }
......
}

HibernateTransactionManager.doGetTransaction()方法:

尝试获取当前已绑定到TransactionSynchronizationManager的上下文的事务,主要为事务传播行为而设 

public class HibernateTransactionManager extends AbstractPlatformTransactionManager
		implements ResourceTransactionManager, InitializingBean {

	protected Object doGetTransaction() {
		HibernateTransactionObject txObject = new HibernateTransactionObject();
		......

		//在TransactionSynchronizationManager的上下文中查找当前的Session(实质上也是与线程绑定的)
		SessionHolder sessionHolder =
				(SessionHolder) TransactionSynchronizationManager.getResource(getSessionFactory());

		......
		return txObject;
	}

}

HibernateTransactionManager.doBegin()方法:

开启一个新的事务,并放进TransactionSynchronizationManager的上下文(ThreadLocal的Map)中,绑定到当前线程)

public class HibernateTransactionManager extends AbstractPlatformTransactionManager
		implements ResourceTransactionManager, InitializingBean {
......
     protected void doBegin(Object transaction, TransactionDefinition definition) {
		
                HibernateTransactionObject txObject = (HibernateTransactionObject) transaction;

		.........

		try {
			if (txObject.getSessionHolder() == null || txObject.getSessionHolder().isSynchronizedWithTransaction()) {
				//这里才真正的打开Session
				Session newSession = SessionFactoryUtils.openSession(getSessionFactory());
				.........
			}

			session = txObject.getSessionHolder().getSession();

                        .........

			Transaction hibTx;

			// Register transaction timeout.
			.........
			if (timeout != TransactionDefinition.TIMEOUT_DEFAULT) {
				.........
			}
			else {
				//这里才真正地开启事务
				hibTx = session.beginTransaction();
			}

			.........

                        //如果这新开启的Session,则将SessionHolder(Session和Transaction)放到TransactionSynchronizationManager的上下文中(绑定到当前线程)
			// Bind the session holder to the thread.

			if (txObject.isNewSessionHolder()) {                                                                                                        
                                //以键值对<SessionFactory,SessionHolder>形式绑定到TransactionSynchronizationManager的上下文中
				TransactionSynchronizationManager.bindResource(getSessionFactory(), txObject.getSessionHolder());
			}
			
			.......
		}

		.........
     }
......
}

Spring @Transactional 如何开启事务 总结:


@Transactional声明的方法执行时会调用AbstractPlatformTransactionManager.getTransaction()取得当前事务


而getTransaction()的执行流程如下:

1:尝试获取当前已绑定到TransactionSynchronizationManager的上下文的事务

(调用HibernateTransactionManager.doGetTransaction()方法)


2:如果取得已存在的事务,则根据事务传播属性的设置来处理

(调用AbstractPlatformTransactionManager.handleExistingTransaction()方法)


3:如果没有事务,则打开新的Session,开启新的事务,并将该Session和事务绑定到TransactionSynchronizationManager的上下文中

(调用HibernateTransactionManager.doBegin()方法)



-------------------------------------------------

核心还是理解TransactionSynchronizationManager,要懂得Spring的TransactionManager开启事务后是以键值对<SessionFactory,SessionHolder>形式 存放到 TransactionSynchronizationManager的上下文(ThreadLocal的Map)中(以ThreadLocal的方式与当前线程绑定).

<div class="dp-highlighter bg_java"><div class="bar"><div class="tools"><b>[java]</b> <a href="#" class="ViewSource" title="view plain" οnclick="dp.sh.Toolbar.Command('ViewSource',this);return false;">view plain</a><a href="#" class="CopyToClipboard" title="copy" οnclick="dp.sh.Toolbar.Command('CopyToClipboard',this);return false;">copy</a><a href="#" class="PrintSource" title="print" οnclick="dp.sh.Toolbar.Command('PrintSource',this);return false;">print</a><a href="#" class="About" title="?" οnclick="dp.sh.Toolbar.Command('About',this);return false;">?</a><div style="position: absolute; left: 0px; top: 0px; width: 0px; height: 0px; z-index: 99;"><embed id="ZeroClipboardMovie_8" src="http://static.blog.csdn.net/scripts/ZeroClipboard/ZeroClipboard.swf" loop="false" menu="false" quality="best" bgcolor="#ffffff" name="ZeroClipboardMovie_8" allowscriptaccess="always" allowfullscreen="false" type="application/x-shockwave-flash" pluginspage="http://www.macromedia.com/go/getflashplayer" flashvars="id=8&width=0&height=0" wmode="transparent" align="middle" height="0" width="0"></div></div></div><ol class="dp-j" start="1"><li class="alt"><span><span><pre></pre>  </span></span></li><li class=""><span><pre></pre>  </span></li><li class="alt"><span><pre></pre>  </span></li><li class=""><span><pre></pre>  </span></li><li class="alt"><span><pre></pre>  </span></li><li class=""><span><pre></pre>  </span></li><li class="alt"><span><pre></pre>  </span></li><li class=""><span><pre></pre>  </span></li><li class="alt"><span><pre></pre>  </span></li><li class=""><span><pre></pre>  </span></li><li class="alt"><span><pre></pre>  </span></li><li class=""><span><pre></pre>  </span></li><li class="alt"><span><pre></pre>  </span></li><li class=""><span><pre></pre>  </span></li><li class="alt"><span><pre></pre>  </span></li><li class=""><span><pre></pre>  </span></li><li class="alt"><span><pre></pre>  </span></li><li class=""><span><pre></pre>  </span></li><li class="alt"><span><pre></pre>  </span></li><li class=""><span><pre></pre>  </span></li><li class="alt"><span><pre></pre>  </span></li><li class=""><span><pre></pre>  </span></li><li class="alt"><span><pre></pre>  </span></li><li class=""><span><pre></pre>  </span></li><li class="alt"><span><pre></pre>  </span></li></ol></div><pre style="display: none;" name="code" class="java"><pre></pre>
<pre></pre>
<pre></pre>
<pre></pre>
<pre></pre>
<pre></pre>
<pre></pre>
<pre></pre>
<pre></pre>
<pre></pre>
<pre></pre>
<pre></pre>
<pre></pre>
<pre></pre>
<pre></pre>
<pre></pre>
<pre></pre>
<pre></pre>
<pre></pre>
<pre></pre>
<pre></pre>
<pre></pre>
<pre></pre>
<pre></pre>
<pre></pre>

</pre>


智能体格
关注
专栏目录
Spring @Transactional工作原理详解
08-28
这个过程是由Spring AOP（面向切面编程）代理实现的，它会在方法执行前开启事务，在方法结束后根据执行情况决定是否提交或回滚事务。 事务的传播行为（propagation）是`@Transactional`的另一个重要特性。它定义了...
Spring中@Transactional什么时候开启事务？
1
03-29 5281
http://www.voidcn.com/article/p-tvhtywql-tz.html 在使用注解事务的情况时，Spring会把每个方法的执行封装为AOP执行过程。每次执行被事务注解方法时，会判断是否有必要创建事务。如果创建事务成功，则继续调用业务逻辑方法。事务是在方法执行最开始阶段创建的，因此方法要越小越好。 事务的执行入口是TransactionInterceptor的invok...
在一个事物方法中开启新事物，完成对数据库的修改
最新发布
qq_36608622的博客
07-23 492
但是，在一个已经标记为@Transactional的方法内部调用另一个也标记了@Transactional的方法时，如果不正确处理，可能会导致一些意料之外的行为。这是因为默认情况下，Spring的@Transactional是基于代理的，这意味着如果在一个事务方法中直接调用另一个事务方法，后者并不会开启新的事务。这种方式会强制在当前事务的上下文中开启一个新的事务。这样，你就可以在一个已经处于事务中的方法内，安全地开启并完成对数据库的另一组修改操作。如何在一个事务方法中开启新事务。
Spring事务（通俗易懂）
weixin_43412919的博客
02-04 1124
本文主要介绍Spring的实现方式、隔离级别、传播机制以及事务何时失效。 1.事务的实现方式 spring事务的实现方式有两种，编程式事务和声明式事务，编程式事务要手动管理事务，实际开发当中基本不会使用。本文主要重点介绍声明式事务，声明式事务管理有三种实现方式：基于TransactionProxyFactoryBean的方式、基于AspectJ的XML方式、基于注解的方式。下面主要介绍常用的两种 基于AspectJ的XML方式 在spring核心配置文件中添加事务管理器的配置、事务的增强以及切面 &l.
@Transactional开启事务以及@Transactional属性配置
weixin_44976835的博客
08-25 4810
@Transactional事务有如下可添加参数： 参数名 参数值 参数作用 noRollbackFor Class<? extends Throwable>[] 一组异常类，遇到时不回滚。默认为{} isolation 枚举org.springframework.transaction.annotation.Isolation的值 事务隔离级别 noRollbackForClassName Stirng[] 一组异常类名，遇到时不回滚，默认为{} propagati
基于注解@Transactional事务基本用法
tiantiantbtb的博客
03-05 1419
事务(TRANSACTION) 是作为单个逻辑工作单元执行的一系列操作。多个操作作为一个整体向系统提交，要么都执行，要么都不执行。事务是一个不可分割的逻辑单元。脏读:简单来说,就是一个事务读取到了另一个事务未提交的数据。不可重复读:就是说,比如在A事务中进行多次相同的查询,B事务在A事务多次查询之间修改对应表中的数据,导致A事务多次读取的结果不一致。
spring @Transactional 无效的解决方案
08-26
3. 注意仅仅 @Transactional 注解的出现不足于开启事务行为，它仅仅 是一种元数据。必须在配置文件中使用配置元素，才真正开启了事务行为。 在实际开发中，我们可能会遇到@Transactional注解无效的情况。那么，到底...
Spring @Transactional注解失效解决方案
08-25
如果方法没有关联到一个事务，容器不会为他开启事务，如果方法在一个事务中被调用，该事务会被挂起，调用结束后，原先的事务会恢复执行。 3. REQUIRESNEW：不管是否存在事务，该方法总汇为自己发起一个新的事务。...
后端 Java Spring Data Jpa @Transactional 介绍
03-17
- **开始事务**：当方法被调用时，Spring会检测到`@Transactional`，并开启一个新的数据库事务。 - **事务处理**：在方法内部执行的所有数据库操作都在这个事务中进行。 - **提交事务**：如果方法正常结束，Spring会...
Spring中@Transactional用法详细介绍
08-31
如果不存在，则不开启事务。 - `Propagation.MANDATORY`：如果当前存在事务，则加入该事务；如果不存在，则抛出异常。 - `Propagation.REQUIRES_NEW`：总是创建新的事务，如果当前存在事务，则挂起当前事务。 - `...
Spring @Transactional事务传播机制详解
endwas
04-09 3859
## 总结 本文讲解了Spring事务的七种传播机制，我们可以根据具体的类型，具体设置，避免事务的方法过于长，一个事务里面调用的库表越多，就越有可能造成死锁，所以我们要根据具体的需要拆分使用。
SpringBoot 开启事务的两种常用方式
weixin_44340643的博客
01-12 1万+
spring boot 使用事务
事务及SpringBoot中的事务开启
m0_70770402的博客
02-28 4872
1.什么是事务？1.什么是事务？事务是指在数据库管理系统中执行的一系列操作的逻辑单元。事务可以由一个或多个数据库操作（例如插入、更新、删除等）组成，这些操作被视为一个不可分割的工作单元。在事务中，要么所有的操作都成功执行，要么所有的操作都不执行，不会出现部分操作成功而部分操作失败的情况。传播行为（Propagation）：指定事务的传播行为，即定义了事务方法调用之间的关系。隔离级别（Isolation Level）：指定事务的隔离级别，即定义了事务之间的可见性和并发控制的程度。
@Transactional事务注解
Blair686的博客
11-09 1361
声明式事务处理
@Transactional 在一个事物方法中开启新事物，完成对数据库的修改
热门推荐
X_kai_style的博客
08-18 2万+
@Transactional 这个注解之前用到的不多，也没具体了解过，今天才发现他是一个很重要的注解。 今天碰到个问题在一个service的实现方法中，需要对当前方法记录一个字段，并且实时更新到数据库，刚开始以为只是简单的调用mapper的update或者insert方法就可以了，后来发现数据库字段的值并没有改变， JDBC Connection [com.alibaba.druid.pro...
springboot如何开启事务@Transactional
OceanSky的专栏
05-26 4210
上图展示了springboot事务管理器实现的一个结构图，直接使用的是JdbcTransactionManager事务管理器，spring的核心接口是PlatformTransactionManager； 一、通过自动化配置类TransactionAutoConfiguration启动spring事务 @Configuration(proxyBeanMethods = false) @ConditionalOnBean(TransactionManager.class) @Conditional..
Transactional的7种Propagation 事务配置 开启 关闭 spring springboot mybatis
global_coding的博客
10-17 1415
Transactional的7种Propagation 事务配置 开启 关闭 spring springboot mybatis
Spring 随笔 transactional 7-事务实际的开启时机
hyoka的博客
10-03 951
Spring 随笔 transactional 7-事务实际的开启时机
spring @Transactional 原理
07-23
当一个方法被@Transactional注解标记时，Spring会在方法执行前开启一个事务，在方法执行后根据方法执行的结果决定是提交事务还是回滚事务。如果方法执行成功，则提交事务，如果方法执行失败，则回滚事务。 @...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

智能体格

你的鼓将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值