GUICE辅助注射+多重结合+仿制药

Question

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

首先，这是泛型的小层次结构(在生产情况下有 N 个实体的层次结构)：

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

接下来，我想通过工厂创建的类ToCreate1和ToCreate2。

基类：

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<Type1> 和Factory<Type2>分别创建 ToInject1 和ToInject2。

因此，我使用配置方法创建了Guice的抽象模块：

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

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

@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>>(){}));
}

而且它不起作用！吉斯 说：

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 无法在泛型中"读取"类型参数的值; 无论调用方使用什么V实例化，new TypeLiteral<Factory<V>>(){}始终是相同的值。

与遇到与擦除相关的问题时经常出现的情况一样，诀窍是添加一个表示所需类型的运行时值。在这种情况下，这尤其棘手，因为您要做的是将类型参数的值表示为更大的类型。

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

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);

一切都会按预期工作。

不过，这是非常花哨的东西，理解它取决于对类型的编译时和运行时表示之间的区别有很好的理解。如果是我，如果你只期望使用一两次，我不会这样做，因为混乱负担相当高;只有当这是库或其他东西的一部分时，我才会这样做，您可以为每个调用者节省一些工作。