在 Guice 中管理同一依赖树的多个版本的最佳模式是什么？

我想实例化同一类型依赖树/链的多个版本，它们对该树/链中的某些接口使用不同的实现。在这种情况下使用的最佳 Guice 实践/模式是什么？

这是我的问题的具体示例。

我有一个Writer接口可能是文件编写器或标准输出编写器，它将位于我的依赖关系层次结构的叶子。像这样的东西：

interface Writer { ... }
class FileWriter implements Writer { ... }
class StdOutWriter implements Writer { ... }

另一个记录器接口用于在编写器上添加一个间接层。例如：

interface Logger { ... }

class LoggerImpl{
  @Inject
  public Logger(Writer out){ ... }
  public void log(String message){ out.println(message); }
}

然后有一个使用记录器的客户端。

class Client{
  @Inject
  public Client(Logger logger){ ... }
  public void do(){ logger.log("my message"); }
}

现在，我想在我的程序中使用两种类型的层次结构：

1. 客户端 -> LoggerImpl -> FileWriter
2. 客户端 -> LoggerImpl -> StdOutWriter

有没有一种好的方法可以在不为 1 和 2 使用单独的 Guice 模块的情况下进行连接？

理想情况下我希望有一个ClientFactory像这样的类：

interface ClientFactory{
  public Client stdOutClient();
  public Client fileClient(); 
  //or fileClient(File outputFile) for extra points ;)
}

任何人都可以想出一种方法来使用这个工厂或通过任何其他方式来连接它吗？

我还想要一个可以扩展到我有更多种类的较长依赖树/链的情况的解决方案。谢谢！

这是机器人腿问题。解决办法基本上就是使用私有模块绑定每个依赖树并仅公开该树的根。您可以通过多种方法来执行此操作，但以下是您通常可以如何执行此操作的示例（您可以根据需要执行多种操作）：

public class ClientModule extends PrivateModule {
  private final Writer writer;
  private final Class<? extends Annotation> annotationType;

  public ClientModule(Writer writer, Class<? extends Annotation> annotationType) {
    this.writer = writer;
    this.annotationType = annotationType;
  }

  @Override protected void configure() {
    bind(Writer.class).toInstance(writer);
    bind(Logger.class).to(LoggerImpl.class);
    expose(Client.class).annotatedWith(annotationType);
  }
}

public class ClientFactoryModule extends AbstractModule {
  private final File file;

  public ClientFactoryModule(File file) {
    this.file = file;
  }

  @Override protected void configure() {
    install(new ClientModule(new StdOutWriter(), StdOut.class));
    install(new ClientModule(new FileWriter(file), FileOut.class));
    bind(ClientFactory.class).to(ClientFactoryImpl.class);
  }
}

public class ClientFactoryImpl implements ClientFactory {
  private final Client stdOutClient;
  private final Client fileClient;

  @Inject public ClientFactoryImpl(@StdOut Client stdOutClient, 
                                   @FileOut Client fileClient) {
    this.stdOutClient = stdOutClient;
    this.fileClient = fileClient;
  }

  ...
}

您的方法场景Client fileClient(File)但还是有一点不同。