java - Guice、FactoryModuleBuilder、多个实现和泛型

Question

我正在使用 Guice 和 FactoryModuleBuilder。通常，只需定义一个工厂接口(interface)就足够了，Guice 会自动注入(inject)实现。

但是，我正在努力的部分是工厂中的方法使用泛型。假设我有以下内容。由接口(interface)定义的构造实例的基本类型。

interface Foo<T> {
    T get();
}

以及由下面两个类定义的 Foo 接口(interface)的两个实现。

class FooA<T> implements Foo<T> {
    @Inject
    FooA(@Assisted Class<T> clazz, @Assisted String s) {...}
}

class FooB<T> implements Foo<T> {
    @Inject
    FooB(@Assisted Class<T> clazz, @Assisted Integer i) {...}
}

然后我有如下定义的工厂接口(interface)，使用两个允许我使用多个实现的自定义绑定(bind)注释。

interface FooFactory {
    @A Foo<T> build(Class<T> clazz, String s);
    @B Foo<T> build(Class<T> clazz, Integer i);
}

我已经尝试了多种可能的解决方案，但到目前为止，除了一个以外，其他的都行得通。有效的解决方案基本上是编写我自己的 FooFactory 实现，如下所示。并在模块的configure方法中，将接口(interface)绑定(bind)到实现； 绑定(bind)(FooFactory.class).to(FooFactoryImpl.class);

class FooFactoryImpl {
    Foo<T> build(Class<T> clazz, String s) {
        return new FooA(clazz, s):
    }
    Foo<T> build(Class<T> clazz, Integer i) {
        return new FooB(clazz, i);
    }
}

但是，我对这个解决方案有一个问题。这些实例不是由 Guice 创建的，因此我失去了 Guice 附带的空检查。这与我的其他没有这个问题的工厂截然不同。这意味着我必须为 Foo 的每个实现显式编写 null 检查。我想避免这种情况。

以下是我尝试过的一些解决方案。

解决方案一:

FactoryModuleBuilder fmb = new FactoryModuleBuilder()
    .implement(Foo.class, A.class, FooA.class)
    .implement(Foo.class, B.class, FooB.class);
install(fmb.build(FooFactory.class));

解决方案 2:

FactoryModuleBuilder fmb = new FactoryModuleBuilder()
    .implement(TypeLiteral.get(Foo.class), A.class, TypeLiteral.get(FooA.class))
    .implement(TypeLiteral.get(Foo.class), B.class, TypeLiteral.get(FooB.class));
install(fmb.build(TypeLiteral.get(FooFactory.class)));

示例代码位于 GitHub。 (如果有人感兴趣的话)。

Answer 1

据我所知，您无法将 AssistedInject 工厂设计为以这种方式工作。但是，在我看来你在一节课上做得太多了。因为你对Class<T>没有限制，很明显您在构造函数中没有使用此类的任何方法，这意味着，将行为重构到单独的类中应该相当容易。我知道这是一些样板文件，并不是您想要的，但它可能看起来像这样:

interface FooDataFactory {
    @A FooData build(String s);
    @B FooData build(Integer i);
}

public class FooA<T> implements Foo<T> {
    public FooA(FooData data) {
        // You should know what class you need when you're actually calling the constructor.
        // This way you don't even need to pass around Class<T> instances
    }
}

如果此方法不适用于您的用例，请告诉我，我会进行编辑以进行补偿。