0

我对谷歌 guice 很陌生。

我正在编写一个 nexus 插件，其中 nexus 注入了一些类。例如说要在 A 类中注入的类。

现在在注入 A 类之前，我有另一个被实例化的B 类，并且在其中我有一个方法，其中初始化了一个对象（比如 obj）。

我必须将这个初始化的对象传递给 A 类。

通常，如果实例化在我们的控制之下，我会这样做

A a = new A();

A.setObject(obj);

但是现在考虑到该类将由系统注入，我不知道如何将这个初始化的对象传递给这个类 A。

4

1 回答 1

1

如果我理解正确，你有类似的东西

public class C {
}

public class A {
    private C c;

    public void setC(C c) {
        this.c = c;
    }
}

public class B {
    private final C c;

    public B() {
        this.c = new C();
    }

    public C getC() {
        return this.c;
    }
}

public class Main {
    public static void main(String[] args) {
        B b = new B();
        A a = new A();

        C c = b.getC();
        a.setC(c);
    }
}

这种设计不遵循 DI 原则，应该重构。您应该让 Guice 创建您的C实例。在这种情况下，您将拥有类似的东西

public class C {
}

public class A {
    private final C c;

    @Inject
    A(C c) {
        this.c = c;
    }
}

public class B {
    private final C c;

    @Inject
    B(C c) {
        this.c = c;
    }
}

public class Main {
    public static void main(String[] args) {
        Injector injector = Guice.createInjector();
        A a = injector.getInstance(A.class);
        B b = injector.getInstance(B.class);
    }
}

在这里，您已经C自动注入A和B。

如果您真的无法重构代码，请考虑使用提供程序：

public class AProvider extends Provider<A> {
    private final B b;

    @Inject
    AProvider(B b) {
        this.b = b;
    }

    @Override
    public A get() {
        A a = new A();
        C c = b.getC();
        a.setC(c);
        // Or, better
        // A a = new A(b.getC());
        return a;
    }
}

public class Main {
    public static void main(String[] args) {
        Injector injector = Guice.createInjector(new AbstractModule() {
            @Override
            protected void configure() {
                bind(A.class).toProvider(AProvider.class);
            }
        });
        A a = injector.getInstance(A.class);
    }
}

在这种情况下，提供者用于创建A和设置其C依赖项。

但有时即使这样还不够（例如，当您的B.getC()行为取决于用户输入时）。在这种情况下，您必须使用辅助注入扩展：

public interface AFactory {
    public A create(C c);
}

public class A {
    private final C c;
    private final Other other;

    @Inject
    A(@Assisted C c, Other other) {
        this.c = c;
        this.other = other;
    }
}

public class Main {
    public static void main(String[] args) {
        Injector injector = Guice.createInjector(new AbstractModule() {
            @Inject
            protected void configure() {
                install(new FactoryModuleBuilder()
                    .build(AFactory.class));
            }
        });

        B b = injector.getInstance(B.class);
        C c = b.getC(someUserInput);
        AFactory af = injector.getInstance(AFactory.class);
        A a = af.create(c);
    }
}

A在最后一个示例中，将通过调用注入两个对象af.create(c)：首先，c您提供的对象，其次Other是由 Guice 自动解析的类的实例。换句话说，辅助注入允许您实例化类，这些类的一部分依赖关系由您解决，另一部分由 Guice 解决。

于 2013-09-05T18:22:43.937 回答