如何让自定义Aspect直接在SpringBootTest的测试方法上生效？

我创建了一个与@WithTenant注解绑定的Aspect，直接将该注解标注在SpringBootTest的测试方法上时无法生效——Aspect内的断点未触发，断言失败；但将注解标注在@Component辅助类的方法上时可以正常生效。请问如何让该Aspect直接作用于测试方法？

测试类 #

import org.junit.jupiter.api.Test;
import org.opennms.horizon.inventory.SpringContextTestInitializer;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.actuate.observability.AutoConfigureObservability;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.ContextConfiguration;

@SpringBootTest
@ContextConfiguration(initializers = {SpringContextTestInitializer.class})
@AutoConfigureObservability
public class AspectTest {
    @Autowired
    AspectTestHelper aspectTestHelper;

    @Test
    @WithTenant(tenantId = "Fred")
    public void testAspect() {
        // Test fails
        assert("Fred".equals(TenantContext.getTenantId()));
    }

    @Test
    public void testAspectHelper() {
        // Test succeeds
        aspectTestHelper.setTenant();
    }
}

辅助类 #

import org.springframework.stereotype.Component;

@Component
public class AspectTestHelper {
    @WithTenant(tenantId = "Alex")
    public void setTenant() {
        assert("Alex".equals(TenantContext.getTenantId()));
    }
}

注解定义 #

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface WithTenant {
    String tenantId() default "";
    int tenantIdArg() default -1;
    String tenantIdArgInternalMethod() default "";
    String tenantIdArgInternalClass() default "";
}

Aspect实现 #

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.lang.reflect.Method;

@Component
@Aspect
public class WithTenantAspect {
    private static final Logger LOG = LoggerFactory.getLogger(WithTenantAspect.class);

    @Autowired
    private TenantLookup tenantLookup;

    @Around(("@annotation(withTenant)"))
    public Object getTenant(ProceedingJoinPoint joinPoint, WithTenant withTenant) throws Throwable {
        String tenantId = withTenant.tenantId();
        int tenantIdArg = withTenant.tenantIdArg();
        String tenantIdArgInternalMethod = withTenant.tenantIdArgInternalMethod();
        String tenantIdArgInternalClass = withTenant.tenantIdArgInternalClass();

        if (tenantIdArg >= 0) {
            Object[] args = joinPoint.getArgs();
            if (args.length <= tenantIdArg) {
                throw new RuntimeException("TenantIdArg position is greater than the number of arguments to the method");
            }
            if (tenantIdArgInternalMethod == null || tenantIdArgInternalMethod.isEmpty() || tenantIdArgInternalClass == null || tenantIdArgInternalClass.isEmpty()) {
                tenantId = String.valueOf(args[tenantIdArg]);
            } else {
                Object tenantObj = args[tenantIdArg];
                Class clazz = Class.forName(tenantIdArgInternalClass);
                Method method = clazz.getMethod(tenantIdArgInternalMethod);
                Object tenant = method.invoke(tenantObj);
                tenantId = String.valueOf(tenant);
            }
        }

        if (tenantId == null || tenantId.isEmpty()) {
            tenantId = tenantLookup.lookupTenantId().orElseThrow();
        }

        try {
            TenantContext.setTenantId(tenantId);
            Object proceed = joinPoint.proceed();
            return proceed;
        } finally {
            TenantContext.clear();
        }
    }
}

Spring AOP默认采用基于代理的实现，只会对Spring容器管理的Bean生成代理并拦截方法调用。而测试类本身并不是Spring管理的Bean（即使标注了@SpringBootTest，测试类实例由JUnit框架创建，而非Spring容器），因此Aspect无法拦截测试方法的执行。

方案1：自定义JUnit测试扩展 #

通过实现JUnit 5的Extension，在测试方法执行前后处理@WithTenant注解，复用Aspect中的租户上下文逻辑。

实现Extension

import org.junit.jupiter.api.extension.AfterEachCallback;
import org.junit.jupiter.api.extension.BeforeEachCallback;
import org.junit.jupiter.api.extension.ExtensionContext;
import org.springframework.test.context.junit.jupiter.SpringExtension;

import java.lang.reflect.Method;

public class WithTenantExtension implements BeforeEachCallback, AfterEachCallback {

    @Override
    public void beforeEach(ExtensionContext context) throws Exception {
        Method testMethod = context.getRequiredTestMethod();
        WithTenant withTenant = testMethod.getAnnotation(WithTenant.class);
        if (withTenant != null) {
            // 复用Aspect中的租户ID解析逻辑
            String tenantId = resolveTenantId(withTenant);
            TenantContext.setTenantId(tenantId);
        }
    }

    @Override
    public void afterEach(ExtensionContext context) throws Exception {
        Method testMethod = context.getRequiredTestMethod();
        if (testMethod.isAnnotationPresent(WithTenant.class)) {
            TenantContext.clear();
        }
    }

    // 提取Aspect中的租户ID解析逻辑为公共方法
    private String resolveTenantId(WithTenant withTenant) throws Exception {
        String tenantId = withTenant.tenantId();
        // 如果需要处理tenantIdArg或TenantLookup，可通过SpringExtension获取上下文
        ExtensionContext.Store store = context.getStore(ExtensionContext.Namespace.create(SpringExtension.class));
        TenantLookup tenantLookup = store.get(TenantLookup.class, TenantLookup.class);
        
        if (tenantId == null || tenantId.isEmpty()) {
            tenantId = tenantLookup.lookupTenantId().orElseThrow();
        }
        return tenantId;
    }
}

配置测试类

在测试类上添加扩展注解：

@SpringBootTest
@ContextConfiguration(initializers = {SpringContextTestInitializer.class})
@AutoConfigureObservability
@ExtendWith(WithTenantExtension.class)
public class AspectTest {
    // ... 测试方法
}

方案2：启用AspectJ加载时织入（LTW） #

如果希望直接用Aspect拦截测试方法，可以改用AspectJ的加载时织入，它能拦截所有类的方法调用（包括非Spring Bean）。

1. 添加AspectJ依赖：

<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <scope>test</scope>
</dependency>

2. 在测试类上启用LTW：

@SpringBootTest
@ContextConfiguration(initializers = {SpringContextTestInitializer.class})
@AutoConfigureObservability
@EnableLoadTimeWeaving
public class AspectTest {
    // ... 测试方法
}

3. 创建src/test/resources/META-INF/aop.xml配置织入规则：

<!DOCTYPE aspectj PUBLIC
        "-//AspectJ//DTD//EN" "https://www.eclipse.org/aspectj/dtd/aspectj.dtd">
<aspectj>
    <weaver>
        <!-- 织入测试类和Aspect所在包 -->
        <include within="com.yourpackage.*"/>
    </weaver>
    <aspects>
        <aspect name="com.yourpackage.WithTenantAspect"/>
    </aspects>
</aspectj>

4. 配置测试启动参数：
   在IDE运行配置或Maven Surefire插件中添加JavaAgent参数：

-javaagent:path/to/aspectjweaver.jar

方案3：复用现有辅助类（临时方案） #

如果不想修改配置，可以继续使用@Component辅助类封装测试逻辑，但这并非直接作用于测试方法的方案。

推荐使用方案1（JUnit Extension），它无需修改AOP模式，实现简单且轻量，能直接在测试方法上生效。方案2（AspectJ LTW）功能更强大，但配置相对复杂，适合需要全局织入的场景。

内容的提问来源于stack exchange，提问作者James Hutchinson