java - 具有逻辑的 Guice AssistedInjection Factory

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 替换工厂来直接注入(inject) A 的实现(请注意，它们应该使用辅助注入(inject))？

谢谢。

Answer 1

You will still need MyFactory根据您的 id 选择实现，但 your assisted injection can be very short .

// 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上的implement，因为B.Factory 有一个返回子类 B 的 create 方法。如果您希望该方法返回父类(super class) A，隐藏具体类型，您可以这样做；那么你需要 implement 调用，因为 Guice 不知道要尝试调用哪个构造函数。

如果您想强制使用者编写实现代码，您可能需要引用仅返回接口(interface)的工厂。隐藏实现细节通常是一个好主意，并且可能涉及使用方法 A create(Bar bar) 创建 A.Factory并用implement将其连接起来。但是，这里是不必要的，因为您的 MyFactory 已经返回 A 并隐藏了实现子类(就像带有逻辑的 A.Factory 一样)，并且因为您需要 @ Named 或其他一些限定符注释来区分您正在创建的两个 A.Factory 绑定(bind)。简而言之，这会带来额外的复杂性，对于这种特定情况没有任何好处。