Spring系列.事务管理原理简析
Spring的事务管理功能能让我们非常简单地进行事务管理。只需要进行简单的两步配置即可:
step1:开启事务管理功能
@Configuration
//@EnableTransactionManagement注解有以下几个属性
//proxyTargetClass属相:指定事务的AOP是通过JDK动态代理实现,还是CGLIB动态代理实现。true的话是CGLIB,false的话是JDK动态代理
// 需要注意的是这个属性只有在AdviceMode设置成AdviceMode.PROXY的情况下才会生效,加入使用ASPECTJ这AOP框架的话,这个属性就失效了。
// 另外,这个属性的设定可能会影响其他需要动态代理的类。比如说将这个属性设置成true,@Async注解的方法也会使用CGLIB生成代理类。
// 但是总的来说,这个属性的设置不会造成什么负面影响,毕竟JDK动态代理和CGLIB动态代理都能实现我们的需求
//mode属性:Spring提供的AOP功能有两种实现方式,一种是Spring自带的AOP功能,主要靠JDK代理和CGLIB代理实现,另外一种是通过第三方框架ASPECTJ实现。这个选项
// 就是设定Spring用哪种方式提供AOP功能。AdviceMode.PROXY表示用Spring自带的AOP功能,AdviceMode.ASPECTJ表示使用AdviceMode提供AOP功能。
// 需要注意的是Spring自带的AOP功能不支持本地调用的代理功能,也就是说同一个类中的方法互相调用不会“触发”代理方法。如果想让自调用触发代理,可以考虑使用ASPECTJ。
//order属性:表示当一个连接点(方法)被切多次时(也就是说有多个Advice和连接点关联),这些连接点的执行顺序。
@EnableTransactionManagement
public class TxConfig {
}
step2:在需要事务管理的方法上添加@Transactional注解
@Override
@Transactional
public int saveSysUser(SysUser user) {
int i = sysUserMapper.insert(user);
return i;
}
整个使用流程就这么简单。这篇博客就来简单分析下Spring是怎么实现事务管理的。
对事务管理进行AOP的过程
Spring的很多功能都是通过AOP功能实现的,事务管理也是。我们之前的文章分析过Spring基础AOP实现的原理。这边再简单提下Spring实现AOP的
原理:
Spring基础的AOP功能的开关是@EnableAspectJAutoProxy,这个注解注册了一个Bean——AnnotationAwareAspectJAutoProxyCreator,这个Bean才是实现AOP功能的关键。
这个Bean实现了InstantiationAwareBeanPostProcessor接口(这个接口是BeanPostProcessor的子接口)。熟悉Spring的读者知道,实现BeanPostProcessor接口的Bean
会在其他Bean初始化之前初始,然后在其他Bean初始化的时候,BeanPostProcessor的实现会对这些Bean进行“加工处理”。这边AnnotationAwareAspectJAutoProxyCreator就承担了加工处理类的角色。这个Bean在其他Bean初始化前后会判断这个Bean中的方法是不是有对应的Advice,如果有的话就会
通过动态代理的方式生成动态代理类将通知织入进去。
我们发现开启事务管理的方式和开启AOP功能的方式很像,也是通过Enable注解开启。所以很自然就猜想事务管理是不是也是通过BeanPostProcessor的方式实现的。带着这个猜想去看下@EnableTransactionManagement注解。
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(TransactionManagementConfigurationSelector.class)
public @interface EnableTransactionManagement {
boolean proxyTargetClass() default false;
AdviceMode mode() default AdviceMode.PROXY;
int order() default Ordered.LOWEST_PRECEDENCE;
}
看到上面的代码,我们很自然的会去看TransactionManagementConfigurationSelector
的代码。Spring有两种方式提供AOP功能,一种是自带的动态代理的功能,一种是
通过ASPECTJ的方式提供。这边主要讨论Spring自带的AOP功能。
protected String[] selectImports(AdviceMode adviceMode) {
switch (adviceMode) {
//用代理的方式实现事务管理的AOP功能
case PROXY:
return new String[] {AutoProxyRegistrar.class.getName(),
ProxyTransactionManagementConfiguration.class.getName()};
case ASPECTJ:
return new String[] {determineTransactionAspectClass()};
default:
return null;
}
}
上面的代码中,我们主要关注PROXY这个case中的方法。这个case中注册了两个类:AutoProxyRegistrar和ProxyTransactionManagementConfiguration。
首先我们来看AutoProxyRegistrar这个类,层层点进入,我们发现这个类最终就是注册了InfrastructureAdvisorAutoProxyCreator
这个类。仔细看InfrastructureAdvisorAutoProxyCreator
这个类实现的接口的话,你会发现这个类也是BeanPostProcesser
系列的类。看到这里,我的直觉是事务管理的AOP过程和Spring基础的AOP功能原理可能是一样的。
再仔细看InfrastructureAdvisorAutoProxyCreator对BeanPostProcesser系列接口的实现,你会发现都是继承的AbstractAutoProxyCreator。看到这个验证了我之前的想法。
下面是Spring对事务管理进行AOP的过程,你会发现和基础的AOP功能是一套代码。
@Override
public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {
if (bean != null) {
Object cacheKey = getCacheKey(bean.getClass(), beanName);
if (this.earlyProxyReferences.remove(cacheKey) != bean) {
return wrapIfNecessary(bean, beanName, cacheKey);
}
}
return bean;
}
protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
if (StringUtils.hasLength(beanName) && 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.
// 代码1
// 这边是获取Advice和Advisor的具体代码
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;
}
再来看看ProxyTransactionManagementConfiguration做了些啥?点进源代码你会发现这个类的功能很简单,就是注册了下面几个事务管理相关的基础Bean。
- BeanFactoryTransactionAttributeSourceAdvisor;
- TransactionAttributeSource;
- TransactionInterceptor。
事务管理的生效过程
上面的章节中讲了Spring是怎么生成事务相关的AOP代理类的。这边来讲下Spring的事务管理是怎么生效的——怎么开启事务,怎么回滚事务,怎么提交事务,Spring中的事务传播
机制是怎么生效的。
这块的代码主要是在TransactionAspectSupport的invokeWithinTransaction方法中(不要问我是怎么找到这段代码的...)。下面讲下这个方法中的几个关键点。
protected Object invokeWithinTransaction(Method method, @Nullable Class<?> targetClass,
final InvocationCallback invocation) throws Throwable {
// If the transaction attribute is null, the method is non-transactional.
TransactionAttributeSource tas = getTransactionAttributeSource();
//获取TransactionAttribute,这个类主要是@Transactional注解的配置信息
final TransactionAttribute txAttr = (tas != null ? tas.getTransactionAttribute(method, targetClass) : null);
//确认事务管理器
final TransactionManager tm = determineTransactionManager(txAttr);
if (this.reactiveAdapterRegistry != null && tm instanceof ReactiveTransactionManager) {
ReactiveTransactionSupport txSupport = this.transactionSupportCache.computeIfAbsent(method, key -> {
if (KotlinDetector.isKotlinType(method.getDeclaringClass()) && KotlinDelegate.isSuspend(method)) {
throw new TransactionUsageException(
"Unsupported annotated transaction on suspending function detected: " + method +
". Use TransactionalOperator.transactional extensions instead.");
}
ReactiveAdapter adapter = this.reactiveAdapterRegistry.getAdapter(method.getReturnType());
if (adapter == null) {
throw new IllegalStateException("Cannot apply reactive transaction to non-reactive return type: " +
method.getReturnType());
}
return new ReactiveTransactionSupport(adapter);
});
return txSupport.invokeWithinTransaction(
method, targetClass, invocation, txAttr, (ReactiveTransactionManager) tm);
}
PlatformTransactionManager ptm = asPlatformTransactionManager(tm);
final String joinpointIdentification = methodIdentification(method, targetClass, txAttr);
if (txAttr == null || !(ptm instanceof CallbackPreferringPlatformTransactionManager)) {
// Standard transaction demarcation with getTransaction and commit/rollback calls.
TransactionInfo txInfo = createTransactionIfNecessary(ptm, txAttr, joinpointIdentification);
Object retVal;
try {
// This is an around advice: Invoke the next interceptor in the chain.
// This will normally result in a target object being invoked.
retVal = invocation.proceedWithInvocation();
}
catch (Throwable ex) {
// target invocation exception
completeTransactionAfterThrowing(txInfo, ex);
throw ex;
}
finally {
cleanupTransactionInfo(txInfo);
}
if (vavrPresent && VavrDelegate.isVavrTry(retVal)) {
// Set rollback-only in case of Vavr failure matching our rollback rules...
TransactionStatus status = txInfo.getTransactionStatus();
if (status != null && txAttr != null) {
retVal = VavrDelegate.evaluateTryFailure(retVal, txAttr, status);
}
}
commitTransactionAfterReturning(txInfo);
return retVal;
}else {
final ThrowableHolder throwableHolder = new ThrowableHolder();
// It's a CallbackPreferringPlatformTransactionManager: pass a TransactionCallback in.
try {
Object result = ((CallbackPreferringPlatformTransactionManager) ptm).execute(txAttr, status -> {
TransactionInfo txInfo = prepareTransactionInfo(ptm, txAttr, joinpointIdentification, status);
try {
Object retVal = invocation.proceedWithInvocation();
if (vavrPresent && VavrDelegate.isVavrTry(retVal)) {
// Set rollback-only in case of Vavr failure matching our rollback rules...
retVal = VavrDelegate.evaluateTryFailure(retVal, txAttr, status);
}
return retVal;
}
catch (Throwable ex) {
if (txAttr.rollbackOn(ex)) {
// A RuntimeException: will lead to a rollback.
if (ex instanceof RuntimeException) {
throw (RuntimeException) ex;
}
else {
throw new ThrowableHolderException(ex);
}
}
else {
// A normal return value: will lead to a commit.
throwableHolder.throwable = ex;
return null;
}
}
finally {
cleanupTransactionInfo(txInfo);
}
});
// Check result state: It might indicate a Throwable to rethrow.
if (throwableHolder.throwable != null) {
throw throwableHolder.throwable;
}
return result;
}
catch (ThrowableHolderException ex) {
throw ex.getCause();
}
catch (TransactionSystemException ex2) {
if (throwableHolder.throwable != null) {
logger.error("Application exception overridden by commit exception", throwableHolder.throwable);
ex2.initApplicationException(throwableHolder.throwable);
}
throw ex2;
}
catch (Throwable ex2) {
if (throwableHolder.throwable != null) {
logger.error("Application exception overridden by commit exception", throwableHolder.throwable);
}
throw ex2;
}
}
}
事务操作的主要代码都在这个方法中,要详细将这个方法能写很多内容。这边就不详细展开了,大家感兴趣的可以仔细研究下这个方法。
重要类总结
- InfrastructureAdvisorAutoProxyCreator:事务管理AOP注册
- BeanFactoryTransactionAttributeSourceAdvisor:Spring事务管理基础Bean
- TransactionAttributeSource:Spring事务管理基础Bean
- TransactionInterceptor:Spring事务管理基础Bean
- TransactionAspectSupport的invokeWithinTransaction方法:事务处理的主要方法
Spring系列.事务管理原理简析的更多相关文章
- Spring系列.事务管理
Spring提供了一致的事务管理抽象.这个抽象是Spring最重要的抽象之一, 它有如下的优点: 为不同的事务API提供一致的编程模型,如JTA.JDBC.Hibernate和MyBatis数据库层 ...
- Spring系列.@EnableRedisHttpSession原理简析
在集群系统中,经常会需要将Session进行共享.不然会出现这样一个问题:用户在系统A上登陆以后,假如后续的一些操作被负载均衡到系统B上面,系统B发现本机上没有这个用户的Session,会强制让用户重 ...
- [转载] Thrift原理简析(JAVA)
转载自http://shift-alt-ctrl.iteye.com/blog/1987416 Apache Thrift是一个跨语言的服务框架,本质上为RPC,同时具有序列化.发序列化机制:当我们开 ...
- 通俗的讲法理解spring的事务实现原理
拿房屋买卖举例,流程:销售房屋 -- 接待员 -- 销售员 -- 财务 售楼处 存放着所有待售和已售的房屋数据(数据源 datasource) 总经理 带领一套自己的班底,下属员工都听自己的,服务于售 ...
- 深入Spring:自定义事务管理
转自: http://www.jianshu.com/p/5347a462b3a5 前言 上一篇文章讲了Spring的Aop,这里讲一下Spring的事务管理,Spring的事务管理是建立在Aop的基 ...
- 【spring源码学习】spring的事务管理的源码解析
[一]spring事务管理(1)spring的事务管理,是基于aop动态代理实现的.对目标对象生成代理对象,加入事务管理的核心拦截器==>org.springframework.transact ...
- Linux内存管理机制简析
Linux内存管理机制简析 本文对Linux内存管理机制做一个简单的分析,试图让你快速理解Linux一些内存管理的概念并有效的利用一些管理方法. NUMA Linux 2.6开始支持NUMA( Non ...
- Spring的事务管理
事务 事务:是逻辑上一组操作,要么全都成功,要么全都失败. 事务特性(ACID) 原子性:事务不可分割 一致性:事务执行的前后,数据完整性保持一致 隔离性:一个事务执行的时候,不应该受到其他事务的打扰 ...
- spring笔记--事务管理之声明式事务
事务简介: 事务管理是企业级应用开发中必不可少的技术,主要用来确保数据的完整性和一致性, 事务:就是一系列动作,它们被当作一个独立的工作单元,这些动作要么全部完成,要么全部不起作用. Spring中使 ...
随机推荐
- JavaScript 实现 冒泡排序
<script> //数组排序(冒泡排序) //冒泡排序是一种算法,把一系列的数据按照一定的循序进行排列显示(从小到大或从大到小) ...
- 《CEO说》读后感
<CEO说>读书心得(1至3章): 成功的企业和街头小贩有着共性的商业智慧,能够透过复杂的表象看到商业的本质,化繁为简,抓住企业经营的根本要素(现金净流入.利润.周转率.资产收益率.业务增 ...
- 通过一个vue+elementUI的小实例来讲解一下它们是如何使用的
需求:点击一个按钮,弹出一个模态框,这个模态框有两个tab,tab中是各种报警条件,这些报警条件是从数据库中动态取出的,数据库中数据变更后,这个界面也要变更,我们可以查看和编辑这些报警条件.底部“确定 ...
- 内部服务器错误Internal server error解决方法
这里说的内部服务器错误是网站前台能正常访问,而后台程序在执行某项任务/功能时所出现的内部服务器错误解决方法: 此错误通常是超时导致的,像程序在执行采集.静态页面生成时所耗时间太长导致达到超时限制的: ...
- vnc server,vnc server去哪下载,下载后如何连接使用(vnc viewer)
vnc server是vnc服务端,通过需要下载的服务器连接之后在服务器端下载. 1.使用到的工具:iis7服务器管理 2.首先去服务器端下载vnc 3.根据要求安装结束,得到登录密码. 4.用IIS ...
- 【HIVE】(3)联合查询join、时间戳函数、字符串函数
数据 t_join1.txt 1,a,1 2,b,2 3,c,4 t_join2.txt 1,2a 2,2b 3,2c 建表.导入: create table t_join1(id int, name ...
- Java实现 LeetCode 459 重复的子字符串
459. 重复的子字符串 给定一个非空的字符串,判断它是否可以由它的一个子串重复多次构成.给定的字符串只含有小写英文字母,并且长度不超过10000. 示例 1: 输入: "abab" ...
- Java实现 LeetCode 268 缺失数字
268. 缺失数字 给定一个包含 0, 1, 2, -, n 中 n 个数的序列,找出 0 - n 中没有出现在序列中的那个数. 示例 1: 输入: [3,0,1] 输出: 2 示例 2: 输入: [ ...
- Fiddler工具学习使用总结
1.初识fiddler: 作用:截获http/HTTPS请求,查看截获的请求内容,伪造客户端请求和服务器响应,测试网站性能,解密https的web会话,提供插件. 工作环境:支持素有操作系统和所有浏览 ...
- 经典文本特征表示方法: TF-IDF
引言 在信息检索, 文本挖掘和自然语言处理领域, IF-IDF 这个名字, 从它在 20 世纪 70 年代初被发明, 已名震江湖近半个世纪而不曾衰歇. 它表示的简单性, 应用的有效性, 使得它成为不同 ...