Spring全家桶系列Spring的事务管理注解完成实现

⭐️前面的话⭐️

本文已经收录到《Spring框架全家桶系列》专栏，本文将介绍Spring中的事务管理，事务的概念与作用，以及Spring事务的属性和传播机制。

---

---

---

1.Spring中事务使用方式

1.1Spring事务简介

前面我们已经介绍了如何在Spring环境中整合mybatis完成数据库的增删查改操作，在正常情况下，操作数据库是没有问题的，但是一个业务需要多次操作数据库，并且需要完成修改，插入，删除操作可能会有问题，如转账，其实是有两个步骤，第一步从A账户扣钱，第二步在B账户中加钱。

如果第一步顺利执行后，在执行完成第二步前，程序发生了异常，那就完了，第二个操作就不能够正常执行了，这导致的结果就是，A的钱少了，B的钱没有增多，这种事情客户是完全不能容忍的，所以我们写的程序也是不能够容忍这样的bug。

为了解决这个问题，Spring引入了事务管理的机制，事务的作用就是：

• 保证执行一组数据库操作的时候，要么全部失败，要不全部成功，即同成功同失败。

那也就是在程序发生异常的时候，回滚所有已经成功数据库操作，这样就算这一次转账失败了，也不会给客户和商家带来损失。

Spring中事务的作用就是：

• 保证在数据层或业务层执行的一系列数据库操作同成功同失败。

1.2Spring事务的使用

需求: 实现任意两个账户间转账操作

需求微缩: A账户减钱，B账户加钱

为了实现上述的业务需求，我们可以按照下面步骤来实现下:
①：数据层提供基础操作，指定账户减钱（outMoney），指定账户加钱（inMoney）

②：业务层提供转账操作（transfer），调用减钱与加钱的操作

③：提供2个账号和操作金额执行转账操作

④：基于Spring整合MyBatis环境搭建上述操作

为了使用Spring事务，Spring提供了一个平台事务管理器PlatformTransactionManager，使用该管理器，就能够去使用Spring的事务了。

commit是用来提交事务，rollback是用来回滚事务，PlatformTransactionManager只是一个接口，Spring还为其提供了一个具体的实现类DataSourceTransactionManager。

下面我们就基于该事务管理器DataSourceTransactionManager来实现Spring中的事务。

1.2.1项目准备

具体的步骤不再多说了，创建Maven项目，导入依赖，配置业务层，数据层，单元测试，整合mybatis。

项目结构如下：

项目依赖：

    <!--  spring框架依赖 -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>5.3.19</version>
    </dependency>
    <!-- druid数据库连接池依赖 -->
    <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>druid</artifactId>
      <version>1.1.16</version>
    </dependency>
    <!--   mybatis依赖-->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
      <version>3.5.6</version>
    </dependency>
    <!--    spring整合mybatis依赖-->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis-spring</artifactId>
      <version>2.0.7</version>
    </dependency>
    <!--  jdbc依赖  -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-jdbc</artifactId>
      <version>5.3.15</version>
    </dependency>
    <!--  mysql驱动依赖  -->
    <!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>8.0.28</version>
    </dependency>
    <!--  lombok依赖 用于快速生成setter getter 和 toString  -->
    <!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
    <dependency>
      <groupId>org.projectlombok</groupId>
      <artifactId>lombok</artifactId>
      <version>1.18.26</version>
      <scope>provided</scope>
    </dependency>
    <!-- 整合junit -->
    <!-- https://mvnrepository.com/artifact/junit/junit -->
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.13.2</version>
      <scope>test</scope>
    </dependency>
    <!-- spring test环境-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-test</artifactId>
      <version>5.2.10.RELEASE</version>
    </dependency>

数据表：

create database if not exists transfer;
use transfer;
-- 创建账户表
drop table if exists account;
create table account (
    -- 用户编号uid
                         uid int primary key auto_increment,
    -- 姓名
                         username varchar(32),
    -- 余额
                         money double(8, 2) not null default 0
    );

配置类：

Spring配置类：

@Configuration
@PropertySource("classpath:jdbc.properties")
@ComponentScan("com.transfer.demo")
@Import({MybatisConfig.class, JdbcConfig.class})
@EnableTransactionManagement
public class SpringConfig {
}

数据库配置类，包含数据源等信息的配置：

public class JdbcConfig {
    //驱动
    @Value("${jdbc.driver}")
    private String drive;
    //url
    @Value("${jdbc.url}")
    private String url;
    //账户
    @Value("${jdbc.username}")
    private String username;
    //密码
    @Value("${jdbc.password}")
    private String password;

    /**
     * 配置数据源
     */
    @Bean
    public DataSource getDataSource() {
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setUrl(url);
        dataSource.setDriverClassName(drive);
        dataSource.setUsername(username);
        dataSource.setPassword(password);
        //设置数据自动提交
        dataSource.setDefaultAutoCommit(true);
        return dataSource;
    }
    @Bean
    public PlatformTransactionManager getTransactionManger(DataSource dataSource) {
        DataSourceTransactionManager transactionManager = new DataSourceTransactionManager();
        transactionManager.setDataSource(dataSource);
        return transactionManager;
    }
}

mybatis配置类，使用数据源配置SqlSessionFactory对象工厂，配置xml扫描路径，扫描sql相关注解扫描范围：

public class MybatisConfig {
    /**
     * 配置mybatis
     * @param dataSource 数据库的数据源
     * @return SqlSessionFactoryBean
     */
    @Bean
    public SqlSessionFactoryBean getSqlSessionFactoryBean(DataSource dataSource) {
        SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
        //配置数据源
        sqlSessionFactoryBean.setDataSource(dataSource);
        //简化
        sqlSessionFactoryBean.setTypeAliasesPackage("com.transfer.demo.mode");
        //配置所需要扫描到的mapper文件
        sqlSessionFactoryBean.setMapperLocations(new ClassPathResource("mapper/TransferMapper.xml"));
        return sqlSessionFactoryBean;
    }

    /**
     * 配置所对应需要扫描的mapper接口 基于注解编写sql需要设置这个 使用xml文件配置编写sql不需要
     * @return  MapperScannerConfigurer
     */
    @Bean
    public MapperScannerConfigurer getMapperScannerConfigurer() {
        MapperScannerConfigurer configurer = new MapperScannerConfigurer();
        configurer.setBasePackage("com.transfer.demo.dao");
        return configurer;
    }
}

properties配置文件：

jdbc.driver=com.mysql.cj.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/transfer?useSSL=false&serverTimezone=GMT+8&characterEncoding=utf-8
jdbc.username=root
jdbc.password=123456

数据层说明，具体代码以及配置文件sql见博主码云仓库，本项目环境也适应了使用注解进行sql语句的编写：

业务层说明：

项目环境：
Spring版本：5
MySQL版本：8
Java版本：1.8

1.2.2Spring事务的使用

因为mybatis使用的就是jdbc的事务，所以直接配置jdbc的事务即可。

第一步，配置DataSourceTransactionManager类的Bean，前面在数据库配置当中以及配置好数据源了，直接将数据源配进去即可。

第二步，在转账功能上加上@Transactional注解，表示将该方法开启Spring事务，建议加在接口上，降低耦合。

第三步，在Spring上启动Spring事务，加上@EnableTransactionManagement注解即可。

这样就完成spring事务的设计了，下面我们在转账的两个步骤之间加上一个算术异常，来模拟转账的时候出现异常的情况。

单元测试：

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = {SpringConfig.class})
public class TransferTest {
    @Autowired
    private TransferService transferService;
    @Test
    public void SelectAllTest() {
        System.out.println(transferService.selectAll());
    }
    @Test
    public void transferMoneyTest() {
        Account user1 = new Account();
        Account user2 = new Account();
        user1.setUid(1);
        user2.setUid(2);
        System.out.println("转账前:");
        System.out.println(transferService.selectByUid(user1.getUid()));
        System.out.println(transferService.selectByUid(user2.getUid()));
        try{
            transferService.transferMoney(user1, user2, 520);
        } catch (ArithmeticException e) {
            System.out.println("转账异常:");
        }
        System.out.println("转账后：");
        System.out.println(transferService.selectByUid(user1.getUid()));
        System.out.println(transferService.selectByUid(user2.getUid()));
    }
}

当前数据库表信息：

测试结果：

从结果上来看，通过spring事务，虽然转账的第一次数据库操作成功了，但是因为遇到异常，进行了数据库回滚操作，保证了数据的可靠性。

实际上，并不是所有的异常都可以触发回滚操作，默认情况下，程序发生ERROR或者运行时异常会触发回滚操作，其他异常不会触发，当然这些都是可以通过操作@Transactional注解中的参数来设置的。

2.Spring事务角色

在Spring事务中，有两种身份，一种是事务管理员，另外一种是事务协调员：

• 事务管理员：Spring事务的发起方，在Spring中通常指的是业务层的开启事务的方法。
• 事务协调员：Spring事务的参与方，在Spring中通常指的是数据层的方法，也可以是业务层的方法。

Spring事务没有开启的时候，数据层的两个修改操作默认情况下在数据库中分别都会开启一个事务。

此时，transferMoney方法没有开启事务，会存在以下的可能：

• 两个数据库操作都执行正常，顺利完成转账。
• 执行过程中出现意外，第一个数据库操作成功，第二个数据库操作失败，会导致账户A钱变少，B账户钱没到账的情况，这就会造成数据出错。

Spring事务开启后，transferMoney方法就是事务的发起方，即Spring事务管理员，数据层的两个操作虽然需要开启事务，但Spring会告诉数据层的两个方法，让它们加入到Spring的事务当中来，以便保证数据操作同成功同失败，即原子性，数据层的两个方法就是Spring事务协调员。

• transferMoney上添加了@Transactional注解，在该方法上就会有一个事务T。
• 数据层的outMoney方法的事务T1加入到transfer的事务T中。
• 数据层的inMoney方法的事务T2加入到transfer的事务T中。
• 这样就保证他们在同一个事务中，当业务层中出现异常，整个事务就会回滚，保证数据的准确性。

需要保证事务管理是基于DataSourceTransactionManager和SqlSessionFactoryBean使用的是同一个数据源。

3.Spring事务属性

前面我们提到了，并不是所有的异常都会引发回滚操作，如默认情况下遇到IOException事务就不会回滚，如果需要指定其他异常引发回滚或不回滚是可以通过配置@Transactional注解的rollbackFor或者noRollbackFor属性进行配置。

@Transactional注解相关属性如下表：

说明：

• readOnly：true只读事务，false读写事务，增删改要设为false,查询设为true。
• timeout:设置超时时间单位秒，在多长时间之内事务没有提交成功就自动回滚，-1表示不设置超时时间。
• rollbackFor:当出现指定异常进行事务回滚，不影响错误和运行时异常进行事务回滚。
• noRollbackFor:当出现指定异常不进行事务回滚，可以将某种会引发回滚的异常设置为不回滚。
• rollbackForClassName等同于rollbackFor,只不过属性为异常的类全名字符串。
• noRollbackForClassName等同于noRollbackFor，只不过属性为异常的类全名字符串。
• isolation设置事务的隔离级别：
  • DEFAULT :默认隔离级别, 会采用数据库的隔离级别
  • READ_UNCOMMITTED : 读未提交
  • READ_COMMITTED : 读已提交
  • REPEATABLE_READ : 重复读取
  • SERIALIZABLE: 串行化

重点属性就是rollbackFor属性，设置遇到哪一些异常就会回滚事务，默认情况是遇到Error异常和RuntimeException异常及其子类就会自动回滚。

示例1，将运行时异常设置为不回滚。

@Transactional(noRollbackFor = {ArithmeticException.class})

示例2，将非运行时异常和非错误的异常设置为引发回滚。

@Transactional(rollbackFor = {IOException.class})

4.Spring事务的传播机制

4.1Spring事务传播机制

前面我们说过Spring事务中，开启事务的时候，事务管理员所在方法中所有的其他事务默认情况下都会加入该事务，成为事务协调员，但是有时候并不需要将里面所有的事务都加入到事务管理员所开启的事务当中，为了解决这种情况，我们可以调整Spring中事务的传播机制，Spring中传播机制的种类有如下几种：

REQUIRED: 需要事务,外部存在事务融入当前事务,外部没有事务,开启新的事务。
SUPPORTS: 支持事务,外部存在事务融入当前事务,外部没有事务,不开启新的事务。
REQUIRES_NEW: 每次开启新的事务,如果外部存在事务外部事务挂起,开启新的事务运行,运行结束后回到外部事务。
NOT_SUPPORTED: 不支持事务,如果外部存在事务外部事务挂起,以非事务方式运行。
NEVER: 不支持事务,存在事务报错。
MANDATORY: 强制事务，没有事务报错。
NESTED: 嵌套事务,数据库不支持。

通过设置@Transactional注解中的propagation属性就可以完成Spring事务传播机制的修改。

前面实现了一个转账的案例，在实际的转账的过程中都会存在转账记录，对于转账记录，无论转账是否成功都需要记录，如果使用默认的事务传播机制，一旦转账失败，转账记录就无法存入到数据库当中。所以对于日志记录的事务需要新建一个事务单独运行，需要采用REQUIRES_NEW的事务传播机制。

4.2转账日志记录案例实现

下面我们在转账的基础上加上这样一个记录日志的要求，并实现。

需求：记录转账过程中的转账记录，不论成功还是失败都需要记录，不影响转账操作的原子性。
解决方案：调整日志记录的事务传播机制，当转账事务开启的时候，不加入该事务。

第一步，准备一张表，用来记录转账日志信息，设计如下：

lid表示日志的编号，content表示转账细节信息，state表示转账是成功还是失败。

建表语句如下：

use transfer;
-- 创建日志表
drop table if exists account_log;
create table account_log (
    -- 日志id
    lid int primary key auto_increment,
    -- 日志内容
    content varchar(128),
    -- 状态
    state varchar(16)
);

insert into account_log values(null, '测试', '成功');

第二步，编写数据层接口，至少有日志的插入和查询方法，基于注解就直接在数据层写sql即可，配置文件实现，需要另外再写一个配置文件用来写sql，不论哪种都要保证mybatis都能够扫描到。

对应业务层实现：

第三步，编写日志插入和查询操作的业务层方法，在转账操作中加入转账日志记录功能，因为不论转账失败还是成功都需要记录，所以日志插入可以写在finally中。

为了方便判断转账操作是否成功，我们将转账的两部数据操作放入到同一个try中，然后使用一个变量flag来表示转账操作是否成功，如果执行完第二步转账操作没有出现异常，就将flag置为true。

这样还不够，在存转账日志的时候，因为不论转账成功还是失败都需要存入转账记录，那么日志插入操作的事务必须单独开启，需要在插入日志的service方法设置事务传播属性为REQUIRES_NEW。

第四步，编写单元测试代码并验证。

单元测试代码如下，就不解释了，按照自己的思路写个验证程序即可。

测试结果：

5.总结

知识点1：@EnableTransactionManagement

知识点2：@Transactional

1. @Transactional 注解只能用在public 方法上，如果用在protected或者private的方法上，不会报错，但是该注解不会生效。
2. @Transactional注解只能回滚非检查型异常，具体为RuntimeException及其子类和Error子类，可以从Spring源码的DefaultTransactionAttribute类里找到判断方法rollbackOn。
3. 使用rollbackFor 属性来定义回滚的异常类型，使用 propagation 属性定义事务的传播行为。如: 回滚Exception类的异常，事务的传播行为支持当前事务，当前如果没有事务，那么会创建一个事务。
4. @Transactional注解不能回滚被try{}catch() 捕获的异常。
5. @Transactional注解只能对在被Spring 容器扫描到的类下的方法生效。

其实Spring事务的创建也是有一定的规则，对于一个方法里已经存在的事务，Spring 也提供了解决方案去进一步处理存在事务，通过设置@Tranasctional的propagation 属性定义Spring 事务的传播规则。

---

觉得文章写得不错的老铁们，点赞评论关注走一波！谢谢啦！

这篇好文章是转载于：学新通技术网