Spring事务aftercommit原理及实践
题引示例
sql
CREATE TABLE `goods` ( `id` bigint(20) NOT NULL AUTO_INCREMENT, `good_id` varchar(20) DEFAULT NULL, `num` int(11) DEFAULT NULL, PRIMARY KEY (`id`), KEY `goods_good_id_index` (`good_id`) ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci
java示例
Class.forName("com.mysql.jdbc.Driver"); Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/test","root",""); //part1 conn.setAutoCommit(false); Statement statement = conn.createStatement(); statement.execute("INSERT INTO test.goods ( good_id, num) VALUES ( 'sku123', 0);"); conn.commit(); //part2 statement = conn.createStatement(); statement.execute("INSERT INTO test.goods ( good_id, num) VALUES ( 'sku123', 0);"); conn.setAutoCommit(true); //part3 try { statement = conn.createStatement(); statement.execute("INSERT INTO test.goods ( good_id, num) VALUES ( 'sku123', 0);"); int i = 1/0; }catch (Exception ex){ System.out.println("there is an error"); } conn.setAutoCommit(true); //part4 conn.setAutoCommit(false); try { statement = conn.createStatement(); statement.execute("INSERT INTO test.goods ( good_id, num) VALUES ( 'sku123', 0);"); int i = 1/0; }catch (Exception ex){ System.out.println("there is an error"); } conn.setAutoCommit(true);
你举得这4段代码都提交了吗,为什么?
如果你知道这个知识点,那么本文对于你来说很容易理解。
一个知识点
首先,上面4段代码都会提交成功。
主要的知识点是, autocommit
的状态切换时,会对自动提交之前执行的内容。
看下这个方法的注释就知道了。
他这边说,如果事务执行过程中,如果 autocommit
状态改变了,会提交之前的事务。
额,这有个逻辑上的问题,如果autocommit
本身就是true,我们的语句不是直接就提交了么,那这个描述应该改成从false改成true的时候。
其实这段注释还有前半段。
针对DML和DDL语句,autocommit
=true的情况下,statement是立刻提交的。
而对于select语句,要等到关联的result set被关闭,对于存储过程....
而这个知识点太偏了,懂的朋友了解下,告诉我是啥..
所以我们这边的知识点严谨点来说就是: 对于DDL和DML语句,当autocommit从false切换为true时,事务会自动提交。
spring事务中的aftercommit
afterCommit是Spring事务机制中的一个回调钩子,用于在事务提交后做一些操作。
我们可以这么使用它
TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronization(){ public void afterCommit() { //...执行一些操作 } });
也可以通过@TransactionalEventListener间接使用它,它的底层原理就是上面这段代码
@TransactionalEventListener public void handleEvent(Event event){ //...执行一些操作 }
重点是在事务提交后执行一些操作,也就是我题目中conn.commit()
之后再执行一些操作。
这个时候存在一个问题,如果这个操作是数据库相关的操作,会不会被提交。
根据我文章开篇的代码,你肯定就知道答案就是会提交,但是是autocommit的切换导致的提交。
额,其实并不是,对比2个常用db框架,Mybatis和JPA(Hibernate),Mybatis会提交,而Hibernate会丢失。
在afercomit的注释中,他也警告我们了,在aftercommit中做数据库操作可能不会被提交。如果你要做数据库操作,你需要在一个新的事务中,可以使用PROPAGATION_REQUIRES_NEW
隔离级别。
源码中的NOTE要仔细的看!!很重点
在不创建新事务的前提下,为什么对于Mybatis和JPA在aftercommit中执行操作,一个提交,一个不提交?开始我们的源码解析。
源码解析
Spring Transaction的核心逻辑封装在TransactionAspectSupport的invokeWithinTransaction方法中,而核心流程中重要的三个操作,获取/提交/回滚事务,由PlatformTransactionManager来实现。
public interface PlatformTransactionManager extends TransactionManager { TransactionStatus getTransaction(@Nullable TransactionDefinition definition) throws TransactionException; void commit(TransactionStatus status) throws TransactionException; void rollback(TransactionStatus status) throws TransactionException; }
PlatformTransactionManager使用了策略模式和模板方法模式,它的子类AbstractPlatformTransactionManager又对上面三个方法做了抽象,暴露了一一系列钩子方法让子类实现。
最常用的子类就是DataSourceTransactionManager和HibernateTransactionManager,分别对应Mybatis和JPA框架。
本文讲解的aftercommit同步钩子在AbstractPlatformTransactionManager的processCommit中被触发。
回顾我们上面展示的场景,我们在一个事务里,注册了一个aftercommit钩子,并且aftercommit里面,也会再次操作数据库,执行dml操作。
private void processCommit(DefaultTransactionStatus status) throws TransactionException { try { //... else if (status.isNewTransaction()) { if (status.isDebug()) { logger.debug("Initiating transaction commit"); } unexpectedRollback = status.isGlobalRollbackOnly(); //...假设事务提交成功 doCommit(status); } try { triggerAfterCommit(status); } finally { triggerAfterCompletion(status, TransactionSynchronization.STATUS_COMMITTED); } } finally { cleanupAfterCompletion(status); }
在第一个事务doCommit成功,他会通过triggerAfterCommit触发它的aftercommit钩子逻辑,进行下一次事务操作,但是此时的Transaction还没有释放,并且它也不是newTransaction了。
为什么不是newTransaction,见以下代码
private TransactionStatus handleExistingTransaction( TransactionDefinition definition, Object transaction, boolean debugEnabled) throws TransactionException { //... return prepareTransactionStatus(definition, transaction, false, newSynchronization, debugEnabled, null); }
因为 status.isNewTransaction()
不成立,所以 doCommit(status);
不会执行。
doCommit
中会进行什么操作?
对于DataSourceTransactionManager,就是调用了Connection的commit方法,对事务进行提交。
protected void doCommit(DefaultTransactionStatus status) { DataSourceTransactionObject txObject = (DataSourceTransactionObject) status.getTransaction(); Connection con = txObject.getConnectionHolder().getConnection(); if (status.isDebug()) { logger.debug("Committing JDBC transaction on Connection [" + con + "]"); } try { con.commit(); } catch (SQLException ex) { throw new TransactionSystemException("Could not commit JDBC transaction", ex); } }
虽然错失了doCommit这个机会,但是在cleanupAfterCompletion(status);
方法
private void cleanupAfterCompletion(DefaultTransactionStatus status) { status.setCompleted(); if (status.isNewSynchronization()) { TransactionSynchronizationManager.clear(); } if (status.isNewTransaction()) { doCleanupAfterCompletion(status.getTransaction()); } if (status.getSuspendedResources() != null) { if (status.isDebug()) { logger.debug("Resuming suspended transaction after completion of inner transaction"); } Object transaction = (status.hasTransaction() ? status.getTransaction() : null); resume(transaction, (SuspendedResourcesHolder) status.getSuspendedResources()); } }
在doCleanupAfterCompletion的逻辑中,注意doCleanupAfterCompletion也是一个钩子,这个逻辑也由DataSourceTransactionManager实现
protected void doCleanupAfterCompletion(Object transaction) { DataSourceTransactionObject txObject = (DataSourceTransactionObject) transaction; // Remove the connection holder from the thread, if exposed. if (txObject.isNewConnectionHolder()) { TransactionSynchronizationManager.unbindResource(obtainDataSource()); } // Reset connection. Connection con = txObject.getConnectionHolder().getConnection(); try { if (txObject.isMustRestoreAutoCommit()) { con.setAutoCommit(true); } DataSourceUtils.resetConnectionAfterTransaction( con, txObject.getPreviousIsolationLevel(), txObject.isReadOnly()); } catch (Throwable ex) { logger.debug("Could not reset JDBC Connection after transaction", ex); } if (txObject.isNewConnectionHolder()) { if (logger.isDebugEnabled()) { logger.debug("Releasing JDBC Connection [" + con + "] after transaction"); } DataSourceUtils.releaseConnection(con, this.dataSource); } txObject.getConnectionHolder().clear(); }
调用到了 con.setAutoCommit(true);
间接了提交了事务
然后我们再来看看HibernateTransactionManager对这个两个方法的实现
HibernateTransactionManager#doCommit
protected void doCommit(DefaultTransactionStatus status) { HibernateTransactionObject txObject = (HibernateTransactionObject) status.getTransaction(); Transaction hibTx = txObject.getSessionHolder().getTransaction(); Assert.state(hibTx != null, "No Hibernate transaction"); if (status.isDebug()) { logger.debug("Committing Hibernate transaction on Session [" + txObject.getSessionHolder().getSession() + "]"); } try { //看这里 hibTx.commit(); } catch (org.hibernate.TransactionException ex) { // assumably from commit call to the underlying JDBC connection throw new TransactionSystemException("Could not commit Hibernate transaction", ex); } catch (HibernateException ex) { // assumably failed to flush changes to database throw convertHibernateAccessException(ex); } catch (PersistenceException ex) { if (ex.getCause() instanceof HibernateException) { throw convertHibernateAccessException((HibernateException) ex.getCause()); } throw ex; } }
HibernateTransactionManager#doCleanupAfterCompletion
protected void doCleanupAfterCompletion(Object transaction) { HibernateTransactionObject txObject = (HibernateTransactionObject) transaction; // Remove the session holder from the thread. if (txObject.isNewSessionHolder()) { TransactionSynchronizationManager.unbindResource(obtainSessionFactory()); } // Remove the JDBC connection holder from the thread, if exposed. if (getDataSource() != null) { TransactionSynchronizationManager.unbindResource(getDataSource()); } Session session = txObject.getSessionHolder().getSession(); if (this.prepareConnection && isPhysicallyConnected(session)) { // We're running with connection release mode "on_close": We're able to reset // the isolation level and/or read-only flag of the JDBC Connection here. // Else, we need to rely on the connection pool to perform proper cleanup. try { Connection con = ((SessionImplementor) session).connection(); Integer previousHoldability = txObject.getPreviousHoldability(); if (previousHoldability != null) { con.setHoldability(previousHoldability); } DataSourceUtils.resetConnectionAfterTransaction( con, txObject.getPreviousIsolationLevel(), txObject.isReadOnly()); } catch (HibernateException ex) { logger.debug("Could not access JDBC Connection of Hibernate Session", ex); } catch (Throwable ex) { logger.debug("Could not reset JDBC Connection after transaction", ex); } } if (txObject.isNewSession()) { if (logger.isDebugEnabled()) { logger.debug("Closing Hibernate Session [" + session + "] after transaction"); } SessionFactoryUtils.closeSession(session); } else { if (logger.isDebugEnabled()) { logger.debug("Not closing pre-bound Hibernate Session [" + session + "] after transaction"); } if (txObject.getSessionHolder().getPreviousFlushMode() != null) { session.setFlushMode(txObject.getSessionHolder().getPreviousFlushMode()); } if (!this.allowResultAccessAfterCompletion && !this.hibernateManagedSession) { disconnectOnCompletion(session); } } txObject.getSessionHolder().clear(); }
docommit里的逻辑还是用到了底层connection的commit,而在doCleanupAfterCompletion中,没有见到设置autocommit的身影。
所以在JPA中你在aftercommit中进行dml操作是会丢失的。
另外一个点是,如果你在aftercommit进行了事务操作,但是中间发生了异常,比如2条insert语句后,发生了异常,这两条insert会不会回滚?
答案是不会
回顾processCommit方法
private void processCommit(DefaultTransactionStatus status) throws TransactionException { try { //... else if (status.isNewTransaction()) { if (status.isDebug()) { logger.debug("Initiating transaction commit"); } unexpectedRollback = status.isGlobalRollbackOnly(); //...假设事务提交成功 doCommit(status); } try { triggerAfterCommit(status); } finally { triggerAfterCompletion(status, TransactionSynchronization.STATUS_COMMITTED); } } finally { cleanupAfterCompletion(status); } }
我们的aftercommit在triggerAfterCommit执行,这个方法里面抛出了异常,因为没有catch,异常会往上传递,在cleanupAfterCompletion里也没有处理异常,但是对于mybatis来讲,它改变了autocommit状态,所以更改被提交了。这是一个你想不到的坑。
最佳实践
- aftercommit或者说是transactionlistener,最好不要有dml操作
- 一但aftercommit中有事务操作,存在的风险是,一致性得不到保证,异常不会让这部分的事务回滚
demo
写了一个工程,用于测试mybatis和jpa中对于aftercommit中执行dml操作是否会提交
地址 https://github.com/shengchaojie/spring_tx_aftercommit_problem
参考资料 https://www.jb51.net/article/279094.htm
以上就是Spring事务aftercommit原理及实践的详细内容,更多关于Spring事务aftercommit原理的资料请关注脚本之家其它相关文章!
相关文章
Java Spring框架创建项目与Bean的存储与读取详解
本篇文章将介绍Spring项目的创建,IDEA国内源的配置以及Bean的存储与读取,所谓的Bean其实就是对象的意思,更详细地说Spring Bean是被实例的,组装的及被Spring 容器管理的Java对象2022-07-07详解Spring Boot 2.0.2+Ajax解决跨域请求的问题
这篇文章主要介绍了详解Spring Boot 2.0.2+Ajax解决跨域请求的问题,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧2019-03-03IntelliJ IDEA2021.1 配置大全(超详细教程)
这篇文章主要介绍了IntelliJ IDEA2021.1 配置大全(超详细教程),需要的朋友可以参考下2021-04-04
最新评论