Spring Aop - Transactional注解原理深入剖析-第九篇

最新推荐文章于 2023-06-01 14:44:28 发布
最新推荐文章于 2023-06-01 14:44:28 发布
阅读量567 收藏
点赞数 2
分类专栏： Java 文章标签： spring java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/y510662669/article/details/106159947
版权

在研究Spring Aop Transaction之前，阅读了其他同学写的csdn的文章，这些文章对于事务切面执行的逻辑剖析的非常详细。但是我始终有一个疑问，就是我写了一个Service，是在什么阶段，通过Spring的哪个拓展点，生成的事物对象，翻阅了很多人的文章，始终没有找到满意答案，自己做了个Demo，从头到尾Debug了几遍，终于搞清楚了，瞬间豁然开朗。主要是从三个大的方面按照顺序去剖析：1.Spring tx包内的自定义标签解析。2.生成事物代理对象的过程。3.事物真正执行的过程。

实际例子

xml文件：

<import resource="classpath:mysql-datasource.xml"/>

<bean id="dataSourceLogService" class="com.yangt.risk.data.service.datasource.log.DataSourceLogServiceImpl"/>


<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<property name="dataSource" ref="dataSource" />
</bean>

<!-- 使用annotation注解方式配置事务 -->
<tx:annotation-driven />
<tx:annotation-driven transaction-manager="transactionManager"/>

java代码

    @Override
    @Transactional(rollbackFor = { Exception.class })
    public void saveLog(DataSourceLogDTO sourceLogDTO) {
        RiskCallDatasourceLogDO datasourceLogDO = DataSourceLogConvert.dto2SourceLogDO(sourceLogDTO);
        if (Objects.isNull(datasourceLogDO)) {
            return;
        }
        riskCallDatasourceLogMapper.insert(datasourceLogDO);
        RiskCallDatasourceParamLogWithBLOBsDO paramLogWithBLOBsDO = DataSourceLogConvert.dto2ParamLogDO(sourceLogDTO, datasourceLogDO.getId());
        if (paramLogWithBLOBsDO == null) {
            throw new YTRiskException("dataSourceLog表未返回正确主键或者sourceLogDTO is null");
        }
        riskCallDatasourceParamLogMapper.insert(paramLogWithBLOBsDO);
    }

执行结果debug截图

截图说明：由于设置的lazy-init = false，所以在执行getBean方法之前，applicationContext内就已经将事务代理Bean初始化好了，下面会具体剖析代理Bean生成的整体流程。

前奏铺垫之Tx自定义标签

在spring-tx包内, META-INF下面spring.handler内http\://www.springframework.org/schema/tx=org.springframework.transaction.config.TxNamespaceHandler

可以看到自定义标签解析类，org.springframework.transaction.config.TxNamespaceHandler，主要是有对三个标签的处理

    @Override
	public void init() {
		registerBeanDefinitionParser("advice", new TxAdviceBeanDefinitionParser());
		registerBeanDefinitionParser("annotation-driven", new AnnotationDrivenBeanDefinitionParser());
		registerBeanDefinitionParser("jta-transaction-manager", new JtaTransactionManagerBeanDefinitionParser());
	}

这里重点关注annotation-driven，这个标签类的解析，这里会有四个标签类解析注册。

  • InfrastructureAdvisorAutoProxyCreator(实现了 SmartInstantiationAwareBeanPostProcessor 接口，负责代理类的生成)

  • AnnotationTransactionAttributeSource（主要是用来存储一些事务相关的属性信息）

  • TransactionInterceptor（事务实现的核心拦截器，事务的回滚都是在其中完成）

  • BeanFactoryTransactionAttributeSourceAdvisor（增强器）

  • CompositeComponentDefinition（上述三种 bean 的组合）

事务代理类生成过程

以上是大体的流程图，需要对每一个步骤进行深入剖析：

第一步骤，回调方法被触发：

org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator#postProcessAfterInitialization在Bean的初始化阶段，会被回调，主要原因是：AbstractAutoProxyCreator继承了org.springframework.beans.factory.config.BeanPostProcessor。回调方法被触发后，wrapIfNecessary会被执行，这一段逻辑很重要。

protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
		if (beanName != null && this.targetSourcedBeans.contains(beanName)) {
			return bean;
		}
		if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
			return bean;
		}
		if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {
			this.advisedBeans.put(cacheKey, Boolean.FALSE);
			return bean;
		}

		// Create proxy if we have advice.
		Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
		if (specificInterceptors != DO_NOT_PROXY) {
			this.advisedBeans.put(cacheKey, Boolean.TRUE);
			Object proxy = createProxy(bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
			this.proxyTypes.put(cacheKey, proxy.getClass());
			return proxy;
		}

		this.advisedBeans.put(cacheKey, Boolean.FALSE);
		return bean;
	}

第二步骤，getAdviceAndAdvisorsForBean，这里会获取到所有符合条件的advisor和advice

protected List<Advisor> findEligibleAdvisors(Class<?> beanClass, String beanName) {
		List<Advisor> candidateAdvisors = findCandidateAdvisors();
		List<Advisor> eligibleAdvisors = findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName);
		extendAdvisors(eligibleAdvisors);
		if (!eligibleAdvisors.isEmpty()) {
			eligibleAdvisors = sortAdvisors(eligibleAdvisors);
		}
		return eligibleAdvisors;
	}

AbstractAdvisorAutoProxyCreator#findCandidateAdvisors找到所有实现Advisor接口的子类。这里会找到，BeanFactoryTransactionAttributeSourceAdvisor这个类的实例bean，注意：此bean是在前面的tx标签内注册的，已经注册到bean工厂内了。所以会拿到对应的实例bean。findAdvisorsThatCanApply是一个匹配的过程，具体的匹配逻辑如下：

for (Class<?> clazz : classes) {
			Method[] methods = clazz.getMethods();
			for (Method method : methods) {
				if ((introductionAwareMethodMatcher != null &&
						introductionAwareMethodMatcher.matches(method, targetClass, hasIntroductions)) ||
						methodMatcher.matches(method, targetClass)) {
					return true;
				}
			}
		}

具体匹配逻辑流程图：

最核心的matchs逻辑在：org.springframework.transaction.interceptor.AbstractFallbackTransactionAttributeSource#computeTransactionAttribute

即寻找TransactionAttribute对象的过程。如果寻找到TransactionAttribute对象，即代表匹配到了合适的Advisor，那么getAdviceAndAdvisorsForBean方法则会返回数组，数组内部包含适配到的Advisor。

第三步骤，createProxy，构造代理对象

ProxyFactory proxyFactory = new ProxyFactory();
proxyFactory.copyFrom(this);

if (!proxyFactory.isProxyTargetClass()) {
if (shouldProxyTargetClass(beanClass, beanName)) {
proxyFactory.setProxyTargetClass(true);
}
else {
evaluateProxyInterfaces(beanClass, proxyFactory);
}
}

Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);
proxyFactory.addAdvisors(advisors);
proxyFactory.setTargetSource(targetSource);
customizeProxyFactory(proxyFactory);

proxyFactory.setFrozen(this.freezeProxy);
if (advisorsPreFiltered()) {
proxyFactory.setPreFiltered(true);
}

ProxyFactory对象内会填充targetSource以及advisor对象。

第四步骤，ProxyFactory#getProxy(java.lang.ClassLoader) 生成代理对象

这里会选择使用JdkDynamicAopProxy还是CglibAopProxy，如果是接口则使用JdkDynamicAopProxy，这里的内容https://blog.csdn.net/y510662669/article/details/106033377 有详细的介绍。

根据流程图上画的是九个步骤，后面总结了下，根据以上四个步骤，Transaction的代理类就真正生成了。

事务真正执行过程

由于此处使用的是接口方式，所以真正执行代理逻辑的切入点是：

org.springframework.aop.framework.JdkDynamicAopProxy#invoke

由前面的文章可知，真正代理的执行方法是：

List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);

拿到实现MethodInterceptor或者Advice接口的实例。根据前面生成AopProxy代理类的逻辑可知，advised即：

BeanFactoryTransactionAttributeSourceAdvisor，那么就是从Advisor内拿到MethodInterceptor，为何能从Advisor内拿到MethodInterceptor呢？主要原因如下：

在org.springframework.transaction.config.TxNamespaceHandler解析xml，构造BeanDefinition时，已经将adviceName set进了BeanFactoryTransactionAttributeSourceAdvisor内，所以通过getAdvice方法，getAdvice方法即从BeanFactory工厂内根据adviceName去获取对应的TransactionInterceptor。

那么后面的逻辑，就水到渠成，只是执行TransactionInterceptor内的方法了。

以下是两个重要类的结构图：

通知器Advisor : org.springframework.transaction.interceptor.BeanFactoryTransactionAttributeSourceAdvisor

切面Intercepter: org.springframework.transaction.interceptor.TransactionInterceptor

TransactionInterceptor 执行逻辑：

核心逻辑代码在：org.springframework.transaction.interceptor.TransactionAspectSupport#invokeWithinTransaction

1. 获取到TransactionAttribute、数据源管理对象、获取到要执行的切点信息。

2.判断是否是使用了TransactionCallback，就是使用transactionTemplate这种形式，默认@Transactional的注解，这个步骤会返回false，直接执行下面的逻辑。

3.创建一个TransactionInfo，这里又可以细分为两步。

1）拿到AbstractPlatformTransactionManager#getTransaction，获取到一个TransactionStatus，具体流程：

     1.1 会执行doBegin方法，doBegin方法首先会从dataSourceManager内拿到connection对象，然后利用connection对象设置一系列事务相关的属性。例如：把自动提交置为false，transactionActive置为true。这里会有一个判断，如果@Transactional 注解的readOnly=true，则会执行只读事物。这里重点看了下，什么是只读事务？即开启只读事务后，只能读到事务开启之前的修改，之后的修改感知不到。除非只读事务提交后，再次利用只读事物去读。适用场景：如果在一个查询中，需要查询数据库多个表，为了保证这几个表的数据的一致性和完整性，可以开启只读事务。注意：开启只读事务后，如果在只读事务内执行update,insert,delete操作，则会抛出异常。Spring事务开启只读事务的动作，即会执行一个sql : SET TRANSACTION READ ONLY。如下代码：

protected void prepareTransactionalConnection(Connection con, TransactionDefinition definition)
			throws SQLException {

		if (isEnforceReadOnly() && definition.isReadOnly()) {
			Statement stmt = con.createStatement();
			try {
				stmt.executeUpdate("SET TRANSACTION READ ONLY");
			}
			finally {
				stmt.close();
			}
		}
	}

   1.2 执行一系列的同步操作，把一些列变量绑定到一个单例类的ThreadLocal上，如下：

protected void prepareSynchronization(DefaultTransactionStatus status, TransactionDefinition definition) {
		if (status.isNewSynchronization()) {
			TransactionSynchronizationManager.setActualTransactionActive(status.hasTransaction());
			TransactionSynchronizationManager.setCurrentTransactionIsolationLevel(
					definition.getIsolationLevel() != TransactionDefinition.ISOLATION_DEFAULT ?
							definition.getIsolationLevel() : null);
			TransactionSynchronizationManager.setCurrentTransactionReadOnly(definition.isReadOnly());
			TransactionSynchronizationManager.setCurrentTransactionName(definition.getName());
			TransactionSynchronizationManager.initSynchronization();
		}
	}

2）org.springframework.transaction.interceptor.TransactionAspectSupport#prepareTransactionInfo，执行此方法准备一个TransactionInfo，具体步骤如下：

   1.1 构造一个TransactionInfo对象，传入数据源管理对象、TransactionAttribute、切点信息对象。

   1.2 绑定到一个ThreadLocal。

4. 执行org.springframework.transaction.interceptor.TransactionAspectSupport.InvocationCallback#proceedWithInvocation这个方法，这个方法就是原始方法的回调。例如：此例子中，就是原始的saveLog方法，即执行此方法。

5.finally内的逻辑：cleanupTransactionInfo(txInfo); 把线程上绑定的txInfo置为老的txInfo，没太理解这部分的作用？

6.TransactionAspectSupport#commitTransactionAfterReturning方法执行，会通过txInfo拿到数据源管理对象，执行commit逻辑。具体代码：

private void processCommit(DefaultTransactionStatus status) throws TransactionException {
		try {
			boolean beforeCompletionInvoked = false;
			try {
                // 拓展点：准备预提交
				prepareForCommit(status);
                // 拓展点：提交之前的trigger
				triggerBeforeCommit(status);
				triggerBeforeCompletion(status);
				beforeCompletionInvoked = true;
				boolean globalRollbackOnly = false;
				if (status.isNewTransaction() || isFailEarlyOnGlobalRollbackOnly()) {
					globalRollbackOnly = status.isGlobalRollbackOnly();
				}
				if (status.hasSavepoint()) {
					if (status.isDebug()) {
						logger.debug("Releasing transaction savepoint");
					}
					status.releaseHeldSavepoint();
				}
				else if (status.isNewTransaction()) {
					if (status.isDebug()) {
						logger.debug("Initiating transaction commit");
					}
                    // 新事务则提交，即执行connection.commit方法
					doCommit(status);
				}
				// Throw UnexpectedRollbackException if we have a global rollback-only
				// marker but still didn't get a corresponding exception from commit.
				if (globalRollbackOnly) {
					throw new UnexpectedRollbackException(
							"Transaction silently rolled back because it has been marked as rollback-only");
				}
			}
			catch (UnexpectedRollbackException ex) {
				// can only be caused by doCommit
				triggerAfterCompletion(status, TransactionSynchronization.STATUS_ROLLED_BACK);
				throw ex;
			}
			catch (TransactionException ex) {
				// can only be caused by doCommit
				if (isRollbackOnCommitFailure()) {
					doRollbackOnCommitException(status, ex);
				}
				else {
					triggerAfterCompletion(status, TransactionSynchronization.STATUS_UNKNOWN);
				}
				throw ex;
			}
			catch (RuntimeException ex) {
				if (!beforeCompletionInvoked) {
					triggerBeforeCompletion(status);
				}
				doRollbackOnCommitException(status, ex);
				throw ex;
			}
			catch (Error err) {
				if (!beforeCompletionInvoked) {
					triggerBeforeCompletion(status);
				}
				doRollbackOnCommitException(status, err);
				throw err;
			}

			// Trigger afterCommit callbacks, with an exception thrown there
			// propagated to callers but the transaction still considered as committed.
			try {
				triggerAfterCommit(status);
			}
			finally {
				triggerAfterCompletion(status, TransactionSynchronization.STATUS_COMMITTED);
			}

		}
		finally {
			cleanupAfterCompletion(status);
		}
	}

可以看到：Spring事务执行阶段也是有很多拓展点的，方便我们使用，详细参考：https://www.jyoryo.com/archives/155.html

阿健2020
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
spring-aop-4.0.0.RELEASE
05-31
本文将深入探讨Spring AOP的核心概念、主要功能以及实际应用。 1. **AOP核心概念** - **切面（Aspect）**：切面是关注点的模块化，通常包含一组相关的通知（advises）和切入点（pointcuts）。 - **通知...
Spring @Transactional工作原理详解
08-28
在Spring框架中，`@Transactional`注解是一个强大的工具，用于声明式地管理事务。它使得开发者无需显式地在代码中控制事务的开始、提交和回滚，从而提高了代码的可读性和可维护性。下面我们将深入探讨`@...
springboot---mybatis操作事务配置的处理
最新发布
喜欢猪猪
06-01 3734
目前大多数的项目都是通过spring或者springboot来开发的，并且项目里面操作数据库常用的有mybatis\mybatis-plus等，在操作数据库的时候，经常会使用事务的处理，因为在操作数据库的时候，如果出现异常的话，所有的数据库操作都能够回滚操作，避免造成一些异常数据的问题。目前网络上搜索的都是原始的配置方式，比如说使用xml进行bean的配置，或者说直接在方法头上面进行添加注解的方式进行调用的，本文主要介绍通过配置类进行管理实务的方式，统一的管理、统一的处理方式。
关于executeUpdate方法返回的值问题
热门推荐
qq_24184997的博客
03-06 1万+
今天在项目中出现了一个问题，delete 语句使用executeUpdate方法后，如果是更新一条数则返回1，但是更新一条以上数据就出现返回0的问题，我一直以为executeUpdate返回更新的条数是错误的？带着疑问我们查看源码： @Override public int update(final String sql) throws DataAccessException { Asser...
关于事务回滚
鹏的博客
06-25 948
//Propagation.REQUIRED : 有事务就使用当前的事务,没有事务就创建一个事务 //Isolation=Isolation.DEFAULT : 事务数据库的默认隔离级别 //rollbackFor = Exception.class :事务回滚的异常类型 @Transactional(propagation = Propagation.REQUIRED,isolation = I...
SpringAop学习笔记（四）——@Transactional
weixin_39555954的博客
08-24 213
一、入口 package com.xiaojie.config; import com.mysql.jdbc.jdbc2.optional.MysqlDataSource; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.ComponentScan; import org.springframework.context.annotation.Configu
SPRING AOP Transaction
alex的博客
12-10 149
    今天在公司（Symbio CORP .）里修改一个老的投票系统的时候出现了一个和事物处理相关问题，最终在Andy的帮助下得以解决。首先真的很感谢他的帮助！呵呵，说实话他真对Spring很了解！还得多向他学习。     问题是这样的 控制器VoteViewFrontController的save方法的代码（SPRING MVC） public ModelAndView save...
spring的@Transactional注解用法解读
08-28
【Spring的@Transactional注解用法解读】 事务管理是企业级应用程序中的关键部分，它确保了在发生异常时数据的一致性。Spring框架提供了一种统一的方式来处理事务管理，包括对不同事务API（如JTA、JDBC、Hibernate...
spring-framework-5.1.x-源碼解析详细注解
09-22
本资源提供了Spring 5.1.x版本的源码详细注解，旨在帮助开发者深入理解Spring框架的核心功能，包括IOC（Inversion of Control）容器、懒加载（lazy-init）、循环依赖处理、AOP（Aspect Oriented Programming）实现...
spring-nested-aop.zip_aop_spring aop
09-23
Spring AOP，全称Aspect-Oriented Programming（面向切面编程），是Spring框架的一个重要组成部分。它提供了一种模块化和声明式的方式来处理横切关注点，如事务管理、日志记录、性能监控等，这些关注点通常会分散在...
springAOP通知
a18792721831的博客
02-19 912
springAOP通知1.什么是AOP通知2.通知的类型3.原理4.例子4.1创建一个spring项目4.2创建Java文件4.3创建xml文件4.4运行结果5.总结 1.什么是AOP通知 AOP通知就是面向切面编程中冗余的代码。 比如在每次对数据库进行操作之前，需要记录操作的SQL语句，或者调用方法前打印方法名，这些就是AOP的通知。 用大白话说，就是在横向业务中相同的操作，比如日志，事物，异常...
数据库事务的四大特性、隔离级别以及Spring中如何利用AOP进行事务管理
c_w_d的博客
03-18 8314
首先，什么是事务？ 事务就是业务上的一个逻辑单元，它能够保证其中对数据所有的操作，要么成功，要么失败。 其次，事务的特性有哪些？ 1.原子性。 例如，转账，A账户减少，B账户增加。虽然是两条 DML语句，但是被当做是一个整体，一次事务。两条语句只能同时成功或者同时失败。 2.一致性。 账户A和B,要么都是转账前的状态，要么都是转账后的状态。(不能A账户的钱减少了但是B账户的钱没有增加)
spring中aop事务
dreamzuora的博客
04-17 2626
事务 为什要用到Spring中AOP事务？ 首先举个例子了解一下什么是事务操作？以及出现的问题？课程中老师用到的例子是转账的事务例子，A将钱转给B，此时service层提供一个方法用来在数据库中进行减操作、B收到钱后会开启一个事务用来加操作，但是如果A在赚钱给B操作过程中出现了异常，此时很可能是A中的减操作已经执行完毕，而B却没有收到钱，那么此时钱就不翼而飞了，那么此时我们就应该提供一种...
Spring AOP事务实现原理之事务管理器TransactionManager
ystyaoshengting的专栏
03-16 3441
TransactionManager public interface TransactionManager {} PlatformTransactionManager 这是 Spring 事务基础类中的中心接口。 对于实现者，建议从提供的 {@link org.springframework.transaction.support.AbstractPlatformTransactionManager} 类派生，该类实现了事务的传播行为并负责事务同步处理。该类使用了模板模式，子类必须为底层事务的特定状态实
Spring AOP实践（一）动态代理和静态代理，为什么使用AOP
nokiaisacat的专栏
08-22 5071
作为Spring仅次于IOC的第二大代表功能，AOP的应用就不是很广泛了。众所周知AOP是面向方面编程，是对面向对象编程做出补充的一种编程方式。AOP使得编程人员可以把分散在代码各个地方的相同功能抽象到一处进行处理。任何方法的出现都是因为有着广泛的需求，比如在编程的过程中你总会想：凡是遇到某某情况，就做某某事。这就是AOP所要解决的问题，凡是遇到某某情况，这里的某某情况就是切入点，而“就做某某事”
深入理解spring中的各种注解
weixin_34062469的博客
05-25 297
Spring中的注解大概可以分为两大类： 1）spring的bean容器相关的注解，或者说bean工厂相关的注解； 2）springmvc相关的注解。 spring的bean容器相关的注解，先后有：@Required， @Autowired, @PostConstruct, @PreDestory，还有Spring3.0开始支持的JSR-330标准javax.inject.*中的注解(@In...
spring boot实现声明式事物的三种方式以及spring aop事物不生效问题的解决
生而为人我很抱歉
06-11 1706
spring aop事物不生效问题，spring aop只能代理目标类存在的方法，不能代理目标类父类的方法，从而导致有多级service实现类时，会出现事物失效。内部调用时无法触发事务，因为隐式的是`this`是源对象，而不是代理对象。怎么在内部调用而且触发事务呢？不要使用this，而是从Spring容器里取。spring aop事务不生效还有其他原因，如事务的扫描包配错了、数据库不支持事务、service的方法不是public、service方法中新起了线程...
Spring 事务 RequestNew 不生效，不能创建新的事务
u010548207的博客
01-21 1695
先看个缩减版的业务逻辑 逻辑上要求：当生成业务数据失败时，已落地的数据不可回滚 开发时将 数据落地 和 生成业务数据 这两个处理逻辑放在不同的事物中 @Service(“asyncSendMessage”) public class AsyncSendMessageServiceImpl implements SendMessageService{ public Response doAsyncS...
transactional注解原理
05-01
它的原理是在Spring的AOP（面向切面编程）和事务管理器之间进行协作，将标有Transactional注解的方法封装在一个事务中进行统一管理。当Transactional注解被加在一个方法上时，Spring会在该方法执行之前开启一个新的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值