如何验证Spring @Transactional 注解的有效性与事务行为

package com.my.app; // 确保在与被测试类相同的包中，或在公共可访问的包中

import org.springframework.transaction.interceptor.TransactionInterceptor;
import org.aopalliance.intercept.MethodInvocation;
import java.util.concurrent.atomic.LongAdder;

public class MyTransactionInterceptor extends TransactionInterceptor {

    private final LongAdder transactionCount = new LongAdder();

    /**
     * 获取事务拦截器被调用的次数。
     * @return 事务拦截器被调用的总次数。
     */
    public long getTransactionCount() {
        return transactionCount.sum();
    }

    /**
     * 重写invoke方法，在执行父类事务逻辑前增加计数。
     * @param invocation 方法调用信息
     * @return 方法执行结果
     * @throws Throwable 任何抛出的异常
     */
    @Override
    public Object invoke(MethodInvocation invocation) throws Throwable {
        transactionCount.increment(); // 在事务逻辑执行前增加计数
        return super.invoke(invocation); // 调用父类（即Spring的默认事务处理）
    }
}

package com.my.app; // 确保在与被测试类相同的包中，或在公共可访问的包中

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.transaction.interceptor.TransactionAttributeSource;
import org.springframework.transaction.interceptor.TransactionInterceptor;

@Configuration
public class AppConfiguration {

    /**
     * 配置自定义的MyTransactionInterceptor作为Spring事务拦截器。
     * Spring会自动注入TransactionAttributeSource。
     * @param transactionAttributeSource 事务属性源
     * @return 配置好的MyTransactionInterceptor实例
     */
    @Bean
    public TransactionInterceptor transactionInterceptor(TransactionAttributeSource transactionAttributeSource) {
        MyTransactionInterceptor interceptor = new MyTransactionInterceptor();
        interceptor.setTransactionAttributeSource(transactionAttributeSource);
        // 可以根据需要设置其他属性，如TransactionManager
        // interceptor.setTransactionManager(transactionManager);
        return interceptor;
    }
}

package com.my.app;

import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class SomeService {

    @Transactional // 包私有方法上的@Transactional
    void foo() {
        System.out.println("Executing SomeService.foo() within a transaction context.");
        // 模拟一些业务逻辑，例如数据库操作
        // ...
    }

    @Transactional // 公共方法上的@Transactional
    public void bar() {
        System.out.println("Executing SomeService.bar() within a transaction context.");
        // ...
    }
}

package com.my.app; // 与SomeService在同一个包中

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 // 启用Spring Boot测试上下文
class SomeServiceTest {

    @Autowired
    private SomeService service; // 注入被测试的Service

    @Autowired
    private ApplicationContext context; // 注入ApplicationContext以获取自定义拦截器

    /**
     * 测试包私有方法foo()的事务行为。
     * 预期：由于是包私有方法，默认情况下@Transactional可能不生效，
     * 导致事务拦截器计数不变。
     */
    @Test
    void testPackagePrivateTransactionalMethodFoo() {
        // 确保当前没有活跃事务
        assertFalse(TransactionSynchronizationManager.isActualTransactionActive(), "在调用事务方法前不应有活跃事务");

        long beforeCount = getTransactionInvocationCount(); // 获取调用前的事务计数

        service.foo(); // 调用包私有方法。在同一个包中，编译不会报错。

        long afterCount = getTransactionInvocationCount(); // 获取调用后的事务计数

        // 断言事务拦截器被调用，意味着@Transactional生效
        // 原始问题指出包私有方法可能不生效，所以这里预期的结果是失败（afterCount == beforeCount）
        // 如果Spring配置了CGLIB代理且允许代理非public方法，则可能成功。
        // 但根据问题描述，默认情况是失败的。
        // 对于本教程，我们假设要验证它是否 *被拦截*。
        // 如果不被拦截，则 afterCount == beforeCount。
        // 如果被拦截，则 afterCount == beforeCount + 1。
        // 根据原始问题，包私有方法不工作，所以我们预期 afterCount == beforeCount。
        assertEquals(beforeCount, afterCount, "包私有方法上的@Transactional可能未被拦截，事务计数不应增加");
    }

    /**
     * 测试公共方法bar()的事务行为。
     * 预期：公共方法上的@Transactional应该生效，事务拦截器计数增加。
     */
    @Test
    void testPublicTransactionalMethodBar() {
        assertFalse(TransactionSynchronizationManager.isActualTransactionActive(), "在调用事务方法前不应有活跃事务");

        long beforeCount = getTransactionInvocationCount();

        service.bar(); // 调用公共方法

        long afterCount = getTransactionInvocationCount();

        // 断言事务拦截器被调用，证明@Transactional生效
        assertEquals(beforeCount + 1, afterCount, "公共方法上的@Transactional应该被拦截，事务计数应增加");
    }


    /**
     * 从ApplicationContext中获取MyTransactionInterceptor并返回其事务调用计数。
     * @return 事务拦截器被调用的次数。
     */
    private long getTransactionInvocationCount() {
        // 注意：这里需要确保AppConfiguration中的@Bean方法返回的是MyTransactionInterceptor实例，
        // 而不是TransactionInterceptor的父类实例，否则可能无法直接转型。
        // 更好的做法是在AppConfiguration中直接将MyTransactionInterceptor作为Bean返回。
        return context.getBean(MyTransactionInterceptor.class).getTransactionCount();
    }
}