Der folgende Code ist ein Beispiel für eine Factory, die ein @ erzeugBar<T> angenommenFoo<T>. Die Fabrik ist es egal, wasT ist: für jeden TypT, es kann ein @ machBar<T> von einemFoo<T>.

import com.google.inject.*;
import com.google.inject.assistedinject.*;

class Foo<T> {
  public void flip(T x) { System.out.println("flip: " + x); }
}

interface Bar<T> {
  void flipflop(T x);
}

class BarImpl<T> implements Bar<T> {
  Foo<T> foo;

  @Inject
  BarImpl(Foo<T> foo) { this.foo = foo; }

  public void flipflop(T x) { foo.flip(x); System.out.println("flop: " + x); }
}

interface BarFactory {
  <T> Bar<T> create(Foo<T> f);
}

class Module extends AbstractModule {
  public void configure() {
    bind(BarFactory.class)
      .toProvider( 
          FactoryProvider.newFactory( BarFactory.class, BarImpl.class ) 
                   );
  }
}

public class GenericInject {
  public static void main(String[] args) {
    Injector injector = Guice.createInjector(new Module());

    Foo<Integer> foo = new Foo<Integer>();
    Bar<Integer> bar = injector.getInstance(BarFactory.class).create(foo);
    bar.flipflop(0);
  }
}

Wenn ich den Code ausführe, erhalte ich die folgenden Fehlermeldungen von Guice:

1) No implementation for BarFactory was bound.
  at Module.configure(GenericInject.java:38)

2) Bar<T> cannot be used as a key; It is not fully specified.

Der einzige Verweis, den ich auf Generika in der Guice-Dokumentation finden kann, besagt, ein @ zu verwendeTypeLiteral. Aber ich habe keinen wörtlichen Typ, sondern einen generischen Platzhalter, der für die Fabrik überhaupt nicht relevant ist. Irgendwelche Tipps