如何抑制外部类@BeforeEach/@AfterEach在内部嵌套类测试间执行

核心思路 #

结合JUnit5的TestExecutionListener与InvocationInterceptor扩展能力，通过测试上下文跟踪内部类的测试执行状态：先统计内部类的测试总数，再对比当前执行的测试序号，判断是否为内部类的第一个或最后一个测试，以此控制外部类@BeforeEach/@AfterEach的执行时机。

具体实现步骤 #

1. 自定义扩展类，实现双接口 #

实现InvocationInterceptor拦截生命周期方法执行，同时用TestExecutionListener收集测试类元数据（比如内部类的测试方法总数）：

import org.junit.jupiter.api.extension.*;
import org.junit.jupiter.api.extension.InvocationInterceptor.Invocation;
import org.junit.platform.commons.support.AnnotationSupport;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.atomic.AtomicInteger;

public class OuterLifecycleControlExtension implements InvocationInterceptor, TestExecutionListener {
    // 存储每个内部测试类的总测试方法数
    private final Map<Class<?>, Integer> innerTestCountMap = new HashMap<>();
    // 记录当前内部类已执行的测试数（线程隔离）
    private final ThreadLocal<AtomicInteger> currentInnerTestCounter = ThreadLocal.withInitial(AtomicInteger::new);
    // 标记当前是否在外部类自身的测试中（线程隔离）
    private final ThreadLocal<Boolean> isOuterTest = ThreadLocal.withInitial(() -> true);

    // 测试计划启动时，统计所有内部类的测试方法数量
    @Override
    public void testPlanExecutionStarted(TestPlan testPlan) {
        testPlan.getTestClasses().forEach(testClass -> {
            Class<?> javaClass = testClass.getJavaClass();
            if (javaClass.isMemberClass() && !javaClass.isStatic()) {
                int testCount = AnnotationSupport.findAnnotatedMethods(javaClass, org.junit.jupiter.api.Test.class).size();
                innerTestCountMap.put(javaClass, testCount);
            }
        });
    }

    // 拦截@BeforeEach方法
    @Override
    public void interceptBeforeEachMethod(Invocation<Void> invocation, ReflectiveInvocationContext<Method> invocationContext, ExtensionContext extensionContext) throws Throwable {
        Class<?> testClass = extensionContext.getRequiredTestClass();
        // 外部类自身测试，正常执行@BeforeEach
        if (isOuterClassTest(testClass, extensionContext)) {
            invocation.proceed();
            return;
        }
        // 内部类测试：仅第一个测试前执行外部类的@BeforeEach
        if (currentInnerTestCounter.get().get() == 0) {
            if (invocationContext.getExecutable().getDeclaringClass().equals(testClass.getEnclosingClass())) {
                invocation.proceed();
            }
        }
        // 内部类自身的@BeforeEach正常执行
        if (invocationContext.getExecutable().getDeclaringClass().equals(testClass)) {
            invocation.proceed();
        }
    }

    // 拦截@AfterEach方法
    @Override
    public void interceptAfterEachMethod(Invocation<Void> invocation, ReflectiveInvocationContext<Method> invocationContext, ExtensionContext extensionContext) throws Throwable {
        Class<?> testClass = extensionContext.getRequiredTestClass();
        // 外部类自身测试，正常执行@AfterEach
        if (isOuterClassTest(testClass, extensionContext)) {
            invocation.proceed();
            return;
        }
        // 内部类自身的@AfterEach正常执行
        if (invocationContext.getExecutable().getDeclaringClass().equals(testClass)) {
            invocation.proceed();
        }
        // 内部类测试：仅最后一个测试后执行外部类的@AfterEach
        int currentCount = currentInnerTestCounter.get().incrementAndGet();
        Integer totalCount = innerTestCountMap.get(testClass);
        if (currentCount == totalCount) {
            if (invocationContext.getExecutable().getDeclaringClass().equals(testClass.getEnclosingClass())) {
                invocation.proceed();
                currentInnerTestCounter.get().set(0); // 重置计数器
            }
        }
    }

    // 测试类启动时，标记是否进入内部类测试
    @Override
    public void testClassStarted(ExtensionContext extensionContext) {
        Class<?> testClass = extensionContext.getRequiredTestClass();
        isOuterTest.set(!testClass.isMemberClass());
    }

    // 辅助方法：判断当前测试是否属于外部类自身
    private boolean isOuterClassTest(Class<?> testClass, ExtensionContext extensionContext) {
        return !testClass.isMemberClass() || extensionContext.getTestInstance().getClass().equals(testClass.getEnclosingClass());
    }
}

2. 在外部测试类上注册扩展 #

在OuterTest类上添加@ExtendWith注解启用自定义扩展：

import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;

@ExtendWith(OuterLifecycleControlExtension.class)
public class OuterTest {

    @BeforeEach
    void outerBeforeEach() {
        System.out.println("Outer @BeforeEach");
    }

    @AfterEach
    void outerAfterEach() {
        System.out.println("Outer @AfterEach");
    }

    @Test
    void outerTest1() {
        System.out.println("Outer Test 1");
    }

    @Test
    void outerTest2() {
        System.out.println("Outer Test 2");
    }

    class InnerTest {

        @BeforeEach
        void innerBeforeEach() {
            System.out.println("Inner @BeforeEach");
        }

        @AfterEach
        void innerAfterEach() {
            System.out.println("Inner @AfterEach");
        }

        @Test
        void innerTest1() {
            System.out.println("Inner Test 1");
        }

        @Test
        void innerTest2() {
            System.out.println("Inner Test 2");
        }
    }
}

3. 执行效果验证 #

执行后输出顺序符合预期：

Outer @BeforeEach
Outer Test 1
Outer @AfterEach
Outer @BeforeEach
Outer Test 2
Outer @AfterEach
Outer @BeforeEach
Inner @BeforeEach
Inner Test 1
Inner @AfterEach
Inner @BeforeEach
Inner Test 2
Inner @AfterEach
Outer @AfterEach

关键逻辑说明 #

• 利用TestExecutionListener在测试计划启动阶段，提前统计所有内部测试类的测试方法总数，避免实时统计带来的性能损耗。
• 通过ThreadLocal存储计数器和测试状态，确保多线程测试环境下的隔离性，不会出现跨测试类的状态干扰。
• 严格区分外部类与内部类的生命周期方法，仅在内部类的第一个/最后一个测试节点触发外部类的对应方法，内部类自身的生命周期方法不受影响。

内容的提问来源于stack exchange，提问作者0x5F3759DF