前言
事务大家平时应该都有写,之前写事务的时候遇到一点坑,居然不生效,后来排查了一下,复习了一下各种事务失效的场景,想着不如来一个总结,这样下次排查问题,就能有恃无恐了。那么先来复习一下事务相关知识,事务是指操作的最小工作单位,作为一个单独且不可切割的单元操作,要么全部成功,要么全部失败。事务有四大特性(ACID
):
原子性(Atomicity
):事务包含的操作,要么全部成功,要么全部失败回滚,不会存在一半成功一半失败的中间状态。比如A
和B
一开始都有500
元,A
给B
转账100
,那么A
的钱少了100
,B
的钱就必须多了100
,不能A
少了钱,B
也没收到钱,那这个钱就不翼而飞了,不符合原子性了。
一致性(Consistency
):一致性是指事务执行之前和之后,保持整体状态的一致,比如A
和B
一开始都有500
元,加起来是1000
元,这个是之前的状态,A
给B
转账100
,那么最后A
是400
,B
是600
,两者加起来还是1000
,这个整体状态需要保证。
隔离性(Isolation
):前面两个特性都是针对同一个事务的,而隔离性指的是不同的事务,当多个事务同时在操作同一个数据的时候,需要隔离不同事务之间的影响,并发执行的事务之间不能相互干扰。
持久性(Durability
):指事务如果一旦被提交了,那么对数据库的修改就是永久性的,就算是数据库发生故障了,已经发生的修改也必然存在。
事务的几个特性并不是数据库事务专属的,广义上的事务是一种工作机制,是并发控制的基本单位,保证操作的结果,还会包括分布式事务之类的,但是一般我们谈论事务,不特指的话,说的就是与数据库相关的,因为我们平时说的事务基本都基于数据库来完成。
事务不仅是适用于数据库。我们可以将此概念扩展到其他组件,类似队列服务或外部系统状态。因此,“一系列数据操作语句必须完全完成或完全失败,以一致的状态离开系统”
测试环境
前面我们已经部署过了一些 demo 项目,以及用 docker 快速搭建环境,本文基于的也是之前的环境:
JDK 1.8
Maven 3.6
Docker
Mysql
事务正常回滚的样例
正常的事务样例,包含两个接口,一个是获取所有的用户中的数据,另外一个更新的,是update
用户数据,其实就是每个用户的年龄+1
,我们让一次操作完第一个之后,抛出异常,看看最后的结果:
@Service("userService")
public class UserServiceImpl implements UserService {
@Resource
UserMapper userMapper;
@Autowired
RedisUtil redisUtil;
@Override
public List<User> getAllUsers() {
List<User> users = userMapper.getAllUsers();
return users;
}
@Override
@Transactional
public void updateUserAge() {
userMapper.updateUserAge(1);
int i= 1/0;
userMapper.updateUserAge(2);
}
}
复制代码
数据库操作:
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="com.aphysia.springdocker.mapper.UserMapper">
<select id="getAllUsers" resultType="com.aphysia.springdocker.model.User">
SELECT * FROM user
</select>
<update id="updateUserAge" parameterType="java.lang.Integer">
update user set age=age+1 where id =#{id}
</update>
</mapper>
复制代码
先获取http://localhost:8081/getUserList
所有的用户看看:
在调用更新接口,页面抛出错误了:
控制台也出现了异常,意思是除以 0,异常:
java.lang.ArithmeticException: / by zero
at com.aphysia.springdocker.service.impl.UserServiceImpl.updateUserAge(UserServiceImpl.java:35) ~[classes/:na]
at com.aphysia.springdocker.service.impl.UserServiceImpl$$FastClassBySpringCGLIB$$c8cc4526.invoke(<generated>) ~[classes/:na]
at org.springframework.cglib.proxy.MethodProxy.invoke(MethodProxy.java:218) ~[spring-core-5.3.12.jar:5.3.12]
at org.springframework.aop.framework.CglibAopProxy$CglibMethodInvocation.invokeJoinpoint(CglibAopProxy.java:783) ~[spring-aop-5.3.12.jar:5.3.12]
at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:163) ~[spring-aop-5.3.12.jar:5.3.12]
at org.springframework.aop.framework.CglibAopProxy$CglibMethodInvocation.proceed(CglibAopProxy.java:753) ~[spring-aop-5.3.12.jar:5.3.12]
at org.springframework.transaction.interceptor.TransactionInterceptor$1.proceedWithInvocation(TransactionInterceptor.java:123) ~[spring-tx-5.3.12.jar:5.3.12]
at org.springframework.transaction.interceptor.TransactionAspectSupport.invokeWithinTransaction(TransactionAspectSupport.java:388) ~[spring-tx-5.3.12.jar:5.3.12]
at org.springframework.transaction.interceptor.TransactionInterceptor.invoke(TransactionInterceptor.java:119) ~[spring-tx-5.3.12.jar:5.3.12]
at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:186) ~[spring-aop-5.3.12.jar:5.3.12]
at org.springframework.aop.framework.CglibAopProxy$CglibMethodInvocation.proceed(CglibAopProxy.java:753) ~[spring-aop-5.3.12.jar:5.3.12]
at org.springframework.aop.framework.CglibAopProxy$DynamicAdvisedInterceptor.intercept(CglibAopProxy.java:698) ~[spring-aop-5.3.12.jar:5.3.12]
at com.aphysia.springdocker.service.impl.UserServiceImpl$$EnhancerBySpringCGLIB$$25070cf0.updateUserAge(<generated>) ~[classes/:na]
复制代码
然后我们再次请求http://localhost:8081/getUserList
,看到数据两个都是11
说明数据都没有发生变化,第一个操作完之后,异常,回滚成功了:
[{"id":1,"name":"李四","age":11},{"id":2,"name":"王五","age":11}]
复制代码
那什么时候事务不正常回滚呢?且听我细细道来:
实验
1. 引擎设置不对
我们知道,Mysql
其实有一个数据库引擎的概念,我们可以用show engines
来查看Mysql
支持的数据引擎:
可以看到Transactions
那一列,也就是事务支持,只有InnoDB
,那就是只有InnoDB
支持事务,所以要是引擎设置成其他的事务会无效。
我们可以用show variables like 'default_storage_engine'
看默认的数据库引擎,可以看到默认是InnoDB
:
mysql> show variables like 'default_storage_engine';
+------------------------+--------+
| Variable_name | Value |
+------------------------+--------+
| default_storage_engine | InnoDB |
+------------------------+--------+
复制代码
那我们看看我们演示的数据表是不是也是用了InnoDB
,可以看到确实是使用InnoDB
那我们把该表的引擎修改成MyISAM
会怎么样呢?试试,在这里我们只修改数据表的数据引擎:
mysql> ALTER TABLE user ENGINE=MyISAM;
Query OK, 2 rows affected (0.06 sec)
Records: 2 Duplicates: 0 Warnings: 0
复制代码
然后再update
,不出意料,还是会报错,看起来错误没有什么不同:
但是获取全部数据的时候,第一个数据更新成功了,第二个数据没有更新成功,说明事务没有生效。
[{"id":1,"name":"李四","age":12},{"id":2,"name":"王五","age":11}]
复制代码
结论:必须设置为InnoDB
引擎,事务才生效。
2. 方法不能是 private
事务必须是public
方法,如果用在了private
方法上,那么事务会自动失效,但是在IDEA
中,只要我们写了就会报错:Methods annotated with '@Transactional' must be overrideable
,意思是事务的注解加上的方法,必须是可以重写的,private
方法是不可以重写的,所以报错了。
同样的final
修饰的方法,如果加上了注解,也会报错,因为用final
就是不想被重写:
Spring
中主要是用放射获取Bean
的注解信息,然后利用基于动态代理技术的AOP
来封装了整个事务,理论上我想调用private
方法也是没有问题的,在方法级别使用method.setAccessible(true);
就可以,但是可能Spring
团队觉得private
方法就是开发人员意愿上不愿意公开的接口,没有必要破坏封装性,这样容易导致混乱。
Protected
方法可不可以?不可以!
下面我们为了实现,魔改代码结构,因为接口不能用Portected
,如果用了接口,就不可能用protected
方法,会直接报错,而且必须在同一个包里面使用,我们把controller
和service
放到同一个包下:
测试后发现事务不生效,结果依然是一个更新了,另外一个没有更新:
[{"id":1,"name":"李四","age":12},{"id":2,"name":"王五","age":11}]
复制代码
结论:必须使用在public
方法上,不能用在private
,final
,static
方法上,否则不会生效。
3. 异常必须是运行期的异常
Springboot
管理异常的时候,只会对运行时的异常(RuntimeException
以及它的子类) 进行回滚,比如我们前面写的i=1/0;
,就会产生运行时的异常。
从源码来看也可以看到,rollbackOn(ex)
方法会判断异常是RuntimeException
或者Error
:
public boolean rollbackOn(Throwable ex) {
return (ex instanceof RuntimeException || ex instanceof Error);
}
复制代码
异常主要分为以下类型:
所有的异常都是Throwable
,而Error
是错误信息,一般是程序发生了一些不可控的错误,比如没有这个文件,内存溢出,IO
突然错误了。而Exception
下,除了RuntimeException
,其他的都是CheckException
,也就是可以处理的异常,Java
程序在编写的时候就必须处理这个异常,否则编译是通不过去的。
由下面的图我们可以看出,CheckedException
,我列举了几个常见的IOException
IO 异常,NoSuchMethodException
没有找到这个方法,ClassNotFoundException
没找到这个类,而RunTimeException
有常见的几种:
数组越界异常:IndexOutOfBoundsException
类型转换异常:ClassCastException
空指针异常:NullPointerException
事务默认回滚的是:运行时异常,也就是RunTimeException
,如果抛出其他的异常是无法回滚的,比如下面的代码,事务就会失效:
@Transactional
public void updateUserAge() throws Exception{
userMapper.updateUserAge(1);
try{
int i = 1/0;
}catch (Exception ex){
throw new IOException("IO异常");
}
userMapper.updateUserAge(2);
}
复制代码
4. 配置不对导致
方法上需要使用@Transactional
才能开启事务
多个数据源配置或者多个事务管理器的时候,注意如果操作数据库A
,不能使用B
的事务,虽然这个问题很幼稚,但是有时候用错难查找问题。
如果在Spring
中,需要配置@EnableTransactionManagement
来开启事务,等同于配置xml
文件*<tx:annotation-driven/>*
,但是在Springboot
中已经不需要了,在springboot
中SpringBootApplication
注解包含了@EnableAutoConfiguration
注解,会自动注入。
@EnableAutoConfiguration
自动注入了哪些东西呢?在jetbrains://idea/navigate/reference?project=springDocker&path=~/.m2/repository/org/springframework/boot/spring-boot-autoconfigure/2.5.6/spring-boot-autoconfigure-2.5.6.jar!/META-INF/spring.factories
下有自动注入的配置:
# Auto Configure
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
org.springframework.boot.autoconfigure.admin.SpringApplicationAdminJmxAutoConfiguration,\
org.springframework.boot.autoconfigure.aop.AopAutoConfiguration,\
org.springframework.boot.autoconfigure.amqp.RabbitAutoConfiguration,\
...
org.springframework.boot.autoconfigure.transaction.TransactionAutoConfiguration,\
...
复制代码
里面配置了一个TransactionAutoConfiguration
,这是事务自动配置类:
@Configuration(proxyBeanMethods = false)
@ConditionalOnClass(PlatformTransactionManager.class)
@AutoConfigureAfter({ JtaAutoConfiguration.class, HibernateJpaAutoConfiguration.class,
DataSourceTransactionManagerAutoConfiguration.class, Neo4jDataAutoConfiguration.class })
@EnableConfigurationProperties(TransactionProperties.class)
public class TransactionAutoConfiguration {
...
@Configuration(proxyBeanMethods = false)
@ConditionalOnBean(TransactionManager.class)
@ConditionalOnMissingBean(AbstractTransactionManagementConfiguration.class)
public static class EnableTransactionManagementConfiguration {
@Configuration(proxyBeanMethods = false)
@EnableTransactionManagement(proxyTargetClass = false) // 这里开启了事务
@ConditionalOnProperty(prefix = "spring.aop", name = "proxy-target-class", havingValue = "false")
public static class JdkDynamicAutoProxyConfiguration {
}
...
}
}
复制代码
值得注意的是,@Transactional
除了可以用于方法,还可以用于类,表示这个类所有的public
方法都会配置事务。
5. 事务方法不能在同个类里面调用
想要进行事务管理的方法只能在其他类里面被调用,不能在当前类被调用,否则会失效,为了实现这个目的,如果同一个类有不少事务方法,还有其他方法,这个时候有必要抽取出一个事务类,这样分层会比较清晰,避免后继者写的时候在同一个类调用事务方法,造成混乱。
事务失效的例子:
比如我们将service
事务方法改成:
public void testTransaction(){
updateUserAge();
}
@Transactional
public void updateUserAge(){
userMapper.updateUserAge(1);
int i = 1/0;
userMapper.updateUserAge(2);
}
复制代码
在controller
里面调用的是没有事务注解的方法,再间接调用事务方法:
@RequestMapping("/update")
@ResponseBody
public int update() throws Exception{
userService.testTransaction();
return 1;
}
复制代码
调用之后,发现事务失效,一个更新另外一个没有更新:
[{"id":1,"name":"李四","age":12},{"id":2,"name":"王五","age":11}]
复制代码
为什么会这样呢?
Spring
用切面对方法进行包装,只对外部调用方法进行拦截,内部方法没有进行拦截。
看源码:实际上我们调用事务方法的时候,会进入DynamicAdvisedInterceptor
的public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy)()
方法:
里面调用了AdvisedSupport.getInterceptorsAndDynamicInterceptionAdvice()
,这里是获取调用调用链。而没有@Transactional
注解的方法userService.testTransaction()
,根本获取不到代理调用链,调用的还是原来的类的方法。
spring
里面要想对一个方法进行代理,用的就是aop
,肯定需要一个标识,标识哪一个方法或者类需要被代理,spring
里面定义了@Transactional
作为切点,我们定义这个标识,就会被代理。
代理的时机是什么时候呢?
Spring
统一管理了我们的bean
,代理的时机自然就是创建bean
的过程,看看哪一个类带了这个标识,就生成代理对象。
SpringTransactionAnnotationParser
这个类有一个方法是用来判断TransactionAttribute
注解的:
@Override
@Nullable
public TransactionAttribute parseTransactionAnnotation(AnnotatedElement element) {
AnnotationAttributes attributes = AnnotatedElementUtils.findMergedAnnotationAttributes(
element, Transactional.class, false, false);
if (attributes != null) {
return parseTransactionAnnotation(attributes);
}
else {
return null;
}
}
复制代码
6.多线程下事务失效
假设我们在多线程里面像以下方式使用事务,那么事务是不能正常回滚的:
@Transactional
public void updateUserAge() {
new Thread(
new Runnable() {
@Override
public void run() {
userMapper.updateUserAge(1);
}
}
).start();
int i = 1 / 0;
userMapper.updateUserAge(2);
}
复制代码
因为不同的线程使用的是不同SqlSession
,相当于另外一个连接,根本不会用到同一个事务:
2021-11-28 14:06:59.852 DEBUG 52764 --- [ Thread-2] org.mybatis.spring.SqlSessionUtils : Creating a new SqlSession
2021-11-28 14:06:59.930 DEBUG 52764 --- [ Thread-2] c.a.s.mapper.UserMapper.updateUserAge : <== Updates: 1
2021-11-28 14:06:59.931 DEBUG 52764 --- [ Thread-2] org.mybatis.spring.SqlSessionUtils : Closing non transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@2e956409]
复制代码
7. 注意合理使用事务嵌套
首先事务是有传播机制的:
REQUIRED
(默认):支持使用当前事务,如果当前事务不存在,创建一个新事务,如果有直接使用当前的事务。
SUPPORTS
:支持使用当前事务,如果当前事务不存在,就不会使用事务。
MANDATORY
:支持使用当前事务,如果当前事务不存在,则抛出Exception
,也就是必须当前处于事务里面。
REQUIRES_NEW
:创建新事务,如果当前事务存在,把当前事务挂起。
NOT_SUPPORTED
:没有事务执行,如果当前事务存在,把当前事务挂起。
NEVER
:没有事务执行,如果当前有事务则抛出Exception
。
NESTED
:嵌套事务,如果当前事务存在,那么在嵌套的事务中执行。如果当前事务不存在,则表现跟`REQUIRED
查不多。
默认的是REQUIRED
,也就是事务里面调用另外的事务,实际上不会重新创建事务,而是会重用当前的事务。那如果我们这样来写嵌套事务:
@Service("userService")
public class UserServiceImpl {
@Autowired
UserServiceImpl2 userServiceImpl2;
@Resource
UserMapper userMapper;
@Transactional
public void updateUserAge() {
try {
userMapper.updateUserAge(1);
userServiceImpl2.updateUserAge();
}catch (Exception ex){
ex.printStackTrace();
}
}
}
复制代码
调用的另外一个事务:
@Service("userService2")
public class UserServiceImpl2 {
@Resource
UserMapper userMapper;
@Transactional
public void updateUserAge() {
userMapper.updateUserAge(2);
int i = 1 / 0;
}
}
复制代码
会抛出以下错误:
org.springframework.transaction.UnexpectedRollbackException: Transaction rolled back because it has been marked as rollback-only
复制代码
我们但是实际事务是正常回滚掉了,结果是对的,之所以出现这个问题,是因为里面到方法抛出了异常,用的是同一个事务,说明事务必须被回滚掉的,但是外层被catch
住了,本来就是同一个事务,一个说回滚,一个catch
住不让spring
感知到Exception
,那不是自相矛盾么?所以spring
报错说:这个事务被标识了必须回滚掉,最终还是回滚掉了。
怎么处理呢?
外层主动抛出错误,throw new RuntimeException()
使用TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
主动标识回滚
@Transactional
public void updateUserAge() {
try {
userMapper.updateUserAge(1);
userServiceImpl2.updateUserAge();
}catch (Exception ex){
ex.printStackTrace();
TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
}
}
复制代码
8. 依赖外部网络请求回滚需要考虑
有些时候,我们不仅操作自己的数据库,还需要同时考虑外部的请求,比如同步数据,同步失败,需要回滚掉自己的状态,在这种场景下,必须考虑网络请求是否会出错,出错如何处理,错误码是哪一个的时候才成功。
如果网络超时了,实际上成功了,但是我们判定为没有成功,回滚掉了,可能会导致数据不一致。这种需要被调用方支持重试,重试的时候,需要支持幂等,多次调用保存状态的一致,虽然整个主流程很简单,里面的细节还是比较多的。
总结
事务被Spring
包裹了复杂性,很多东西可能源码很深,我们用的时候注意模拟测试一下调用是不是能正常回滚,不能理所当然,人是会出错的,而很多时候黑盒测试根本测试这种异常数据,如果没有正常回滚,后面需要手动处理,考虑到系统之间同步的问题,会造成很多不必要的麻烦,手动改数据库这流程就必须走。
【作者简介】:
秦怀,公众号【秦怀杂货店】作者,技术之路不在一时,山高水长,纵使缓慢,驰而不息。个人写作方向:Java源码解析
,JDBC
,Mybatis
,Spring
,redis
,分布式
,剑指Offer
,LeetCode
等,认真写好每一篇文章,不喜欢标题党,不喜欢花里胡哨,大多写系列文章,不能保证我写的都完全正确,但是我保证所写的均经过实践或者查找资料。遗漏或者错误之处,还望指正。
剑指Offer全部题解PDF
2020年我写了什么?
开源编程笔记
评论