JUnit5中@BeforeAll/@AfterAll按测试类执行而非全局执行的问题排查

@BeforeAll和@AfterAll的作用范围是单个测试类——不管这些方法定义在接口、抽象基类还是当前测试类里，每个测试类执行时都会独立触发这些钩子。

@TestInstance(TestInstance.Lifecycle.PER_CLASS)只是改变单个测试类的实例创建逻辑（每个测试类只生成一个实例，而非每个测试方法生成一个），但完全不会改变@BeforeAll/@AfterAll的作用范围——它们依然绑定到单个测试类的生命周期，而非所有测试类的全局生命周期。

要做到所有测试类执行前/后各触发一次，可以用以下两种常用方法：

方案1：用JUnit 5测试套件（最直接） #

创建一个测试套件类，在套件级别定义全局的@BeforeAll和@AfterAll，所有被套件包含的测试类都会共享这两个钩子：

import org.junit.platform.suite.api.SelectClasses;
import org.junit.platform.suite.api.Suite;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.AfterAll;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

@Suite
@SelectClasses({Test1Test.class, Test2Test.class})
public class GlobalTestSuite {
    private static final Logger logger = LoggerFactory.getLogger(GlobalTestSuite.class);

    @BeforeAll
    static void globalBeforeAll() {
        logger.info("全局beforeAll：所有测试类执行前触发");
    }

    @AfterAll
    static void globalAfterAll() {
        logger.info("全局afterAll：所有测试类执行后触发");
    }
}

运行这个套件类，输出会变成：

全局beforeAll：所有测试类执行前触发
beforeAll Optional[class Test1Test]
testFoo1
afterAll Optional[class Test1Test]
beforeAll Optional[class Test2Test]
testFoo2
afterAll Optional[class Test2Test]
全局afterAll：所有测试类执行后触发

如果不需要每个测试类自己的前置后置，直接把BaseTest里的@BeforeAll/@AfterAll方法删掉就行。

方案2：自定义JUnit 5扩展（更灵活） #

通过实现BeforeAllCallback和AfterAllCallback接口，结合@ExtendWith注解实现全局钩子：

1. 写自定义扩展类 #

import org.junit.jupiter.api.extension.BeforeAllCallback;
import org.junit.jupiter.api.extension.AfterAllCallback;
import org.junit.jupiter.api.extension.ExtensionContext;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class GlobalLifecycleExtension implements BeforeAllCallback, AfterAllCallback {
    private static final Logger logger = LoggerFactory.getLogger(GlobalLifecycleExtension.class);
    private static boolean isBeforeAllExecuted = false;

    @Override
    public void beforeAll(ExtensionContext context) throws Exception {
        if (!isBeforeAllExecuted) {
            logger.info("全局beforeAll：所有测试类执行前触发");
            isBeforeAllExecuted = true;
        }
    }

    @Override
    public void afterAll(ExtensionContext context) throws Exception {
        // 用全局存储跟踪测试类数量，判断是否是最后一个测试类执行完成
        ExtensionContext.Store globalStore = context.getRoot().getStore(ExtensionContext.Namespace.GLOBAL);
        Integer testClassCount = globalStore.get("testClassCount", Integer.class);
        testClassCount = (testClassCount == null) ? 1 : testClassCount + 1;
        globalStore.put("testClassCount", testClassCount);

        // 添加JVM关闭钩子，确保所有测试结束后触发全局afterAll
        Runtime.getRuntime().addShutdownHook(new Thread(() -> {
            if (isBeforeAllExecuted) {
                logger.info("全局afterAll：所有测试类执行后触发");
                isBeforeAllExecuted = false;
            }
        }));
    }
}

2. 在BaseTest里启用扩展 #

import org.junit.jupiter.api.TestInstance;
import org.junit.jupiter.api.extension.ExtendWith;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.TestInfo;

@TestInstance(TestInstance.Lifecycle.PER_CLASS)
@ExtendWith(GlobalLifecycleExtension.class)
public interface BaseTest {
    Logger logger = LoggerFactory.getLogger(BaseTest.class);

    // 不需要每个测试类的前置后置就删掉这两个方法
    @BeforeAll
    default void beforeAll(final TestInfo testInfo) {
        logger.info("beforeAll {}", testInfo.getTestClass());
    }

    @AfterAll
    default void afterAll(final TestInfo testInfo) {
        logger.info("afterAll {}", testInfo.getTestClass());
    }
}

这样所有实现BaseTest的测试类都会自动应用全局扩展，实现全局钩子只执行一次的效果。

• JUnit 5的@BeforeAll/@AfterAll从设计上就是测试类级别的，不管放在接口还是抽象类，每个测试类都会单独调用一次。
• 测试套件适合明确知道要执行哪些测试类的场景，配置简单直观。
• 自定义扩展适合需要全局统一配置、不想显式定义套件的场景，但需要自己处理重复触发的逻辑。

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