Spring 事务和事务传播机制（详解）

Spring 事务传播机制定义了多个包含了事务的⽅法，相互调⽤时，事务是如何在这些⽅法间进⾏传递的Spring中使用事务,有两种方式:编程式事务(手动操作)和声明式事务.其中声明式事务使用较多,在方法上添加就可以实现了通过）设置事务的隔离级别.Spring 中的事务隔离级别有 5种通过设置事务的传播机制, Spring 中的事务传播级别有7种,重点关注REQUIRED(默认值)和。

每天都要进步1

2011人浏览 · 2025-02-26 15:32:58

每天都要进步1 · 2025-02-26 15:32:58 发布

2.2 Spring 声明式事务 @Transactional

2.2.1 声明式事务实现共分为两步：

2.2.2 @Transactional 作⽤范围

5.4.1 REQUIRED (加入事务）

5.4.2 EQUIRES_NEW (新建事务)

总结：

1 .事务

1.1.什么是事务？

事务是一组操作的集合,是不可分割的操作

事务作为一个整体，要不同时完成，要不同时失败

1.2什么时候需要事务？

关于金钱的操作基本都会有事务

例如转账操作：

第一步 A账号 - 500元

第二步 B账户+ 500元

如果没有事务，第⼀步执⾏成功了, 第⼆步执⾏失败了, 那么A 账⼾的500 元就平⽩⽆故消失了. 如果使⽤事务就可以解决这个问题, 让这⼀组操作要么⼀起成功, 要么⼀起失败

1.3 事务的操作

事务的操作主要有三步：

开启事务：start transaction / begin（一组操作前开启事务）

提交事务：commit (这组操作全部成功,提交事务)

回滚事务：rollback（这组操作中间任何一个操作出现异常，回滚事务）

2 .Spring 中事务的实现

spring事务操作分为两类：

编程式事务（手动写代码操作事务）

声明式事务（使用注解自动开启事务和提交事务）

2.1编程式事务（了解）

Spring ⼿动操作事务和上⾯ MySQL 操作事务类似, 有 3 个重要操作步骤：

开启事务（获取事务）

提交事务

回滚事务

SpringBook内置了两个对象：

1.DataSoureTransactionManager 事务管理器，用来获取事务（开启事务），提交和回滚事务的

2. TransactionDefinition 是事务的属性在获取事务的时候需要将 TransactionDefinition 传递进去从而获取一个事务事务 TransactionStatus

代码实现：

@RestController
public class UserController {
     // JDBC 事务管理器
     @Autowired
     private DataSourceTransactionManager dataSourceTransactionManager;

     // 定义事务属性
     @Autowired
     private TransactionDefinition transactionDefinition;

     @Autowired
     private UserService userService;

     @RequestMapping("/registry")
     public String registry(String name,String password){
         // 开启事务
         TransactionStatus transactionStatus = dataSourceTransactionManager
         .getTransaction(transactionDefinition);
         //⽤⼾注册
         userService.registryUser(name,password);
         //提交事务
         dataSourceTransactionManager.commit(transactionStatus);
         //回滚事务
         //dataSourceTransactionManager.rollback(transactionStatus);
         return "注册成功";
     }
}

以上代码虽然可以实现事务, 但操作也很繁琐, 有没有更简单的实现⽅法呢?

2.2 Spring 声明式事务 @Transactional

2.2.1 声明式事务实现共分为两步：

1.添加依赖：
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-tx</artifactId>
</dependency>
2.在需要事务的方法上添加@Transactional 即可，无需手动开启事务和提交回滚事务。

进⼊⽅法时⾃动开启事务, ⽅法执⾏完会⾃动提交事务, 如果中途发⽣了没有处理的异常会⾃动 回滚事务.
@RequestMapping("/trans")
@RestController
public class TransactionalController {

 @Autowired
 private UserService userService;

 @Transactional
 @RequestMapping("/registry")
 public String registry(String name,String password){
     //⽤⼾注册
     userService.registryUser(name,password);
     return "注册成功";
 }
}

2.2.2 @Transactional 作⽤范围

修饰方法时：只有修饰public方法时才会生效

修饰类时：对@Transactional修饰的类中所有的public方法都生效

⽅法/类被 @Transactional 注解修饰时, 在⽬标⽅法执⾏开始之前, 会⾃动开启事务, ⽅法执⾏结束之后, ⾃动提交事务.

如果在⽅法执⾏过程中, 出现异常, 且异常未被捕获, 就进⾏事务回滚操作.

如果异常被程序捕获, ⽅法就被认为是成功执⾏, 依然会提交事务

2.2.3 @Transactional 在异常被捕获不会进⾏事务⾃动回滚

实例：

@Transactional
@RequestMapping("/registry")
public String registry(String name,String password){
     //⽤⼾注册
     userService.registryUser(name,password);
     log.info("⽤⼾数据插⼊成功");
     //对异常进⾏捕获
     try {
         //强制程序抛出异常
         int a = 10/0;
     }catch (Exception e){
         e.printStackTrace();
     }
     return "注册成功";
}

运⾏程序, 发现虽然程序出错了, 但是由于异常被捕获了, 所以事务依然得到了提交.

如果需要事务进⾏回滚, 有以下两种⽅式

方法一重新抛出异常：

@Transactional
@RequestMapping("/registry")
public String registry(String name,String password){
     //⽤⼾注册
     userService.registryUser(name,password);

     log.info("⽤⼾数据插⼊成功");

     //对异常进⾏捕获
     try {
          //强制程序抛出异常
         int a = 10/0;
     }catch (Exception e){
         //将异常重新抛出去
         throw e;
     }
     return "注册成功";
}

方法二手动回滚事务:

使⽤ TransactionAspectSupport.currentTransactionStatus() 得到当前的事务, 并

使⽤ setRollbackOnly 设置 setRollbackOnly

@Transactional
@RequestMapping("/registry")
public String registry(String name,String password){
     //⽤⼾注册
     userService.registryUser(name,password);
     log.info("⽤⼾数据插⼊成功");
     //对异常进⾏捕获
     try {
         //强制程序抛出异常
         int a = 10/0;
     }catch (Exception e){
         // ⼿动回滚事务
         TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
     }
     return "注册成功";
}

3. @Transactional 详解

@Transactional 注解的使用细节（三个常见属性）：

rollbackFor：异常回滚属性，指定触发回滚事务的异常类型，也可以指定多个异常类型

lsolation：事务的隔离级别，默认值为Isolation.DEFAULT

propagation：事务的传播机制，默认值为Propagation.REQUIRED

rollbackFor （详解）

@Transactional 默认只在遇到运⾏时异常和Error时才会回滚, ⾮运⾏时异常不回滚. 即Exception的⼦类中, 除了RuntimeException及其⼦类

但是如果我们需要所有异常都回滚, 需要来配置 @Transactional 注解当中的 rollbackFor 属性, 通

过 rollbackFor 这个属性指定出现何种异常类型时事务进⾏回滚

小结：

在Spring的事务管理中，默认只在遇到运⾏时异常RuntimeException和Error时才会回滚

如果需要回滚指定类型的异常, 可以通过rollbackFor属性来指定.

4. 事务的隔离级别

Mysql 事务隔离级别 ,SQL 标准定义了四种隔离级别, MySQL 全都⽀持.

这四种隔离级别分别是:

读未提交(READ UNCOMMITTED): 读未提交, 也叫未提交读. 该隔离级别的事务可以看到其他事务中未提交的数据

因为其他事务未提交的数据可能会发⽣回滚, 但是该隔离级别却可以读到, 我们把该级别读到的数据称之为脏数据, 这个问题称之为脏读 .

读提交(READ COMMITTED): 读已提交, 也叫提交读. 该隔离级别的事务能读取到已经提交事务的数据

该隔离级别不会有脏读的问题.但由于在事务的执⾏中可以读取到其他事务提交的结果, 所以在不同时间的相同 SQL 查询可能会得到不同的结果, 这种现象叫做不可重复读

可重复读(REPEATABLE READ): 事务不会读到其他事务对已有数据的修改, 即使其他事务已提交. 也就可以确保同⼀事务多次查询的结果⼀致, 但是其他事务新插⼊的数据, 是可以感知到的. 这也就引发了幻读问题. 可重复读, 是 MySQL 的默认事务隔离级别.

⽐如此级别的事务正在执⾏时, 另⼀个事务成功的插⼊了某条数据, 但因为它每次查询的结果都是⼀样的, 所以会导致查询不到这条数据, ⾃⼰重复插⼊时⼜失败(因为唯⼀约束的原因). 明明在事务中查询不到这条信息，但⾃⼰就是插⼊不进去, 这个现象叫幻读

串⾏化(SERIALIZABLE): 序列化, 事务最⾼隔离级别. 它会强制事务排序, 使之不会发⽣冲突, 从⽽解决了脏读, 不可重复读和幻读问题, 但因为执⾏效率低, 所以真正使⽤的场景并不多

Spring 事务隔离级别：

Spring中隔离级别有五种：

Isolation.DEFAULT：以连接的数据库的事务隔离级别为主

Isolation.READ_UNCOMMITTED：读未提交,对应SQL标准中READ UNCOMMITTED

Isolation.READ_COMMITTED：读已提交,对应SQL标准中READCOMMITTED

solation.REPEATABLE_READ：可重复读，对应SQL标准中REPEATABLE READ

Isolation.SERIALIZABLE :串行化：对应SQL标准中 SERIALIZABLE

Spring 中事务隔离级别可以通过 @Transactional 中的 isolation 属性进⾏设置

@Transactional(isolation = Isolation.READ_COMMITTED)
@RequestMapping("/registry")
public String registry(String name,String password){
   .....略
}

5 Spring事务传播机制

5.1什么是事务传播机制

Spring 事务传播机制定义了多个包含了事务的⽅法，相互调⽤时，事务是如何在这些⽅法间进⾏传递的

5.2事务传播机制的作用

事务传播机制是保证⼀个事务在多个调⽤⽅法间的可控性的（稳定性的）

事务的传播机制有哪些

5.3事务的传播机制有哪些

@Transactional 注解可以通过 propagation属性来指定传播行为

Spring 事务传播机制有以下7种：

opagation.REQUIRED：默认的事务传播级别.如果当前存在事务,则加入该事务.如果当前没有事务,则创建一个新的事务

opagation.SUPPORTS：如果当前存在事务,则加入该事务.如果当前没有事务,则以非事务的方式继续运行

opagation.MANDAToRY：强制性.如果当前存在事务,则加入该事务.如果当前没有事务,则抛出异常

opagation.REQUIRES_NEW：创建一个新的事务.如果当前存在事务,则把当前事务挂起.也就是说不管外部方法是否开启事务，Propagation.REQUIRES_NEW 修饰的内部方法都会新开启自己的事务，且开启的事务相互独立，互不干扰

ropagation.NOT_SUPPORTED：以非事务方式运行,如果当前存在事务，则把当前事务挂起不用

ropagation.NEVER：以非事务方式运行,如果当前存在事务,则抛出异常.

opagation.NESTED：如果当前存在事务,则创建一个事务作为当前事务的嵌套事务来运行.如果当前没有事务,则该取值等价于 PROPAGATION_REQUIRED

5.4Spring 事务传播机制使⽤

上面7种传播机制重点关心两个就可以了：

REQUIRED（默认情况下就是这个）

REQUIRES_NEW

5.4.1 REQUIRED (加入事务）

默认的事务传播级别.如果当前存在事务,则加入该事务.如果当前没有事务,则创建一个新的事务

代码实现：

@RequestMapping("/user")
@RestController
@Slf4j
public class TransController {
    @Autowired
    private UserService userService;
    @Autowired
    private LogService logService;

    @Transactional(propagation = Propagation.REQUIRED)
    @RequestMapping("/insert")
    public boolean UserInsert(UserInfo userInfo) {
        Integer n = userService.insert();
        Integer m = logService.insert();
        log.info("插入成功");
        if(n>0 || m>0){
            System.out.println("插入成功");
            return  true;
        }
        return  false;
    }
}

在对应的userService和LogService 都添加上：

@Transactional(propagation = Propagation.REQUIRES)

LogService代码：

@Service
public class LogService {
    @Autowired
    private LogMapper logMapper;

    @Transactional(propagation = Propagation.REQUIRED)
    public Integer insert() {
        LogInfo logInfo = new LogInfo();
        logInfo.setUserName("用户2");
        logInfo.setOp("添加2");
        Integer n = logMapper.insertLog(logInfo);
        int a =10/0;
        if(n>0){
            return  n;
        }
        return 0;
    }
}

userService代码：

@Service
public class UserService {
    @Autowired
    UserMapper userMapper;

    @Transactional(propagation = Propagation.REQUIRED)
    public Integer insert() {
        UserInfo userInfo = new UserInfo();
        userInfo.setUserName("zhangsan");
        userInfo.setPassword("1234");
        Integer n = userMapper.insertUser(userInfo);
       if(n>0){
           return  n;
       }
       return 0;
    }
}

运⾏程序, 发现数据库没有插⼊任何数据

流程描述：

UserInsert 方法开启事务

用户注册,插入一条数据 (执行成功) (和 UserInsert 使用同一个事务)

插入一条数据出现异常,执行失败 (和 UserInsert 使用同一个事务)

因为步骤三出现异常，导致事务回滚，步骤2和步骤3使用同一个事务，导致步骤2的数据也需要回滚

5.4.2 EQUIRES_NEW (新建事务)

将上述UserService和LogService中相关方法事务传播机制改为

Propagation.REQUIRES_NEw

创建一个新的事务.如果当前存在事务,则把当前事务挂起.也就是说不管外部方法是否开启事务，Propagation.REQUIRES_NEW 修饰的内部方法都会新开启自己的事务，且开启的事务相互独立，互不干扰

UserMapper代码：

@Service
public class UserService {
    @Autowired
    UserMapper userMapper;

    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public Integer insert() {
        UserInfo userInfo = new UserInfo();
        userInfo.setUserName("zhangsan");
        userInfo.setPassword("1234");
        Integer n = userMapper.insertUser(userInfo);
       if(n>0){
           return  n;
       }
       return 0;
    }
}

LogService代码：

@Service
public class LogService {
    @Autowired
    private LogMapper logMapper;

    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public Integer insert() {
        LogInfo logInfo = new LogInfo();
        logInfo.setUserName("用户2");
        logInfo.setOp("添加2");
        Integer n = logMapper.insertLog(logInfo);
        int a =10/0;
        if(n>0){
            return  n;
        }
        return 0;
    }
}

运行结果：

运行程序，发现用户数据插入成功了，日志表数据插入失败，

LogService方法中的事务不影响UserService中的事务

当我们不希望事务之间相互影响时，可以使用该传播行为

总结：

Spring中使用事务,有两种方式:编程式事务(手动操作)和声明式事务.其中声明式事务使用较多,在方法上添加@Transactional就可以实现了

通过 @Transactional(isolation=Isolation.SERIALIZABLE）设置事务的隔离级别.Spring 中的事务隔离级别有 5种

通过 @Transactional(propagation = Propagation.REQUIRED) 设置事务的传播机制, Spring 中的事务传播级别有7种,重点关注 REQUIRED(默认值)和REQUIRES_NEW