如何在分叉JVM进程中使用CucumberJVM执行单次前置/后置操作？

这个问题我之前帮团队解决过好几次——当用分叉JVM跑Cucumber测试时，@Before/@After注解的方法会在每个JVM实例里重复执行，完全没法实现全局单次的前置验证和后置清理。下面是几个经过实践验证的可行方案，按推荐程度排序：

方案1：利用构建工具的生命周期钩子（最推荐） #

因为分叉JVM通常是由Maven或Gradle这类构建工具的测试插件（Surefire/Failsafe）控制的，直接借助构建工具的生命周期阶段来执行全局操作是最可靠的，完全不会受分叉JVM的隔离影响。

Maven 实现 #

• 全局前置操作：把自定义的初始化逻辑绑定到pre-integration-test（集成测试场景）或pre-test（单元测试场景）阶段，这个阶段会在所有测试JVM启动前执行仅一次。
  你可以在pom.xml中配置exec-maven-plugin来调用你的全局初始化类：

  <build>
    <plugins>
      <!-- 全局前置任务 -->
      <plugin>
        <groupId>org.codehaus.mojo</groupId>
        <artifactId>exec-maven-plugin</artifactId>
        <executions>
          <execution>
            <id>global-test-setup</id>
            <phase>pre-integration-test</phase>
            <goals>
              <goal>java</goal>
            </goals>
            <configuration>
              <mainClass>com.yourteam.test.setup.GlobalTestSetup</mainClass>
              <!-- 传递必要参数（如果需要） -->
              <arguments>
                <argument>--env=test</argument>
              </arguments>
            </configuration>
          </execution>
        </executions>
      </plugin>
      <!-- 配置Failsafe插件开启分叉模式 -->
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-failsafe-plugin</artifactId>
        <configuration>
          <forkCount>2</forkCount> <!-- 按需设置分叉数量 -->
          <reuseForks>true</reuseForks>
        </configuration>
        <executions>
          <execution>
            <goals>
              <goal>integration-test</goal>
              <goal>verify</goal>
            </goals>
          </execution>
        </executions>
      </plugin>
      <!-- 全局后置任务 -->
      <plugin>
        <groupId>org.codehaus.mojo</groupId>
        <artifactId>exec-maven-plugin</artifactId>
        <executions>
          <execution>
            <id>global-test-teardown</id>
            <phase>post-integration-test</phase>
            <goals>
              <goal>java</goal>
            </goals>
            <configuration>
              <mainClass>com.yourteam.test.teardown.GlobalTestTeardown</mainClass>
            </configuration>
          </execution>
        </executions>
      </plugin>
    </plugins>
  </build>
  

  其中GlobalTestSetup就是你要执行的全局验证逻辑，比如检查测试环境可用性、初始化共享测试资源等。

• 全局后置操作：把清理逻辑绑定到post-integration-test阶段，这个阶段会在所有测试JVM执行完毕后执行仅一次，用法和前置任务类似。

Gradle 实现 #

Gradle的思路和Maven一致，通过任务依赖关系来控制执行顺序：

// 定义全局前置任务
task globalTestSetup(type: JavaExec) {
    mainClass = 'com.yourteam.test.setup.GlobalTestSetup'
    classpath = sourceSets.main.runtimeClasspath
    args = ['--env=test'] // 传递参数（可选）
}

// 定义全局后置任务
task globalTestTeardown(type: JavaExec) {
    mainClass = 'com.yourteam.test.teardown.GlobalTestTeardown'
    classpath = sourceSets.main.runtimeClasspath
}

// 配置测试任务的依赖关系
test {
    forkEvery = 1 // 开启分叉模式，每个测试类启动一个新JVM（按需调整）
    dependsOn globalTestSetup // 测试任务启动前先执行前置任务
    finalizedBy globalTestTeardown // 测试任务结束后执行后置任务
}

这样globalTestSetup会在所有测试JVM启动前执行一次，globalTestTeardown会在所有测试完成后执行一次。

方案2：Cucumber插件+共享标记文件（轻量场景备选） #

如果不想修改构建配置，也可以用Cucumber的Plugin扩展，配合临时目录的标记文件来控制全局操作的执行时机。核心思路是：第一个启动的测试JVM执行前置逻辑并创建标记，最后一个结束的测试JVM执行后置逻辑并删除标记。

1. 编写Cucumber插件类：

import io.cucumber.plugin.Plugin;
import io.cucumber.plugin.event.EventPublisher;
import io.cucumber.plugin.event.TestRunFinished;
import io.cucumber.plugin.event.TestRunStarted;

import java.io.File;
import java.io.IOException;

public class GlobalCucumberHookPlugin implements Plugin {
    private static final String SETUP_MARKER = System.getProperty("java.io.tmpdir") + "/cucumber_global_setup_done";
    private static final String TEARDOWN_MARKER = System.getProperty("java.io.tmpdir") + "/cucumber_global_teardown_pending";

    @Override
    public void setEventPublisher(EventPublisher publisher) {
        // 监听测试启动事件，执行全局前置
        publisher.registerHandlerFor(TestRunStarted.class, event -> {
            File setupMarker = new File(SETUP_MARKER);
            if (!setupMarker.exists()) {
                runGlobalSetup();
                try {
                    setupMarker.createNewFile();
                    // 创建后置标记，用于标记需要执行后置操作
                    new File(TEARDOWN_MARKER).createNewFile();
                } catch (IOException e) {
                    throw new RuntimeException("Failed to create global setup marker", e);
                }
            }
        });

        // 监听测试结束事件，执行全局后置
        publisher.registerHandlerFor(TestRunFinished.class, event -> {
            File teardownMarker = new File(TEARDOWN_MARKER);
            if (teardownMarker.exists()) {
                // 简单处理：延迟几秒确保其他JVM已结束，再尝试删除标记并执行后置
                try {
                    Thread.sleep(2000);
                    if (teardownMarker.delete()) {
                        runGlobalTeardown();
                        // 同时删除前置标记，方便下次测试
                        new File(SETUP_MARKER).delete();
                    }
                } catch (IOException | InterruptedException e) {
                    throw new RuntimeException("Failed to handle global teardown", e);
                }
            }
        });
    }

    private void runGlobalSetup() {
        // 你的全局前置逻辑：比如验证数据库连接、启动测试容器
        System.out.println("[GLOBAL] Executing setup once before all forked JVMs");
    }

    private void runGlobalTeardown() {
        // 你的全局后置逻辑：比如停止测试容器、清理共享数据
        System.out.println("[GLOBAL] Executing teardown once after all forked JVMs");
    }
}

2. 在Cucumber配置中启用这个插件：
   可以在cucumber.properties文件中添加：

cucumber.plugin=com.yourteam.test.plugins.GlobalCucumberHookPlugin

或者在测试启动命令中加上--plugin com.yourteam.test.plugins.GlobalCucumberHookPlugin

⚠️ 注意：这个方案依赖临时文件的锁机制，在高并发的分叉场景下可能存在边缘情况（比如多个JVM同时检查标记），适合测试环境可控的轻量场景。

方案3：分布式协调工具（大规模测试场景） #

如果你的测试是跨多机器运行的大规模集群场景，可以用Testcontainers（用于统一管理测试资源）或者自定义的协调服务来控制全局操作，但这个方案复杂度较高，需要额外的基础设施支持，一般中小团队用不上。

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