黄瓜将在每个场景之前创建您每个粘合代码类的全新实例，因此您的步骤不会泄漏状态。

• 注意：在使用 Spring 时，有一个注解ScenarioScope可以用于任何已用于共享步骤状态的 Spring Bean；此注解可确保这些 Bean 不跨场景持久化，因此不会泄漏状态。
• 注意：在使用 Guice 时，有一个范围ScenarioScoped应该始终用于步骤定义类。

另请参见依赖注入。

如果您的编程语言是 JVM 语言，则将在类中编写粘合代码（步骤定义和钩子）。

黄瓜将在每个场景之前创建您每个粘合代码类的全新实例。

如果所有粘合代码类都具有空构造函数，则无需执行任何其他操作。但是，大多数项目将受益于依赖注入 (DI) 模块，以更好地组织代码并共享步骤定义之间的状态。

可用的依赖注入模块是

• PicoContainer（如果您的应用程序没有使用其他 DI 模块，则推荐使用此模块）
• Spring
• Guice
• OpenEJB
• Weld
• Needle

要使用 PicoContainer，请将以下依赖项添加到您的pom.xml中

<dependency>
    <groupId>io.cucumber</groupId>
    <artifactId>cucumber-picocontainer</artifactId>
    <version>7.20.1</version>
    <scope>test</scope>
</dependency>

或者，如果您使用的是 Gradle，请添加

compile group: 'io.cucumber', name: 'cucumber-picocontainer', version: '7.20.1'

目前还没有文档，但代码位于GitHub上。有关更多信息，请参见使用 PicoContainer 共享状态。

要使用 Spring，请将以下依赖项添加到您的pom.xml中

<dependency>
    <groupId>io.cucumber</groupId>
    <artifactId>cucumber-spring</artifactId>
    <version>7.20.1</version>
    <scope>test</scope>
</dependency>

或者，如果您使用的是 Gradle，请添加

compile group: 'io.cucumber', name: 'cucumber-spring', version: '7.20.1'

目前还没有文档，但代码位于GitHub上。

要使用 Guice，请将以下依赖项添加到您的pom.xml中

<dependency>
    <groupId>io.cucumber</groupId>
    <artifactId>cucumber-guice</artifactId>
    <version>7.20.1</version>
    <scope>test</scope>
</dependency>

或者，如果您使用的是 Gradle，请添加

compile group: 'io.cucumber', name: 'cucumber-guice', version: '7.20.1'

目前还没有文档，但代码位于GitHub上。有关更多信息，请参见使用 Guice 共享状态。

要使用 OpenEJB，请将以下依赖项添加到您的pom.xml中

<dependency>
    <groupId>io.cucumber</groupId>
    <artifactId>cucumber-openejb</artifactId>
    <version>7.20.1</version>
    <scope>test</scope>
</dependency>

或者，如果您使用的是 Gradle，请添加

compile group: 'io.cucumber', name: 'cucumber-openejb', version: '7.20.1'

目前还没有文档，但代码位于GitHub上。

要使用 Weld，请将以下依赖项添加到您的pom.xml中

<dependency>
    <groupId>io.cucumber</groupId>
    <artifactId>cucumber-weld</artifactId>
    <version>7.20.1</version>
    <scope>test</scope>
</dependency>

或者，如果您使用的是 Gradle，请添加

compile group: 'io.cucumber', name: 'cucumber-weld', version: '7.20.1'

目前还没有文档，但代码位于GitHub上。

要使用 Needle，请将以下依赖项添加到您的pom.xml中

<dependency>
    <groupId>io.cucumber</groupId>
    <artifactId>cucumber-needle</artifactId>
    <version>7.20.1</version>
    <scope>test</scope>
</dependency>

或者，如果您使用的是 Gradle，请添加

compile group: 'io.cucumber', name: 'cucumber-needle', version: '7.20.1'

目前还没有文档，但代码位于GitHub上。

在使用 DI 框架时，所有步骤定义、钩子、转换器等都将由框架实例注入器创建。

黄瓜示例测试通常很小，没有依赖项。但是，在现实生活中，测试通常需要访问特定于应用程序的对象实例，这些实例也需要由注入器提供。这些实例需要使您的步骤定义能够使用，以便可以对它们应用操作并测试传递的结果。

使用黄瓜与 DI 框架通常起源于被测应用程序也使用相同框架这一事实。因此，我们需要配置一个自定义注入器以与黄瓜一起使用。此注入器将测试和应用程序实例绑定在一起。

以下是如何使用Google Guice的典型步骤定义示例。使用黄瓜提供的 Guice 注入器将无法实例化必需的appService成员。

package com.example.app;

import static org.junit.Assert.assertTrue;

import io.cucumber.java.en.When;
import io.cucumber.java.en.Then;
import io.cucumber.guice.ScenarioScoped;
import com.example.app.service.AppService;
import java.util.Objects;
import javax.inject.Inject;

@ScenarioScoped
public final class StepDefinition {

    private final AppService appService;

    @Inject
    public StepDefinition( AppService appService ) {
        this.appService = Objects.requireNonNull( appService, "appService must not be null" );
    }

    @When("the application services are started")
    public void startServices() {
        this.appService.startServices();
    }

    @Then("all application services should be running")
    public void checkThatApplicationServicesAreRunning() {
        assertTrue( this.appService.servicesAreRunning() );
    }
}

AppService 的实现可能需要其他参数和配置，这些参数和配置通常需要由 Guice 模块提供。Guice 模块用于配置注入器，可能如下所示

package com.example.app.service.impl;

import com.example.app.service.AppService;
import com.google.inject.AbstractModule;

public final class ServiceModule extends AbstractModule {
    @Override
    protected void configure() {
        bind( AppService.class ).to( AppServiceImpl.class );
        // ... (further bindings)
    }
}

然后像这样创建实际的注入器：injector = Guice.createInjector( new ServiceModule() );

这意味着我们需要创建自己的注入器并告诉黄瓜使用它。

每当 Cucumber 需要特定对象时，它会使用对象工厂。Cucumber 拥有一个默认的对象工厂，该工厂（在使用 Guice 时）会创建一个默认的注入器并将对象创建委托给该注入器。如果您想自定义注入器，我们需要提供自己的对象工厂并告诉 Cucumber 使用它而不是默认的工厂。

package com.example.app;

import io.cucumber.core.backend.ObjectFactory;
import io.cucumber.guice.CucumberModules;
import io.cucumber.guice.ScenarioScope;
import com.example.app.service.impl.ServiceModule;
import com.google.inject.Guice;
import com.google.inject.Injector;
import com.google.inject.Stage;

public final class CustomObjectFactory implements ObjectFactory {

    private Injector injector;

    public CustomObjectFactory() {
        // Create an injector with our service module
        this.injector =
          Guice.createInjector( Stage.PRODUCTION, CucumberModules.createScenarioModule(), new ServiceModule());
    }

    @Override
    public boolean addClass( Class< ? > clazz ) {
        return true;
    }

    @Override
    public void start() {
        this.injector.getInstance( ScenarioScope.class ).enterScope();
    }

    @Override
    public void stop() {
        this.injector.getInstance( ScenarioScope.class ).exitScope();
    }

    @Override
    public < T > T getInstance( Class< T > clazz ) {
        return this.injector.getInstance( clazz );
    }
}

这是 Guice 的默认对象工厂，除了我们已将自己的绑定添加到注入器中。Cucumber 通过 java.util.ServiceLoader 加载对象工厂。为了让 ServiceLoader 能够获取我们的自定义实现，我们需要提供 META-INF/services/io.cucumber.core.backend.ObjectFactory 文件。

com.example.app.CustomObjectFactory
#
# ... additional custom object factories could be added here
#

现在，我们必须告诉 Cucumber 使用我们的自定义对象工厂。有几种方法可以实现这一点。

当从命令行运行 Cucumber 时，可以将自定义对象工厂指定为参数。

java io.cucumber.core.cli.Main --object-factory com.example.app.CustomObjectFactory

如果存在，Cucumber 会使用属性文件（cucumber.properties）。可以在此文件中指定自定义对象工厂，并在 Cucumber 运行时获取它。以下条目需要在 cucumber.properties 文件中可用

cucumber.object-factory=com.example.app.CustomObjectFactory

用于 JUnit 4 和 TestNG 的 Cucumber 模块允许通过 JUnit/TestNG 测试运行 Cucumber。可以使用 @CucumberOptions 注解配置自定义对象工厂。对于 JUnit 5，请参阅 cucumber-junit-platform-engine 文档。

Cucumber 在许多情况下会在事件总线上发出事件，例如：- 在功能文件解析过程中 - 当执行测试场景时

每个事件都具有 UUID 作为唯一标识符。可以使用 cucumber.uuid-generator 属性配置 UUID 生成器

| UUID 生成器 | 特性 | 性能 [百万 UUID/秒] | 典型使用示例 | |——————————————————-|————————————————————————————————————————————————————————————————————|————————————|——————————————————————————————————————————————————————————————————————————————————————————–| | io.cucumber.core.eventbus.RandomUuidGenerator |

• 线程安全
• 在单 JVM/多 JVM 中无冲突

• 线程安全
• 在同一个类加载器中无冲突
• 在不同的类加载器/JVM 中几乎无冲突
• 使用来自同一个类加载器的实例生成的 UUID 是可排序的

实际项目中的性能提升取决于功能大小。

如果未指定生成器，则使用 RandomUuidGenerator。

当 RandomUuidGenerator 和 IncrementingUuidGenerator 都无法满足项目需求时，可以定义自定义的 UUID 生成器。这可以通过以下方法完成

1. 创建 UUID 类生成器，例如：java package mypackage.mysubpackage; import io.cucumber.core.eventbus.UuidGenerator; public class MyUuidGenerator implements UuidGenerator { @Override public UUID generateId() { return ... } }
2. 使用文件 META-INF/services/io.cucumber.code.eventbus.UuidGenerator 将 UUID 生成器定义为 SPI，该文件位于类路径上（例如 Maven resources 目录），其中包含生成器类名称：java mypackage.mysubpackage.MyUuidGenerator

此 UUID 生成器将覆盖默认的 RandomUuidGenerator。

当 META-INF/services/... 文件包含多个 UUID 生成器，或者当类路径上有多个 META-INF/services/... 文件时，必须配置 cucumber.uuid-generator 属性以选择所需的生成器。

请参阅 Cucumber-JVM 中的 spring-java-junit5 示例，了解最小设置。