spring框架的 @transactional 注解是管理数据库事务的强大工具，它极大地简化了事务边界的声明式管理。然而，由于spring aop代理机制的工作原理，当 @transactional 应用于非公共（如 package-private）方法时，事务可能不会如预期般生效。这通常是因为spring默认使用基于jdk动态代理或cglib代理的aop，这些代理机制在某些情况下无法拦截到非公共方法的调用。这种隐蔽的失效可能导致数据一致性问题，因此，开发人员需要一种可靠的方法来验证 @transactional 注解是否真正起作用，尤其是在这些边缘场景下。
1. 理解 @Transactional 的工作原理与挑战
@Transactional 注解的生效依赖于Spring AOP（面向切面编程）机制。当一个带有 @Transactional 注解的Bean被Spring容器创建时，Spring会为其生成一个代理对象。所有对该Bean的外部调用都会先经过这个代理对象，由代理对象负责拦截方法调用，并在调用实际业务逻辑前后织入事务管理逻辑（如开启事务、提交事务或回滚事务）。
挑战：
- 方法可见性： JDK动态代理只能代理接口方法，而CGLIB代理可以代理类方法，但要求方法不能是 final 或 private。package-private 方法虽然不是 private，但对于代理类而言，它们通常不可见或无法被覆盖，导致代理无法拦截其调用。这意味着，直接通过代理对象调用 package-private 方法时，事务切面可能不会被织入。
- 内部调用： 如果一个 @Transactional 方法在其Bean内部被另一个方法直接调用（this.someTransactionalMethod()），Spring的代理机制也不会生效，因为这是直接的对象引用，而非通过代理对象。
为了有效验证这些场景下的事务行为，我们需要一种能够观察事务生命周期的机制。
2. 定制 TransactionInterceptor 以监控事务生命周期
Spring 的 TransactionInterceptor 是处理事务切面的核心组件。通过扩展或定制这个拦截器，我们可以在事务的创建和提交/回滚过程中插入自定义逻辑，从而监控事务的实际发生次数。
实现自定义拦截器：
首先，创建一个继承自 TransactionInterceptor 的自定义类，并在其中添加一个计数器（例如，使用 LongAdder 来确保线程安全地统计事务调用次数）。
package com.my.app; // 建议与业务代码同包，方便访问
import org.aopalliance.intercept.MethodInvocation;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.transaction.interceptor.TransactionAttributeSource;
import org.springframework.transaction.interceptor.TransactionInterceptor;
import java.util.concurrent.atomic.LongAdder;
@Configuration
public class AppConfiguration {
public static class MyTransactionInterceptor extends TransactionInterceptor {
private final LongAdder transactionCount = new LongAdder();
/**
* 覆盖invoke方法，在事务处理逻辑前后增加计数。
* 每次@Transactional方法被代理拦截时，此方法都会被调用。
*/
@Override
public Object invoke(MethodInvocation invocation) throws Throwable {
transactionCount.increment(); // 每次拦截到@Transactional方法调用时计数
return super.invoke(invocation); // 调用父类方法执行实际事务逻辑
}
public long getTransactionCount() {
return transactionCount.longValue();
}
/**
* 重置计数器，方便在每次测试前清零。
*/
public void resetCount() {
transactionCount.reset();
}
}
/**
* 将自定义的MyTransactionInterceptor注册为Spring Bean。
* Spring会自动将其用于所有@Transactional注解的方法，替换默认的TransactionInterceptor。
* @param transactionAttributeSource 事务属性源，由Spring自动提供
* @return 自定义的事务拦截器实例
*/
@Bean
public TransactionInterceptor transactionInterceptor(TransactionAttributeSource transactionAttributeSource) {
MyTransactionInterceptor interceptor = new MyTransactionInterceptor();
interceptor.setTransactionAttributeSource(transactionAttributeSource);
return interceptor;
}
}说明：
- MyTransactionInterceptor 继承了 TransactionInterceptor，并添加了一个 LongAdder 来追踪事务方法的调用次数。
- 我们覆盖了 invoke 方法，确保每次 @Transactional 方法被拦截时，计数器都会增加。这直接反映了Spring AOP是否成功织入了事务切面。
- @Configuration 类确保这个自定义拦截器被Spring容器检测到并注册为Bean，从而替换默认的 TransactionInterceptor。
3. 构建集成测试用例
为了验证 package-private 方法的事务行为，我们需要编写一个集成测试。关键在于，测试类必须与被测试的服务类位于同一个包下，这样才能直接调用 package-private 方法。
示例服务类：
假设我们有一个 SomeService 类，其中包含一个 package-private 的 @Transactional 方法 foo()，以及一个 public 的 @Transactional 方法 bar() 作为对比：
package com.my.app;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
@Service
public class SomeService {
@Transactional
void foo() { // package-private 方法
System.out.println("Executing SomeService.foo() within a transaction.");
// 模拟一些数据库操作，如果事务生效，这些操作会在事务中完成
}
@Transactional
public void bar() { // public 方法
System.out.println("Executing SomeService.bar() within a transaction (public).");
// 模拟一些数据库操作
}
}编写测试类：
测试类 SomeServiceTest 需要与 SomeService 位于同一个包 (com.my.app) 下，通常在Maven或Gradle项目的 src/test/java 目录下。
package com.my.app; // 必须与SomeService在同一个包下
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.context.ApplicationContext;
import org.springframework.transaction.support.TransactionSynchronizationManager;
import static org.junit.jupiter.api.Assertions.*;
@SpringBootTest
class SomeServiceTest {
@Autowired
private SomeService service; // 注入被测试的服务
@Autowired
private ApplicationContext context; // 用于获取自定义的拦截器Bean
private AppConfiguration.MyTransactionInterceptor myTransactionInterceptor;
@BeforeEach
void setup() {
// 在每个测试方法执行前获取自定义拦截器实例并重置计数器
myTransactionInterceptor = context.getBean(AppConfiguration.MyTransactionInterceptor.class);
myTransactionInterceptor.resetCount();
}
/**
* 测试 package-private 方法的事务行为。
* 预期：由于AOP代理机制的限制，该方法上的@Transactional通常不会生效。
* 因此，事务计数不会增加。
*/
@Test
void testPackagePrivateTransactionalMethod() {
// 确保当前线程没有正在进行的事务
assertFalse(TransactionSynchronizationManager.isActualTransactionActive(), "Expected no active transaction before method call.");
long beforeCount = myTransactionInterceptor.getTransactionCount();
service.foo(); // 调用 package-private 方法
long afterCount = myTransactionInterceptor.getTransactionCount();
// 断言：预期事务计数保持不变，表明事务未被拦截和开启
assertEquals(beforeCount, afterCount, "Expected transaction count to remain unchanged for package-private method.");
}
/**
* 测试 public 方法的事务行为。
* 预期：public 方法上的@Transactional会正常生效。
* 因此，事务计数会增加。
*/
@Test
void testPublicTransactionalMethod() {
assertFalse(TransactionSynchronizationManager.isActualTransactionActive(), "Expected no active transaction before method call.");
long beforeCount = myTransactionInterceptor.getTransactionCount();
service.bar(); // 调用 public 方法
long afterCount = myTransactionInterceptor.getTransactionCount();
// 断言：预期事务计数增加1，表明事务已被拦截和开启
assertEquals(beforeCount + 1, afterCount, "Expected transaction count to increase by 1 for public method.");
}
}测试代码说明：
- @SpringBootTest 启动Spring应用上下文，确保所有Bean都被正确加载，包括我们自定义的 MyTransactionInterceptor。
- @Autowired 注入 SomeService 和 ApplicationContext，后者用于获取 MyTransactionInterceptor 实例。
- @BeforeEach 方法在每个测试运行前获取 MyTransactionInterceptor 实例并重置其计数器，确保测试的独立性，避免交叉污染。
- testPackagePrivateTransactionalMethod() 测试 package-private 方法 foo()。我们首先断言当前没有活跃事务，然后记录事务计数，调用 foo()，再记录事务计数。对于 package-private 方法，由于AOP代理通常无法拦截，预期事务计数不会增加。如果断言失败，则说明事务意外生效或配置有误。
- testPublicTransactionalMethod() 作为对比，测试 public 方法 bar()。对于 public 方法，预期事务计数会增加1，验证 @Transactional 的正常工作。
- TransactionSynchronizationManager.isActualTransactionActive() 是一个非常有用的工具，可以在任何时候检查当前线程是否处于活跃事务中。
4. 验证事务回滚
除了验证事务是否开启，我们还可以扩展此方法来验证事务是否在异常发生时正确回滚。虽然上述 MyTransactionInterceptor 没有直接提供回滚计数，但可以通过以下方式间接验证：
-
修改业务方法： 在 public 事务方法中，模拟抛出一个运行时异常。
@Transactional public void methodThatRollsBack() { // 模拟一些数据库操作，例如插入一条记录 // someRepository.save(new Entity("data_to_rollback")); System.out.println("Attempting to save data, then throwing exception..."); throw new RuntimeException("Simulating rollback due to business error."); } -
在测试中捕获异常并验证数据：
@Test void testTransactionRollback() {
