Spring 事务传播和自调用行为

为了方便讲解，这里的A、B、C类都是Spring管理的Bean。

自调用行为

自调用行为示例

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.stereotype.Component;
​
@Component
public class B {
    @Autowired
    public void b() {
        this.c();
    }
    
    @Transactional
    public void c() {
​
    }
}

不生效的原因

代码示例 B.b() 直接调用 B.c() 是一个典型的自调用情况。在这种情况下，即使 B.c() 方法有 @Transactional 注解，由于是在同一个类的内部直接调用，事务注解不会被 Spring 的代理机制捕获，因此不会生效。

在 Spring 的 AOP（面向切面编程）架构中，事务管理是通过代理（Proxy）来实现的。当一个方法被调用时，如果这个方法从外部（即通过 Spring 容器管理的 Bean）调用，并且配置了 @Transactional，Spring 会通过代理来拦截这个调用，然后根据 @Transactional 的属性来开始、加入、挂起或结束事务。但如果这个调用是从同一个类的内部发生的，比如一个方法直接调用同一个类中的另一个方法，这种调用就不会经过代理，Spring 无法施加事务管理的逻辑。

自调用行为解决方案

通过 Spring ApplicationContext 获取代理

可以让 Spring 注入自身的 ApplicationContext，并使用它来获取当前 Bean 的代理，然后通过代理来调用方法。

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.stereotype.Component;
​
@Component
public class B {
    @Autowired
    private ApplicationContext applicationContext;
​
    public void b() {
        B b = applicationContext.getBean(B.class);
        b.c();
    }
​
    public void c() {
        // Transactional code
    }
}

使用 AopContext.currentProxy()

这是一个更简单的方式，但需要在 Spring 配置中启用 exposeProxy=true。然后你可以通过 AopContext.currentProxy() 来获取当前对象的代理并进行调用。

要启用 exposeProxy，需要在 Spring 的配置中设置：

@EnableAspectJAutoProxy(exposeProxy = true)

import org.springframework.aop.framework.AopContext;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
​
@Component
public class B {
    public void b() {
        ((B) AopContext.currentProxy()).c();
    }
​
    @Transactional
    public void c() {
        // Transactional code
    }
}

正确的事务传播行为

2. 创建三个Bean类

接下来，我们创建三个类，每个类都有不同的方法，演示事务的传播：

A类

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
​
@Service
public class A {
    @Autowired
    private B b;
​
    @Transactional
    public void methodA() {
        System.out.println("Inside A.methodA");
        b.methodB();
    }
}

B类

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
​
@Service
public class B {
    @Autowired
    private C c;
​
    @Transactional
    public void methodB() {
        System.out.println("Inside B.methodB");
        c.methodC();
    }
}

C类

import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
​
@Service
public class C {
​
    @Transactional
    public void methodC() {
        System.out.println("Inside C.methodC");
        // 这里可以添加实际的数据库操作代码
    }
}

解释

在这个设置中：

• 当 methodA 被调用时，它在 A 类的事务环境中开始执行。

• A.methodA 调用 B.methodB，B.methodB 进一步调用 C.methodC。由于每个方法都通过Spring的代理调用，每个方法都有 @Transactional 注解，这保证了事务在整个调用链中得以正确管理。

• 如果有需要，每个方法可以根据其事务传播设置独立地控制事务行为。在这个示例中，我们没有明确设置传播行为，所以它们默认使用 Propagation.REQUIRED，这意味着它们会加入到现有的事务中。

为什么这里的methodB没有明写事务，但是methodA、methodB、methodC都有事务

因为A.methodA事务传播到B.methodB，B.methodB传播到C.methodC，因为B.methodB调用C.methodC不属于自调用，所以Spring能捕获到并且进行添加事务。