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

所以，现在我想注入一个map，包含< i>Factory

因此，我使用配置方法创建了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>>(){});
        }

所以，我注入它@注入公共地图

    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不能“读取”泛型中类型参数的值；新TypeLit的

当您遇到与擦除相关的问题时，经常会遇到这种情况，技巧是添加一个表示您想要的类型的运行时值。在这种情况下，这尤其棘手，因为您想要做的是将一个类型参数的值表示为一个更大的类型。

有几种方法可以获得表示静态类型的运行时值。< code>TypeToken是一个，而< code>Class是另一个，但是它们都不允许您用参数表示类型，然后以编程方式填充该值。幸运的是，Google Guava包含另一种表示方式，< code > com . Google . common . reflect . type token ，它将为我们工作。< code>TypeToken可以用变量表示类型，并支持以编程方式用具体表示形式“填充”该变量，例如:

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

表示类型＜code＞列表

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

一切都将按预期工作。

不过，这是非常奇特的东西，理解它取决于很好地理解类型的编译时和运行时表示之间的区别。如果是我，我不会这样做，如果你只希望使用一次或两次，因为混淆负担相当高；如果这是一个库的一部分或者什么的话，我才会这么做，这样你就可以为每个呼叫者节省一些工作。