专栏首页Java技术大杂烩Spring 事务使用详解

Spring 事务使用详解

本文首发于个人公众号 Java 技术大杂烩,欢迎关注

前言

什么是事务?根据 维基百科事务 介绍,数据库事务(简称:事务)是数据库管理系统执行过程中的一个逻辑单位,由一个有限的数据库操作序列构成。简单来说,事务就是将一系列操作当成一个不可拆分的执行逻辑单元,这些要么都成功,要么都失败。事务具有4个属性:原子性、一致性、隔离性、持久性。称为ACID特性。

Spring 事务

在使用 Spring 进行开发过程中,一般都会使用 Spring 来进行事务的控制,接下来就来看下 Spring 使用事务的详细过程,包括事务的传播方式等。本文根据 官方文档 的介绍,结合例子来进行说明。

Spring 事务支持两种方式,编程式事务声明式事务,下面的栗子会使用声明式事务来举例,即使用 @Transactional 注解的方式.

栗子

首先来看个简单栗子,后面再来对事务的一些属性进行详细的分析和介绍。 1. 首先来看下两个数据库表结构 user 表和 address 表: user 表:

address表:

2.Spring 配置文件启动事务:

 1<tx:annotation-driven transaction-manager="transactionManager"/>
 2<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
 3    <property name="dataSource" ref="dataSource"/>
 4</bean>
 5<bean id="dataSource" class="org.apache.commons.dbcp2.BasicDataSource" destroy-method="close">
 6    <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
 7    <property name="url" value="jdbc:mysql://localhost:3306/tsmyk"/>
 8    <property name="username" value="root"/>
 9    <property name="password" value="root"/>
10</bean>

3.定义需要事务执行的方法:

 1public class UserServiceImpl implements IUserService {
 2
 3    private JdbcTemplate jdbcTemplate;
 4    public void setDataSource(DataSource dataSource) {
 5        this.jdbcTemplate = new JdbcTemplate(dataSource);
 6    }
 7
 8    @Transactional
 9    @Override
10    public void add(User user) throws RuntimeException {
11        String sql = "insert into user(name, age, sex, money, job) values (?, ?, ?, ?, ?)";
12        Object[] args = new Object[]{user.getName(), user.getAge(),user.getSex(),user.getMoney(), user.getJob()};
13        jdbcTemplate.update(sql, args);
14        throw new RuntimeException("保存出现异常...");
15    }
16}

这里使用 JdbcTemplate 来操作数据库

4.在上述的配置文件中配置该 bean:

1<bean id="txUserService" class="main.tsmyk.transaction.UserServiceImpl">
2    <property name="dataSource" ref="dataSource"/>
3</bean>

5.单元测试:

 1@RunWith(SpringJUnit4ClassRunner.class)
 2@ContextConfiguration("/resources/myspring.xml")
 3public class TestTransaction {
 4
 5    @Autowired
 6    private IUserService userServiceImpl;
 7
 8    @Test
 9    public void test1() throws RuntimeException {
10        User user = new User("xiaoqi", 20, 1, 1000, "java");
11        userServiceImpl.add(user);
12    }
13}

6.运行结果会抛出异常:

7.此时数据库的数据还是原来的。

上述的栗子中,在 add() 方法加上了事务注解 @Transactional ,当该方法抛出异常的时候,数据库会进行回滚,数据插入失败。

事务的原理

Spring 事务是使用 AOP 来实现的,在 Spring AOP 注解方式源码解析 和 Spring AOP 创建代理的源码解析 文章中,了解到,在执行目标方法之前和之后,我们可以进行一些增强操作,而这恰恰可以符合事务的使用情况,在目标方法执行成功后,提交事务,失败的时候,回滚事务。当然,我们还可以通过 AOP 来自定义事务的行为。从概念上讲,在事务代理上调用方法看起来如下所示:

当客户端调用的时候,调用的是代理对象,在执行目标方法之前,会创建事务,即事务增强,之后会执行我们自定义的增强行为(如果有的话,可以在事务增强之前或之后执行),之后执行目标方法,执行目标方法之后,又会执行自定义增强和事务增强,事务要么提交要么回滚,之后再返回给客户端;这就是它的一个流程,和 分析 AOP 的流程是一致的。

Spring 事务详解

事务只会对 public 方法有效,对 protectedprivatepackage-visible 的方法,事务不会有效,在 proxy 模式下,如果是对象内部的方法自我调用,则调用的内部方法事务也不会生效.

下面通过栗子来验证下方法的自我调用看下事务是否生效

 1public class UserServiceImpl implements IUserService {
 2
 3    private JdbcTemplate jdbcTemplate;
 4    public void setDataSource(DataSource dataSource) {
 5        this.jdbcTemplate = new JdbcTemplate(dataSource);
 6    }
 7
 8    @Override
 9    public void add(User user) throws RuntimeException {
10        this.add_2(user);
11    }
12
13    @Transactional
14    @Override
15    public void add_2(User user) throws RuntimeException {
16        String sql = "insert into user(name, age, sex, money, job) values (?, ?, ?, ?, ?)";
17        Object[] args = new Object[]{user.getName(), user.getAge(),user.getSex(),user.getMoney(), user.getJob()};
18        jdbcTemplate.update(sql, args);
19        throw new RuntimeException("保存出现异常2...");
20    }
21}

现在 add() 方法调用 add_2() 方法,add() 方法不加事务,而 add_2() 方法添加了事务,此时客户端调用 add() 方法:

虽然 add_2() 方法抛出了异常,但是不会回滚,数据还是成功的插入:

这是为什么呢?因为 add() 方法通过 this 来调用 add_2() 方法,而 this 代表的是目标对象而不是代理对象,所以 this.add_2() 不会被代理,也就不会被事务控制,即事务不生效;这种情况下,怎么使 add_2() 也被事务进行控制呢?当然不能使用 this 来调用了,而是使用 代理对象 来调用: ((IUserService)AopContext.currentProxy()).add_2(user) ,但是,使用这种方式有个前提,需要把我们的代理对象暴露出来,放到 ThreadLocal 中,即在 配置文件 配置 expose-proxy 属性,即 <aop:aspectj-autoproxy expose-proxy="true"/> ,在 Spring AOP 注解方式源码解析 中已经分析过该属性。如下所示:

 1<aop:aspectj-autoproxy expose-proxy="true"/>
 2<tx:annotation-driven transaction-manager="transactionManager" mode="proxy"/>
 3@Override
 4public void add(User user) throws RuntimeException {
 5    ((IUserService)AopContext.currentProxy()).add_2(user);
 6}
 7
 8@Transactional
 9@Override
10public void add_2(User user) throws RuntimeException {
11    String sql = "insert into user(name, age, sex, money, job) values (?, ?, ?, ?, ?)";
12    Object[] args = new Object[]{user.getName(), user.getAge(),user.getSex(),user.getMoney(), user.getJob()};
13    jdbcTemplate.update(sql, args);
14    throw new RuntimeException("保存出现异常2...");
15}

再运行上面的测试代码,会发现,事务回滚了,数据插入失败。

如果我们在 add() 方法和 add_2() 方法都加上注解,且通过 this 来调用 add_2() 方法,事务会不会生效呢?

 1@Transactional
 2@Override
 3public void add(User user) throws RuntimeException {
 4    this.add_2(user);
 5}
 6
 7@Transactional
 8@Override
 9public void add_2(User user) throws RuntimeException {
10    String sql = "insert into user(name, age, sex, money, job) values (?, ?, ?, ?, ?)";
11    Object[] args = new Object[]{user.getName(), user.getAge(),user.getSex(),user.getMoney(), user.getJob()};
12    jdbcTemplate.update(sql, args);
13    throw new RuntimeException("保存出现异常2...");
14}

运行上面的测试代码,事务是生效的,这是因为它们属于同一个事务,且 add() 方法被事务进行管理。

@Transactional 注解可以放在接口上,接口方法上,上,类的 public 方法上,但是 Spring 建议的是 @Transactional 尽量放在 类方法上,而不建议放在接口接口方法;这是为什么呢?我们知道,事务是通过 Spring AOP 来实现的,而 Spring AOP 是通过动态代理来实现的,而 Spring 使用的动态代理主要有 JDK 动态代理CGLIB 代理JDK 动态代理主要代理接口,这时 把 @Transactional 放在接口或接口方法上,事务是有效的;而 CGLIB 代理则是代理类,通过继承的方式来实现,这时把 @Transactional 放在接口或接口方法上,则事务就不会生效:

1@Transactional
2publicinterfaceIUserService{
3      voidadd(Useruser)throwsRuntimeException;
4}

针对该配置方式,把事务注解放在接口上,则只会对 JDK 代理有效

1@Transactional
2@Override
3publicvoidadd(Useruser)throwsRuntimeException{
4    Stringsql="insert into user(name,age,sex,money,job)values(?,?,?,?,?)";
5    Object[]args=newObject[] {user.getName(),user.getAge(),user.getSex(),user.getMoney(),user.getJob()};
6    jdbcTemplate.update(sql,args);
7    thrownewRuntimeException("保存出现异常...");
8}

把事务注解放在实现类上,则对 CGLIB 和 JDK 代理都有效 使用 CGLIB 代理,需要配置 proxy-target-class 属性为true<tx:annotation-driven proxy-target-class="true"/>

<tx:annotation-driven/> 的属性

<tx:annotation-driven/> 标签用来表示开启事务功能,它有 4 个属性:

1<tx:annotation-driven transaction-manager="transactionManager" mode="proxy" proxy-target-class="true" order="1"/>
  1. transaction-manager :事务管理器的名称,默认为 transactionManager,因为可以不写,如果管理器的名称不是这个才需要写。
  2. mode : 模式,两种,proxy 模式和 aspectj 模式,proxy 仅适用于通过代理进入的方法调用,aspectj 适用于任何类型的方法调用
  3. proxy-target-class : 使用 CGLIB 进行代理,代理类而不是代理接口
  4. order:代理顺序

@Transactional 属性

@Transactional 有很多属性来控制事务的行为,共 9 个属性

属性

类型

描述

默认值

value

String

该事务对应的事务管理器

transactionManager

propagation

枚举:Propagation

事务传播方式

REQUIRED

isolation

枚举: Isolation

事务隔离级别

DEFAULT

readOnly

boolean

读/写 与 只读

false

timeout

int(以秒为单位)

超时时间

-1

rollbackFor

Class对象数组

需要回滚的异常

空数组 {}

rollbackForClassName

类名数组

需要回滚的异常类名

空数组 {}

noRollbackFor

Class对象数组

不需要回滚的异常

空数组 {}

noRollbackForClassName

类名数组

不需要回滚的异常类名

空数组 {}

事务的名称就是方法的全限定名,无法设置

事务的传播方式

接下来看下事务的传播方式,事务的传播方式在 Spring 事务中非常重要,需要理解清楚,否则有时候事务不回滚不知道问题出在哪里。

事务的传播方式使用 propagation 属性来表示,它是一个枚举类型,共有 7 个,即事务的传播方式有 7 种:

1public enum Propagation {    
2    REQUIRED //required:需要事务,如果事务不存在,则创建一个新事务    
3    REQUIRES_NEW //required_new:需要创建一个新事务,如果已存在事务,则把当前事务挂起  
4    NESTED //nested:嵌套事务
5    SUPPORTS //supports:支持事务,如果没有事务,则以非事务的方式运行    
6    NOT_SUPPORTED //not_supported:不支持事务,以非事务的方式运行,如果存在事务,则挂起    
7    NEVER //never:不支持事务,如果存在事务,则抛出异常    
8    MANDATORY //mandatory:支持事务,如果没有事务,则抛出异常 
9}

下面以栗子的方式来验证这几种传播方式,数据库的相关表结构还是文章开头的 user表和 address 表,代码如下:

 1public class UserServiceImpl implements IUserService {
 2    private JdbcTemplate jdbcTemplate;
 3    public void setDataSource(DataSource dataSource) {this.jdbcTemplate = new JdbcTemplate(dataSource);}
 4
 5    @Autowired
 6    private IAddressService addressService;
 7
 8    @Override
 9    public void addUser(User user) throws RuntimeException {
10        String sql = "insert into user(name, age, sex, money, job) values (?, ?, ?, ?, ?)";
11        Object[] args = new Object[]{user.getName(), user.getAge(),user.getSex(),user.getMoney(), user.getJob()};
12        jdbcTemplate.update(sql, args);
13        addressService.addAddress(3, "shanghai");
14    }
15}
16
17public class AddressServiceImpl implements IAddressService {
18    private JdbcTemplate jdbcTemplate;
19    public void setDataSource(DataSource dataSource) {this.jdbcTemplate = new JdbcTemplate(dataSource);}
20
21    @Override
22    public void addAddress(int id, String name) throws RuntimeException{
23        String sql = "insert into address(id, name) values (?, ?)";
24        Object[] args = new Object[]{id, name};
25        jdbcTemplate.update(sql, args);
26        throw new RuntimeException("保存Address出现异常...");
27    }
28}
29
30// 测试代码
31@Test
32public void testUser() throws RuntimeException {
33    User user = new User("xiaoqi", 20, 1, 1000, "java");
34    userServiceImpl.addUser(user);
35}

即就是在 UserServiceImpladdUser() 方法里面调用 AddressServiceImpladdAddress() 方法

REQUIRED

required 这种传播方式,它是需要在事务中运行的,如果事务不存在,则创建一个新事务 在 addAddress() 方法加上注解 @Transactional(propagation = Propagation.REQUIRED),如下所示:

 1public void addUser(User user) throws RuntimeException {
 2    String sql = "insert into user(name, age, sex, money, job) values (?, ?, ?, ?, ?)";
 3    Object[] args = new Object[]{user.getName(), user.getAge(),user.getSex(),user.getMoney(), user.getJob()};
 4    jdbcTemplate.update(sql, args);
 5    addressService.addAddress(3, "shanghai");
 6}
 7
 8@Transactional(propagation = Propagation.REQUIRED)
 9public void addAddress(int id, String name) throws RuntimeException{
10    String sql = "insert into address(id, name) values (?, ?)";
11    Object[] args = new Object[]{id, name};
12    jdbcTemplate.update(sql, args);
13    throw new RuntimeException("保存Address出现异常...");
14}

因为 addUser 没要添加事务,所以 addAddress 会创建一个新事务,运行上面的测试代码,日志如下(IDEA 把 log4j 日志输出到文件查看):

可以看到,第一步,执行user插入操作,插入成功,并没有创建事务,第二步,创建事务,事务名称为 main.tsmyk.transaction.AddressServiceImpl.addAddress,执行 address 插入,插入成功,又因为 address 抛出异常,所以 address 插入进行回滚,回滚的数据库连接是 515809288,即执行 address 插入的连接,并没有回滚 user 插入的连接,所以结果是 user 正常插入,而 address 插入失败。为什么addUser 没有进行回滚呢,因为 它又没有在事务中运行,自然就不会回滚了。

addUseraddAddress 方法都加上注解 @Transactional(propagation = Propagation.REQUIRED),如下所示:

 1@Transactional(propagation = Propagation.REQUIRED)
 2public void addUser(User user) throws RuntimeException {
 3    String sql = "insert into user(name, age, sex, money, job) values (?, ?, ?, ?, ?)";
 4    Object[] args = new Object[]{user.getName(), user.getAge(),user.getSex(),user.getMoney(), user.getJob()};
 5    jdbcTemplate.update(sql, args);
 6    addressService.addAddress(3, "shanghai");
 7}
 8
 9@Transactional(propagation = Propagation.REQUIRED)
10public void addAddress(int id, String name) throws RuntimeException{
11    String sql = "insert into address(id, name) values (?, ?)";
12    Object[] args = new Object[]{id, name};
13    jdbcTemplate.update(sql, args);
14    throw new RuntimeException("保存Address出现异常...");
15}

运行测试代码,日志如下:

可以看到,首先会创建事务,名称为 addUser 的全限定名,获取数据库连接 418958713,之后会在该连接中执行 useraddress 的插入操作,即在同一个事务中,address 插入抛出异常,进行回滚,回滚的是连接 418958713,所以 useraddress 的操作都会被回滚,都插入失败。

如果在 addUser 调用 addAddress 的时候,进行异常的捕获,addUser 会进行回滚嘛?如下:

 1@Transactional(propagation = Propagation.REQUIRED)
 2public void addUser(User user) throws RuntimeException {
 3    String sql = "insert into user(name, age, sex, money, job) values (?, ?, ?, ?, ?)";
 4    Object[] args = new Object[]{user.getName(), user.getAge(),user.getSex(),user.getMoney(), user.getJob()};
 5    jdbcTemplate.update(sql, args);
 6    try {
 7        addressService.addAddress(3, "shanghai");
 8    }catch (Exception e){}
 9}
10
11@Transactional(propagation = Propagation.REQUIRED)
12public void addAddress(int id, String name) throws RuntimeException{
13    String sql = "insert into address(id, name) values (?, ?)";
14    Object[] args = new Object[]{id, name};
15    jdbcTemplate.update(sql, args);
16    throw new RuntimeException("保存Address出现异常...");
17}

运行日志如下:

可以看到,它们还是在同一个事务中运行,同一个连接中进行插入,回滚的是同一个连接,所以都会插入失败,即使进行了异常捕获。

总结:所以 REQUIRED 这种传播方式,必须要在事务中运行,不存在事务在,则创建一个,即使进行的异常的捕获,外部还是会进行回滚,这是因为虽然在每个方法都加上了事务注解,看起来是独立的事务,可是都会映射到底层数据库中的同一个物理事务中,所以只要有一个进行了回滚,则都会进行回滚。

REQUIRES_NEW

·required_new·,需要创建一个新事务,如果已存在事务,则把当前事务挂起 在 addUser 方法加上注解 @Transactional(propagation = Propagation.REQUIRED)addAddress 方法加上注解 @Transactional(propagation = Propagation.REQUIRES_NEW)

 1@Transactional(propagation = Propagation.REQUIRED)
 2public void addUser(User user) throws RuntimeException {
 3    String sql = "insert into user(name, age, sex, money, job) values (?, ?, ?, ?, ?)";
 4    Object[] args = new Object[]{user.getName(), user.getAge(),user.getSex(),user.getMoney(), user.getJob()};
 5    jdbcTemplate.update(sql, args);
 6    addressService.addAddress(3, "shanghai");
 7}
 8
 9@Transactional(propagation = Propagation.REQUIRES_NEW)
10public void addAddress(int id, String name) throws RuntimeException{
11    String sql = "insert into address(id, name) values (?, ?)";
12    Object[] args = new Object[]{id, name};
13    jdbcTemplate.update(sql, args);
14    throw new RuntimeException("保存Address出现异常...");
15}

运行日志如下:

可以看到,创建了两个事务,获取了两个数据库连接 1164799006418958713,当执行 address 插入的时候,会把已经存在的事务挂起,新创建一个事务进行运行,当 address 插入抛出异常的时候,这两个事务都进行了回滚,所以都会插入失败。

addUser 调用 addAddress 的时候,进行异常捕获,则会怎么样呢?

 1@Transactional(propagation = Propagation.REQUIRED)
 2public void addUser(User user) throws RuntimeException {
 3    String sql = "insert into user(name, age, sex, money, job) values (?, ?, ?, ?, ?)";
 4    Object[] args = new Object[]{user.getName(), user.getAge(),user.getSex(),user.getMoney(), user.getJob()};
 5    jdbcTemplate.update(sql, args);
 6    try {
 7        addressService.addAddress(3, "shanghai");
 8    }catch (Exception e){}
 9}
10
11@Transactional(propagation = Propagation.REQUIRES_NEW)
12public void addAddress(int id, String name) throws RuntimeException{
13    String sql = "insert into address(id, name) values (?, ?)";
14    Object[] args = new Object[]{id, name};
15    jdbcTemplate.update(sql, args);
16    throw new RuntimeException("保存Address出现异常...");
17}

运行日志如下:

可以看到,还是创建两个事务,获取了两个连接,进行异常捕获了之后,只会回滚一个事务,

总结:REQUIRES_NEW 它是创建了一个新的事务进行运行,它们是完全独立的事务范围,对应到底层数据库的物理事务也是不同的,所以它们可以独立提交或回滚,外部事务不受内部事务的回滚状态的影响; 对于上述栗子来说,如果 addAddress 抛异常且 addUser 不进行异常捕获,则两个事务都会进行回滚,如果 addUser 进行了异常捕获,则 addUser 可以进行提交的,它们是两个独立的事务;如果 addAddress 执行成功,外层的 addUser 执行失败,则 addUser 会回滚,则内部执行成功的 addAddress 不会回滚。

NESTED

nested,嵌套事务,它是外部事务的一个子事务,新建一个子事务进行运行;它们并不是独立,如果外部事务提交,则嵌套事务也会提交,外部事务回滚,则嵌套事务也会回滚。嵌套事务主要支持 saveponit 保存点。

addUser方法加上注解@Transactional(propagation = Propagation.REQUIRED)addAddress方法加上注解@Transactional(propagation = Propagation.NESTED)

 1@Transactional(propagation = Propagation.REQUIRED)
 2public void addUser(User user) throws RuntimeException {
 3    String sql = "insert into user(name, age, sex, money, job) values (?, ?, ?, ?, ?)";
 4    Object[] args = new Object[]{user.getName(), user.getAge(),user.getSex(),user.getMoney(), user.getJob()};
 5    jdbcTemplate.update(sql, args);
 6    addressService.addAddress(3, "shanghai");
 7}
 8
 9@Transactional(propagation = Propagation.NESTED)
10public void addAddress(int id, String name) throws RuntimeException{
11    String sql = "insert into address(id, name) values (?, ?)";
12    Object[] args = new Object[]{id, name};
13    jdbcTemplate.update(sql, args);
14    throw new RuntimeException("保存Address出现异常...");
15}

运行日志如下:

可以看到,新建了两个事务,一个是 nested 嵌套事务,而且只是获取了一个数据库连接 418958713,在同一个连接中执行两条SQL,当 addAddress 出现异常进行回滚的时候,只是回滚到 savepoint 保存到,由于外层的 addUser 没有进行异常捕获,所以外部事务回滚,即回滚连接 418958713

如果在外层进行异常捕获,则外层的 addUser会插入成功嘛?

 1@Transactional(propagation = Propagation.REQUIRED)
 2public void addUser(User user) throws RuntimeException {
 3    String sql = "insert into user(name, age, sex, money, job) values (?, ?, ?, ?, ?)";
 4    Object[] args = new Object[]{user.getName(), user.getAge(),user.getSex(),user.getMoney(), user.getJob()};
 5    jdbcTemplate.update(sql, args);
 6    try {
 7        addressService.addAddress(3, "shanghai");
 8    }catch (Exception e){}
 9}
10
11@Transactional(propagation = Propagation.NESTED)
12public void addAddress(int id, String name) throws RuntimeException{
13    String sql = "insert into address(id, name) values (?, ?)";
14    Object[] args = new Object[]{id, name};
15    jdbcTemplate.update(sql, args);
16    throw new RuntimeException("保存Address出现异常...");
17}

运行日志如下:

可以看到,内层的事务会回滚到 savepoint 保存点,而外层的事务则可以正常提交,结果就是 address 插入失败,user 插入成功。

现在如果内层的 addAddress 执行成功,不抛异常,外层的 addUser 抛异常,则 内层的 addAddress 会回滚嘛?

 1@Transactional(propagation = Propagation.REQUIRED)
 2public void addUser(User user) throws RuntimeException {
 3    String sql = "insert into user(name, age, sex, money, job) values (?, ?, ?, ?, ?)";
 4    Object[] args = new Object[]{user.getName(), user.getAge(),user.getSex(),user.getMoney(), user.getJob()};
 5    jdbcTemplate.update(sql, args);
 6    addressService.addAddress(3, "shanghai");
 7    throw new RuntimeException("保存User出现异常...");
 8}
 9
10@Transactional(propagation = Propagation.NESTED)
11public void addAddress(int id, String name) throws RuntimeException{
12    String sql = "insert into address(id, name) values (?, ?)";
13    Object[] args = new Object[]{id, name};
14    jdbcTemplate.update(sql, args);
15}

运行日志如下:

如果外部事务回滚了,内部事务也会回滚,因为它们属于同一个底层数据库的物理事务。

总结:嵌套事务, 它是已经存在事务的子事务. 嵌套事务开始执行时, 它将取得一个savepoint. 如果这个嵌套事务失败, 将回滚到此savepoint. 嵌套事务是外部事务的一部分, 只有外部事务结束后它才会被提交. 使用NESTED 有限制,它只支持 JDBC,且数据库要支持 savepoint 保存点,还要 JDBC 的驱动在3.0以上

SUPPORTS

supports,支持事务,如果没有事务,则以非事务的方式运行

NOT_SUPPORTED

not_supported,不支持事务,以非事务的方式运行,如果存在事务,则挂起

NEVER

never,不支持事务,如果存在事务,则抛出异常

MANDATORY

mandatory,支持事务,如果没有事务,则抛出异常

这几种传播方式比较好理解,就不把栗子贴出来了。

事务的隔离级别

事务的隔离级别使用 isolation 表示,它是一个枚举 Isolation

1public enum Isolation {
2
3    DEFAULT // 默认的隔离级别,和底层数据库有关,MySQL 是可重复读(Repeated Read)
4    READ_UNCOMMITTED // 读未提交,允许脏读,可能读取到其他会话中未提交事务修改的数据
5    READ_COMMITTED // 读已提交,只能读取到已经提交的数据
6    REPEATABLE_READ // 可重复读,该隔离级别消除了不可重复读,但是还存在幻象读
7    SERIALIZABLE // 序列化,完全串行化的读,每次读都需要获得表级共享锁,读写相互都会阻塞
8
9}

总结

1. Spring 事务原理:

Spring 事务是通过 Spring AOP 来实现的,还可以通过 AOP 来自定义事务的行为。

2. 事务注解 @Transactional

事务注解 @Transactional 可以放在接口上,接口方法上,类上,类的public方法上,如果放在接口或接口方法上,则只会对 JDK 代理有效,对 CGLIB 代理无效,我们知道,事务是通过 Spring AOP 来实现的,而 Spring AOP是通过动态代理来实现的,而Spring 使用的动态代理主要有 JDK 动态代理CGLIB 代理JDK 动态代理主要代理接口,这时 把 @Transactional 放在接口或接口方法上,事务是有效的;而 CGLIB 代理则是代理类,通过继承的方式来实现,这时把 @Transactional 放在接口或接口方法上,则事务就不会生效的。

3. 内部调用事务不生效的解决方法

一是把该方法放到其他的对象中,不过不太实用,二是不通过 this 来调用方法,而是通过代理来调用,如 AopContext.currentProxy().xxxx ,但是,使用这种方式有个前提,需要把我们的代理对象暴露出来,放到 ThreadLocal 中,即在 配置文件配置 expose-proxy 属性,即<aop:aspectj-autoproxy expose-proxy="true"/>

4. 事务的传播方式,7 种

1REQUIRED //required:需要事务,如果事务不存在,则创建一个新事务    
2REQUIRES_NEW //required_new:需要创建一个新事务,如果已存在事务,则把当前事务挂起    
3NESTED //nested:嵌套事务
4SUPPORTS //supports:支持事务,如果没有事务,则以非事务的方式运行    
5NOT_SUPPORTED //not_supported:不支持事务,以非事务的方式运行,如果存在事务,则挂起    
6NEVER //never:不支持事务,如果存在事务,则抛出异常    
7MANDATORY //mandatory:支持事务,如果没有事务,则抛出异常  

REQUIRED : 必须要在事务中运行,不存在事务在,则创建一个,即使进行的异常的捕获,外部还是会进行回滚,这是因为虽然在每个方法都加上了事务注解,看起来是独立的事务,可是都会映射到底层数据库中的同一个物理事务中,所以只要有一个进行了回滚,则都会进行回滚。

REQUIRES_NEW 它是创建了一个新的事务进行运行,它们是完全独立的事务范围,对应到底层数据库的物理事务也是不同的,所以它们可以独立提交或回滚,外部事务不受内部事务的回滚状态的影响.

NESTED 嵌套事务, 它是已经存在事务的子事务. 嵌套事务开始执行时, 它将取得一个 savepoint. 如果这个嵌套事务失败, 将回滚到此 savepoint. 嵌套事务是外部事务的一部分, 只有外部事务结束后它才会被提交. 使用 NESTED 有限制,它只支持 JDBC,且数据库要支持 savepoint 保存点,还要 JDBC 的驱动在3.0以上。

5. 事务的隔离级别

1DEFAULT // 默认的隔离级别,和底层数据库有关,MySQL 是可重复读(Repeated Read)
2READ_UNCOMMITTED // 读未提交,允许脏读,可能读取到其他会话中未提交事务修改的数据
3READ_COMMITTED // 读已提交,只能读取到已经提交的数据
4REPEATABLE_READ // 可重复读,该隔离级别消除了不可重复读,但是还存在幻象读
5SERIALIZABLE // 序列化,完全串行化的读,每次读都需要获得表级共享锁,读写相互都会阻塞

本文分享自微信公众号 - Java技术大杂烩(tsmyk0715),作者:TSMYK

原文出处及转载信息见文内详细说明,如有侵权,请联系 yunjia_community@tencent.com 删除。

原始发表时间:2019-01-13

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

我来说两句

0 条评论
登录 后参与评论

相关文章

  • Redis 初探-安装与使用

    Redis是一个使用ANSI C编写的开源、支持网络、基于内存、可选持久性的键值对存储数据库。从2015年6月开始,Redis的开发由Redis Labs赞助,...

    Java技术大杂烩
  • Vue加载优化,速度提高一倍。

    之前做的一个Vue项目,流程大概是这这样的:从公众号进入,由外系统获取用户的openid等信息,然后再跳转到项目首页进行加载初始化操作。

    Java技术大杂烩
  • Mybatis 类型转换源码分析

    JDBC 提供的数据类型和Java的数据类型并不是完全对应的,当 Mybatis 在解析 SQL ,使用 PreparedStatement 来为 SQL 设置...

    Java技术大杂烩
  • python 计算函数执行时间装饰器(带参数装饰器写法)

    import time import functools DEFAULT_FMT = '[{elapsed:0.8f}s] {name}({args}) -...

    用户5760343
  • Flask 统计在线人数

    服务端完成以后,如果检验应用的效果呢,在线人数/客户端是一个不错的指标。但是客户端的连接通常是短连接「请求建立一次连接,请求完成连接即断开」,基于这种情况服务端...

    keinYe
  • python用selenium驱动浏览器爬取天府新区二手房房价--并展示在网页上

    3,web 应用测试工具selenium库: pip install selenium

    小末快跑
  • Android 实现把bitmap图片的某一部分的颜色改成其他颜色

    dp(density-independent pixel):密度无关像素,当dpi为160时,1dp=1px,当dpi为320时,1dp=2px,以此类推……....

    砸漏
  • SpringMVC 提交表单400 Bad Request

    第一种: 后台:  @RequestMapping(value="/add",method=RequestMethod.POST)     public Str...

    冷冷
  • Spring Cloud和聚合工程架构设计微服务框架

            最近在做游戏商人的过程中,发现很多的同行,都是用记事本记录交易相关信息,于是我觉得自己搭建一个针对游戏行业,搭建一个进销存的微服务管理系统。

    kinbug [进阶者]
  • 分布式事务之数据库事务与JDBC事务实现(一)

    介绍事务的四大原则,并通过实例介绍数据库实现事务的方法,以及使用JDBC实现事务的方法。

    蒋老湿

扫码关注云+社区

领取腾讯云代金券