Spring事务管理中@Transactional的propagation参数

目录

什么是事务传播性及其作用

@Transactional 的 propagation 属性代码示例

---

转载自Spring事务管理中@Transactional的propagation参数 - Deltamaster Tech Center - 技术宅 (is-programmer.com)

关于Spring事务管理中@Transactional的其他配置问题，请参看Spring事务管理中@Transactional的参数配置 - Deltamaster Tech Center - 技术宅。

什么是事务传播性及其作用

　　本文重点讲一讲propagation参数，propagation配置的就是一个事务的传播性问题。

　　所谓事务传播性，就是被调用者的事务与调用者的事务之间的关系。举例说明。

//in A.java
Class A {
    @Transactional(propagation=propagation.REQUIRED)
    public void aMethod {
        B b = new B();
        b.bMethod();
    }
}
 
//in B.java
Class B {
    @Transactional(propagation=propagation.REQUIRED)
    public void bMethod { //something }
}

　　在上面这个例子中，传播性被设为了REQUIRED，注意，这是默认值，也即不进行该参数配置等于配置成REQUIRED。

　　REQUIRED的含义是，支持当前已经存在的事务，如果还没有事务，就创建一个新事务。在上面这个例子中，假设调用aMethod前不存在任何事务，那么执行aMethod时会自动开启一个事务，而由aMethod调用bMethod时，由于事务已经存在，因此会使用已经存在的事务（也就是执行aMethod之前创建的那个事务）。

　　对于这样的配置，如果bMethod过程中发生异常需要回滚，那么aMethod中所进行的所有数据库操作也将同时被回滚，因为这两个方法使用了同一个事务。

　　MANDATORY的含义是，支持当前已经存在的事务，如果还没有事务，就抛出一个异常。如果上例中aMethod的传播性配置为MANDATORY，我们就无法在没有事务的情况下调用aMethod，因此，传播性为MANDATORY的方法必定是一个其他事务的子事务，当逻辑上独立存在没有意义或者可能违反数据、事务完整性的时候，就可以考虑设置这样的传播性设置。

　　NESTED的含义是，在当前事务中创建一个嵌套事务，如果还没有事务，那么就简单地创建一个新事务。

　　REQUIRES_NEW的含义是，挂起当前事务，创建一个新事务，如果还没有事务，就简单地创建一个新事务。

　　请注意以上两者的区别，大多数情况下一上两种传播性行为是类似的，不过在事务回滚的问题上，以上两者有很大的区别。

　　首先，REQUIRES_NEW会创建一个与原事务无关的新事务，尽管是由一个事务调用了另一个事务，但却没有父子关系。

　　如果bMethod的传播性是REQUIRES_NEW，而抛出了一个异常，则bMethod一定会被回滚，而如果aMethod捕获并处理了这个bMethod抛出的异常，那么aMethod仍有可能成功提交。当然，如果aMethod没有处理这个异常，那么aMethod也会被回滚。

　　如果aMethod在bMethod完成后出现了异常，那么bMethod已经提交而无法回滚，只有aMethod被回滚了。

　　而对于NESTED，虽然也会创建一个新事务，但是这个事务与调用者是有父子关系的相互依存的。

　　如果bMethod的传播性是NESTED，而抛出了一个异常，事务的回滚行为与REQUIRES_NEW是一致的。

　　但是如果aMethod在bMethod完成后出现了异常，bMethod同样也会被回滚。因为事实上，EJB中没有对于NESTED传播性的类似实现，NESTED并不是真正启动了一个事务，而是开启了一个新的savepoint。

　　NEVER的含义很简单，就是强制要求不在事务中运行，如果当前存在一个事务，则抛出异常，因此如果bMethod传播性是NEVER，则一定抛出异常。

　　NOT_SUPPORTED的含义是，强制不在事务中运行，如果当前存在一个事务，则挂起该事务。

　　SUPPORTS的含义是，支持当前事务，如果没有事务那么就不在事务中运行。SUPPORTS传播性的逻辑含义比较模糊，因此一般是不推荐使用的。

@Transactional 的 propagation 属性代码示例

比如如下代码，save 方法首先调用了 method1 方法，然后抛出了异常，就会导致事务回滚，如下两条数据都不会插入数据库。

@Transactional(propagation = Propagation.REQUIRED)
@Override
public void save() {
​
    method1();
​
    User user = new User("服部半藏");
    userMapper.insertSelective(user);
​
    if (true) {
        throw new RuntimeException("save 抛异常了");
    }
}
​
public void method1() {
    User user = new User("宫本武藏");
    userMapper.insertSelective(user);
}

现在有需求： 就算 save 方法的后面抛异常了，也不能影响 method1 方法的数据插入。

或许很多人的想法如下，给 method1 页加入一个新的事务，这样 method1 就会在这个新的事务中执行，原来的事务不会影响到新的事务。比如 method1 方法上面再加入注解 @Transactional，设置 propagation 属性为 Propagation.REQUIRES_NEW，代码如下。

@Transactional(propagation = Propagation.REQUIRED)
@Override
public void save() {
​
    method1();
​
    User user = new User("服部半藏");
    userMapper.insertSelective(user);
​
    if (true) {
        throw new RuntimeException("save 抛异常了");
    }
}
​
@Transactional(propagation = Propagation.REQUIRES_NEW)
public void method1() {
    User user = new User("宫本武藏");
    userMapper.insertSelective(user);
}

运行之后，发现然并卵，数据也是没有插入数据库。怎么肥四，看起来很不科学。我们先来看看日志内容。

从日志内容可以看出：其实两个方法都是处于同一个事务中，method1 方法并没有创建一个新的事务。

这就得看看 [Spring 官方文档] 下图截取自官网：

In proxy mode (which is the default), only external method calls coming in through the proxy are intercepted. This means that self-invocation, in effect, a method within the target object calling another method of the target object, will not lead to an actual transaction at runtime even if the invoked method is marked with @Transactional.

大概意思：在默认的代理模式下，只有目标方法由外部调用，才能被 Spring 的事务拦截器拦截。在同一个类中的两个方法直接调用，是不会被 Spring 的事务拦截器拦截，就像上面的 save 方法直接调用了同一个类中的 method1方法，method1 方法不会被 Spring 的事务拦截器拦截。可以使用 AspectJ 取代 Spring AOP 代理来解决这个问题，但是这里暂不讨论。

为了解决这个问题，我们可以新建一个类。

​
@Service
public class OtherServiceImpl implements OtherService {
​
    @Autowired
    private UserMapper userMapper;
​
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    @Override
    public void method1() {
        User user = new User("风魔小太郎");
        userMapper.insertSelective(user);
    }
}

然后在 save 方法中调用 otherService.method1 方法。

​
@Autowired
private OtherService otherService;
​
@Transactional(propagation = Propagation.REQUIRED)
@Override
public void save() {
​
    otherService.method1();
​
    User user = new User("服部半藏");
    userMapper.insertSelective(user);
​
    if (true) {
        throw new RuntimeException("save 抛异常了");
    }
}

这下，otherService.method1 方法的数据插入成功，save 方法的数据未插入，事务回滚。

继续看一下日志内容

从日志可以看出：

首先创建了 save 方法的事务，由于 otherService.method1 方法的 @Transactional 的 propagation 属性为 Propagation.REQUIRES_NEW ，所以接着暂停了 save 方法的事务，重新创建了 otherService.method1 方法的事务，接着 otherService.method1 方法的事务提交，接着 save 方法的事务回滚。这就印证了只有目标方法由外部调用，才能被 Spring 的事务拦截器拦截。