spring事务 connection

最新推荐文章于 2024-03-07 14:29:04 发布
最新推荐文章于 2024-03-07 14:29:04 发布
阅读量1k 收藏 1
点赞数
分类专栏： spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013038630/article/details/73929005
版权

spring事务使用了aop、动态代理，而数据库的事务最终是作用在connection上面的，那么spring整个过程中开头的begin，结束的commit，rollback如何保证使用的是同一个connection，以及mybatis如何拿到这条connection执行sql，还有再加上spring事务的传播特性的时候connection变化呢

一、spring事务从开启到结束使用同一条connection

1、TransactionInterceptor.invoke -> TransactionAspectSupport.invokeWithinTransaction 方法中的

      createTransactionIfNecessary方法

      

TransactionStatus status = null;
		if (txAttr != null) {
			if (tm != null) {
				status = tm.getTransaction(txAttr);
			}

2、AbstractPlatformTransactionManager  的 TransactionStatus getTransaction(TransactionDefinition definition)

     DataSourceTransactionManager  的  doGetTransaction()

@Override
	protected Object doGetTransaction() {
		DataSourceTransactionObject txObject = new DataSourceTransactionObject();
		txObject.setSavepointAllowed(isNestedTransactionAllowed());
		ConnectionHolder conHolder =
			(ConnectionHolder) TransactionSynchronizationManager.getResource(this.dataSource);
		txObject.setConnectionHolder(conHolder, false);
		return txObject;
	}
此时ConnectionHolder可能是null，比如新的线程时候，TransationSynchronizationManager就是关键，使用了ThreadLocal保存ConnectionHolder，

也就是说在一个线程执行过程中，你可以随时拿到保存的connection，这也就是整个过程的关键。


3、回到AbstractPlatformTransactionManager  的getTransaction

    doBegin(transaction, definition);

 DataSourceTransactionManager  的doBegin片段

                  
if (txObject.getConnectionHolder() == null ||
					txObject.getConnectionHolder().isSynchronizedWithTransaction()) {
				Connection newCon = this.dataSource.getConnection();
				if (logger.isDebugEnabled()) {
					logger.debug("Acquired Connection [" + newCon + "] for JDBC transaction");
				}
				txObject.setConnectionHolder(new ConnectionHolder(newCon), true);
			}
//如果当前connectionHolder是null，从数据源取出一条connection生成一个ConnectionHolder设置到DataSourceTransactionObject

			txObject.getConnectionHolder().setSynchronizedWithTransaction(true);
			con = txObject.getConnectionHolder().getConnection();

			Integer previousIsolationLevel = DataSourceUtils.prepareConnectionForTransaction(con, definition);
			txObject.setPreviousIsolationLevel(previousIsolationLevel);

			// Switch to manual commit if necessary. This is very expensive in some JDBC drivers,
			// so we don't want to do it unnecessarily (for example if we've explicitly
			// configured the connection pool to set it already).
			if (con.getAutoCommit()) {
				txObject.setMustRestoreAutoCommit(true);
				if (logger.isDebugEnabled()) {
					logger.debug("Switching JDBC Connection [" + con + "] to manual commit");
				}
				con.setAutoCommit(false);
			}
			txObject.getConnectionHolder().setTransactionActive(true);

			int timeout = determineTimeout(definition);
			if (timeout != TransactionDefinition.TIMEOUT_DEFAULT) {
				txObject.getConnectionHolder().setTimeoutInSeconds(timeout);
			}

			// Bind the session holder to the thread.新的就绑定线程，供后面使用
			if (txObject.isNewConnectionHolder()) {
				TransactionSynchronizationManager.bindResource(getDataSource(), txObject.getConnectionHolder());
			}


4、以提交为例，TransactionAspectSupport中

正常提交事务commitTransactionAfterReturning(TransactionInfo txInfo)

最后到了DataSourceTransactionManager的doCommit(DefaultTransactionStatus status)

Connection con = txObject.getConnectionHolder().getConnection();

从status中拿到当前的connection，执行commit


5、mybatis

SpringManagedTransaction的openConnection

this.connection = DataSourceUtils.getConnection(this.dataSource);

DataSourceUtils

ConnectionHolder conHolder = (ConnectionHolder) TransactionSynchronizationManager.getResource(dataSource);
		if (conHolder != null && (conHolder.hasConnection() || conHolder.isSynchronizedWithTransaction())) {
			conHolder.requested();
			if (!conHolder.hasConnection()) {
				logger.debug("Fetching resumed JDBC Connection from DataSource");
				conHolder.setConnection(dataSource.getConnection());
			}
			return conHolder.getConnection();
		}

也是从上面保存的地方，根据线程拿到connection


二、spring事务的传播特性

TransactionDefinition中定义了事务的传播特性

PROPAGATION_REQUIRED  支持当前事务，如果当前没有新建一个新的

PROPAGATION_SUPPORTS  支持当前事务，如果当前没有无事务执行

PROPAGATION_MANDATORY  支持当前事务，如果当前没有抛出异常

PROPAGATION_REQUIRES_NEW  新建新的事务，当前有则挂起当前的事务

PROPAGATION_NOT_SUPPORTED  不支持当前事务，无事务执行

PROPAGATION_NEVER  不支持当前事务，当前有事务则抛出异常

PROPAGATION_NESTED  嵌套事务，类似PROPAGATION_REQUIRED  

从AbstractPlatformTransactionManager  的getTransaction方法中的

if (isExistingTransaction(transaction)) {
			// Existing transaction found -> check propagation behavior to find out how to behave.
			return handleExistingTransaction(definition, transaction, debugEnabled);
		}
可以分析到当前存在事务的情况，后面的就是当前不存在事务的处理。


下面看下PROPAGATION_REQUIRES_NEW  处理过程
handleExistingTransaction中

if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRES_NEW) {
			if (debugEnabled) {
				logger.debug("Suspending current transaction, creating new transaction with name [" +
						definition.getName() + "]");
			}
			SuspendedResourcesHolder suspendedResources = suspend(transaction);
			try {
				boolean newSynchronization = (getTransactionSynchronization() != SYNCHRONIZATION_NEVER);
				DefaultTransactionStatus status = newTransactionStatus(
						definition, transaction, true, newSynchronization, debugEnabled, suspendedResources);
				doBegin(transaction, definition);
				prepareSynchronization(status, definition);
				return status;
			}
			catch (RuntimeException beginEx) {
				resumeAfterBeginException(transaction, suspendedResources, beginEx);
				throw beginEx;
			}
			catch (Error beginErr) {
				resumeAfterBeginException(transaction, suspendedResources, beginErr);
				throw beginErr;
			}
		}
suspend最终调用了DataSourceTransactionManager的doSuspend

过程就是当前线程解绑上一个事务的connectionHoder，当前的DataSourceTransactionObject的connectionHolder设置为null

回到上面  会给当前的事务新建一个DefaultTransactionStatus，并且这个status会引用上一个事务的SuspendedResourcesHolder(主要就是connection)

作用呢就是当前事物结束的时候，再拿出来恢复上一个事物。

AbstractPlatformTransactionManager的cleanupAfterCompletion



三、事务与aop

看spring事物时候，知道了事务拦截器TransactionInterceptor环绕通知处理了事务，也就是拦截有@Transactional的bean的方法
虽然都知道是使用了aop进一步是用了动态代理，那么源头是从哪开始的


建了一个工程，添加事务注解，启动容器，如下打印的日志：

[localhost-startStop-1] [DEBUG]  DefaultListableBeanFactory:  Returning cached instance of singleton bean 'org.springframework.aop.aspectj.AspectJPointcutAdvisor#0'
 [localhost-startStop-1] [DEBUG]  DefaultListableBeanFactory:  Returning cached instance of singleton bean 'org.springframework.transaction.config.internalTransactionAdvisor'
 [localhost-startStop-1] [DEBUG]  DefaultListableBeanFactory:  Returning cached instance of singleton bean 'org.springframework.aop.aspectj.AspectJPointcutAdvisor#0'
 [localhost-startStop-1] [DEBUG]  AutowiredAnnotationBeanPostProcessor:  Autowiring by type from bean name 'tradeServiceImpl' to bean named 'goodsDao'
 [localhost-startStop-1] [DEBUG]  InjectionMetadata:  Processing injected method of bean 'tradeServiceImpl': AutowiredFieldElement for com.yi.trade.dao.TradeDao com.yi.trade.service.impl.TradeServiceImpl.tradeDao
 [localhost-startStop-1] [DEBUG]  DefaultListableBeanFactory:  Returning cached instance of singleton bean 'tradeDao'
 [localhost-startStop-1] [DEBUG]  DefaultListableBeanFactory:  Returning cached instance of singleton bean 'org.springframework.transaction.config.internalTransactionAdvisor'
 [localhost-startStop-1] [DEBUG]  DefaultListableBeanFactory:  Returning cached instance of singleton bean 'org.springframework.aop.aspectj.AspectJPointcutAdvisor#0'
 [localhost-startStop-1] [DEBUG]  DefaultListableBeanFactory:  Returning cached instance of singleton bean 'org.springframework.transaction.config.internalTransactionAdvisor'
 [localhost-startStop-1] [DEBUG]  DefaultListableBeanFactory:  Returning cached instance of singleton bean 'org.springframework.aop.aspectj.AspectJPointcutAdvisor#0'
 [localhost-startStop-1] [DEBUG]  AutowiredAnnotationBeanPostProcessor:  Autowiring by type from bean name 'tradeServiceImpl' to bean named 'tradeDao'
 [localhost-startStop-1] [DEBUG]  DefaultListableBeanFactory:  Returning cached instance of singleton bean 'org.springframework.transaction.config.internalTransactionAdvisor'
 [localhost-startStop-1] [DEBUG]  DefaultListableBeanFactory:  Returning cached instance of singleton bean 'org.springframework.aop.aspectj.AspectJPointcutAdvisor#0'
 [localhost-startStop-1] [DEBUG]  DefaultListableBeanFactory:  Returning cached instance of singleton bean 'org.springframework.transaction.config.internalTransactionAdvisor'
 [localhost-startStop-1] [DEBUG]  DefaultListableBeanFactory:  Returning cached instance of singleton bean 'org.springframework.aop.aspectj.AspectJPointcutAdvisor#0'
 [localhost-startStop-1] [DEBUG]  AnnotationTransactionAttributeSource:  Adding transactional method 'byTrade' with attribute: PROPAGATION_REQUIRED,ISOLATION_DEFAULT; ''
 [localhost-startStop-1] [DEBUG]  DefaultListableBeanFactory:  Returning cached instance of singleton bean 'org.springframework.transaction.interceptor.TransactionInterceptor#0'
 [localhost-startStop-1] [DEBUG]  AnnotationAwareAspectJAutoProxyCreator:  Creating implicit proxy for bean 'tradeServiceImpl' with 0 common interceptors and 1 specific interceptors
 [localhost-startStop-1] [DEBUG]  JdkDynamicAopProxy:  Creating JDK dynamic proxy: target source is SingletonTargetSource for target object [com.yi.trade.service.impl.TradeServiceImpl@1a1cd3f]
 [localhost-startStop-1] [DEBUG]  DefaultListableBeanFactory:  Finished creating instance of bean 'tradeServiceImpl'

可以看到AnnotationAwareAspectJAutoProxyCreator:  Creating implicit proxy for bean 'tradeServiceImpl'以及后面的JdkDynamicAopProxy
明显就是生成代理类的日志


可是还是看不出在哪一步生成的，肯定是在createBean过程中，因为有Creating instance of bean 'tradeServiceImpl'~Finished creating instance of bean 'tradeServiceImpl'
那么继续跟踪代码发现是在
org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.initializeBean(String, Object, RootBeanDefinition)的applyBeanPostProcessorsAfterInitialization
方法中，是一个beanProcessor.postProcessAfterInitialization方法生成代理类的，这个类就是AnnotationAwareAspectJAutoProxyCreator


以及知道在spring容器refresh时候会把容器中的beanProcessor注册到一个list中(registerBeanPostProcessors(beanFactory))
看了一下这个地方及其周边代码发现没有显式注入的，断点发现会有一个org.springframework.aop.config.internalAutoProxyCreator的bean


然后想到aop的一些标签处理 

registerBeanDefinitionParser("aspectj-autoproxy", new AspectJAutoProxyBeanDefinitionParser());
在AspectJAutoProxyBeanDefinitionParser中可以跟踪到注册
org.springframework.aop.config.AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(BeanDefinitionRegistry, Object)
public static BeanDefinition registerAspectJAnnotationAutoProxyCreatorIfNecessary(BeanDefinitionRegistry registry, Object source) {
		return registerOrEscalateApcAsRequired(AnnotationAwareAspectJAutoProxyCreator.class, registry, source);
	}

然后去掉配置中所有aop相关的，打印日志发现AnnotationAwareAspectJAutoProxyCreator变成了InfrastructureAdvisorAutoProxyCreator

AbstractAutoProxyCreator
     AbstractAdvisorAutoProxyCreator
	      DefaultAdvisorAutoProxyCreator
		  InfrastructureAdvisorAutoProxyCreator
		  AspectJAwareAdvisorAutoProxyCreator
		       AnnotationAwareAspectJAutoProxyCreator
搜寻代码在<tx:annotation-driven/>的解析类AnnotationDrivenBeanDefinitionParser 的proxy模式中发现
AopNamespaceUtils.registerAutoProxyCreatorIfNecessary(parserContext, element);


AbstractAutoProxyCreator的postProcessAfterInitialization会根据是否需要，返回bean的包装类，也就是根据
bean是否有advice生成代理类，织入通知。


注解事务的就会生成代理类，织入事务拦截器逻辑。

ry_______
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
spring事务1
08-08
【Spring 事务管理】 在Spring框架中，事务管理是核心功能之一，它允许开发者处理数据库操作的原子性、一致性、隔离性和持久性（ACID属性）。Spring提供了两种主要的事务管理方式：编程式事务管理和声明式事务管理...
Spring 长事务导致connection closed，又熬了一个大夜！
BASK2312的博客
12-06 1881
大家好，我是不才陈某~是的，今早一到公司就收到了机器人的告警，从异常日志来看是数据库连接已关闭，然后我在解决这个问题的过程中发现了几个问题，不急，听我一一道来我们看到前文示例代码会发现我们在 try 之后只是 rollback 了，对于异常也只是打印一下并没有继续抛出。那么就会导致一种情况：假设你在 Service 层中调用多个调用数据库的修改方法，那么第一个操作失败后异常没有抛出，Service 层不知道，就会继续向后面执行，修复很简单，只需要将异常抛出即可： 大事务/长事务导致 connection
Spring入门详解
qq_45774743的博客
05-06 304
typora-copy-images-to: upload Spring入门详解 Spring框架是Java开发中最常用的框架，功能非常强大 源码下载：Spring Framework jar包、文档下载：reposity Spring核心概念 Ioc：Inversion of Control 控制反转 DI：Dependency Injection 依赖注入 AOP：Aspect Oriented Programming 面向切面编程 Spring下载 在reposity按照下图顺序依次点击 .
Spring事务之如何保证同一个Connection对象
热门推荐
Haiwi-Song
04-13 1万+
Spring容器的事务机制的实质是对传统JDBC的封装，也即是Spring事务管理无论是对单数据库实例还是分布式数据库实例，要实现事务管理，那么必须保证在一个事务过程获得Connetion对象是同一个，那么即使在同一个函数中调用其他多个的函数，通过Spring框架的AOP动态代理机制，使得Spring容器底层能够按传统JDBC的方式进行事务处理，从而保证对这个函数做事务控制。
JDBC 事务的传播特性和隔离级别
zhaoyan8783的专栏
07-23 764
事务的传播特性： 1、required：
mybatis整合spring 是怎样获取到 spring 创建的连接（connection ）
最新发布
weixin_42918955的博客
03-07 657
到此就可以知道，在同一个线程中 获取 connection 和 设置都是通过 TransactionSynchronizationManager.resources 操作的，只有 key 相同（也就是datesource 是同一个对象）获取到的 connection 是一致的，只有当mybaties 获取到的 connection 与 spring 创建的 connection 为同一个时 ，spring事务才会生效。
spring声明式事务解析
09-01
1.1 Spring事务管理器 Spring并不直接管理事务，而是利用JTA（Java Transaction API）或者特定持久层技术（如JDBC、JPA、Hibernate等）提供的事务实现。Spring通过AOP（面向切面编程）来实现事务管理，创建代理对象...
Spring事务管理
08-20
Spring事务管理是Spring框架中的重要组成部分，用于在多方法调用之间保持数据一致性，确保数据库操作的原子性、一致性、隔离性和持久性。事务管理在Java应用，尤其是企业级应用中至关重要，因为它们通常涉及复杂的...
MyBatis在Spring环境下的事务管理
08-25
MyBatis 在 Spring 环境下的事务管理是企业级应用中常见的技术组合，它结合了 MyBatis 的强大 SQL 映射能力和 Spring 的事务控制能力。MyBatis 是一个轻量级的持久层框架，它对 JDBC 进行了封装，提供了动态 SQL ...
Spring（三） Spring的事务处理及AOP基本原理
Hello World!
08-19 286
基于上一节尾部的案例，我们继续来完善这个项目，添加一个银行转账的功能，即从转出账户中转出一定的金额到转入账户，系统中初始用户有两个，分别为小明和小华，金额均为1000，说干就干，完善编码如下：
【Spring从入门到实战教程】第六章 Spring 事务管理详解
波哩个波的博客
05-16 511
1、事务概述 2、事务属性：传播行为、隔离级别、回滚、只读事务、超时 3、事务案例
Spring 获取Connection
X9X9X9X9的专栏
05-02 2400
JDBC/TEST                     或者                                     通过DataSourceUtils.getConnection(DataSource）;就能获取到设置的DataSource 然后获得connection public static Connection
java spring 数据库连接_Spring连接数据库的几种常用的方式
weixin_33894125的博客
02-12 326
先在本地mysql创建数据库luo,再建立表user。1,建立maven项目HelloSpring2，pom.xml添加需要用到的Jar包xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">4.0.0com.aluoHelloSpring0.0.1...
hibernate，spring管理事务中(transaction，JDBC connection，Hibernate Session的使用)
Java
08-07 1737
首先hibernate的Connection release mode有以下几种： 1 after_statement 2 after_transaction 3 on_close 其中after_statement 用在jta中 ，on_close 是3.1之前遗留的（也许是为spring留的-_-），也就是3.1之前默认是on_close ，但3.1之后默认如果单独使用hibernate
springboot学习(下)
Lightllll的博客
06-26 4446
springboot
浅谈Spring中事务管理器
持续Java学习中
02-19 917
由于事务部分代码在设计上整体比较简单，我自己觉得它在设计上没有什么特别让我眼前一亮的东西，所以下文更多的是侧重执行流程，能理解事务管理器等一众概念以及相关的变量含义，真正遇到Bug会调试，知道在什么地方打断点就行。后文更多的是代码+注释的形式呈现（注意，而且根据Spring的不同版本，代码实现上也略有差异），请配合自己项目源码慢慢食用。
一文读懂Spring事务管理器
qq826654664jx的专栏
10-17 215
为什么需要事务管理器 如果没有事务管理器的话，我们的程序可能是这样： Connection connection = acquireConnection(); try{ int updated = connection.prepareStatement().executeUpdate(); connection.commit(); }catch (Exception e){ ...
Spring是如何保证同一事务获取同一个Connection的？使用Spring的事务同步机制解决：数据库刚插入的记录却查询不到的问题【享学Spring】
架构师：通透，才能写出好代码！
06-13 9387
前言 关于Spring的事务，我前面用了大量的篇幅从应用层面、原理层面都进行了比较全方位的一个讲解。但是因为它过于重要，所以本文继续做补充：Spring事务的同步机制 Spring事务同步机制？我猜测很多小伙伴从来没听过有这么一说法，毕竟它在平时开发中你可能很少遇到（如果你没怎么考虑过系统性能的话）。 让我记录本文的动力是由于我在开发自己测试过程中遇到这样一个诡异异常： java.sql.SQLE...
spring事务和threadlocal
09-27
在Spring事务管理过程中，ThreadLocal起到了关键的作用。ThreadLocal是一种线程本地变量，使用ThreadLocal的形式声明一个变量，该变量就会在每个线程中创建一个变量的副本。在Spring中，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值