𝓝𝓮𝓶𝓸&博客

𝓝𝓮𝓶𝓸&博客

【Spring】事务操作

事务概念

1.什么事务

  1. 事务是数据库操作最基本单元，逻辑上一组操作，要么都成功，如果有一个失败所有操作都失败
  2. 典型场景：银行转账
    • lucy 转账 100 元 给 mary
    • lucy 少 100，mary 多 100

注意：这里的事务用的就是数据库中的事务，而不是程序单独实现的事务。不信的话可以做个实验，运行两个服务AB，访问同一数据库，服务A进行debug卡着不动，服务B的请求会显示超时，因为服务A占用了数据库的事务。

特性

2.事务四个特性（ACID）

  1. 原子性
  2. 一致性
  3. 隔离性
  4. 持久性

隔离级别

Spring中事务隔离级别包含五种：

  • Isolation.DEFAULT：默认隔离级别，连接的数据库的默认隔离级别。mysql为可重复读，oracle为提交读。
  • Isolation.READ_UNCOMMITTED：读未提交
  • Isolation.READ_COMMITTED：读已提交
  • Isolation.REPEATABLE_READ：可重复读
  • Isolation.SERIALIZABLE：串行化

但要根据实际的业务场景选择事务传播级别，不一定默认的传播级别适用！

假设现在的业务场景是，先创建用户信息，然后根据用户信息创建学生信息（Student表），但如果由于某些原因，创建学生信息失败，但不能影响用户信息的创建。所以创建用户信息和学生信息应该在不同的事务内，这样才不会相互影响，这样的话，使用@Transactional默认的传播级别就实现不了，但我们可以改变propagation属性值，改为Propagation.REQUIRES_NEW

传播行为

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

  • 事务隔离级别：保证多个并发事务执行的可控性

    理解：事务并行时，控制互不干扰

  • 事务传播行为：保证一个事务在多个调用方法间的可控性

    理解：事务串行时，保证事务之间的调用逻辑

Spring 事务的传播机制包含以下 7 种 :

  • Propagation.REQUIRED: 默认的事务传播级别，它表示如果当前存在事务，则加入该事务；如果当前没有事务，则创建一个新的事务。

    在方法中添加了事务注解，其方法中所涉及的所有方法都会处于事务注解中，如果遇到异常，方法内的所有涉及数据均会回滚。

  • Propagation.SUPPORTS: 如果当前存在事务，则加入该事务；如果当前没有事务，则以非事务的方式继续运行。
  • Propagation.MANDATORY: 如果当前存在事务，则加入该事务；如果当前没有事务，则抛出异常。
  • Propagation.REQUIRES_NEW: 表示创建一个新的事务，如果当前存在事务，则把当前事务挂起。
  • Propagation.NOT_SUPPORTED: 以非事务方式运行，如果当前存在事务，则把当前事务挂起。
  • Propagation.NEVER: 以非事务方式运行，如果当前存在事务，则抛出异常。
  • Propagation.NESTED: 如果当前存在事务，则创建一个事务作为当前事务的嵌套事务来运行；如果不存在事务，则创建一个新的事务。

死活不要事务的

  • PROPAGATION_NEVER：没有就非事务执行，有就抛出异常
  • PROPAGATION_NOT_SUPPORTED：没有就非事务执行，有就直接挂起，然后非事务执行

事务可有可无的

  • PROPAGATION_SUPPORTS：有就用，没有就算了

必须有事务的

  • PROPAGATION_REQUIRES_NEW：有没有都新建事务，如果原来有，就将原来的挂起。
  • PROPAGATION_REQUIRED：如果没有，就新建一个事务；如果有，就加入当前事务
  • PROPAGATION_NESTED：如果没有，就新建一个事务；如果有，就在当前事务中嵌套其他事务。
  • PROPAGATION_MANDATORY：如果没有，就抛出异常；如果有，就使用当前事务。

搭建事务操作环境

1.创建数据库表，添加记录

2.创建 service，搭建 dao，完成对象创建和注入关系

  1. service 注入 dao，在 dao 注入 JdbcTemplate，在 JdbcTemplate 注入 DataSource
  2. @Service
public class UserService {
    //注入 dao
    @Autowired
    private UserDao userDao;
}

    @Repository
public class UserDaoImpl implements UserDao {
    @Autowired
    private JdbcTemplate jdbcTemplate; 
}

3.在 dao 创建两个方法：多钱和少钱的方法，在 service 创建方法（转账的方法）

@Repository
public class UserDaoImpl implements UserDao {
    @Autowired
    private JdbcTemplate jdbcTemplate;
    //lucy 转账 100 给 mary
    //少钱
    @Override
    public void reduceMoney() {
        String sql = "update t_account set money=money-? where username=?";
        jdbcTemplate.update(sql,100,"lucy");
    }
    //多钱
    @Override
    public void addMoney() {
        String sql = "update t_account set money=money+? where username=?";
        jdbcTemplate.update(sql,100,"mary");
    }
}

@Service
public class UserService {
    //注入 dao
    @Autowired
    private UserDao userDao;
    //转账的方法
    public void accountMoney() {
        //lucy 少 100
        userDao.reduceMoney();
        //mary 多 100
        userDao.addMoney();
    } 
}

4.上面代码，如果正常执行没有问题的，但是如果代码执行过程中出现异常，有问题

//转账的方法
public void accountMoney() {
    //lucy少100
    userDao.reduceMoney();

    //模拟异常
    int i = 10/0;

    //mary多100
    userDao.addMoney();
}

  1. 上面问题如何解决呢？
    使用事务进行解决

  2. 事务操作过程

    public void accountMoney() {
    try {
        //第一步 开启事务
        
        //第二步 进行业务操作
        //lucy少100
        userDao.reduceMoney();
        //模拟异常
        int i = 10/0;

        //mary多100
        userDao.addMoney();

        //第三步 没有发生异常，提交事务
    } catch(Exception e) {
        //第四步 出现异常，事务回滚
    }
}

Spring 事务管理介绍

1.事务添加到 JavaEE 三层结构里面 Service 层（业务逻辑层）

2.在 Spring 进行事务管理操作
（1）有两种方式：编程式事务管理和声明式事务管理（使用）

3.声明式事务管理

  1. 基于注解方式（使用）
  2. 基于 xml 配置文件方式

4.在 Spring 进行声明式事务管理，底层使用 AOP 原理
5.Spring 事务管理 API

  1. 提供一个接口，代表事务管理器，这个接口针对不同的框架提供不同的实现类

注解声明式事务管理

1.在 spring 配置文件配置事务管理器

<!--创建事务管理器-->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <!--注入数据源-->
    <property name="dataSource" ref="dataSource"></property>
</bean>

2.在 spring 配置文件，开启事务注解

  1. 在 spring 配置文件引入名称空间 tx（即 transaction）

    <beans xmlns="http://www.springframework.org/schema/beans" 
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
       xmlns:context="http://www.springframework.org/schema/context" 
       xmlns:aop="http://www.springframework.org/schema/aop" 
       xmlns:tx="http://www.springframework.org/schema/tx" 
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd 
       http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd 
       http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd 
       http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">

  2. 开启事务注解

    <!--开启事务注解-->
<tx:annotation-driven transaction-manager="transactionManager"></tx:annotation-driven>

3.在 service 类上面（或者 service 类里面方法上面）添加事务注解

  1. @Transactional，这个注解添加到类上面，也可以添加方法上面
  2. 如果把这个注解添加类上面，这个类里面所有的方法都添加事务
  3. 如果把这个注解添加方法上面，为这个方法添加事务
@Service
@Transactional
public class UserService {

声明式事务管理参数配置

1.在 service 类上面添加注解@Transactional，在这个注解里面可以配置事务相关参数

2.propagation：事务传播行为

  1. 多事务方法直接进行调用，这个过程中事务 是如何进行管理的

    @Service
@Transactional(propagation = Propagation.REQUIRED)
public class UserService {
}

3.ioslation：事务隔离级别

  1. 事务有特性成为隔离性，多事务操作之间不会产生影响。不考虑隔离性产生很多问题

  2. 有三个读问题：脏读、不可重复读、虚（幻）读

  3. 脏读：一个未提交事务读取到另一个未提交事务的数据

  4. 不可重复读：一个未提交事务读取到另一提交事务修改数据

  5. 虚读：一个未提交事务读取到另一提交事务添加数据

  6. 解决：通过设置事务隔离级别，解决读问题

    @Service
@Transactional(propagation = Propagation.REQUIRED, isolation = Isolation.REPEATEABLE_READ)
public class UserService {
}

4.timeout：超时时间

  1. 事务需要在一定时间内进行提交，如果不提交进行回滚
  2. 默认值是 -1 ，设置时间以秒单位进行计算

5.readOnly：是否只读

  1. 读：查询操作，写：添加修改删除操作
  2. readOnly 默认值 false，表示可以查询，可以添加修改删除操作
  3. 设置 readOnly 值是 true，设置成 true 之后，只能查询

6.rollbackFor：回滚

  1. 设置出现哪些异常进行事务回滚

7.noRollbackFor：不回滚

  1. 设置出现哪些异常不进行事务回滚

XML 声明式事务管理

1.在 spring 配置文件中进行配置

  1. 第一步 配置事务管理器
  2. 第二步 配置通知
  3. 第三步 配置切入点和切面
<!--1 创建事务管理器--> 
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <!--注入数据源-->
    <property name="dataSource" ref="dataSource"></property>
</bean>
<!--2 配置通知--> <tx:advice id="txadvice">
    <!--配置事务参数-->
    <tx:attributes>
        <!--指定哪种规则的方法上面添加事务-->
        <tx:method name="accountMoney" propagation="REQUIRED"/>
        <!--<tx:method name="account*"/>-->
    </tx:attributes>
</tx:advice>
<!--3 配置切入点和切面--> 
<aop:config>
    <!--配置切入点-->
    <aop:pointcut id="pt" expression="execution(* com.nemo.spring5.service.UserService.*(..))"/>
    <!--配置切面-->
    <aop:advisor advice-ref="txadvice" pointcut-ref="pt"/>
</aop:config>

完全注解声明式事务管理

1.创建配置类，使用配置类替代 xml 配置文件

@Configuration //配置类
@ComponentScan(basePackages = "com.nemo") //组件扫描
@EnableTransactionManagement //开启事务
public class TxConfig {
    //创建数据库连接池
    @Bean
    public DruidDataSource getDruidDataSource() {
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setDriverClassName("com.mysql.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql:///user_db");
        dataSource.setUsername("root");
        dataSource.setPassword("root");
        return dataSource;
    }
 //创建 JdbcTemplate 对象
    @Bean
    public JdbcTemplate getJdbcTemplate(DataSource dataSource) {
        //到 ioc 容器中根据类型找到 dataSource
        JdbcTemplate jdbcTemplate = new JdbcTemplate();
        //注入 dataSource
        jdbcTemplate.setDataSource(dataSource);
        return jdbcTemplate;
    }
    //创建事务管理器
    @Bean
    public DataSourceTransactionManager getDataSourceTransactionManager(DataSource dataSource) {
        DataSourceTransactionManager transactionManager = new DataSourceTransactionManager();
        transactionManager.setDataSource(dataSource);
        return transactionManager;
    } 
}

概念

事务定义

事务，就是一组操作数据库的动作集合。事务是现代数据库理论中的核心概念之一。如果一组处理步骤或者全部发生或者一步也不执行，我们称该组处理步骤为一个事务。当所有的步骤像一个操作一样被完整地执行，我们称该事务被提交。由于其中的一部分或多步执行失败，导致没有步骤被提交，则事务必须回滚到最初的系统状态。

事务特点

1.原子性：一个事务中所有对数据库的操作是一个不可分割的操作序列，要么全做要么全不做

2.一致性：数据不会因为事务的执行而遭到破坏

3.隔离性：一个事物的执行，不受其他事务的干扰，即并发执行的事物之间互不干扰

4.持久性：一个事物一旦提交，它对数据库的改变就是永久的。

事务实现机制

Spring 为事务管理提供了丰富的功能支持。Spring 事务管理分为编码式和声明式的两种方式。

  • 编程式事务管理： 编程式事务管理使用 TransactionTemplate 或者直接使用底层的 PlatformTransactionManager。对于编程式事务管理，spring推荐使用TransactionTemplate。
  • 声明式事务管理： 建立在AOP之上的。其本质是对方法前后进行拦截，然后在目标方法开始之前创建或者加入一个事务，在执行完目标方法之后根据执行情况提交或者回滚事务。
  • 声明式事务管理不需要入侵代码，更快捷而且简单，推荐使用。

声明式事务有两种方式：

  • 一种是在配置文件（xml）中做相关的事务规则声明
  • 另一种是基于 @Transactional 注解的方式。注释配置是目前流行的使用方式，推荐使用。

在应用系统调用声明了 @Transactional 的目标方法时，Spring Framework 默认使用 AOP 代理，在代码运行时生成一个代理对象，根据 @Transactional 的属性配置信息，这个代理对象决定该声明 @Transactional 的目标方法是否由拦截器 TransactionInterceptor 来使用拦截，在 TransactionInterceptor 拦截时，会在目标方法开始执行之前创建并加入事务，并执行目标方法的逻辑，最后根据执行情况是否出现异常，利用抽象事务管理器 AbstractPlatformTransactionManager 操作数据源 DataSource 提交或回滚事务。

Spring AOP
代理有 CglibAopProxy 和 JdkDynamicAopProxy 两种，以 CglibAopProxy 为例，对于 CglibAopProxy，需要调用其内部类的 DynamicAdvisedInterceptor 的 intercept 方法。对于 JdkDynamicAopProxy，需要调用其 invoke 方法。

开启事务

Spirng Boot 默认开启事务，无需做任何事情，直接使用@Transactional即可

Spring 开启事务的方式：

方式1：Spring中 纯XML 配置事务

<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="pooledDataSource"/>
</bean>
<aop:config>
    <aop:pointcut expression="execution(* cn.yuanyu.crud.service..*(..))" id="txPoint"/>
    <aop:advisor advice-ref="txAdvice" pointcut-ref="txPoint"/>
</aop:config>
<tx:advice id="txAdvice" transaction-manager="transactionManager">
    <tx:attributes>
        <tx:method name="*"/>
        <tx:method name="get*" read-only="true"/>
    </tx:attributes>
</tx:advice>

方式2：Spring中 XML+注解 配置事务

一般xml里面配置粗粒度的控制，然后使用注解

<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="pooledDataSource"/>
</bean>
<aop:config>
    <aop:pointcut expression="execution(* cn.yuanyu.crud.service..*(..))" id="txPoint"/>
    <aop:advisor advice-ref="txAdvice" pointcut-ref="txPoint"/>
</aop:config>
<tx:advice id="txAdvice" transaction-manager="transactionManager">
    <tx:attributes>
        <tx:method name="*"/>
        <tx:method name="get*" read-only="true"/>
    </tx:attributes>
</tx:advice>
<!--
-->
<tx:annotation-driven transaction-manager="transactionManager"/>

方式3：Spring中 纯注解 配置事务，使用@EnableTransactionManagement 注解也可以启用事务管理功能

@Configuration //声明配置类
@MapperScan("cn.yuanyu.tx.mapper")
@EnableTransactionManagement // 开启事务注解，等同于配置文件<tx:annotation-driven/>
public class MybatisPlusConfiguration {

注解@Transactional的使用

注解@Transactional常用配置

参 数 名 称 功 能 描 述
readOnly 该属性用于设置当前事务是否为只读事务，设置为true表示只读，false则表示可读写，默认值为false。例如：@Transactional(readOnly=true)
rollbackFor rollbackFor 该属性用于设置需要进行回滚的异常类数组 ，当方法中抛出指定异常数组中的异常时，则进行事务回滚。例如：指定单一异常类（常用，囊括所有了异常）：@Transactional(rollbackFor=Exception.class)
指定多个异常类：@Transactional(rollbackFor={RuntimeException.class, Exception.class})
rollbackForClassName 该属性用于设置需要进行回滚的异常类名称数组，当方法中抛出指定异常名称数组中的异常时，则进行事务回滚。例如：指定单一异常类名称@Transactional(rollbackForClassName="RuntimeException")
指定多个异常类名称：@Transactional(rollbackForClassName={"RuntimeException","Exception"})
noRollbackFor 该属性用于设置不需要进行回滚的异常类数组，当方法中抛出指定异常数组中的异常时，不进行事务回滚。例如：指定单一异常类：@Transactional(noRollbackFor=RuntimeException.class)
指定多个异常类：@Transactional(noRollbackFor={RuntimeException.class, Exception.class})
noRollbackForClassName 该属性用于设置不需要进行回滚的异常类名称数组，当方法中抛出指定异常名称数组中的异常时，不进行事务回滚。例如：指定单一异常类名称：@Transactional(noRollbackForClassName="RuntimeException")
指定多个异常类名称：@Transactional(noRollbackForClassName={"RuntimeException", "Exception"})
propagation 该属性用于设置事务的传播行为。例如：@Transactional(propagation=Propagation.NOT_SUPPORTED, readOnly=true)
isolation 该属性用于设置底层数据库的事务隔离级别，事务隔离级别用于处理多事务并发的情况，通常使用数据库的默认隔离级别即可，基本不需要进行设置
timeout 该属性用于设置事务的超时秒数，默认值为-1表示永不超时
事物超时设置：@Transactional(timeout=30)，设置为30秒

Propagation的属性（事务的传播行为）

例如：@Transactional(propagation=Propagation.NOT_SUPPORTED,readOnly=true)

Propagation属性 含义
REQUIRED 默认值 在有transaction状态下执行；如当前没有transaction，则创建新的transaction；
SUPPORTS 如当前有transaction，则在transaction状态下执行；如果当前没有transaction，在无transaction状态下执行；
MANDATORY 必须在有transaction状态下执行，如果当前没有transaction，则抛出异常IllegalTransactionStateException；
REQUIRES_NEW 创建新的transaction并执行；如果当前已有transaction，则将当前transaction挂起；
NOT_SUPPORTED 在无transaction状态下执行；如果当前已有transaction，则将当前transaction挂起；
NEVER 在无transaction状态下执行；如果当前已有transaction，则抛出异常IllegalTransactionStateException。

事务5种隔离级别

例如：@Transactional(isolation = Isolation.READ_COMMITTED)

隔离级别 含义
DEFAULT 这是一个PlatfromTransactionManager默认的隔离级别，使用数据库默认的事务隔离级别另外四个与JDBC的隔离级别相对应；
READ_UNCOMMITTED 最低的隔离级别。事实上我们不应该称其为隔离级别，因为在事务完成前，其他事务可以看到该事务所修改的数据。而在其他事务提交前，该事务也可以看到其他事务所做的修改。可能导致脏，幻，不可重复读
READ_COMMITTED 大多数数据库的默认级别。在事务完成前，其他事务无法看到该事务所修改的数据。遗憾的是，在该事务提交后，你就可以查看其他事务插入或更新的数据。这意味着在事务的不同点上，如果其他事务修改了数据，你就会看到不同的数据。可防止脏读，但幻读和不可重复读仍可以发生。
REPEATABLE_READ 比ISOLATION_READ_COMMITTED更严格，该隔离级别确保如果在事务中查询了某个数据集，你至少还能再次查询到相同的数据集，即使其他事务修改了所查询的数据。然而如果其他事务插入了新数据，你就可以查询到该新插入的数据。可防止脏读，不可重复读，但幻读仍可能发生。
SERIALIZABLE 完全服从ACID的隔离级别，确保不发生脏读、不可重复读和幻影读 。这在所有隔离级别中也是最慢的，因为它通常是通过完全锁定当前事务所涉及的数据表来完成的。代价最大、可靠性最高的隔离级别，所有的事务都是按顺序一个接一个地执行。避免所有不安全读取。

使用注意事项（防止事务失效）

  • 在具体的类（或类的方法）上使用 @Transactional 注解 ，而不要使用在类所要实现的任何接口上。

  • @Transactional 注解应该只被应用在 public 修饰的方法上。 如果你在 protected、private 或者 package-visible 的方法上使用 该注解，它也不会报错（IDEA会有提示）， 但事务并没有生效。

  • 被外部调用的公共方法A有两个进行了数据操作的子方法B和子方法C的事务注解说明：

    • 被外部调用的公共方法A声明事务@Transactional，无论子方法B和C是不是本类的方法，无论子方法B和C是否声明事务，事务均由公共方法A控制
    • 被外部调用的公共方法A未声明事务@Transactional，子方法B和C若是其他类的方法且各自声明事务：事务由子方法B和C各自控制
    • 被外部调用的公共方法A未声明事务@Transactional，子方法B和C若是本类的方法，则即使子方法B和C各自声明事务，事务也不会生效，并且会报错（没有可用的transactional）
    • 被外部调用的公共方法A声明事务@Transactional，子方法运行异常，但运行异常被子方法自己 try-catch 处理了，则事务回滚是不会生效的！
      如果想要事务回滚生效，需要将子方法的事务控制交给调用的方法来处理：
      • 方案1：子方法中不用 try-catch 处理运行异常
      • 方案2：子方法的catch里面将运行异常抛出【throw new RuntimeException();】

  • 默认情况下，Spring会对unchecked异常进行事务回滚，也就是默认对 RuntimeException() 异常或是其子类进行事务回滚。
    如果是checked异常则不回滚，例如空指针异常、算数异常等会被回滚；文件读写、网络问题Spring就没法回滚。
    若想对所有异常（包括自定义异常）都起作用，注解上面需配置异常类型：@Transactional(rollbackFor = Exception.class)

  • 数据库要支持事务，如果是mysql，要使用innodb引擎，myisam不支持事务

  • 事务@Transactional由spring控制时，它会在抛出异常的时候进行回滚。如果自己使用try-catch捕获处理了，是不生效的。如果想事务生效可以进行手动回滚或者在catch里面将异常抛出【throw new RuntimeException();】

    • 方案一：手动抛出运行时异常（缺陷是不能在catch代码块自定义返回值）
        try{
      ....  
  }catch(Exception e){
      logger.error("",e);
      throw new RuntimeException;
  }
    • 方案二：手动进行回滚【 TransactionAspectSupport.currentTransactionStatus().setRollbackOnly(); 】
        try{
      ...
  }catch(Exception e){
      log.error("fail",e);
      TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
      return false;
  }

  • @Transactional可以放在Controller下面直接起作用，看到网上好多同学说要放到@Component下面或者@Service下面，经过试验，可以不用放在这两个下面也起作用。

  • @Transactional引入包问题，它有两个包：

    import javax.transaction.Transactional; 
// 和
import org.springframework.transaction.annotation.Transactional; 		// 推荐

    这两个都可以用，对比了一下他们两个的方法和属性，发现后面的比前面的强大。建议使用后面的。

使用场景

自动回滚

直接抛出，不try/catch

@Override
@Transactional(rollbackFor = Exception.class)
public Object submitOrder() throws Exception {  
     success();  
     //假如exception这个操作数据库的方法会抛出异常，方法success()对数据库的操作会回滚。 
     exception(); 
     return ApiReturnUtil.success();
}

手动回滚

进行try/catch，回滚并抛出

@Override
@Transactional(rollbackFor = Exception.class)
public Object submitOrder (){  
    success();  
    try {  
        exception(); 
     } catch (Exception e) {  
        e.printStackTrace();   
        //手工回滚异常
        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
        return ApiReturnUtil.error();
     }  
    return ApiReturnUtil.success();
}

回滚部分异常

使用【Object savePoint = TransactionAspectSupport.currentTransactionStatus().createSavepoint(); 】设置回滚点。

使用【TransactionAspectSupport.currentTransactionStatus().rollbackToSavepoint(savePoint);】回滚到savePoint。

@Override
@Transactional(rollbackFor = Exception.class)
public Object submitOrder (){  
    success();  
    //只回滚以下异常，
    Object savePoint = TransactionAspectSupport.currentTransactionStatus().createSavepoint();
    try {  
        exception(); 
     } catch (Exception e) {  
        e.printStackTrace();   
        //手工回滚异常
        TransactionAspectSupport.currentTransactionStatus().rollbackToSavepoint(savePoint);
        return ApiReturnUtil.error();
     }  
    return ApiReturnUtil.success();
}

手动创建、提交、回滚事务

PlatformTransactionManager 这个接口中定义了三个方法 getTransaction创建事务，commit 提交事务，rollback 回滚事务。它的实现类是 AbstractPlatformTransactionManager。

@Autowired
priDataSourceTransactionManager dataSourceTransactionManager;
@Autowired
TransactionDefinition transactionDefinition;

// 手动创建事务
TransactionStatus transactionStatus = dataSourceTransactionManager.getTransaction(transactionDefinition);

// 手动提交事务
dataSourceTransactionManager.commit(transactionStatus);

// 手动回滚事务。（最好是放在catch 里面，防止程序异常而事务一直卡在哪里未提交）
dataSourceTransactionManager.rollback(transactionStatus);

编程式事务

上面聊的这些内容都是基于@Transactional注解的，主要说的是它的事务问题，我们把这种事务叫做：声明式事务。
其实，spring还提供了另外一种创建事务的方式，即通过手动编写代码实现的事务，我们把这种事务叫做：编程式事务。例如：

   @Autowired
   private TransactionTemplate transactionTemplate;
   
   ...
   
   public void save(final User user) {
         queryData1();
         queryData2();
         transactionTemplate.execute((status) => {
            addData1();
            updateData2();
            return Boolean.TRUE;
         })
   }

在spring中为了支持编程式事务，专门提供了一个类：TransactionTemplate，在它的execute方法中，就实现了事务的功能。
相较于@Transactional注解声明式事务，我更建议大家使用，基于TransactionTemplate的编程式事务。主要原因如下：
1.避免由于spring aop问题，导致事务失效的问题。
2.能够更小粒度的控制事务的范围，更直观。

建议在项目中少使用@Transactional注解开启事务。但并不是说一定不能用它，如果项目中有些业务逻辑比较简单，而且不经常变动，使用@Transactional注解开启事务开启事务也无妨，因为它更简单，开发效率更高，但是千万要小心事务失效的问题。

事务失效不回滚的问题

事务源码（非public方法）

事务开始，拦截器，从这里可以看出事务其实就是一个方法拦截器的实现类，他是基于AOP的。
TransactionInterceptor
image

image

TransactionAspectSupport
image

AbstractFallbackTransactionAttributeSource
image

AbstractFallbackTransactionAttributeSource
image

一路追下来可以看到，方法中有个判断，如果目标方法不是public，则TransactionAttribute返回null，即不支持事务。

final方法

有时候，某个方法不想被子类重新，这时可以将该方法定义成final的。普通方法这样定义是没问题的，但如果将事务方法定义成final，例如：

@Service
public class UserService {

    @Transactional
    public final void add(UserModel userModel){
        saveData(userModel);
        updateData(userModel);
    }
}

我们可以看到add方法被定义成了final的，这样会导致事务失效。为什么？

如果你看过spring事务的源码，可能会知道spring事务底层使用了aop，也就是通过jdk动态代理或者cglib，帮我们生成了代理类，在代理类中实现的事务功能。
但如果某个方法用final修饰了，那么在它的代理类中，就无法重写该方法，而添加事务功能。

注意：如果某个方法是static的，同样无法通过动态代理，变成事务方法。

异常被捕获导致事务失效

在spring boot 中，使用事务非常简单，直接在方法上面加入@Transactional 就可以实现，以下是我的做法

@GetMapping("delete")
@ResponseBody
@Transactional  
public void delete(@RequestParam("id") int id) {
	try {
        //delete country
        this.repository.delete(id);
        if(id == 1){
            throw Exception("测试事务");
        }
         //delete city
        this.repository.deleteByCountryId(id);
    }catch (Exception e){
        logger.error("delete false:" + e.getMessage());
        return new MessageBean(101,"delete false");
    }
}

发现事务不回滚，即 this.repository.delete(id)；成功把数据删除了。

原因：

默认spring事务只在发生未被捕获的 RuntimeException 时才回滚。

spring aop 异常捕获原理：被拦截的方法需显式抛出异常，并不能经任何处理，这样aop代理才能捕获到方法的异常，才能进行回滚，默认情况下aop只捕获 RuntimeException 的异常，但可以通过配置来捕获特定的异常并回滚。

换句话说在service的方法中不使用 try catch 或者在 catch 中最后加上throw new RuntimeExcetpion()抛出运行异常，这样程序异常时才能被aop捕获进而回滚。

解决方案：

  • 方案1：例如service层处理事务，那么service中的方法中不做异常捕获，或者在catch语句中最后增加
    throw new RuntimeException(); 语句，以便让aop捕获异常再去回滚，并且在service的上层要继续捕获这个异常。

  • 方案2：在service层方法的catch语句中进行手动回滚，这样上层就无需去处理异常。

    @GetMapping("delete") 
@ResponseBody 
@Transactional 
public Object delete(@RequestParam("id") int id){ 
    if (id < 1){
         return new MessageBean(101,"parameter wrong: id = " + id) ; 
     } 
    try { 
         //delete country
         this.countryRepository.delete(id);
         //delete city
         this.cityRepository.deleteByCountryId(id);
         return new MessageBean(200,"delete success");
     }catch (Exception e){
         logger.error("delete false:" + e.getMessage());
         // 手动回滚
         TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
         return new MessageBean(101,"delete false");
     }
}

扩展：回滚部分事务（嵌套事务回滚多了）

public class UserService {

    @Autowired
    private UserMapper userMapper;

    @Autowired
    private RoleService roleService;

    @Transactional
    public void add(UserModel userModel) throws Exception {
        userMapper.insertUser(userModel);
        roleService.doOtherThing();
    }
}

@Service
public class RoleService {

    @Transactional(propagation = Propagation.NESTED)
    public void doOtherThing() {
        System.out.println("保存role表数据");
    }
}

这种情况使用了嵌套的内部事务，原本是希望调用roleService.doOtherThing方法时，如果出现了异常，只回滚doOtherThing方法里的内容，不回滚 userMapper.insertUser里的内容，即回滚保存点。。但事实是，insertUser也回滚了。
因为doOtherThing方法出现了异常，没有手动捕获，会继续往上抛，到外层add方法的代理方法中捕获了异常。所以，这种情况是直接回滚了整个事务，不只回滚单个保存点。
怎么样才能只回滚保存点呢？

@Slf4j
@Service
public class UserService {

    @Autowired
    private UserMapper userMapper;

    @Autowired
    private RoleService roleService;

    @Transactional
    public void add(UserModel userModel) throws Exception {

        userMapper.insertUser(userModel);
        try {
            roleService.doOtherThing();
        } catch (Exception e) {
            log.error(e.getMessage(), e);
        }
    }
}

可以将内部嵌套事务放在try/catch中，并且不继续往上抛异常。这样就能保证，如果内部嵌套事务中出现异常，只回滚内部事务，而不影响外部事务。

手动抛了别的异常

即使开发者没有手动捕获异常，但如果抛的异常不正确，spring事务也不会回滚。

@Slf4j
@Service
public class UserService {
    
    @Transactional
    public void add(UserModel userModel) throws Exception {
        try {
             saveData(userModel);
             updateData(userModel);
        } catch (Exception e) {
            log.error(e.getMessage(), e);
            throw new Exception(e);
        }
    }
}

上面的这种情况，开发人员自己捕获了异常，又手动抛出了异常：Exception，事务同样不会回滚。
因为spring事务，默认情况下只会回滚RuntimeException（运行时异常）和Error（错误），对于普通的Exception（非运行时异常），它不会回滚。

自定义了回滚异常

在使用@Transactional注解声明事务时，有时我们想自定义回滚的异常，spring也是支持的。可以通过设置rollbackFor参数，来完成这个功能。
但如果这个参数的值设置错了，就会引出一些莫名其妙的问题，例如：

@Slf4j
@Service
public class UserService {
    
    @Transactional(rollbackFor = BusinessException.class)
    public void add(UserModel userModel) throws Exception {
       saveData(userModel);
       updateData(userModel);
    }
}

如果在执行上面这段代码，保存和更新数据时，程序报错了，抛了SqlException、DuplicateKeyException等异常。而BusinessException是我们自定义的异常，报错的异常不属于BusinessException，所以事务也不会回滚。
即使rollbackFor有默认值，但阿里巴巴开发者规范中，还是要求开发者重新指定该参数。
这是为什么呢？
因为如果使用默认值，一旦程序抛出了Exception，事务不会回滚，这会出现很大的bug。所以，建议一般情况下，将该参数设置成：Exception或Throwable。

自调用导致事务失效

在 Spring 的 AOP 代理下，只有目标方法由外部调用，目标方法才由 Spring 生成的代理对象来管理，否则会造成自调用问题。

若同一类中的 没有@Transactional 注解的方法 内部调用 有@Transactional 注解的方法，有@Transactional 注解的方法的事务被忽略，不会发生回滚。见 示例代码展示。

自调用问题示例：

@Service
public class OrderService {
  
    private void insert() {
        insertOrder();
    }

    @Transactional
    public void insertOrder() {
        //insert log info
        //insertOrder
        //updateAccount
    }
}

// insertOrder() 尽管有@Transactional 注解，但它被内部方法 insert()调用，事务被忽略，出现异常事务不会发生回滚，并且会报错类似于：
// org.springframework.transaction.NoTransactionException: No transaction aspect-managed TransactionStatus in scope（翻译：没有Transaction无法回滚事务。自调用导致@Transactional 失效。）

自调用失效原因：

  • spring里事务是用注解配置的，当一个方法没有接口，单单只是一个内部方法时，事务的注解是不起作用的，需要回滚时就会报错。
  • 出现这个问题的根本原因在于AOP的实现原理。由于@Transactional 的实现原理是AOP，AOP的实现原理是动态代理，换句话说，自调用时不存在代理对象的调用（即 虽然外部方法调用了代理对象，但是内部方法是在代理对象内部调用自己，没有套上事务），这时不会产生我们注解@Transactional 配置的参数，自然无效了。
  • 虽然可以直接从容器中获取代理对象，但这样有侵入之嫌，不推荐。

解决方案：

我们看到在方法insert中，直接调用事务方法insertOrder。从前面介绍的内容可以知道，insertOrder方法拥有事务的能力是因为spring aop生成代理了对象，但是这种方法直接调用了this对象的方法，所以insertOrder方法不会生成事务。
由此可见，在同一个类中的方法直接内部调用，会导致事务失效。
那么问题来了，如果有些场景，确实想在同一个类的某个方法中，调用它自己的另外一个方法，该怎么办呢？

在外层方法上加事务

1、可以在类服务上加事务（或者最外层的接口方法上加事务）（或者在外层方法上加事务）：

@Service
@Transactional
public class OrderService {
  
    // @Transactional  服务上加了@Transactional后  这里可以不加
    private void insert() {
        insertOrder();
    }

    @Transactional
    public void insertOrder() {
        //insert log info
        //insertOrder
        //updateAccount
    }
}

为什么这种方法可行呢？

其实是因为，在外层方法insert()加上事务之后，即使内层方法this.insertOrder()方法的事务不生效，也会由于事务的传播机制，而套上外层方法的事务，从而达到this.insertOrder()方法事务生效的效果。

在Spring框架中，当你使用@Transactional注解时，Spring会为目标方法创建一个代理，这个代理负责在方法调用前后执行事务逻辑（如开始事务、提交或回滚）。然而，当方法内部通过this引用直接调用同一个类的另一个方法时，这个调用实际上绕过了Spring的代理机制，因此不会触发代理中的事务管理逻辑。

尽管如此，在有些情况下，你可能观察到即使是通过this引用调用的方法，事务仍然能够正常回滚。这通常是因为事务的边界实际上是由外部方法（即被代理的方法）定义的，而不是由内部调用的方法定义的。

以下是几种可能解释为什么事务仍然能够正常回滚的情况：

  • 外部方法的事务管理：如果method2（通过this.method1()调用method1的方法）是带有@Transactional注解的，那么整个method2的执行（包括它对method1的调用）都将在一个事务的上下文中进行。如果method1中抛出了异常，并且这个异常传播到了method2中，那么Spring将会标记这个事务为需要回滚，并且在method2执行完毕时执行回滚操作。
  • 异常传播：重要的是要确保method1中抛出的异常没有被捕获并处理，而是允许它传播到method2。只有这样，Spring的事务管理器才能感知到异常并触发回滚。
  • 事务传播行为：虽然this.method1()调用绕过了代理，但method2作为被代理的方法仍然在其自己的事务上下文中。默认情况下，如果method2已经开始了一个事务，那么method1中的操作也会在这个事务中执行。因此，任何导致事务回滚的异常（无论是在method1还是method2中抛出的）都会导致整个事务回滚。
  • 没有新的事务创建：如果method1没有被标记为@Transactional，或者它的传播行为是PROPAGATION_SUPPORTS或PROPAGATION_REQUIRED（并且当前已经存在一个活动事务），那么method1中的操作将会加入到method2的事务中，而不是创建一个新的事务。因此，method1中的异常仍然可以触发整个事务的回滚。

新加一个Service方法

这个方法非常简单，只需要新加一个Service方法，把@Transactional注解加到新Service方法上，把需要事务执行的代码移到新方法中。具体代码如下：

@Servcie
public class ServiceA {
   @Autowired
   prvate ServiceB serviceB;

   public void save(User user) {
         queryData1();
         queryData2();
         serviceB.doSave(user);
   }
 }

 @Servcie
 public class ServiceB {

    @Transactional(rollbackFor=Exception.class)
    public void doSave(User user) {
       addData1();
       updateData2();
    }

 }

在该Service类中注入自己

如果不想再新加一个Service类，在该Service类中注入自己也是一种选择。具体代码如下：

@Servcie
public class ServiceA {
   @Autowired
   prvate ServiceA serviceA;

   public void save(User user) {
         queryData1();
         queryData2();
         serviceA.doSave(user);
   }

   @Transactional(rollbackFor=Exception.class)
   public void doSave(User user) {
       addData1();
       updateData2();
    }
 }

可能有些人可能会有这样的疑问：这种做法会不会出现循环依赖问题？
答案：不会。当然，如果出现了循环依赖问题，也可以使用@Lazy注解，在项目启动时不装配，使用时再装配。

通过AopContent类

在该Service类中使用AopContext.currentProxy()获取代理对象
上面的方法2确实可以解决问题，但是代码看起来并不直观，还可以通过在该Service类中使用AOPProxy获取代理对象，实现相同的功能。具体代码如下：

@Servcie
public class ServiceA {

   public void save(User user) {
         queryData1();
         queryData2();
         ((ServiceA)AopContext.currentProxy()).doSave(user);
   }

   @Transactional(rollbackFor=Exception.class)
   public void doSave(User user) {
       addData1();
       updateData2();
    }
 }

2、使用AspectJ 取代 Spring AOP 代理

上面的两个问题@Transactional 注解只应用到 public 方法和自调用问题，是由于使用 Spring AOP 代理造成的。为解决这两个问题，可以使用 AspectJ 取代 Spring AOP 代理。

需要将下面的 AspectJ 信息添加到 xml 配置信息中。

AspectJ 的 xml 配置信息

<tx:annotation-driven mode="aspectj" />
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource" />
</bean>
</bean class="org.springframework.transaction.aspectj.AnnotationTransactionAspect" factory-method="aspectOf">
	<property name="transactionManager" ref="transactionManager" />
</bean>

同时在 Maven 的 pom 文件中加入 spring-aspects 和 aspectjrt 的 dependency 以及 aspectj-maven-plugin。

AspectJ 的 pom 配置信息

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aspects</artifactId>
    <version>4.3.2.RELEASE</version>
    </dependency>
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjrt</artifactId>
    <version>1.8.9</version>
</dependency>

<plugin>
<groupId>org.codehaus.mojo</groupId>
<artifactId>aspectj-maven-plugin</artifactId>
<version>1.9</version>
<configuration>
    <showWeaveInfo>true</showWeaveInfo>
    <aspectLibraries>
    <aspectLibrary>
        <groupId>org.springframework</groupId>
        <artifactId>spring-aspects</artifactId>
        </aspectLibrary>
    </aspectLibraries>
</configuration>

<executions>
<execution>
    <goals>
        <goal>compile</goal>
        <goal>test-compile</goal>
    </goals>
</execution>
</executions>
</plugin>

其他

事务提交方式

默认情况下，数据库处于自动提交模式。每一条语句处于一个单独的事务中，在这条语句执行完毕时，如果执行成功则隐式的提交事务，如果执行失败则隐式的回滚事务。

对于正常的事务管理，是一组相关的操作处于一个事务之中，因此必须关闭数据库的自动提交模式。不过，这个我们不用担心，spring
会将底层连接的【自动提交特性】设置为 false 。也就是在使用 spring 进行事物管理的时候，spring
会将【是否自动提交】设置为false，等价于JDBC中的 connection.setAutoCommit(false);
，在执行完之后在进行提交 connection.commit(); 。

事务回滚规则

指示spring事务管理器回滚一个事务的推荐方法是在当前事务的上下文内抛出异常。spring事务管理器会捕捉任何未处理的异常，然后依据规则决定是否回滚抛出异常的事务。

默认配置下，spring只有在抛出的异常为运行时unchecked异常时才回滚该事务，也就是抛出的异常为RuntimeException的子类(Errors也会导致事务回滚)，而抛出checked异常则不会导致事务回滚。

可以明确的配置在抛出那些异常时回滚事务，包括checked异常。也可以明确定义那些异常抛出时不回滚事务。

事务并发会产生的问题

术语 含义
脏读 A事务读取到了B事务还未提交的数据，如果B未提交的事务回滚了，那么A事务读取的数据就是无效的，这就是数据脏读
不可重复读 在同一个事务中，多次读取同一数据返回的结果不一致，这是由于读取事务在进行操作的过程中，如果出现更新事务，它必须等待更新事务执行成功提交完成后才能继续读取数据，这就导致读取事务在前后读取的数据不一致的状况出现
幻读 A事务读取了几行记录后，B事务插入了新数据，并且提交了插入操作，在后续操作中A事务就会多出几行原本不存在的数据，就像A事务出现幻觉，这就是幻读

第一类丢失更新

在没有事务隔离的情况下，两个事务都同时更新一行数据，但是第二个事务却中途失败退出， 导致对数据的两个修改都失效了。

例如：

张三的工资为5000，事务A中获取工资为5000，事务B获取工资为5000，汇入100，并提交数据库，工资变为5100；
随后，事务A发生异常，回滚了，恢复张三的工资为5000，这样就导致事务B的更新丢失了。

脏读

脏读就是指当一个事务正在访问数据，并且对数据进行了修改，而这种修改还没有提交到数据库中，这时，另外一个事务也访问这个数据，然后使用了这个数据。

例如：

张三的工资为5000，事务A中把他的工资改为8000，但事务A尚未提交。
与此同时，事务B正在读取张三的工资，读取到张三的工资为8000。
随后，事务A发生异常，回滚了事务，张三的工资又回滚为5000。
最后，事务B读取到的张三工资为8000的数据即为脏数据，事务B做了一次脏读。

不可重复读

是指在一个事务内，多次读同一数据。在这个事务还没有结束时，另外一个事务也访问该同一数据。那么，在第一个事务中的两次读数据之间，由于第二个事务的修改，那么第一个事务两次读到的的数据可能是不一样的。这样就发生了在一个事务内两次读到的数据是不一样的，因此称为是不可重复读。

例如：

在事务A中，读取到张三的工资为5000，操作没有完成，事务还没提交。
　　与此同时，事务B把张三的工资改为8000，并提交了事务。
　　随后，在事务A中，再次读取张三的工资，此时工资变为8000。在一个事务中前后两次读取的结果并不致，导致了不可重复读。

第二类丢失更新

不可重复读的特例。

有两个并发事务同时读取同一行数据，然后其中一个对它进行修改提交，而另一个也进行了修改提交。这就会造成第一次写操作失效。

例如：

在事务A中，读取到张三的存款为5000，操作没有完成，事务还没提交。
　　与此同时，事务B存入1000，把张三的存款改为6000，并提交了事务。
　　随后，在事务A中，存储500，把张三的存款改为5500，并提交了事务，这样事务A的更新覆盖了事务B的更新。

幻读

是指当事务不是独立执行时发生的一种现象，例如第一个事务对一个表中的数据进行了修改，这种修改涉及到表中的全部数据行。同时，第二个事务也修改这个表中的数据，这种修改是向表中插入一行新数据。那么，以后就会发生操作第一个事务的用户发现表中还有没有修改的数据行，就好象发生了幻觉一样。

例如：

目前工资为5000的员工有10人，事务A读取到所有的工资为5000的人数为10人。
　　此时，事务B插入一条工资也为5000的记录。
　　这时，事务A再次读取工资为5000的员工，记录为11人。此时产生了幻读。

不可重复读和幻读的区别

不可重复读的重点是修改，同样的条件，你读取过的数据，再次读取出来发现值不一样了

幻读的重点在于新增或者删除，同样的条件，第 1 次和第 2 次读出来的记录数不一样

https://www.cnblogs.com/konglxblog/p/16229175.html

踩坑

在方法A中，先调用方法B删除数据，再调用方法C检查数据是否存在，发现数据还是存在

可以打开Mybatis的日志，查看SqlSession是否被创建新的。

  • 如果Creating a new SqlSession，说明方法创建了一个新的事务
  • 如果Fetched SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@478cc9be] from current transaction，说明方法没有额外创建新的事务，而是取到了当前的事务，事务id为478cc9be。

有可能方法A和B使用了同一个事务，但是方法C创建了新的事务（可能里面有方法使用了传播行为REQUIRES_NEW，导致创建了新的事务），这样事务就是隔离的，看不到数据的变化了。

posted @ 2020-08-07 20:04  Nemo&  阅读(185)  评论(0)  编辑  收藏  举报