Spring Boot @Transactional 配置事务管理
目录
Spring 事务管理概述
环境准备
@Transactional 最简单用法
@Transactional 注解属性概述
propagation 事务传播行为
@Transactional 事务实现机制
rollbackFor 与 noRollbackFor
Spring 事务管理概述
1、Spring 事务管理分为编程式和声明式的两种方式。编程式事务通过编码方式实现事务，声明式事务基于 AOP(动态代理)将具体业务逻辑与事务处理解耦。
2、声明式事务管理使业务代码逻辑不受污染，在实际使用中较多。声明式事务有两种方式，一种是在配置文件（xml）中做相关的事务规则声明，另一种是基于 @Transactional 注解的方式。
3、因为现在注解编程已经是主流，所以实际中使用 @Transactional 注解的方式更多，也最方便。
1）默认配置下 Spring 只会回滚运行时异常（非受检查异常），即继承自 RuntimeException 的异常或者 Error。（官网）
2）@Transactional 注解只能应用到 public 修饰的方法。（官网）
4、本文测试的环境是：Spring Boot 2.1.4，内部 Spring 版本为 5.1.6，Spring Data JPA 操作 Mysql 数据库。
事先提醒：JPA 默认使用 MyISAM 作为 Mysql 的存储引擎，此引擎不支持事务、不支持外键。InnoDB 存储引擎支持事务，可以在配置文件中进行指定。
环境准备
1、pom.xml 文件内容如下：
4.0.0
org.springframework.boot
spring-boot-starter-parent
2.1.4.RELEASE
www.wmx.com
h2Smil
0.0.1-SNAPSHOT
h2Smil
Demo project for Spring Boot
1.8
org.springframework.boot
spring-boot-starter-data-jpa
mysql
mysql-connector-java
runtime
org.springframework.boot
spring-boot-starter-web
org.springframework.boot
spring-boot-starter-test
test
org.springframework.boot
spring-boot-maven-plugin
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.MySQL5InnoDBDialect3、实体类如下：
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, JpaSpecificationExecutor {
}
5、service 接口如下：
import com.wmx.entity.TV;
import java.util.List;
public interface TVService {
//查询所有
List 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 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);
}
}
@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[] rollbackFor() default {};
//用于指定能够触发事务回滚的异常名称，可以指定多个
String[] rollbackForClassName() default {};
//抛出指定的异常类型，不回滚事务，可以指定多个
Class[] noRollbackFor() default {};
//抛出指定的异常名称，不回滚事务，可以指定多个。
String[] noRollbackForClassName() default {};
}
propagation（传播）事务传播行为，默认值为 Propagation.REQUIRED，它是一个枚举，可选值如下：
REQUIRED：如果当前存在事务，则加入该事务，如果当前不存在事务，则创建一个新的事务。required（必须的）。
SUPPORTS：如果当前存在事务，则加入该事务；如果当前不存在事务，则以非事务方式继续运行。supports（支持的）
MANDATORY：如果当前存在事务，则加入该事务；如果当前不存在事务，则抛出异常。mandatory（强制的）
REQUIRES_NEW：重新创建一个新的事务，如果当前存在事务，暂停当前的事务。requires_new（依赖新的）
NOT_SUPPORTED：以非事务的方式运行，如果当前存在事务，暂停当前的事务。not_supported（不支持的）
NEVER：以非事务的方式运行，如果当前存在事务，则抛出异常。never（从不）
NESTED：和 REQUIRED 效果一样。nested（嵌套）
isolation（隔离）事务隔离级别，默认值为 Isolation.DEFAULT，它是一个枚举，可选择如下：
DEFAULT：使用底层数据库默认的隔离级别。
READ_UNCOMMITTED：未提交读。无法防止。
READ_COMMITTED：可提交读。可以防止脏读。
REPEATABLE_READ：可重复读。可以防止脏读、可重复读。mysql 默认隔离级别。
SERIALIZABLE：串行事务。最高事务隔离级别，可以防止脏读、可重复读、幻读。
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
rollbackFor 与 noRollbackFor
1、默认配置下 Spring 只会回滚运行时异常（未检查异常）（继承自 RuntimeException 的异常）或者 Error，编译时异常默认不会回滚。
如 @Transactional 标注的方法中抛出异常 throw new RuntimeException("xxx"); 则事务会回滚
如 @Transactional 标注的方法中抛出异常 throw new Exception("xxx"); 则事务会不回滚
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) ｝