1. 项目概述：为什么要把Cucumber和TestNG绑在一起？

如果你正在做Java项目的自动化测试，尤其是那种业务逻辑复杂、需要产品经理或业务方也能看懂测试在验证什么的场景，那你大概率听说过Cucumber。它用近乎自然语言的Gherkin语法写测试用例，读起来就像在念需求文档，沟通成本直线下降。而TestNG，作为JUnit之后一个更强大的测试框架，提供了更灵活的测试配置、依赖管理、分组执行和报告生成能力，是很多Java测试工程师的老伙计。

那么，一个很自然的问题就来了：我能不能让Cucumber这个“业务语言翻译官”和TestNG这个“测试执行指挥官”联手工作？答案是肯定的，而且这种集成在实践中非常普遍。我最初尝试做这个集成，是因为团队遇到了一个典型痛点：我们有一套基于TestNG构建的成熟测试套件，涵盖了大量的单元测试和集成测试。后来引入BDD（行为驱动开发）实践，用Cucumber写了一些端到端的验收测试。结果就是，开发跑单元测试用TestNG的命令，测试人员跑验收测试又是另一套Cucumber的命令，报告分散，持续集成流水线也要配置两套任务，维护起来很麻烦。

把Cucumber集成到TestNG里，核心目标就一个： 统一测试执行入口和报告体系 。让所有测试，无论是传统的@Test注解方法，还是Cucumber的Feature文件场景，都能通过一个 testng.xml 来触发，生成一份统一的、信息丰富的测试报告。这对于维护大型测试套件、管理测试生命周期以及集成到CI/CD管道中，价值巨大。接下来，我就把自己趟过坑、最终稳定运行的集成方法与实战经验拆开揉碎了讲给你听。

2. 环境准备与项目骨架搭建

在开始写代码之前，得先把战场布置好。这里假设你使用Maven作为构建工具，这也是Java生态里最主流的选择。

2.1 Maven依赖配置

在你的 pom.xml 文件中，需要引入几个核心依赖。版本号我会选用当前（撰写时）比较稳定且兼容性好的，你可以根据实际情况微调。

<dependencies>
    <!-- TestNG - 测试执行框架 -->
    <dependency>
        <groupId>org.testng</groupId>
        <artifactId>testng</artifactId>
        <version>7.8.0</version>
        <scope>test</scope>
    </dependency>

    <!-- Cucumber-Java - 提供Step Definitions支持 -->
    <dependency>
        <groupId>io.cucumber</groupId>
        <artifactId>cucumber-java</artifactId>
        <version>7.15.0</version>
        <scope>test</scope>
    </dependency>

    <!-- Cucumber-TestNG - 这是集成的桥梁！ -->
    <dependency>
        <groupId>io.cucumber</groupId>
        <artifactId>cucumber-testng</artifactId>
        <version>7.15.0</version>
        <scope>test</scope>
    </dependency>

    <!-- 可选但强烈推荐：Cucumber报告插件 -->
    <dependency>
        <groupId>io.cucumber</groupId>
        <artifactId>cucumber-picocontainer</artifactId>
        <version>7.15.0</version>
        <scope>test</scope>
    </dependency>
</dependencies>

关键点解析：

1. 版本对齐 ：务必确保 cucumber-java 、 cucumber-testng 和 cucumber-picocontainer （如果用的话）的版本号一致。版本混用是导致 ClassNotFoundException 或 NoSuchMethodError 的常见元凶。
2. cucumber-testng ：这个依赖是集成的核心。它提供了 io.cucumber.testng.AbstractTestNGCucumberTests 这个抽象类，我们的Runner类需要继承它。
3. cucumber-picocontainer ：这是一个依赖注入（DI）容器。它不是必须的，但我强烈建议加上。它允许你在Step Definitions类之间、或者Step Definitions与Hook类之间共享状态（比如一个WebDriver实例），管理测试生命周期内的对象，代码会干净很多。后面讲状态共享时会具体说。

2.2 项目目录结构规范

清晰的目录结构能让你的测试代码更易于维护。我推荐遵循Maven的标准布局，并稍作调整以适应Cucumber。

src/
├── main/
│   ├── java/      # 你的应用源代码
│   └── resources/ # 应用配置文件
└── test/
    ├── java/
    │   └── com/
    │       └── yourcompany/
    │           ├── runner/        # TestNG Runner 类
    │           └── stepdefs/      # Cucumber 步骤定义类
    └── resources/
        └── features/              # .feature 文件存放目录
            ├── login.feature
            ├── search.feature
            └── ...

实操心得：

• features 目录放在 test/resources 下是惯例，这样Maven在构建测试包时会自动包含这些文件。
• 在 stepdefs 包下，可以继续按功能模块划分子包，比如 stepdefs.login 、 stepdefs.order ，避免一个巨大的步骤定义文件。
• runner 包专门放置继承 AbstractTestNGCucumberTests 的Runner类。你可以有多个Runner，分别对应不同的测试套件（如冒烟测试、回归测试）。

3. 核心集成步骤详解

环境搭好，现在进入核心环节：编写代码把两者连接起来。

3.1 创建TestNG Cucumber Runner

这是集成中最关键的一步。你需要创建一个类，继承 io.cucumber.testng.AbstractTestNGCucumberTests ，并用 @CucumberOptions 注解来配置Cucumber的行为。

package com.yourcompany.runner;

import io.cucumber.testng.AbstractTestNGCucumberTests;
import io.cucumber.testng.CucumberOptions;

@CucumberOptions(
        features = "src/test/resources/features", // Feature文件路径
        glue = {"com.yourcompany.stepdefs"},      // 步骤定义和Hook的包路径
        plugin = {
                "pretty",                           // 控制台美观输出
                "html:target/cucumber-reports/cucumber.html", // HTML报告
                "json:target/cucumber-reports/cucumber.json", // JSON报告，用于生成更丰富的报告（如Cucumber Reporting插件）
                "junit:target/cucumber-reports/cucumber.xml"  // JUnit格式报告，方便Jenkins等CI工具集成
        },
        monochrome = true, // 控制台输出避免乱码
        tags = "@smoke" // 默认执行带有@smoke标签的场景，可通过testng.xml覆盖
)
public class TestNGRunner extends AbstractTestNGCucumberTests {
    // 这个类可以是空的，所有配置都在注解里。
    // 但如果你需要覆盖父类方法（如设置数据表转换器），可以在这里做。
}

@CucumberOptions 参数深度解析：

• features : 指定你的 .feature 文件所在目录或具体文件。支持通配符和路径列表。例如 features = {"src/test/resources/features/login", "src/test/resources/features/search"} 。
• glue : 告诉Cucumber去哪里找步骤定义(Step Definitions)、钩子(Hooks)和类型转换器(Type Transformers)。 这里是个大坑 ：如果你把Hooks（比如 @Before 、 @After ）放在和Runner同一个包或子包，但 glue 没有包含这个包，那么这些Hooks将不会生效！务必确保 glue 路径覆盖所有相关类。
• plugin : 配置报告输出。 pretty 用于控制台； html 生成可读的网页报告； json 和 junit 格式主要用于后续处理（如通过Jenkins Cucumber Reports插件生成趋势图）。
• tags : 标签过滤表达式。例如 "@smoke and not @wip" 会运行所有带有 @smoke 标签但不带 @wip 标签的场景。这个配置可以在 testng.xml 中被覆盖，实现动态过滤。
• monochrome : 在Windows命令行下，如果控制台输出有奇怪的字符（如 √ ），设置为 true 可以解决。

3.2 配置TestNG XML以驱动执行

现在，你可以像运行普通TestNG测试一样，通过一个 testng.xml 文件来运行你的Cucumber测试了。这是实现“统一入口”的关键。

在项目根目录或 test/resources 下创建 testng.xml ：

<!DOCTYPE suite SYSTEM "https://testng.org/testng-1.0.dtd">
<suite name="Cucumber with TestNG Suite" verbose="1">
    <test name="Acceptance Tests">
        <parameter name="cucumber.filter.tags" value="@regression"/> <!-- 覆盖Runner中的tags -->
        <classes>
            <class name="com.yourcompany.runner.TestNGRunner"/>
        </classes>
    </test>
</suite>

高级用法：

• 多套件并行 ：你可以定义多个 <test> ，每个指向不同的Runner类，甚至可以通过 @Parameters 注解在Runner类中接收不同的参数，实现测试分组和并行执行。

  <suite name="Parallel Suite" parallel="tests" thread-count="2">
      <test name="Login Module">
          <parameter name="cucumber.filter.tags" value="@login"/>
          <classes><class name="com.yourcompany.runner.LoginRunner"/></classes>
      </test>
      <test name="Order Module">
          <parameter name="cucumber.filter.tags" value="@order"/>
          <classes><class name="com.yourcompany.runner.OrderRunner"/></classes>
      </test>
  </suite>
  

• 参数化覆盖 ：如上例所示，使用 <parameter name="cucumber.filter.tags"> 可以动态覆盖Runner类中 @CucumberOptions 定义的 tags 。这在CI/CD中非常有用，比如通过环境变量传递要运行的标签。

3.3 编写Step Definitions与Hooks

这部分是Cucumber的标准内容，但集成到TestNG后，有一些细节需要注意。

Step Definitions示例：

package com.yourcompany.stepdefs;

import io.cucumber.java.en.Given;
import io.cucumber.java.en.When;
import io.cucumber.java.en.Then;
import org.testng.Assert;

public class LoginStepDefinitions {

    private String username;
    private String actualWelcomeMessage;

    @Given("用户已打开登录页面")
    public void user_is_on_login_page() {
        // 初始化WebDriver，导航到登录页
        System.out.println("Navigating to login page...");
    }

    @When("用户输入用户名 {string} 和密码 {string}")
    public void user_enters_username_and_password(String username, String password) {
        this.username = username;
        // 在实际项目中，这里会调用页面对象输入用户名密码
        System.out.println("Entering username: " + username + ", password: " + password);
    }

    @When("点击登录按钮")
    public void clicks_login_button() {
        // 点击登录
        System.out.println("Clicking login button...");
        // 模拟登录成功
        this.actualWelcomeMessage = "欢迎回来，" + username;
    }

    @Then("用户应该看到欢迎消息 {string}")
    public void user_should_see_welcome_message(String expectedWelcomeMessage) {
        Assert.assertEquals(actualWelcomeMessage, expectedWelcomeMessage,
                "欢迎消息不匹配！");
    }
}

Hooks与TestNG生命周期的协同： Cucumber有自己的Hooks（ @Before ， @After ），TestNG也有（ @BeforeMethod ， @AfterMethod ）。在集成环境中，它们的执行顺序是怎样的？

实际上，当通过 AbstractTestNGCucumberTests 运行时，Cucumber会接管测试方法的执行。一个Cucumber场景（Scenario）在TestNG看来就是一个 @Test 方法。因此：

1. TestNG的 @BeforeSuite ， @BeforeTest 等套件/测试级别的Hook会先执行。
2. 然后，对于 每个Cucumber场景 ：
   • 先执行Cucumber的 @Before Hook（如果指定了 order ，按顺序）。
   • 执行该场景的所有步骤（Step）。
   • 最后执行Cucumber的 @After Hook。
3. TestNG的 @AfterTest ， @AfterSuite 等最后执行。

重要提示 ：避免在Cucumber Step Definitions类中使用TestNG的 @BeforeMethod / @AfterMethod 来管理场景级别的资源（如启动/关闭浏览器）。这可能导致意料之外的行为。应该使用Cucumber的 @Before 和 @After 。

package com.yourcompany.stepdefs;

import io.cucumber.java.After;
import io.cucumber.java.Before;
import io.cucumber.java.Scenario;
import org.openqa.selenium.OutputType;
import org.openqa.selenium.TakesScreenshot;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;

public class Hooks {

    private static WebDriver driver; // 静态变量，便于在Step Definitions间共享

    @Before(order = 1) // order可选，定义执行顺序
    public void setUp(Scenario scenario) {
        System.out.println("Starting scenario: " + scenario.getName());
        // 初始化WebDriver
        System.setProperty("webdriver.chrome.driver", "path/to/chromedriver");
        driver = new ChromeDriver();
        driver.manage().window().maximize();
    }

    @After
    public void tearDown(Scenario scenario) {
        if (scenario.isFailed()) {
            // 如果场景失败，截图并嵌入报告
            final byte[] screenshot = ((TakesScreenshot) driver).getScreenshotAs(OutputType.BYTES);
            scenario.attach(screenshot, "image/png", scenario.getName() + "_failure_screenshot");
        }
        if (driver != null) {
            driver.quit();
        }
        System.out.println("Finished scenario: " + scenario.getName() + " with status: " + scenario.getStatus());
    }

    // 提供一个静态方法供其他类获取driver
    public static WebDriver getDriver() {
        return driver;
    }
}

4. 高级特性与最佳实践

基础集成跑通后，来看看如何用得更好、更稳。

4.1 依赖注入与状态共享

当你的测试步骤分散在多个Step Definitions类中时，如何在它们之间共享数据（如用户会话、数据库连接、WebDriver实例）？硬编码的静态变量是一种方式，但更好的方式是使用依赖注入（DI）容器。这就是为什么之前推荐引入 cucumber-picocontainer 的原因。

使用Picocontainer进行依赖注入：

1. 创建需要共享的类 ：这个类将由Picocontainer管理生命周期（默认是场景级别）。

   package com.yourcompany.context;
   
   import org.openqa.selenium.WebDriver;
   
   public class TestContext {
       private WebDriver driver;
       private String authToken;
       private User currentUser;
   
       // getters and setters
       public WebDriver getDriver() { return driver; }
       public void setDriver(WebDriver driver) { this.driver = driver; }
       // ... 其他属性的getter/setter
   }
   

2. 在Step Definitions中注入 ：Picocontainer会自动实例化 TestContext 并将其注入到需要它的Step Definitions构造函数或字段中。

   package com.yourcompany.stepdefs.login;
   
   import com.yourcompany.context.TestContext;
   import io.cucumber.java.en.Given;
   import org.openqa.selenium.WebDriver;
   
   public class LoginSteps {
       
       private final TestContext testContext; // 通过构造函数注入
       
       public LoginSteps(TestContext testContext) {
           this.testContext = testContext;
       }
       
       @Given("我已打开登录页")
       public void i_am_on_the_login_page() {
           WebDriver driver = testContext.getDriver();
           driver.get("https://example.com/login");
       }
   }
   

   package com.yourcompany.stepdefs.profile;
   
   import com.yourcompany.context.TestContext;
   import io.cucumber.java.en.Then;
   
   public class ProfileSteps {
       
       private final TestContext testContext; // 同样注入
       
       public ProfileSteps(TestContext testContext) {
           this.testContext = testContext;
       }
       
       @Then("我的个人资料页面应显示用户名")
       public void my_profile_page_should_display_username() {
           String username = testContext.getCurrentUser().getUsername();
           // ... 使用driver和username进行断言
       }
   }
   

   关键优势 ： TestContext 对象在每个Cucumber场景开始时被创建，并在该场景的所有步骤和类中共享。场景结束时，对象被丢弃。这完美契合了测试隔离的需求，代码也更清晰、可测试。

4.2 并行测试执行配置

TestNG强大的并行执行能力可以大幅缩短测试总耗时。要让Cucumber场景并行运行，你需要做以下配置：

1. 在 testng.xml 中启用并行模式 ：

   <suite name="Cucumber Parallel Suite" parallel="methods" thread-count="4" data-provider-thread-count="4">
       <test name="All Features">
           <classes>
               <class name="com.yourcompany.runner.ParallelRunner"/>
           </classes>
       </test>
   </suite>
   

   注意： parallel="methods" 是关键，它告诉TestNG将每个测试方法（在这里，每个Cucumber场景被视作一个方法）并行执行。

2. 创建支持并行的Runner类 ：你需要继承 AbstractTestNGCucumberTests 并覆盖 scenarios() 方法，使其返回一个 Iterator<Object[]> ，其中每个 Object[] 包含运行一个场景所需的参数。幸运的是， cucumber-testng 已经提供了一个现成的实现 io.cucumber.testng.FeatureRunner ，但更简单的做法是直接使用一个已经处理好的基类模式，或者使用社区推荐的配置。实际上，从Cucumber 7.x开始， AbstractTestNGCucumberTests 本身通过 @DataProvider(parallel = true) 已经支持了并行。你只需要确保：

   • Runner类中不要有共享的非线程安全状态。
   • Step Definitions和Hooks中的依赖注入容器（如Picocontainer）能正确处理线程隔离（Picocontainer默认是场景/线程隔离的，没问题）。
   • 最重要的 ：你的测试场景本身是独立的，没有共享外部状态（如数据库中的同一条记录、文件系统的同一个文件）。这是实现可靠并行的前提。

   并行Runner示例：

   package com.yourcompany.runner;
   
   import io.cucumber.testng.AbstractTestNGCucumberTests;
   import io.cucumber.testng.CucumberOptions;
   import org.testng.annotations.DataProvider;
   
   @CucumberOptions(...) // 选项与之前相同
   public class ParallelRunner extends AbstractTestNGCucumberTests {
   
       @Override
       @DataProvider(parallel = true) // 启用并行数据提供器
       public Object[][] scenarios() {
           return super.scenarios();
       }
   }
   

   然后，在 testng.xml 中引用这个 ParallelRunner ，并设置 parallel="methods" 和 thread-count 。

4.3 报告生成与整合

集成后，你会有多套报告：

1. TestNG默认报告 ：位于 test-output/ 目录下。它主要记录了TestNG层面的执行情况（套件、测试、方法），但对于Cucumber场景的细节（步骤、Given/When/Then）展示不友好。
2. Cucumber插件报告 ：通过 @CucumberOptions 中的 plugin 配置生成。 html 报告可读性最好， json 报告则可用于二次加工。

最佳实践：生成聚合的富媒体报告 我推荐使用第三方库，如 cucumber-reporting ，它可以将运行产生的 json 报告文件转换成非常美观、信息丰富的HTML报告，包含图表、趋势、标签统计等。

在Maven中集成cucumber-reporting：

<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-surefire-plugin</artifactId>
            <version>3.1.2</version>
            <configuration>
                <suiteXmlFiles>
                    <suiteXmlFile>testng.xml</suiteXmlFile>
                </suiteXmlFiles>
            </configuration>
        </plugin>
        <plugin>
            <groupId>net.masterthought</groupId>
            <artifactId>maven-cucumber-reporting</artifactId>
            <version>5.8.0</version>
            <executions>
                <execution>
                    <id>generate-cucumber-reports</id>
                    <phase>verify</phase>
                    <goals>
                        <goal>generate</goal>
                    </goals>
                    <configuration>
                        <projectName>Your Project BDD Tests</projectName>
                        <outputDirectory>${project.build.directory}/cucumber-reports-advanced</outputDirectory>
                        <inputDirectory>${project.build.directory}/cucumber-reports</inputDirectory>
                        <jsonFiles>
                            <param>**/cucumber.json</param>
                        </jsonFiles>
                    </configuration>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

运行 mvn clean verify 后，除了执行测试，还会在 target/cucumber-reports-advanced 目录下生成一个包含 feature-overview.html 等文件的丰富报告。

5. 常见问题排查与实战技巧

在实际集成过程中，我踩过不少坑。这里把典型问题和解决方案列出来，希望能帮你节省时间。

5.1 典型错误与解决方案

问题现象	可能原因	解决方案
NoClassDefFoundError: io/cucumber/testng/AbstractTestNGCucumberTests	1. cucumber-testng 依赖缺失或版本不对。 2. Maven依赖冲突。	1. 检查 pom.xml ，确保 cucumber-testng 依赖存在且版本与 cucumber-java 一致。 2. 运行 mvn dependency:tree 查看是否有其他库引入了旧版本Cucumber，使用 <exclusions> 排除。
Cucumber场景被跳过，控制台输出 0 scenarios	1. features 路径配置错误。 2. glue 路径配置错误，找不到Step Definitions。 3. Feature文件语法错误。	1. 检查 @CucumberOptions 中 features 的值，使用绝对路径或相对于classpath的路径试试。 2. 检查 glue 包名是否正确，确保Step Definitions类在该包或其子包下。 3. 用 cucumber --dry-run 命令（如果单独安装CLI）或IDE插件检查feature文件语法。
Step Definitions中的 @Before / @After Hook未执行	glue 路径未包含Hook类所在的包。	将Hook类所在的包也添加到 @CucumberOptions 的 glue 参数中，例如： glue = {"com.yourcompany.stepdefs", "com.yourcompany.hooks"}
并行执行时测试数据互相干扰	测试场景不是独立的，共享了类变量、静态变量或外部资源（如数据库同一行数据）。	1. 使用依赖注入 （如Picocontainer）管理测试状态，其生命周期默认是场景隔离的。 2. 清理测试数据 ：每个场景的 @Before 中创建唯一数据， @After 中清理。 3. 避免在Step Definitions中使用静态变量存储场景状态。
TestNG报告中没有Cucumber步骤的详细信息	这是正常现象，TestNG报告只记录到“方法”级别（即整个场景）。	依赖Cucumber生成的HTML/JSON报告来查看步骤详情。使用 cucumber-reporting 等工具生成聚合报告。
运行时报 io.cucumber.core.exception.CucumberException: Failed to instantiate class ...	1. Step Definitions类没有无参构造函数，且使用了需要构造器参数的依赖注入但容器未配置好。 2. Picocontainer依赖缺失，但Step Definitions类尝试了构造函数注入。	1. 如果使用Picocontainer，确保类有合适的构造函数，并且相关依赖类也能被容器管理。 2. 如果不用DI，确保Step Definitions类有无参构造函数。 3. 检查是否添加了 cucumber-picocontainer 依赖。

5.2 性能优化与稳定性建议

1. Driver管理策略 ：对于Web UI测试，频繁启动/关闭浏览器是主要耗时点。可以考虑：

   • 单场景单Driver ：即上面的Hook示例，每个场景独立Driver，稳定但稍慢。
   • 复用Driver（谨慎） ：通过 @BeforeAll 和 @AfterAll （Cucumber 7+）启动和关闭一次Driver供所有场景使用。但这要求每个场景绝对独立（清理Cookies、LocalStorage），并且一个场景失败不能影响后续场景。稳定性要求高，不推荐新手使用。
   • 使用Driver池 ：更高级的方案，如使用 selenium-grid 或 threadlocal 管理Driver，实现并行且隔离。

2. 标签策略 ：善用Cucumber的标签（ @Tag ）来组织测试。

   • @smoke : 核心冒烟测试。
   • @regression : 全量回归测试。
   • @wip (Work In Progress): 开发中的场景，默认不执行。
   • @slow : 执行慢的场景，可以单独运行。 在 testng.xml 中通过参数动态指定标签，CI/CD管道可以根据不同触发条件（如合并请求、每日构建）运行不同的标签集合。

3. 等待与超时 ：在Step Definitions中，避免使用 Thread.sleep() 进行固定等待。应使用Selenium的 WebDriverWait 进行显式等待，或封装重试机制。将超时时间作为可配置参数。

4. 日志与调试 ：在Step Definitions和Hooks中加入清晰的日志输出（使用SLF4J + Logback）。当测试在CI服务器上失败时，详细的日志是定位问题的唯一线索。可以在 @After Hook中，无论成功失败，都输出一些关键上下文信息。

5.3 与CI/CD管道集成

集成到Jenkins、GitLab CI等工具中时，关键点如下：

1. 命令执行 ：CI任务中，执行测试的命令就是运行TestNG。

   # 使用Maven Surefire插件
   mvn clean verify -DsuiteXmlFile=testng-smoke.xml
   # 或者直接使用TestNG命令行运行器（如果项目已打包）
   java -cp "your-test-jar-with-dependencies.jar" org.testng.TestNG testng-regression.xml
   

2. 报告收集 ：在CI配置中，将Cucumber生成的 json 报告（ target/cucumber-reports/cucumber.json ）和 html 报告，以及 cucumber-reporting 生成的富媒体报告，归档为构建产物（Artifacts）。这样每次构建后都能直接下载查看。

3. 失败处理 ：配置CI任务在测试失败时不被标记为完全失败（例如，使用 mvn test 的 -DtestFailureIgnore=true ），以便继续执行后续的报告生成步骤。但最终构建状态应根据测试结果正确设置。

4. 环境变量 ：使用环境变量来传递配置，如数据库连接字符串、测试环境URL、要运行的标签等。在 testng.xml 中通过 ${} 引用系统属性，在CI任务中设置这些属性。

   <parameter name="cucumber.filter.tags" value="${test.tags}"/>
   

   CI命令： mvn verify -Dtest.tags="@smoke" -Dbase.url="https://staging.example.com"

将Cucumber与TestNG集成，绝不是简单的库叠加。它关乎测试架构的统一、执行效率的提升和团队协作的流畅。从最初统一报告入口的简单需求，到后来利用TestNG的并行能力加速反馈，再到通过依赖注入让测试代码更清晰健壮，这个过程让我深刻体会到，好的工具集成能释放出远超单个工具的生产力。如果你也在为多套测试框架并存而烦恼，不妨从创建一个简单的 TestNGRunner 开始，逐步探索这种集成模式带来的便利。