如何将实例传入实现BeforeAllCallback的类？JUnit5@ExtendWith可行吗？

当然可以用JUnit 5的@ExtendWith注解实现这个需求！我给你梳理几种实用的实现方式，都是项目里常用的套路～

核心思路 #

BeforeAllCallback是JUnit 5扩展的类级别回调接口，要把实例传递给它，核心是通过ExtensionContext获取测试类的上下文信息——要么直接拿测试类实例里的成员对象，要么通过自定义注解标记要传递的字段，让扩展自动识别。

方式一：通过测试类实例中转（最直接） #

这种方式适合要传递的实例是测试类的成员变量，步骤很清晰：

1. 准备要传递的业务类 #

比如我们有一个需要初始化的服务类：

public class MyService {
    public void init() {
        System.out.println("MyService 完成初始化");
    }
}

2. 实现BeforeAllCallback扩展类 #

在扩展类里，通过ExtensionContext拿到测试类实例，再提取里面的MyService对象：

import org.junit.jupiter.api.extension.BeforeAllCallback;
import org.junit.jupiter.api.extension.ExtensionContext;

public class MyExtension implements BeforeAllCallback {
    @Override
    public void beforeAll(ExtensionContext context) throws Exception {
        // 获取测试类实例（这里需要测试类设置PER_CLASS生命周期）
        Object testInstance = context.getTestInstance()
                .orElseThrow(() -> new IllegalStateException("测试实例未初始化"));
        
        // 强转成测试类，拿到目标实例
        if (testInstance instanceof MyTestClass) {
            MyService myService = ((MyTestClass) testInstance).getMyService();
            // 在这里使用传入的实例做逻辑，比如初始化
            myService.init();
        }
    }
}

3. 编写测试类并注册扩展 #

关键要给测试类加上@TestInstance(TestInstance.Lifecycle.PER_CLASS)——默认的PER_METHOD生命周期下，BeforeAll执行时测试实例还没创建，拿不到对象：

import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.TestInstance;
import org.junit.jupiter.api.extension.ExtendWith;

@TestInstance(TestInstance.Lifecycle.PER_CLASS)
@ExtendWith(MyExtension.class) // 注册扩展
public class MyTestClass {
    // 初始化要传递的实例
    private final MyService myService = new MyService();

    // 提供getter给扩展类获取实例
    public MyService getMyService() {
        return myService;
    }

    @Test
    void testBusinessLogic() {
        // 你的测试逻辑
    }
}

方式二：用自定义注解解耦（更灵活） #

如果不想给测试类写getter，可以用自定义注解标记要传递的字段，让扩展通过反射自动识别：

1. 定义自定义注解 #

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

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface InjectToExtension {
}

2. 修改扩展类逻辑 #

通过反射扫描测试类中带注解的字段：

import org.junit.jupiter.api.extension.BeforeAllCallback;
import org.junit.jupiter.api.extension.ExtensionContext;
import java.lang.reflect.Field;

public class MyExtension implements BeforeAllCallback {
    @Override
    public void beforeAll(ExtensionContext context) throws Exception {
        Object testInstance = context.getTestInstance()
                .orElseThrow(() -> new IllegalStateException("测试实例未初始化"));
        
        // 遍历测试类字段，找到标记了注解的对象
        for (Field field : testInstance.getClass().getDeclaredFields()) {
            if (field.isAnnotationPresent(InjectToExtension.class)) {
                field.setAccessible(true); // 允许访问private字段
                MyService myService = (MyService) field.get(testInstance);
                myService.init();
                break;
            }
        }
    }
}

3. 测试类简化写法 #

不用写getter，直接给字段加注解就行：

import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.TestInstance;
import org.junit.jupiter.api.extension.ExtendWith;

@TestInstance(TestInstance.Lifecycle.PER_CLASS)
@ExtendWith(MyExtension.class)
public class MyTestClass {
    @InjectToExtension
    private final MyService myService = new MyService();

    @Test
    void testBusinessLogic() {
        // 你的测试逻辑
    }
}

补充：如果要传递外部实例？ #

如果要传递的实例不是测试类的成员，而是外部创建的对象，可以结合@RegisterExtension（这也是JUnit 5的扩展方式，和@ExtendWith互补）：

1. 给扩展类加构造参数 #

public class MyExtension implements BeforeAllCallback {
    private final MyService externalService;

    // 通过构造方法接收外部实例
    public MyExtension(MyService externalService) {
        this.externalService = externalService;
    }

    @Override
    public void beforeAll(ExtensionContext context) throws Exception {
        externalService.init();
    }
}

2. 测试类中注册扩展实例 #

import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.RegisterExtension;

public class MyTestClass {
    // 外部创建的实例
    private static final MyService externalService = new MyService();
    
    // 直接创建扩展实例并传入对象
    @RegisterExtension
    public static MyExtension myExtension = new MyExtension(externalService);

    @Test
    void testBusinessLogic() {
        // 你的测试逻辑
    }
}

这种方式不需要依赖测试类的生命周期，更适合传递全局或外部初始化的对象。

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