Guice 代理以支持循环依赖

Question

我在启动时在代码中收到以下错误：

尝试代理 com.bar.Foo 以支持循环依赖项，但它是 不是接口。

这种代理究竟是如何工作的？如果我只是在接口后面扔了足够的类，一切都会好起来吗？

(我知道循环依赖通常是一种代码气味，但我认为在这种情况下没关系。

Answer 1

虽然"注入接口"方法是完全有效的，在某些情况下甚至可能是更好的解决方案，但通常，您可以使用更简单的解决方案：提供程序。

对于"A"类，guice还可以管理，guice还提供"Provider<A>"。这是javax.inject.Provider-interface的内部实现，其get()消息将"return injector.getInstance(A.class)"。您不必自己实现接口，它是"guice magic"的一部分。

因此，您可以将 A->B、B-A 示例缩短为：

public class CircularDepTest {
static class A {
    private final Provider<B> b;
    private String name = "A";
    @Inject
    public A(Provider<B> b) {
        this.b = b;
    }
}
static class B {
    private final Provider<A> a;
    private String name = "B";
    @Inject
    public B(Provider<A> a) {
        this.a = a;
    }
}
@Inject
A a;
@Inject
B b;
@Before
public void setUp() {
    Guice.createInjector().injectMembers(this);
}

@Test
public void testCircularInjection() throws Exception {
    assertEquals("A", a.name);
    assertEquals("B", a.b.get().name);
    assertEquals("B", b.name);
    assertEquals("A", b.a.get().name);
}}

我更喜欢这个，因为它更具可读性(你不会被愚弄相信构造函数已经拥有"B"的实例(，并且由于你可以自己实现提供程序，它仍然可以"手动"工作，在guice上下文之外(例如测试(。

Answer 2

我对这个概念很陌生，但这是我的理解。

假设你有接口A和B，以及实现Ai和Bi。

如果Ai依赖于B，而Bi依赖于A，那么Guice可以创建一个A的代理实现(称之为Ap(，它将在将来的某个时候被赋予一个委托Ai。 Guice 将这个Ap交给Bi，因为它依赖于A，允许Bi完成实例化。 然后，由于Bi已被实例化，Guice 可以使用 Bi 实例化Ai。 然后，既然Ai现在可以做，Guice 告诉Ap委派给Ai。

如果A和B不是接口(你只有Ai和Bi(，这是不可能的，因为创建Ap需要你扩展Ai，这已经需要一个Bi。

下面是

代码的外观：

public interface A {
    void doA();
}
public interface B {
    void doB();
}
public class Ai implements A {
   private final B b;
   @Inject
   public Ai(B b) {
       this.b = b;
   }
   public void doA() {
       b.doB();
   }
}
public class Bi implements B {
   private final A a;
   @Inject
   public Bi(A a) {
       this.a = a;
   }
   public void doB() {
   }
}

Guice 创建的代理类如下所示：

public class Ap implements A {
    private A delegate;
    void setDelegate(A a) {
        delegate = a;
    }
    public void doA() {
        delegate.doA();
    }
}

这一切都将使用以下基本思想进行连接：

Ap proxyA = new Ap();
B b = new B(proxyA);
A a = new A(b);
proxyA.setDelegate(a);

这就是如果你只有Ai和Bi，没有接口A和B会是什么样子。

public class Ap extends Ai {
    private Ai delegate;
    public Ap() {
       super(_); //a B is required here, but we can't give one!
    }
}

如果我只是在接口后面扔了足够的类，一切都会好起来吗？

我猜想在构造函数中如何与代理交互有严格的限制。 换句话说，如果 B 试图在 Guice 有机会用真正的 A 填充 A 的代理之前调用 A，那么我期望出现 RuntimeException。

Answer 3

以下是@jan-galinski的答案，在Scala中重做：

import javax.inject.Inject
import com.google.inject.{Guice, Injector, Provider}
import net.codingwell.scalaguice.InjectorExtensions._
/** Demonstrates the problem by failing with `Tried proxying CircularDep1$A to support a circular dependency, but it is not an interface.
  while locating CircularDep1$A for parameter 0 at CircularDep1$B.<init>(CircularDep.scala:10)
  while locating CircularDep1$B for parameter 0 at CircularDep1$A.<init>(CircularDep.scala:6)
  while locating CircularDep1$A` */
object CircularDep1 extends App {
  class A @Inject() (val b: B) {
    val name = "A"
  }
  class B @Inject() (val a: A) {
    val name = "B"
  }
  val injector: Injector = Guice.createInjector()
  val a: A = injector.instance[A]
  val b: B = injector.instance[B]
  assert("A" == a.name)
  assert("B" == a.b.name)
  assert("B" == b.name)
  assert("A" == b.a.name)
  println("This program won't run!")
}
/** This version solves the problem by using `Provider`s */
object CircularDep2 extends App {
  class A @Inject() (val b: Provider[B]) {
    val name = "A"
  }
  class B @Inject() (val a: Provider[A]) {
    val name = "B"
  }
  val injector: Injector = Guice.createInjector()
  val a: A = injector.instance[A]
  val b: B = injector.instance[B]
  assert("A" == a.name)
  assert("B" == a.b.get.name)
  assert("B" == b.name)
  assert("A" == b.a.get.name)
  println("Yes, this program works!")
}