java - Guice:绑定(bind)具有不同依赖关系的多个对象

Question

我有以下使用 Guice 绑定(bind)的代码:

public class MyApplication {
    public static void main(String[] args) {
        Guice.createInjector(new AbstractModule() {
            @Override
            protected void configure() {
                bind(Foo.class).annotatedWith(Names.named("first")).toInstance(new Foo("firstFoo"));
                bind(Foo.class).annotatedWith(Names.named("second")).toInstance(new Foo("secondFoo"));

                bind(Bar.class).to(BarImpl.class);

                bind(MyApplication.class).asEagerSingleton();
            }
        });
    }

    private @Named("first") Bar first;
    private @Named("second") Bar second;

    static @Value class Foo { String name; }
    static interface Bar {}

    static class BarImpl implements Bar {
        @Inject @Named Foo foo;
    }
}

我正在尝试为我的应用程序中注入(inject)的两个名为 Foo 的对象获取一个 Bar 对象。基本上，它应该以某种方式将 Foo 上的 @Named 与 Bar 上的连接起来。我尝试了几种解决方案，从将 @Named 放在所有内容上到编写自定义 Provider。后者不起作用，因为我无权访问提供程序内的 @Named 注释的值。我认为解决方案在 bind(Bar.class).to(BarImpl.class); 行中的某处，告诉它记住 @Named 注释的值。

我的问题是，这是否可能，如果可能，如何实现？

Answer 1

它正在使用 PrivateModules .基本上:

默认情况下，私有(private)模块的配置信息对其环境是隐藏的。只有显式公开的绑定(bind)才可用于其他模块和注入(inject)器的用户。有关更多说明，请参阅 this FAQ entry .

以下是您将如何使用它:

protected void configure() {
    install(new PrivateModule() {
        @Override
        protected void configure() {
            // #bind makes bindings internal to this module unlike using AbstractModule
            // this binding only applies to bindings inside this module
            bind(Foo.class).toInstance(new Foo("first"));
            // Bar's foo dependency will use the preceding binding
            bind(Bar.class).annotatedWith(Names.named("first")).to(BarImpl.class);
            // if we'd stop here, this would be useless
            // but the key method here is #expose
            // it makes a binding visible outside as if we did AbstractModule#bind
            // but the binding that is exposed can use "private" bindings
            // in addition to the inherited bindings              
            expose(Bar.class).annotatedWith(Names.named("first"));
        }
    });
    install(new PrivateModule() {
        @Override
        protected void configure() {
            bind(Foo.class).toInstance(new Foo("second"));
            bind(Bar.class).annotatedWith(Names.named("second")).to(BarImpl.class);
            expose(Bar.class).annotatedWith(Names.named("second"));
        }
    });
         bind(MyApplication.class).asEagerSingleton();
    }
}

现在你实际上有 2 个 Bars，每个看起来像

static class BarImpl implements Bar {
    @Inject Foo foo;
}

但借助 PrivateModules 的强大功能，具有针对相同依赖项的不同实现。

希望它有意义。