java - Guice 可以根据一个参数自动创建不同类的实例吗？

Question

一个标准的对象工厂可能是这样的:

interface I { ... }
class A implements I { ... }
class B implements I { ... }

class IFactory {
    I getI(int i) {
        switch (i) {
        case 1: return new A();
        default: return new B();
        }
    }
}

是否可以设置绑定(bind)以便为我完成切换，即我所做的只是调用 getInstance 或注入(inject)？我在看辅助注入(inject)，但这似乎是不同的主题:https://code.google.com/p/google-guice/wiki/AssistedInject

Answer 1

听起来您正在寻找 MapBinder , 这是 Multibindings 的一部分特征。请注意，您仍然需要输入某种类型的 IFactory或其他工厂接口(interface)，因为getInstance不像你的getI那样接受参数确实如此，您仍然需要在某处建立从整数到类实现的映射。

MapBinder 风格

class IModule extends AbstractModule {
  @Override public void configure() {
    MapBinder<Integer, I> myBinder =
        MapBinder.newMapBinder(binder(), Integer.class, I.class);
    myBinder.addBinding(1).to(A.class);
    // Add more here.
  }
}

// You can even split the MapBinding across Modules, if you'd like.
class SomeOtherModule extends AbstractModule {
  @Override public void configure() {
    // MapBinder.newMapBinder does not complain about duplicate bindings
    // as long as the keys are different.
    MapBinder<Integer, I> myBinder =
        MapBinder.newMapBinder(binder(), Integer.class, I.class);
    myBinder.addBinding(3).to(C.class);
    myBinder.addBinding(4).to(D.class);
  }
}

配置了这些模块的注入(inject)器将提供可注入(inject)的 Map<Integer, I>具有所有绑定(bind)的实例；在这里它将是一个从 1 到完全注入(inject)的三项映射 A例如，从 3 到 C例如，从 4 到 D实例。这实际上是对使用 new 的开关示例的改进。关键字，因此没有将任何依赖项注入(inject) A或 B .

为了更好的选择，不会产生如此多的浪费实例，请注入(inject) Map<Integer, Provider<I>> MapBinder 也会自动提供。像这样使用它:

class YourConsumer {
  @Inject Map<Integer, Provider<I>> iMap;

  public void yourMethod(int iIndex) {
    // get an I implementor
    I i = iMap.get(iIndex).get();
    // ...
  }
}

不过，要按照您的方式提供“默认”实现(和不透明接口(interface))，您需要在 MapBinder 之上实现自己的短包装器 map :

class IFactory {
  @Inject Map<Integer, Provider<I>> iMap;
  @Inject Provider<B> defaultI; // Bound automatically for every Guice key

  I getI(int i) {
    return iMap.containsKey(i) ? iMap.get(i).get() : defaultI.get();
  }
}

更简单，工厂风格

如果以上看起来有点矫枉过正，请记住您可以 inject an Injector 并创建一个本地 Map从关键到实现。 (您也可以像我在这里一样使用 ImmutableMap )。

class IFactory {
  @Inject Injector injector; // This is a bad idea, except for times like this
  @Inject Provider<B> defaultI;
  static final ImmutableMap<Integer, Class<? extends I>> map = ImmutableMap.of(
      1, A.class,
      3, C.class,
      4, D.class);

  I getI(int i) {
    return map.containsKey(i)
        ? injector.getInstance(map.get(i))
        : defaultI.get();
  }
}