Spring 事务和事务传播机制

在我们刚接触事务的时候，在Mysql中我们学习到了事务。

---

什么是事务呢？

事务是⼀组操作的集合。是⼀个不可分割的操作。

事务会把所有的操作作为⼀个整体，一起向数据库提交或者是撤销操作请求，所以这组操作要么同时成功，要么同时失败。

---

事务的应用场景是非常多的，例如我们的支付系统，A向B转账，这个过程B只有收到A的转账才会结束，若B没有收到转账，则会发生回滚。

---

事务的操作步骤

事务的操作主要有三步:

1. 开启事务：starttransaction/begin(⼀组操作前开启事务)

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

3. 回滚事务：rollback(这组操作中间任何⼀个操作出现异常，回滚事务)

如代码：.

-- 开启事务 
start transaction;

-- 提交事务 
commit;

-- 回滚事务 
rollback;

---

Spring中事务的实现

---

Spring中的事务操作分为两类：

1. 编程式事务(收手动写代码操作事务)。

2..声明式事务(利用注解自动开启和提交事务)。

---

编程式事务

如代码：

@Slf4j
@RequestMapping("/user")
@RestController
public class UserController {

    @Autowired
    private DataSourceTransactionManager transactionManager;

    @Autowired
    private TransactionDefinition transactionDefinition;

    @Autowired
    private UserService userService;

    @RequestMapping("/registry")
    public Boolean registry(String name, String password){
        //开启事务
        TransactionStatus transaction = transactionManager.getTransaction(transactionDefinition);

        Integer result = userService.insertUser(name, password);
        log.info("数据影响行数: "+ result);

//        //回滚事务
//        transactionManager.rollback(transaction);
        //提交事务
        transactionManager.commit(transaction);

        return true;
    }
}

如代码所示，手动直接创建了一个事务。

---

声明式事务

声明式事务有两个步骤：

1.添加响应的依赖。

2.使用@Transactional注解。

依赖代码：

<dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-tx</artifactId>
</dependency>

---

注意：@Transactional 可以用来修饰方法或类: 

• 修饰方法时：只有修饰public方法时才生效(修饰其他方法时不会报错，也不生效)[推荐]。

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

---

在方法/类被@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详解

---

其实rollbackFor不一定发生异常时就回滚。

@Transactional 默认只在遇到运行时异常和Error时才会回滚，非运行时异常不回滚。即 Exception的子类中，除了RuntimeException及其子类。

如图：

---

Spring事务隔离级别

---

Spring中事务隔离级别有5种：

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

2. Isolation.READ_UNCOMMITTED：读未提交，该隔离级别的事务可以看到其他事务中未提交的数据。

3. Isolation.READ_COMMITTED：读已提交，该隔离级别的事务能读取到已经提交事务的数据。

4. Isolation.REPEATABLE_READ：可重复读，事务不会读到其他事务对已有数据的修改，即使其他事务已提交。也就可以确保同⼀事务多次查询的结果⼀致，但是其他事务新插入的数据，是可以感知到的。这也就引发了幻读问题。

5. Isolation.SERIALIZABLE：串行化，它会强制事务排序，使之不会发生冲突，从而解决了脏读，不可重复读和幻读问题，但因为执行效率低，所以真正使用的场景并不多。

---

Spring事务传播机制

---

事务传播机制就是：多个事务方法存在调用关系时，事务是如何在这些方法间进行传播的。

@Transactional 注解支持事务传播机制的设置，通过propagation 属性来指定传播为，Spring事务传播机制有以下7种：

1. Propagation.REQUIRED：默认的事务传播级别，如果当前存在事务，则加入该事务。如果当前没有事务，则创建⼀个新的事务。

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

3. Propagation.MANDATORY：强制性，如果当前存在事务，则加⼊该事务。如果当前没有事务，则抛出异常。

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

5. Propagation.NOT_SUPPORTED：以非事务方式运行，如果当前存在事务，则把当前事务挂起。

6. Propagation.NEVER：以非事务方式运行如果当前存在事务，则抛出异常。

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

---

对于以上事务传播机制，我们重点关注以下两个就可以了：

1. REQUIRED（默认值)。

2. REQUIRES_NEW。

当为默认的情况时，如图：

当事务传播机制改为 Propagation.REQUIRES_NEW，如图：

转换机制代码：

@Service
public class LogService {
 @Autowired
 private LogInfoMapper logInfoMapper;

 @Transactional(propagation = Propagation.REQUIRED)
 public void insertLog(String name,String op){

 try {
 int a=10/0;
 } catch (Exception e){
 //回滚当前事务 
 
TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
 }
 //记录⽤⼾操作 
 logInfoMapper.insertLog(name,"⽤⼾注册");
 }
}

 直接在注解里面更改即可。