【Spring】声明式事务 spring-tx

「已注销」

已于 2024-03-21 11:49:55 修改

阅读量714

点赞数 13

分类专栏：后端 # Spring 文章标签： spring java 后端

于 2024-02-24 00:02:18 首次发布

本文链接：https://blog.csdn.net/GavinGroves/article/details/136263055

版权

后端同时被 2 个专栏收录

41 篇文章 0 订阅

订阅专栏

Spring

8 篇文章 0 订阅

订阅专栏

声明式事务是什么？

spring-tx : 声明式事务的框架
声明式事务是指使用注解或 XML 配置的方式来控制事务的提交和回滚
开发者只需要添加配置即可，具体事务的实现由第三方框架实现

程序员：
配置文件即可（注解、xml）
指定哪些方法需要添加事务
以及事务的属性

编程式事务与声明式事事务区别：

编程式事务需要手动编写代码来管理事务
而声明式事务可以通过配置文件或注解来控制事务。

使用声明式事务可以将事务的控制和业务逻辑分离开来

一、快速理解事务管理

一个事务中的多个业务操作，要么全部成功，要么全部失败。

1.1 Transactional注解

@Transactional作用：

就是在当前这个方法执行开始之前来开启事务，方法执行完毕之后提交事务。
如果在这个方法执行的过程当中出现了异常，就会进行事务的回滚操作。

@Transactional注解：我们一般会在业务层当中来控制事务，因为在业务层当中，一个业务功能可能会包含多个数据访问的操作。在业务层来控制事务，我们就可以将多个数据访问操作控制在一个事务范围内。

@Transactional注解书写位置：

方法
- 当前方法交给spring进行事务管理
类
- 当前类中所有的方法都交由spring进行事务管理
接口
- 接口下所有的实现类当中所有的方法都交给spring 进行事务管理

1.2 案例

在业务方法delete上加上 @Transactional 来控制事务。

@Slf4j
@Service
public class DeptServiceImpl implements DeptService {
    @Autowired
    private DeptMapper deptMapper;

    @Autowired
    private EmpMapper empMapper;

    
    @Override
    @Transactional  //当前方法添加了事务管理
    public void delete(Integer id){
        //根据部门id删除部门信息
        deptMapper.deleteById(id);
        
        //模拟：异常发生
        int i = 1/0;

        //删除部门下的所有员工信息
        empMapper.deleteByDeptId(id);   
    }
}

添加Spring事务管理后，由于服务端程序引发了异常，所以事务进行回滚。

说明：
可以在application.yml配置文件中开启事务管理日志，这样就可以在控制看到和事务相关的日志信息了

#spring事务管理日志
logging:
  level:
    org.springframework.jdbc.support.JdbcTransactionManager: debug

1.3 Transactional注解使用细节

@Transactional注解当中的两个常见的属性：

异常回滚的属性：rollbackFor
事务传播行为：propagation

1.3.1 rollbackFor

@Transactional默认情况下，只有出现RuntimeException(运行时异常)才会回滚事务。

假如我们想让所有的异常都回滚，需要来配置@Transactional注解当中的rollbackFor属性，通过rollbackFor这个属性指定异常类型回滚。

    @Override
    @Transactional(rollbackFor=Exception.class)
    public void delete(Integer id){
        //根据部门id删除部门信息
        deptMapper.deleteById(id);
        
        //模拟：异常发生
        int num = id/0;

        //删除部门下的所有员工信息
        empMapper.deleteByDeptId(id);   
    }

案例

修改业务功能代码，在模拟异常的位置上直接抛出Exception异常（编译时异常）
在controller中继续把异常向上抛

@Transactional
public void delete(Integer id) throws Exception {
        //根据部门id删除部门信息
        deptMapper.deleteById(id);
        
        //模拟：异常发生
        if(true){
            throw new Exception("出现异常了~~~");
        }

        //删除部门下的所有员工信息
        empMapper.deleteByDeptId(id);   
}

结果：
发生了Exception异常，但事务依然提交了，数据库数据也发生了变化

1.3.2 propagation

用来配置事务的传播行为的

什么是事务的传播行为呢？

就是当一个事务方法被另一个事务方法调用时，这个事务方法应该如何进行事务控制。
例如：两个事务方法，一个A方法，一个B方法。在这两个方法上都添加了@Transactional注解，就代表这两个方法都具有事务，而在A方法当中又去调用了B方法。

所谓事务的传播行为，指的就是在A方法运行的时候，首先会开启一个事务，在A方法当中又调用了B方法， B方法自身也具有事务，那么B方法在运行的时候，到底是加入到A方法的事务当中来，还是B方法在运行的时候新建一个事务？这个就涉及到了事务的传播行为。

想控制事务的传播行为，在@Transactional注解的后面指定一个属性propagation，通过 propagation 属性来指定传播行为。

常见的事务传播行为:

属性值	含义
REQUIRED	【默认值】需要事务，有则加入，无则创建新事务
REQUIRES_NEW	需要新事务，无论有无，总是创建新事务
SUPPORTS	支持事务，有则加入，无则在无事务状态中运行
NOT_SUPPORTED	不支持事务，在无事务状态下运行,如果当前存在已有事务,则挂起当前事务
MANDATORY	必须有事务，否则抛异常
NEVER	必须没事务，否则抛异常
…

主要用：

REQUIRED（默认值）
REQUIRES_NEW

案例

需求：
解散部门时需要记录操作日志

由于解散部门是一个非常重要而且非常危险的操作，所以在业务当中要求每一次执行解散部门的操作都需要留下痕迹，就是要记录操作日志。而且还要求无论是执行成功了还是执行失败了，都需要留下痕迹。

步骤：

执行解散部门的业务：先删除部门，再删除部门下的员工
记录解散部门的日志，到日志表

问题：

解散部门业务和记录日志业务都添加 @Transactional 事务管理且是默认属性REQUIRED （即有事务就加入无事务创建新的）
在默认属性下，日志业务加入了解散部门业务的事务
那么，在执行解散部门业务时候，发生异常，回滚后，日志业务也被回滚了，也就是没有记录失败的操作日志，日志业务数据为空。

解决：
将日志操作业务的 @Transactional注解属性设置为 REQUIRES_NEW属性 （无论有无，总是创建新事务） 运行在一个独立的事务中

原因:：
当解散部门业务方法运行时，开启一个事务。（外部事物）
日志操作业务方法运行时，也开启一个事务。（内部事务）
那么，当解散部门业务出现异常，进行事务回滚，内部日志事务已经提交了，就不会回滚。

REQUIRES_NEW属性：不希望事务之间相互影响时，可以使用该传播行为。
比如：下订单前需要记录日志，不论订单保存成功与否，都需要保证日志记录能够记录成功。

二、Spring事务管理器

Spring声明式事务对应依赖

spring-tx: 包含声明式事务实现的基本规范（事务管理器规范接口和事务增强等等）
spring-jdbc: 包含DataSource方式事务管理器实现类DataSourceTransactionManager
spring-orm: 包含其他持久层框架的事务管理器实现类例如：Hibernate/Jpa等

现在要使用的事务管理器是org.springframework.jdbc.datasource.DataSourceTransactionManager，将来整合 JDBC方式、JdbcTemplate方式、Mybatis方式的事务实现！

DataSourceTransactionManager类中的主要方法：

doBegin()：开启事务
doSuspend()：挂起事务
doResume()：恢复挂起的事务
doCommit()：提交事务
doRollback()：回滚事务

三、基于注解的声明式事务

1.1 准备工作

导入依赖

  <!-- 声明式事务依赖-->
  <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-tx</artifactId>
      <version>6.0.6</version>
  </dependency>
  
        <!-- spring-jdbc -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>6.0.6</version>
        </dependency>

配置文件
- 外部配置文件

doug.url=jdbc:mysql://localhost:3306/studb
doug.driver=com.mysql.cj.jdbc.Driver
doug.username=root
doug.password=root

spring配置文件

package com.doug.config;

import com.alibaba.druid.pool.DruidDataSource;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
import org.springframework.jdbc.core.JdbcTemplate;

import javax.sql.DataSource;

@Configuration
@PropertySource("classpath:jdbc.properties")
@ComponentScan("com.doug")
public class MyConfiguration {

    @Value("${doug.url}")
    private String url;

    @Value("${doug.driver}")
    private String driver;

    @Value("${doug.username}")
    private String username;

    @Value("${doug.password}")
    private String password;

    @Bean
    public DataSource dataSource(){
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setUrl(url);
        dataSource.setDriverClassName(driver);
        dataSource.setUsername(username);
        dataSource.setPassword(password);
        return dataSource;
    }

    @Bean
    public JdbcTemplate jdbcTemplate(DataSource dataSource){
        JdbcTemplate jdbcTemplate = new JdbcTemplate();
        jdbcTemplate.setDataSource(dataSource);
        return jdbcTemplate;
    }
}

准备 dao/service
- dao

@Repository
public class StudentDao {
    @Autowired
    private JdbcTemplate jdbcTemplate;

    public void updateNameById(String name,Integer id){
        String sql = "update students set name = ? where id = ? ;";
        int rows = jdbcTemplate.update(sql, name, id);
    }

    public void updateAgeById(Integer age,Integer id){
        String sql = "update students set age = ? where id = ? ;";
        jdbcTemplate.update(sql,age,id);
    }
}

service

@Service
public class StudentService {
    @Autowired
    private StudentDao studentDao;

    public void changeInfo(){
        studentDao.updateAgeById(100,1);
        System.out.println("-----------");
        studentDao.updateNameById("test1",1);
    }
}

测试

@SpringJUnitConfig(MyConfiguration.class)
public class SpringTxTest {

    @Autowired
    private StudentService studentService;

    @Test
    public void TxTest(){
        studentService.changeInfo();
    }
}

结果

1.2 基本事务控制

配置类设置

@Configuration
@PropertySource("classpath:jdbc.properties")
@ComponentScan("com.doug")
@EnableTransactionManagement  // 开启声明式事物管理
public class MyConfiguration {

    @Value("${doug.url}")
    private String url;

    @Value("${doug.driver}")
    private String driver;

    @Value("${doug.username}")
    private String username;

    @Value("${doug.password}")
    private String password;

    @Bean
    public DataSource dataSource(){
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setUrl(url);
        dataSource.setDriverClassName(driver);
        dataSource.setUsername(username);
        dataSource.setPassword(password);
        return dataSource;
    }

    @Bean
    public JdbcTemplate jdbcTemplate(DataSource dataSource){
        JdbcTemplate jdbcTemplate = new JdbcTemplate();
        jdbcTemplate.setDataSource(dataSource);
        return jdbcTemplate;
    }

    /**
     * 装配事务管理实现对象
     * @param dataSource
     * @return
     */
    @Bean
    public TransactionManager transactionManager(DataSource dataSource){
        DataSourceTransactionManager transactionManager = new DataSourceTransactionManager(dataSource);
        return transactionManager;
    }
}

需要事务的方法添加事务注解

service 层类方法添加事务

    /**
     * 添加事务
     *  @Transactional
     *      位置：  方法 | 类上
     *      方法： 当前方法有事务
     *      类上： 类下的所有方法都有事务
     */
    @Transactional
    public void changeInfo(){
        studentDao.updateAgeById(88,1);
        // 开启事务后 ， 这里报错 会进行回滚，前后功能都不会执行
        int i = 88/0; // 搞一个报错
        System.out.println("-----------");
        studentDao.updateNameById("test2",1);
    }

报错且数据库无变化，说明已经开启了事务

1.3 事务属性：只读

只读模式：

只读模式可以提高查询事务的效率！
事务只涉及查询代码时，可以使用只读！
默认：为FALSE
解释：一般情况下，直接在类上添加注解事务
- 类下的所有方法都有实物
- 那么，查询方法可以单独再设置为TRUE，开启只读模式！提高效率！

@Transactional
public class StudentService {

    @Transactional(readOnly = true)
    public void getStudentInfo(){
    }
 }

1.4 事务属性：超时时间

事务在执行过程中，有可能因为遇到某些问题，导致程序卡住，从而长时间占用数据库资源。
而长时间占用资源，大概率是因为程序运行出现了问题（可能是Java程序或MySQL数据库或网络连接等等）。
此时这个很可能出问题的 程序应该被回滚，撤销它已做的操作，事务结束，把资源让出来，让其他正常程序可以执行。

概括来说就是一句话：超时回滚，释放资源。

    /**
     *   超时时间：
     *      默认：永远不超时 -1
     *      设置timeout = 时间 秒数 超过时间，就会回滚事务和释放异常！ org.springframework.transaction.TransactionTimedOutException: Transaction timed out: deadline
     *      如果类上设置事务属性，方法也设置了事务注解！
     *      不会生效！，方法上有默认的设置属性会覆盖类上的属性设置！
     */
    @Transactional(timeout = 3)
    public void changeInfo(){
        studentDao.updateAgeById(88,1);
        try {
            Thread.sleep(4000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println("-----------");
        studentDao.updateNameById("test2",1);
    }

超时，后回滚数据库无变化

1.5 事务属性：事务异常

指定异常回滚和指定异常不回滚

默认情况发生 运行时异常 事务才会回滚！
- RuntimeException and Error
我们可以指定发生所有异常都回滚
- rollbackFor = Exception.class

1.6 事务属性：事务隔离级别

数据库事务的隔离级别是指在多个事务并发执行时，数据库系统为了保证数据一致性所遵循的规定。常见的隔离级别包括：

读未提交（Read Uncommitted）：事务可以读取未被提交的数据，容易产生脏读、不可重复读和幻读等问题。实现简单但不太安全，一般不用。
- 脏读：一个事务读取了另外一个事务未提交的数据
- 不可重复读：一个事务读取另外一个事务提交的修改数据
- 幻读：一个事务读取了另外一个事务插入的数据
读已提交（Read Committed）：事务只能读取已经提交的数据，可以避免脏读问题，但可能引发不可重复读和幻读。
可重复读（Repeatable Read）：在一个事务中，相同的查询将返回相同的结果集，不管其他事务对数据做了什么修改。可以避免脏读和不可重复读，但仍有幻读的问题。
串行化（Serializable）：最高的隔离级别，完全禁止了并发，只允许一个事务执行完毕之后才能执行另一个事务。可以避免以上所有问题，但效率较低，不适用于高并发场景。
不同的隔离级别适用于不同的场景，需要根据实际业务需求进行选择和调整。

isolation = 设置事务的隔离级别,mysql默认是repeatable read!

建议可以设置为：第二种级别 Read Committed

1.7 事务属性：事务传播行为

在被调用的子方法中设置传播行为，代表如何处理调用的事务！是加入，还是新事务等！

propagation 属性的可选值由 org.springframework.transaction.annotation.Propagation 枚举类提供：

名称	含义
REQUIRED 默认值	如果父方法有事务，就加入，如果没有就新建自己独立！
REQUIRES_NEW	不管父方法是否有事务，我都新建事务，都是独立的！

声明两个独立修改数据库的事务业务方法：

propagation = Propagation.REQUIRED
- 当父方法有事务，就加入其中，合体！（它滚我也滚！）
- 最终就是同一个事物，默认是这样！
propagation = Propagation.REQUIRED_NEW
- 不管父方法是否有事务，与我无关！
- 独立存在！

注意：

在同一个类中，对于@Transactional注解的方法调用，事务传播行为不会生效。
这是因为Spring框架中使用代理模式实现了事务机制，在同一个类中的方法调用并不经过代理，而是通过对象的方法调用，因此@Transactional注解的设置不会被代理捕获，也就不会产生任何事务传播行为的效果。

四、Spring核心掌握总结

核心点	掌握目标
spring框架理解	spring家族和spring framework框架
spring核心功能	ioc/di , aop , tx
spring ioc / di	组件管理、ioc容器、ioc/di , 三种配置方式
spring aop	aop和aop框架和代理技术、基于注解的aop配置
spring tx	声明式和编程式事务、动态事务管理器、事务注解、属性