Java 带Guice的黄瓜-多Guice注射器

我正在使用

Cucumber

和

Guice

作为DI。 我遇到了以下问题： 我有一个步骤，即

class MyStep() {

    @Inject
    private MyService myService;

    @Given("Some acction happen")
    public void sthHappen() {
        myService.doSth();
    }
}

我让这个类作为

JUnit

test运行它

@RunWith(Cucumber.class)
@CucumberOptions(...)
public class MyTest {

}

有一个

class MyModule extends AbstractModule {
    @Override
    protected void configure() {
         bind(MyService.class).to(MyFirstService.class);     
    }
}

my

MyInjectorSource使用的
我定义cucumber.properties，其中我定义
guice.injector source=MyInjectorSource
还有一个包含场景的功能文件。
现在一切正常

不，我想用其他MyService实现运行MyStep步骤（当然我不想重复MyStep的代码）
我用新的场景和新的测试类定义了一个新的特性文件

@RunWith(Cucumber.class)
@CucumberOptions(...)
public class MyOtherTest {

}

现在我尝试创建另一个
InjectorSource
，但无法对其进行配置。
我找到的解决方案是使用自定义Junit4 runner继承原始Cucumber runner并更改其
createRuntime
方法

最新的cucumber guice 1.2.5使用了几个阶段来创建注入器，不幸的是，它使用了全局变量cucumber.runtime.Env.INSTANCE
。此变量由
cucumber.properties
和
System.getProperties
填充

流量为：


Cucumber runner扫描可用的后端（在我的设置中是
Cucumber.runtime.java.JavaBackend
）
一个JavaBackend构造函数加载可用的
ObjectFactory
（在我的设置中是cucumber.runtime.java.guice.impl.GuiceFactory）
GuiceFactory通过InjectorSourceFactory检查
Env.INSTANCE
，它将创建自定义
InjectorSource
或默认注入器

理想情况下，cucumber应该将其在开始时创建的“RuntimeOptions”传递给后端和InjectorSource，但不幸的是，它没有这样做，并且使用全局变量。创建像这样的补丁并不容易，所以我的解决方案简化了这种方法，并通过阅读新注释直接在CustomRunner中创建InjectorSource

public class GuiceCucumberRunner extends Cucumber {

    public GuiceCucumberRunner(Class<?> clazz) throws InitializationError, IOException {
        super(clazz);
    }

    @Override
    protected Runtime createRuntime(ResourceLoader resourceLoader, ClassLoader classLoader, RuntimeOptions runtimeOptions) throws InitializationError, IOException {
        Runtime result = new Runtime(resourceLoader, classLoader, Arrays.asList(createGuiceBackend()), runtimeOptions);
        return result;
    }

    private JavaBackend createGuiceBackend() {
        GuiceCucumberOptions guiceCucumberOptions = getGuiceCucumberOptions(); 
        InjectorSource injectorSource = createInjectorSource(guiceCucumberOptions.injectorSource());
        ObjectFactory objectFactory = new GuiceFactory(injectorSource.getInjector());
        JavaBackend result = new JavaBackend(objectFactory);
        return result;
    }

    private GuiceCucumberOptions getGuiceCucumberOptions() {
        GuiceCucumberOptions guiceCucumberOptions = getTestClass().getJavaClass().getAnnotation(GuiceCucumberOptions.class);
        if (guiceCucumberOptions == null) {
            String message = format("Suite class ''{0}'' is missing annotation GuiceCucumberOptions", getTestClass().getJavaClass());
            throw new CucumberException(message);
        }
        return guiceCucumberOptions;
    }

    private InjectorSource createInjectorSource(Class<? extends InjectorSource> clazz) {
        try {
            return clazz.newInstance();
        } catch (Exception e) {
            String message = format("Instantiation of ''{0}'' failed. InjectorSource must have has a public zero args constructor.", clazz);
            throw new InjectorSourceInstantiationFailed(message, e);
        }
    }

    static class GuiceFactory implements ObjectFactory {

        private final Injector injector;

        GuiceFactory(Injector injector) {
            this.injector = injector;
        }

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

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

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

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

 @Retention(RetentionPolicy.RUNTIME)
 @Target({ ElementType.TYPE })
 public @interface GuiceCucumberOptions {

     Class<? extends InjectorSource> injectorSource();

 }

@RunWith(GuiceCucumberRunner.class)
@GuiceCucumberOptions(injectorSource = MyInjector.class)
@CucumberOptions(
        ...
)
public class Suite {

}

公共类guiceCumberRunner扩展{
公共GuiceCumberRunner（类clazz）引发初始化错误，IOException{
超级（clazz）；
}
@凌驾
受保护的运行时createRuntime（ResourceLoader ResourceLoader，ClassLoader ClassLoader，RuntimeOptions RuntimeOptions）引发初始化错误，IOException{
运行时结果=新运行时（resourceLoader、classLoader、Arrays.asList（createGuiceBackend（））、运行时选项）；
返回结果；
}
私有JavaBackend createGuiceBackend（）{
GuiceCumberOptions GuiceCumberOptions=GetGuiceCumberOptions（）；
InjectorSource InjectorSource=createInjectorSource（guiceCumberOptions.InjectorSource（））；
ObjectFactory ObjectFactory=new-GuiceFactory（injectorSource.getInjector（））；
JavaBackend结果=新的JavaBackend（objectFactory）；
返回结果；
}
私有GuiceCumberOptions GetGuiceCumberOptions（）{
GuiceCumberOptions GuiceCumberOptions=getTestClass（）.getJavaClass（）.getAnnotation（GuiceCumberOptions.class）；
if（guiceCumberOptions==null）{
字符串消息=格式（“套件类“{0}”缺少注释GuiceCumberOptions”，getTestClass（）.getJavaClass（））；
抛出新黄瓜异常（消息）；
}
返回guicecumberOptions；
}
私有InjectorSource createInjectorSource（类）如果将“@Inject”注释放置在“@Before”钩子中会怎么样？可以根据标记创建不同的“@Before”钩子，例如“@Before”（“@tag1”）和“@Before”（“@tag2”）。每个钩子都有不同的“@Inject”定义。如何在注释中转义“@”？