Spring Boot @Transactional 配置事务管理

淩亂°似流年 2022-02-12 11:29 642阅读 0赞

**目录**

Spring 事务管理概述

环境准备

@Transactional 最简单用法

@Transactional 注解属性概述

propagation 事务传播行为

@Transactional 事务实现机制

rollbackFor 与 noRollbackFor

--------------------

# Spring 事务管理概述 #

1、Spring 事务管理分为编程式和声明式的两种方式。编程式事务通过编码方式实现事务，声明式事务基于 AOP(动态代理)将具体业务逻辑与事务处理解耦。

2、声明式事务管理使业务代码逻辑不受污染，在实际使用中较多。声明式事务有两种方式，一种是在配置文件（xml）中做相关的事务规则声明，另一种是基于 @Transactional 注解的方式。

3、因为现在注解编程已经是主流，所以实际中使用 @Transactional 注解的方式更多，也最方便。

<table> 
 <tbody> 
  <tr> 
   <td> <p><span style="color:#f33b45;">1）默认配置下 Spring 只会回滚运行时异常（非受检查异常），即继承自 RuntimeException 的异常或者 Error。</span>（<a href="https://docs.spring.io/spring/docs/4.3.13.RELEASE/spring-framework-reference/htmlsingle/#transaction-declarative-rolling-back" rel="nofollow">官网</a>）</p> <p>2）@Transactional 注解只能应用到 public 修饰的方法。（<a href="https://docs.spring.io/spring/docs/4.3.13.RELEASE/spring-framework-reference/htmlsingle/#transaction-declarative-annotations" rel="nofollow">官网</a>）</p> </td> 
  </tr> 
 </tbody> 
</table>

4、本文测试的环境是：Spring Boot 2.1.4，内部 Spring 版本为 5.1.6，Spring Data JPA 操作 Mysql 数据库。

![20190428210558636.png][]

事先提醒：JPA 默认使用 MyISAM 作为 Mysql 的存储引擎，此引擎不支持事务、不支持外键。InnoDB 存储引擎支持事务，可以在配置文件中进行指定。

# 环境准备 #

1、pom.xml 文件内容如下：

<?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
        <parent>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-parent</artifactId>
            <version>2.1.4.RELEASE</version>
            <relativePath/>
            
        </parent>
        <groupId>www.wmx.com</groupId>
        <artifactId>h2Smil</artifactId>
        <version>0.0.1-SNAPSHOT</version>
        <name>h2Smil</name>
        <description>Demo project for Spring Boot</description>
    
        <properties>
            <java.version>1.8</java.version>
        </properties>
    
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-data-jpa</artifactId>
            </dependency>
    
            
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <scope>runtime</scope>
            </dependency>
    
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
    
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-test</artifactId>
                <scope>test</scope>
            </dependency>
        </dependencies>
    
        <build>
            <plugins>
                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                </plugin>
            </plugins>
        </build>
    
    </project>

2、application.yml 配置文件如下：

#配置数据源
    spring:
      datasource:
        username: root
        password: root
        #h2siml 数据库必须事先在 Mysql 数据库中创建好，上面的 Mysql 账号密码也必须正确
        #mysql驱动8.0.5时，指定时区 serverTimezone. 同时 driver-class-name 也变成如下的新地址，不再是以前的 com.mysql.hdbc.Driver
        url: jdbc:mysql://localhost:3306/h2siml?characterEncoding=UTF-8&serverTimezone=UTC
        driver-class-name: com.mysql.cj.jdbc.Driver
    
    #JPA配置
      jpa:
        show-sql: true
        hibernate:
          ddl-auto: update
        #指定 JPA 底层的 hibernate方言，使用 InnoDB 作为存储引擎。否则默认 JPA 使用的是 MyISAM 存储引擎，此引擎不支持事务、不支持外键的
        database-platform: org.hibernate.dialect.MySQL5InnoDBDialect

3、实体类如下：

import javax.persistence.*;
    import java.util.Date;
    /**
     * Created by Administrator on 2019/2/27 0027.
     * 电视机实体。应用启动时自动，配置文件中配置 ddl-auto: update：如果数据库不存在，则自动新建，否则不再新建。
     */
    @Entity
    public class TV {
        //strategy 指定主键生成的方式，AUTO 可以指定 H2 数据库主键自动增长，IDENTITY 可以指定 mysql 主键自动增长
        @Id//标识为主键
        @GeneratedValue(strategy = GenerationType.IDENTITY)
        private Integer tvId;//电视id，主键
    
        /**
         * 下面没标识的属性都会以默认值和数据库表的字段进行映射对应
         * 如果修改默认值，又不属性的，可以参考：https://blog.csdn.net/wangmx1993328/article/details/82048775
         * 中的 "domain Area" 部分
         */
        @Column(length = 16)//长度为16个字符
        private String tvName;//电视名称
        private Float tvPrice;//电视价格
        private Date dateOfProduction;//生产日期
    
        public Date getDateOfProduction() {
            return dateOfProduction;
        }
    
        public void setDateOfProduction(Date dateOfProduction) {
            this.dateOfProduction = dateOfProduction;
        }
    
        public Integer getTvId() {
            return tvId;
        }
    
        public void setTvId(Integer tvId) {
            this.tvId = tvId;
        }
    
        public String getTvName() {
            return tvName;
        }
    
        public void setTvName(String tvName) {
            this.tvName = tvName;
        }
    
        public Float getTvPrice() {
            return tvPrice;
        }
    
        public void setTvPrice(Float tvPrice) {
            this.tvPrice = tvPrice;
        }
    
        @Override
        public String toString() {
            return "TV{" +
                    "tvId=" + tvId +
                    ", tvName='" + tvName + '\'' +
                    ", tvPrice=" + tvPrice +
                    ", dateOfProduction=" + dateOfProduction +
                    '}';
        }
    }

4、持久化层如下：

import com.wmx.entity.TV;
    import org.springframework.data.jpa.repository.JpaRepository;
    import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
    /**
     * Java 接口可以多继承
     * JpaRepository 中有常用的 CRUD 、分页、排序等方法
     * JpaSpecificationExecutor 可以实现任意的复杂查询
     */
    public interface TVRepository extends JpaRepository<TV, Integer>, JpaSpecificationExecutor<TV> {
    }

5、service 接口如下：

import com.wmx.entity.TV;
    import java.util.List;
    public interface TVService {
        //查询所有
        List<TV> findAll();
    
        //保存或更新
        void save(TV tv);
    
        //根据主键 tvId 删除
        void deleteById(int id);
    }

# `@Transactional` 最简单用法 #

1、只需要将 `@Transactional` 注解添加到 service 层实现类的方法上，这个方法就会进行事务管理，这也是最简单的方法。

import com.wmx.entity.TV;
    import com.wmx.repository.TVRepository;
    import com.wmx.service.TVService;
    import org.springframework.data.domain.Sort;
    import org.springframework.stereotype.Service;
    import org.springframework.transaction.annotation.Transactional;
    import javax.annotation.Resource;
    import java.util.List;
    @Service
    public class TVServiceImpl implements TVService {
        @Resource
        private TVRepository tvRepository;
    
        @Override
        public List<TV> findAll() {
            //查询所有数据，并以主键 tvId 倒序排序
            return tvRepository.findAll(Sort.by(Sort.Direction.DESC, "tvId"));
        }
    
        //org.springframework.transaction.annotation.Transactional：事务管理
        //添加到哪个方法上，哪个方法就会进行事务管理
        @Transactional
        @Override
        public void save(TV tv) {
            tvRepository.save(tv);
            //故意制造一个数组下标越界异常，典型的运行时异常
            //如果没加 Transactional 则抛了异常，数据也会添加进数据库，加了Transactional，则会回滚。
            System.out.println("123".split(",")[1]);
        }
    
        @Override
        public void deleteById(int id) {
            tvRepository.deleteById(id);
        }
    }

![20190428212809639.png][]

# @Transactional 注解属性概述 #

1、@Transactional 注解管理事务就是如此的简单，下面来看看注解的详细信息，如下所示为 @Transactional 的源码：

import java.lang.annotation.Documented;
    import java.lang.annotation.ElementType;
    import java.lang.annotation.Inherited;
    import java.lang.annotation.Retention;
    import java.lang.annotation.RetentionPolicy;
    import java.lang.annotation.Target;
    import org.springframework.core.annotation.AliasFor;
    import org.springframework.transaction.annotation.Isolation;
    import org.springframework.transaction.annotation.Propagation;
    
    @Target({ElementType.METHOD, ElementType.TYPE})
    @Retention(RetentionPolicy.RUNTIME)
    @Inherited
    @Documented
    public @interface Transactional {
        //当配置了多个事务管理器时，可以使用该属性指定选择哪个事务管理器。
        @AliasFor("transactionManager")
        String value() default "";
    
        //当配置了多个事务管理器时，可以使用该属性指定选择哪个事务管理器。
        //如 @Transactional(value = "jpaTransactionManager")
        @AliasFor("value")
        String transactionManager() default "";
    
        //事务的传播行为。默认如果当前存在事务，则加入该事务，如果当前不存在事务，则创建一个新的事务
        Propagation propagation() default Propagation.REQUIRED;
    
        //事务的隔离级。默认使用底层数据库自己的隔离级别
        Isolation isolation() default Isolation.DEFAULT;
    
        //事务超时时间，如果超过该时间限制但事务还没有完成，则自动回滚事务。-1表示永不超时
        int timeout() default -1;
    
        //事务是否为只读事务，为了忽略那些不需要事务的方法,如读取数据，可以设置 read-only 为 true。
        boolean readOnly() default false;
    
        //用于指定能够触发事务回滚的异常类型，可以指定多个异常类型。
        Class<? extends Throwable>[] rollbackFor() default {};
    
        //用于指定能够触发事务回滚的异常名称，可以指定多个
        String[] rollbackForClassName() default {};
    
        //抛出指定的异常类型，不回滚事务，可以指定多个
        Class<? extends Throwable>[] noRollbackFor() default {};
    
        //抛出指定的异常名称，不回滚事务，可以指定多个。
        String[] noRollbackForClassName() default {};
    }

propagation（传播）事务传播行为，默认值为 Propagation.REQUIRED，它是一个枚举，可选值如下：

<table> 
 <tbody> 
  <tr> 
   <td>REQUIRED：如果当前存在事务，则加入该事务，如果当前不存在事务，则创建一个新的事务。required（必须的）。<br> SUPPORTS：如果当前存在事务，则加入该事务；如果当前不存在事务，则以非事务方式继续运行。supports（支持的）<br> MANDATORY：如果当前存在事务，则加入该事务；如果当前不存在事务，则抛出异常。mandatory（强制的）<br> REQUIRES_NEW：重新创建一个新的事务，如果当前存在事务，暂停当前的事务。requires_new（依赖新的）<br> NOT_SUPPORTED：以非事务的方式运行，如果当前存在事务，暂停当前的事务。not_supported（不支持的）<br> NEVER：以非事务的方式运行，如果当前存在事务，则抛出异常。never（从不）<br> NESTED：和&nbsp;REQUIRED 效果一样。nested（嵌套）</td> 
  </tr> 
 </tbody> 
</table>

isolation（隔离）事务隔离级别，默认值为 Isolation.DEFAULT，它是一个枚举，可选择如下：

<table> 
 <tbody> 
  <tr> 
   <td>DEFAULT：使用底层数据库默认的隔离级别。<br> READ_UNCOMMITTED：未提交读。无法防止。<br> READ_COMMITTED：可提交读。可以防止脏读。<br> REPEATABLE_READ：可重复读。可以防止脏读、可重复读。mysql 默认隔离级别。<br> SERIALIZABLE：串行事务。最高事务隔离级别，可以防止脏读、可重复读、幻读。</td> 
  </tr> 
 </tbody> 
</table>

# propagation 事务传播行为 #

**情形1：**同类中 save 方法内部调用 deleteById 方法，且两者上面都没有加 @Transactional 事务管理，当控制器层调用 save 方法后，显然会先删除 id 为 14 的数据，然后插入新数据。

@Override
        public void save(TV tv) {
            deleteById(14);
            tv.setTvName(tv.getTvName());
            tvRepository.save(tv);
        }
    
        @Override
        public void deleteById(int id) {
            tvRepository.deleteById(id);
        }

**情形2**：save 方法内部调用 deleteById（两者都未加@Transactional） 后，故意制造一个运行时异常，结果就是 deleteById 会正常删除 id 为 13 的数据，之后 save 因为抛异常了，所以不会再 save 插入新数据了。

@Override
        public void save(TV tv) {
            deleteById(13);
            //故意制造一个数组下标越界异常，典型的运行时异常
            System.out.println("123".split(",")[1]);
            tv.setTvName(tv.getTvName() + "_xxx");
            tvRepository.save(tv);
        }
    
        @Override
        public void deleteById(int id) {
            tvRepository.deleteById(id);
        }

**情形3**：在上面的基础上，在 save 方法上加上 @Transactionl 事务管理，因为事务具有传播特性，所以 save 与 deleteById 位于同一个事务，deleteById 执行后，save 方法抛了异常，会导致数据回滚，所以不会删除也不会新增。

//org.springframework.transaction.annotation.Transactional：事务管理
        //@Transactional 添加到哪个方法上，哪个方法就会进行事务管理.默认传播特性为REQUIRED
        @Transactional(propagation = Propagation.REQUIRED)
        @Override
        public void save(TV tv) {
            deleteById(12);
            //故意制造一个数组下标越界异常，典型的运行时异常
            System.out.println("123".split(",")[1]);
            tv.setTvName(tv.getTvName() + "_xxx");
            tvRepository.save(tv);
        }
    
        @Override
        public void deleteById(int id) {
            tvRepository.deleteById(id);
        }

**情形4**：假如 save 方法上面不加 @Transactionl ，而在 deleteById 方法上面加 @Transaction 事务管理，显然就是 save 方法根本没有事务，只有 deleteById 有事务管理，结果就是删除操作会成功，而 save 方法因为自己抛异常了，后面的添加数据，不管有没有事务都不会执行的。

**情形5**：同类中内部方法相互调用，默认代理模式下，如果调用者自己已经有事务，则被调用的永远和它处于同一事务。如下所示 save 方法有事务管理，deleteById 方法的 REQUIRES\_NEW、NOT\_SUPPORTED、NEVER 等等都不会有效，REQUIRES\_NEW 并不会为 deleteById 新开一个事务。

//org.springframework.transaction.annotation.Transactional：事务管理
        //@Transactional 添加到哪个方法上，哪个方法就会进行事务管理.默认传播特性为REQUIRED
        @Override
        @Transactional(propagation = Propagation.REQUIRED)
        public void save(TV tv) {
            deleteById(11);
            //故意制造一个数组下标越界异常，典型的运行时异常
            System.out.println("123".split(",")[1]);
            tv.setTvName(tv.getTvName() + "_xxx");
            tvRepository.save(tv);
        }
    
        @Override
        @Transactional(propagation = Propagation.REQUIRES_NEW)
    //    @Transactional(propagation = Propagation.NOT_SUPPORTED)
    //    @Transactional(propagation = Propagation.NEVER)
        public void deleteById(int id) {
            tvRepository.deleteById(id);
        }

**情形6**

1、先准备一个额外的接口与其实现类。

public interface TVServiceExt {
        //根据主键 tvId 删除
        void deleteByIdExt(int id);
    }

import com.wmx.repository.TVRepository;
    import com.wmx.service.TVServiceExt;
    import org.springframework.stereotype.Service;
    import javax.annotation.Resource;
    @Service
    public class TVServiceExtImpl implements TVServiceExt {
        @Resource
        private TVRepository tvRepository;
    
        @Override
        public void deleteByIdExt(int id) {
            tvRepository.deleteById(id);
        }
    }

2、下面从 TvServiceImpl 的 save 方法内部调用 TvServiceExtImpl 的 deleteByIdExt 方法,如下所示，当调用者与被调用双方都没有加 @Transactional 时，完全无事务管理，删除操作会正确执行，save 不执行。

@Service
    public class TVServiceImpl implements TVService {
        @Resource
        private TVRepository tvRepository;
    
        @Resource
        private TVServiceExt tvServiceExt;
        
        //其余方法省略不写了
    
        //org.springframework.transaction.annotation.Transactional：事务管理
        //@Transactional 添加到哪个方法上，哪个方法就会进行事务管理.默认传播特性为REQUIRED
        @Override
        public void save(TV tv) {
            tvServiceExt.deleteByIdExt(11);//调用其它类中的方法
    
            //故意制造一个数组下标越界异常，典型的运行时异常
            System.out.println("123".split(",")[1]);
            tv.setTvName(tv.getTvName() + "_xxx");
            tvRepository.save(tv);
        }
    }

**情形7**：save 方法上加上 @Transactional 事务管理，deleteByIdExt 方法上没加，结果和预期的一样，因为事务的传播特性，deleteByIdExt 和 save 处于同一个事务，一荣俱荣，一损俱损，所以删除与插入都不会成功。

//org.springframework.transaction.annotation.Transactional：事务管理
        //@Transactional 添加到哪个方法上，哪个方法就会进行事务管理.默认传播特性为REQUIRED
        @Override
        @Transactional
        public void save(TV tv) {
            tvServiceExt.deleteByIdExt(10);//调用其它类中的方法
    
            //故意制造一个数组下标越界异常，典型的运行时异常
            System.out.println("123".split(",")[1]);
            tv.setTvName(tv.getTvName() + "_xxx");
            tvRepository.save(tv);
        }

**情形8**：TvServiceImpl 的 save 方法内部调用 TvServiceExtImpl 的 deleteByIdExt 方法，save 上加了 @Transactional ，deleteById 上也加了，但是 propagation 等于 requires\_new，即自己会新开事务。结果就是 deleteByIdExt 与 save 方法位于两个不同的事务，删除操作会成功，save 会失败。

//REQUIRES_NEW：表示新开一个事务，如果当前已经有事务，则会暂停
        @Override
        @Transactional(propagation = Propagation.REQUIRES_NEW)
        public void deleteByIdExt(int id) {
            tvRepository.deleteById(id);
        }

说到这里应该就已经很清楚了，如果  deleteByIdExt 上面传播特性为 @Transactional(propagation = Propagation.REQUIRED)，显然就又会和 save 方法处于同一个事务了。

# @Transactional 事务实现机制 #

1、@Transactional 声明目标方法后，Spring Framework 默认使用 AOP 代理，代码运行时生成一个代理对象，根据 @Transactional 的属性配置，代理对象决定该声明 @Transactional 的目标方法是否由拦截器 TransactionInterceptor 来使用拦截

2、在 TransactionInterceptor 拦截时，会在目标方法开始执行之前创建并加入事务，并执行目标方法的逻辑, 最后根据执行情况是否出现异常，利用抽象事务管理器 AbstractPlatformTransactionManager 操作数据源 DataSource 提交或回滚事务。

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

4、默认的代理模式下，只有目标方法由外部调用，才能被 Spring 事务拦截器拦截。在同一个类中的两个方法直接调用，是不会被 Spring 的事务拦截器拦截。

github 地址：[https://github.com/wangmaoxiong/jpaTransactional][https_github.com_wangmaoxiong_jpaTransactional]

# rollbackFor 与 noRollbackFor #

1、默认配置下 Spring 只会回滚运行时异常（未检查异常）（继承自 RuntimeException 的异常）或者 Error，编译时异常默认不会回滚。

<table> 
 <tbody> 
  <tr> 
   <td> <p>如 @Transactional 标注的方法中抛出异常 throw new RuntimeException("xxx"); 则事务会回滚</p> <p>如 @Transactional 标注的方法中抛出异常 throw new Exception("xxx"); 则事务会不回滚</p> </td> 
  </tr> 
 </tbody> 
</table>

2、如果想方法中发生某些编译时异常时也回滚，则可以通过 rollbackFor 属性指定，如 ：@Transactional(rollbackFor=Exception.class)、@Transactional(rollbackFor=SQLException.class) 等

3、如果想方法中发生某些运行时异常不回滚，则可以通过 noRollbackFor 属性指定，如：@Transactional(notRollbackFor=RunTimeException.class)，@Transactional(notRollbackFor=ClassCastException.class)

4、如果 @Transactional 标注的方法中使用 try｛｝catch｛｝捕获处理了异常，则事务不再回滚，如果想让事务回滚，则必须继续往外抛：try｛xxx｝catch(Exception e)｛ throw new RuntimeException("xxx",e) ｝

[20190428210558636.png]: /images/20220212/15a917e983fe43999c46ce077f082844.png
[20190428212809639.png]: /images/20220212/84107fda4917407cb77432a1f2eaf8dd.png
[https_github.com_wangmaoxiong_jpaTransactional]: https://github.com/wangmaoxiong/jpaTransactional