Guice中带有辅助注入的循环依赖关系

Question

我在用Guice辅助注射。下面是一个标准场景：

Class TargetType {

   @Inject
   TargetType(@Assisted Param1 assistedParam, InjectedType injectedType) 
   {
      /* ... */
   }
}

Class InjectedType {

   @Inject
   injectedType(OtherInjectedType otherInjectedType) 
   {
      /* ... */
   }
}

现在，我可以使用Guice factory调用TargetTypeFactory.Create(assistedArg/*instanceof Param1*/)，并通过Guice注入的InjectedType实例轻松获得我的TargetType实例。

我的问题是：如果我希望InjectedType引用正在创建的TargetType的实例，该怎么办？换句话说，我想要：

Class TargetType {

   @Inject
   TargetType(@Assisted Param1 assistedParam, InjectedType injectedType) 
   {

   }
}

Class InjectedType {

   @Inject
   injectedType(/* How to get this? -> */  TargetType constructedTargetType, OtherInjectedType otherInjectedType) 
   {

   }
}

我当前的解决办法相当难看：我手动创建了一个TargetType，而不使用InjectedType，然后使用InjectedType获取InjectedType实例，并在TargetType实例上调用SetInjectedType(InjectedType)方法。啊！

Answer 1

有趣的问题。我不认为有一个完全干净的解决方案，但也许这个基于儿童注射器的解决方案会适合你：

首先，创建一个自定义guice绑定注释供自己使用：

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.FIELD, ElementType.PARAMETER})
@BindingAnnotation
public @interface JamrozikParam {}

然后，将targettype更改为如下所示：

class TargetType {

   @Inject
   TargetType(@JamrozikParam Param1 assistedParam, InjectedType injectedType) 
   {

   }
}

Injector topInjector = Guice.createInjector(/* Your modules here */);
// Note that the modules used there can't mention TargetType or InjectedType
// Now many lines later
Param1 myP1val;
myP1val = // ... however that was computed
Injector childInjector = topInjector.childInjector(new Param1Module(myP1val));
TargetType t1 = childInjector.getInstance(TargetType.class);

public class Param1Module extends AbstractModule {
  private final Param1 p1val;
  public Param1Module(Param1 p1val) {this.p1val = p1val;}
  protected void configure() {
    bind(Param1.class).annotatedWith(JamrozikParam.class).toInstance(p1val);
    bind(TargetType.class).in(Singleton.class);
    bind(InjectedType.class).in(Singleton.class);
  }
}

class TargetType {

   @Inject
   TargetType(@Assisted Param1 assistedParam) 
   {

   }

   void ttMethod1(InjectedType injected, String other) { }
   // other methods
}

class InjectedType {

   @Inject
   injectedType(OtherInjectedType otherInjectedType) 
   {

   }

   void injMethod1(TargetType constructedTarget, String other) { }
   // other methods
}

class TargetTypeSupervisor {
  private TargetType target;
  private InjectedType injected;

  @Inject TargetTypeSupervisor(@Assisted Param1 assistedParam, InjectedType injected) {
    this.injected = injected;
    this.target = new Target(assistedParam);
  }

  void ttMethod1(String other) { target.ttMethod1(injected, other); }
  void injMethod1(String other) { injected.injMethod1(target, other); }
  // other methods as needed
}