精准测试Spring @Transactional 注解的有效性：从原理到实践

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;
    }
}

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).");
        // 模拟一些数据库操作
    }
}

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.");
    }
}