系列文章索引：
1. [Spring事务Transactional和动态代理（一）-JDK代理实现](http://www.itrensheng.com/archives/spring_transaction_jdk_proxy)
2. [Spring事务Transactional和动态代理（二）-cglib动态代理](http://www.itrensheng.com/archives/cglib)
3. [Spring事务Transactional和动态代理（三）-事务失效的场景](http://www.itrensheng.com/archives/spring_transactional_uneffect)
### 一. Spring事务分类
Spring 提供了两种事务管理方式：声明式事务管理和编程式事务管理。
#### 1.1编程式事务
在 Spring 出现以前，编程式事务管理对基于 POJO 的应用来说是唯一选择。我们需要在代码中显式调用 beginTransaction()、commit()、rollback() 等事务管理相关的方法，这就是编程式事务管理。
简单地说，编程式事务就是在代码中显式调用开启事务、提交事务、回滚事务的相关方法。
#### 1.2声明式事务
Spring 的声明式事务管理是建立在 Spring AOP 机制之上的，其本质是对目标方法前后进行拦截，并在目标方法开始之前创建或者加入一个事务，在执行完目标方法之后根据执行情况提交或者回滚事务。而Spring 声明式事务可以采用 **基于 XML 配置** 和 **基于注解** 两种方式实现
简单地说，声明式事务是编程式事务 + AOP 技术包装，使用注解进行扫包，指定范围进行事务管理。
本文内容是使用SpringBoot的开发的“基于注解”申明式事务管理，示例代码：[https://github.com/qizhelongdeyang/SpringDemo](https://github.com/qizhelongdeyang/SpringDemo)
### 二. @Transacational实现机制
在应用系统调用声明了 @Transactional 的目标方法时，Spring Framework 默认使用 AOP 代理，在代码运行时生成一个代理对象,如下图中所示调用者 Caller 并不是直接调用的目标类上的目标方法(Target Method)，而是
调用的代理类(AOP Proxy)。
根据 @Transactional 的属性配置信息，这个代理对象（AOP Proxy）决定该声明 @Transactional 的目标方法是否由拦截器 TransactionInterceptor 来使用拦截。在 TransactionInterceptor 拦截时，会在目标方法开始执行之前创建并加入事务，并执行目标方法的逻辑, 最后根据执行情况是否出现异常，利用抽象事务管理器 AbstractPlatformTransactionManager 操作数据源 DataSource 提交或回滚事务
### 三. @Transacational失效
在开发过程中，可能会遇到使用 @Transactional 进行事务管理时出现失效的情况，本文中代码请移步[https://github.com/qizhelongdeyang/SpringDemo](https://github.com/qizhelongdeyang/SpringDemo)查看，其中建了两张表table1和table2都只有一个主键字段，示例都是基于两张表的插入来验证的，由表id的唯一性能来抛出异常。如下mapper：
```java
@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
@TableName("table1")
public class Table1Entity implements Serializable {
private static final long serialVersionUID = 1L;
private Integer id;
}
@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
@TableName("table2")
public class Table2Entity implements Serializable {
private static final long serialVersionUID = 1L;
private Integer id;
}
public interface Table1Mapper extends BaseMapper
{
}
public interface Table2Mapper extends BaseMapper {
}
```
#### 3.1 底层数据库引擎不支持事务
并非所有的数据库引擎都支持事务操作，如在MySQL下面，InnoDB是支持事务的，但是MyISAM是不支持事务的。在Spring事务操作中，如果底层表的创建是基于MyISAM引擎创建，那么事务@Transactional 就会失效
#### 3.2 标注修饰无效
因为Spring AOP有两种实现方式：JDK（[Spring事务Transactional和动态代理（一）-JDK代理实现](http://www.itrensheng.com/archives/spring_transaction_jdk_proxy)）和cglib（ [Spring事务Transactional和动态代理（二）-cglib动态代理](http://www.itrensheng.com/archives/cglib)），所以在标注修饰失效的时候也有两种不能情况，如下：
##### 1) 接口JDK动态代理
Spring AOP对于**接口-实现类**这种方式是基于JDK动态代理的方式实现的。这种方式除了实现自接口的非static方法，其他方法均无效。
由于接口定义的方法是public的，java要求实现类所实现接口的方法必须是public的（不能是protected，private等），同时不能使用static的修饰符。所以，可以实施接口动态代理的方法只能是使用“public”或“public final”修饰符的方法，其它方法不可能被动态代理，相应的也就不能实施AOP增强，也即不能进行Spring事务增强
如下代码：
```java
public interface IJdkService {
//非静态方法
public void jdkPublic(Integer id1,Integer id2);
//接口中的静态方法必须有body
public static void jdkStaticMethod(Integer id1,Integer id2){
System.out.println("static method in interface");
}
}
@Service
public class JdkServiceImpl implements IJdkService {
@Autowired
private Table1Mapper table1Mapper;
@Autowired
private Table2Mapper table2Mapper;
@Transactional(rollbackFor = Exception.class)
@Override
public void jdkPublic(Integer id1, Integer id2) {
Table1Entity table1Entity = new Table1Entity();
table1Entity.setId(id1);
table1Mapper.insert(table1Entity);
Table2Entity table2Entity = new Table2Entity();
table2Entity.setId(id2);
table2Mapper.insert(table2Entity);
}
//@Override 编译错误，方法不会覆写父类的方法
@Transactional(rollbackFor = Exception.class)
public static void jdkStaticMethod(Integer id1,Integer id2){
System.out.println("static method in implation");
}
}
```
上面代码中jdkPublic事务可以正常回滚，
而IJdkService中定义的jdkStaticMethod属于静态方法，调用不能通过@Autowired注入的方式调用，只能通过IJdkService.jdkStaticMethod调用，所以定义到实现类中的事务方法根本就不会被调用。
##### 1) cglib动态代理
对于普通@Service注解的类（未实现接口）并通过 @Autowired直接注入类的方式，是通过cglib动态代理实现的。
cglib字节码动态代理的方案是通过扩展被增强类，动态创建子类的方式进行AOP增强植入的，由于使用final,static,private修饰符的方法都不能被子类复写，所以这些方法将不能被实施的AOP增强。即除了public的非final的实例方法，其他方法均无效。
如下定义了@Service注解的CglibTranService，并使用@Autowired注入，测试事务能够回滚
```java
@Service
public class CglibTranService {
@Autowired
private Table1Mapper table1Mapper;
@Autowired
private Table2Mapper table2Mapper;
@Transactional(rollbackFor = Exception.class)
public void testTran(Integer id1, Integer id2) {
Table1Entity table1Entity = new Table1Entity();
table1Entity.setId(id1);
table1Mapper.insert(table1Entity);
Table2Entity table2Entity = new Table2Entity();
table2Entity.setId(id2);
table2Mapper.insert(table2Entity);
}
}
```
对于使用final修饰大的方法无法回滚事务的原因是：**所注入的table1Mapper和table2Mapper会为null**（为空的原因在系列文章后面会有分析），所以到table1Mapper.insert这行代码会抛出NullPointerException
而static修饰的方法就会变为类变量，因为JDK的限制，当在static方法中使用table1Mapper和table2Mapper的时候会报编译错误： 无法从静态上下文中引用非静态变量 table1Mapper
#### 3.2 方法自调用
目标类直接调用该类的其他标注了@Transactional 的方法（相当于调用了this.对象方法），事务不会起作用。事务不起作用其根本原因就是未通过代理调用，因为事务是在代理中处理的，没通过代理，也就不会有事务的处理。
首先在table1和table2中都已经出入了1，并有如下示例代码：
```java
@RestController
@RequestMapping(value = "/cglib")
public class CglibTranController {
@Autowired
private CglibTranService cglibTranService;
@PutMapping("/testThis/{id1}/{id2}")
public boolean testThis(@PathVariable("id1") Integer id1, @PathVariable("id2") Integer id2) {
try {
cglibTranService.testTranByThis(id1,id2);
return true;
}catch (Exception ex){
ex.printStackTrace();
return false;
}
}
}
@Service
public class CglibTranService {
@Autowired
private Table1Mapper table1Mapper;
@Autowired
private Table2Mapper table2Mapper;
/**
* 入口方法，这种方式事务会失效
* @param id1
* @param id2
*/
public void testTranByThis(Integer id1, Integer id2) {
//直接调用目标类的方法
testTranByThis_insert(id1,id2);
}
@Transactional
public void testTranByThis_insert(Integer id1, Integer id2){
Table1Entity table1Entity = new Table1Entity();
table1Entity.setId(id1);
table1Mapper.insert(table1Entity);
Table2Entity table2Entity = new Table2Entity();
table2Entity.setId(id2);
table2Mapper.insert(table2Entity);
}
}
```
通过curl来调用接口
> curl -X PUT "http://localhost:8080/cglib/testThis/2/1"
结果是table1中有1，2两条记录，table2中只有1一条记录。也就是说testTranByThis_insert上面标注@Transactional无效table1Mapper插入成功了，table2Mapper的插入并未导致table1Mapper插入回滚。
那如果必须要在方法内部调用@Transactional注解方法保证事务生效，该怎么做？当然是改为Spring AOP的方式调用
```java
//定义一个ApplicationContext 工具类
@Component
public class SpringContextUtil implements ApplicationContextAware {
private static ApplicationContext applicationContext;
@Override
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
this.applicationContext = applicationContext;
}
public static ApplicationContext getApplicationContext() {
return applicationContext;
}
public static Object getBean(String beanName) {
return applicationContext.getBean(beanName);
}
public static Object getBean(Class c) {
return applicationContext.getBean(c);
}
}
```
并改造testTranByThis方法如下：
```java
public void testTranByThis(Integer id1, Integer id2) {
//直接调用目标类的方法
// testTranByThis_insert(id1,id2);
//注解调用
CglibTranService proxy = (CglibTranService)SpringContextUtil.getBean(CglibTranService.class);
proxy.testTranByThis_insert(id1,id2);
}
```
这样即使是内部调用，但是通过ApplicationContext 获取了Bean，改造后的事务是生效
#### 3.3 多个事务管理器
当一个应用存在多个事务管理器时，如果不指定事务管理器，@Transactional 会按照事务管理器在配置文件中的初始化顺序使用其中一个。
如果存在多个数据源 datasource1 和 datasource2，假设默认使用 datasource1 的事务管理器，当对 datasource2 进行数据操作时就处于非事务环境。
解决办法是，可以通过@Transactional 的 value 属性指定一个事务管理器。在使用多个事务管理器的情况下，事务不生效的原因在本系列后续文章中会有分析
#### 3.4 默认 checked 异常不回滚事务
Spring 默认只为 RuntimeException 异常回滚事务，如果方法往外抛出 checked exception，该方法虽然不会再执行后续操作，但仍会提交已执行的数据操作。这样可能使得只有部分数据提交，造成数据不一致。
要自定义回滚策略，可使用@Transactional 的 noRollbackFor，noRollbackForClassName，rollbackFor，rollbackForClassName 属性
如下代码事务不生效，table1Mapper插入成功。table2Mapper插入失败了，但是异常被捕获了并抛出了IOException，table1Mapper的插入不会回滚
```java
@Transactional(rollbackFor = RuntimeException.class)
public void testCheckedTran(Integer id1, Integer id2) throws IOException {
Table1Entity table1Entity = new Table1Entity();
table1Entity.setId(id1);
table1Mapper.insert(table1Entity);
try {
Table2Entity table2Entity = new Table2Entity();
table2Entity.setId(id2);
table2Mapper.insert(table2Entity);
}catch (Exception ex){
throw new IOException("testCheckedTran");
}
}
```
不会回滚的原因是check了rollbackFor = RuntimeException.class，但是抛出的是IOException，而IOException并不是RuntimeException的子类，如下的继承关系图
改造以上代码如下可以成功回滚事务，DuplicateKeyException是RuntimeException的子类：
```java
@Transactional(rollbackFor = RuntimeException.class)
public void testCheckedTran(Integer id1, Integer id2) throws IOException {
Table1Entity table1Entity = new Table1Entity();
table1Entity.setId(id1);
table1Mapper.insert(table1Entity);
try {
Table2Entity table2Entity = new Table2Entity();
table2Entity.setId(id2);
table2Mapper.insert(table2Entity);
}catch (Exception ex){
throw new DuplicateKeyException("testCheckedTran");
}
}
```
