Guice用逻辑辅助注入工厂

Question

我一直在用guice做一个项目。

我有一个抽象类，它有很多实现。为了使用正确的实现，我使用一个工厂，它接收参数，然后返回正确的实例。

演示代码

@Singleton
public class MyFactory {

    private final Foo foo;

    @Inject
    public MyFactory(final Foo foo) {
        this.foo = foo;
    }

    public A create(final Bar bar) {
        switch (bar) {
            case 0:
                return new B(foo, bar);
            case 1:
                return new C(foo, bar);
            //this goes on
        }
    }
}

public abstract A {
    public A(final Bar bar) {
        //do sth
    }
}

public B extends A {
    private final Foo foo;

    public B(final Foo foo, final Bar bar) {
        super(bar);
        this.foo = foo;
    }
}

public C extends A {
    private final Foo foo;

    public C(final Foo foo, final Bar bar) {
        super(bar);
        this.foo = foo;
    }
}

我想知道的是，如果我可以用Guice替换工厂，直接注入A的实现（请注意，它们应该使用辅助注入）？

谢谢你。

Answer 1

您仍然需要My被害人根据您的id选择实现，尽管您的辅助注入可能非常短。

// No need for this to be @Singleton;
// if you want the same shared Foo instance, make it @Singleton
public class MyFactory {

    private final B.Factory bFactory;
    private final C.Factory cFactory;

    @Inject
    public MyFactory(B.Factory bFactory, C.Factory cFactory) {
        this.bFactory = bFactory;
        this.cFactory = cFactory;
    }

    public A create(final Bar bar) {
        switch (bar.getSomeInteger()) {   // I assume you're checking a
                                          // property of bar
            case 0:
                return bFactory.create(bar);
            case 1:
                return cFactory.create(bar);
            //this goes on
        }
    }
}

public B extends A {
    public interface Factory {
        B create(Bar bar);
    }

    private final Foo foo;

    public B(final Foo foo, @Assisted final Bar bar) {
        super(bar);
        this.foo = foo;
    }
}

public C extends A {
    public interface Factory {
        C create(Bar bar);
    }

    private final Foo foo;

    public C(final Foo foo, @Assisted final Bar bar) {
        super(bar);
        this.foo = foo;
    }
}

以及您的模块：

public class YourModule extends AbstractModule {
  @Override public void configure() {
    install(new FactoryModuleBuilder().build(B.Factory.class));
    install(new FactoryModuleBuilder().build(C.Factory.class));
  }
}

编辑:在我的示例中，您不需要调用FactoryModuleBuilder上的< code>implement,因为< code>B.Factory有一个返回子类B的< code>create方法。那么您将需要< code>implement调用，因为Guice不知道要调用哪个构造函数。

如果您想强制消费者对实现进行编码，您可能需要引用只返回接口的工厂。这通常是一个隐藏实现细节的好主意，可能需要创建＜code＞a。工厂使用方法A创建（条形码）并将其与实现>连接。然而，这在这里是不必要的，因为您的MyFactory已经返回了A并隐藏了实现子类（与＜code＞A.Factory＜/code＞的逻辑类似），并且您需要＜code＞@Named＜/code＞或其他限定符注释来区分这两个＜code＞A。您正在创建的工厂绑定。简言之，这是额外的复杂性，对这个特定的案例没有好处。