guice 辅助注入 + 多绑定 + 泛型

Question

我正在尝试结合 Guice 的这 3 个功能：注入、多重绑定、泛型。我创建了一个生产项目的原型，所以这里是：

首先，这是泛型的一个小层次结构（在生产案例中有 N 个实体的层次结构）：

    public interface Type {
    }
    public class Type1 implements Type{
    }
    public class Type2 implements Type {
    }

接下来，classes ToCreate1 和 ToCreate2 我想通过 Factory[=54 创建=].

基础class:

public abstract class AbstractToCreate<T extends Type> { public T type; public Integer param; public AbstractToCreate(T type, Integer param){ this.type = type; this.param = param; } }

继承人：

public class ToCreate1 extends AbstractToCreate<Type1>{ @Inject public ToCreate1(Type1 type, @Assisted Integer param) { super(type, param); } } public class ToCreate2 extends AbstractToCreate<Type2> { @Inject public ToCreate2(Type2 type, @Assisted Integer param) { super(type, param); } }

然后，工厂本身：

public interface Factory<T extends Type> { AbstractToCreate<T> create(Integer param); }

所以，现在我想注入一个映射，包含 Factory 和 Factory 以创建 ToInject1 和 ToInject2 分别。

因此，我使用配置方法创建了 Guice 的 AbstractModule：

protected void configure() { install(new FactoryModuleBuilder() .implement(new TypeLiteral<AbstractToCreate<Type1>>(){}, ToCreate1.class) .build(new TypeLiteral<Factory<Type1>>(){})); install(new FactoryModuleBuilder() .implement(new TypeLiteral<AbstractToCreate<Type2>>(){}, ToCreate2.class) .build(new TypeLiteral<Factory<Type2>>(){})); MapBinder<String, Factory> mapBinder = MapBinder.newMapBinder(binder(), String.class, Factory.class); mapBinder.addBinding("type1").to(new TypeLiteral<Factory<Type1>>(){}); mapBinder.addBinding("type2").to(new TypeLiteral<Factory<Type2>>(){}); }

所以，我注入它 @Inject public Map<String, Factory> map; 一切正常：

Factory<Type1> factory1 = main.map.get("type1"); Factory<Type2> factory2 = main.map.get("type2"); AbstractToCreate<Type1> create1 = factory1.create(1);//create1 is ToCreate1 instance AbstractToCreate<Type2> create2 = factory2.create(2);//create2 is ToCreate2 instance

正如我之前提到的，我的生产系统中有更多的类型，所以 AbstractModule 变得太麻烦了。我试图避免重复代码并修改了 configure 方法：

@Override protected void configure() { this.<Type1>inst(ToCreate1.class); this.<Type2>inst(ToCreate2.class); } private <V extends Type> void inst(Class<? extends AbstractToCreate<V>> clazz) { install(new FactoryModuleBuilder() .implement(new TypeLiteral<AbstractToCreate<V>>(){}, clazz) .build(new TypeLiteral<Factory<V>>(){})); }

而且它不起作用！ Guice 说：

1) ru.test.genericassistedinject.AbstractToCreate<V> cannot be used as a key; It is not fully specified.

怎么了？

Answer 1

这里的问题是类型擦除。特别是这段代码：

private <V extends Type> void inst(Class<? extends AbstractToCreate<V>> clazz) {
    install(new FactoryModuleBuilder()
            .implement(new TypeLiteral<AbstractToCreate<V>>(){}, clazz)
            .build(new TypeLiteral<Factory<V>>(){}));
}

无法工作，因为它依赖类型参数 V 来帮助做出运行时间决定（使用什么绑定），但是类型参数 V 没有运行时间表示，所以它的值永远不会直接影响运行时间。另一种思考方式：Java 不能 "read" 泛型中的类型参数值； new TypeLiteral<Factory<V>>(){} 始终是相同的值，无论在调用者中实例化 V 是什么。

当您运行遇到与擦除相关的问题时通常会出现这种情况，诀窍是添加一个运行time 值来表示您想要的类型。在这种情况下，这特别棘手，因为您要做的是将类型参数的值表示为更大的类型。

有几种方法可以获取运行表示静态类型的时间值。 TypeToken 是一个，Class 是另一个，但它们都不允许您用参数表示类型，然后以编程方式填充该值。幸运的是，Google Guava 包含另一种表示形式，com.google.common.reflect.TypeToken，它对我们有用。 TypeTokens 可以表示具有变量的类型并以编程方式支持 "filling in" 具有具体表示的变量，例如：

new TypeToken<List<V>>() {}.where(new TypeParameter<V>() {}, Integer.class)

表示运行时的类型List<Integer>。

使用 TypeToken 我们可以构建我们的类型，如下所示：

 private <V extends Type> void inst(Class<? extends AbstractToCreate<V>> clazz, Class<V> binding) {
    TypeToken<AbstractToCreate<V>> implementationType = new TypeToken<AbstractToCreate<V>>() {}
        .where(new TypeParameter<V>() {}, binding);
    TypeToken<Factory<V>> factoryType = new TypeToken<Factory<V>>() {}
        .where(new TypeParameter<V>() {}, binding);

    @SuppressWarnings("unchecked")  // The type returned by TypeToken::getType is always the type it represents
    Key<AbstractToCreate<V>> key = (Key<AbstractToCreate<V>>) Key.get(implementationType.getType());
    @SuppressWarnings("unchecked")  // as above
    Key<Factory<V>> factoryKey = (Key<Factory<V>>) Key.get(factoryType.getType());

    install(
        new FactoryModuleBuilder()
            .implement(key, clazz)
            .build(factoryKey));
  }

现在我们可以通过以下方式调用 inst：

inst(ToCreate1.class, Type1.class);
inst(ToCreate2.class, Type2.class);

一切都会如愿以偿。

不过，这是非常奇特的东西，理解它取决于对类型的编译时表示和运行时表示之间的区别有很好的理解。如果是我，如果你只希望使用一次或两次，我不会这样做，因为混淆负担非常高；如果这是图书馆或其他东西的一部分，我只会这样做，你可以为每个来电者节省一些工作。

guice 辅助注入 + 多绑定 + 泛型

guice assisted inject + multibinding + generics

java

generics

guice

multibinding

assisted-inject