Injecter Générique de la mise en Œuvre à l'aide de Guice

Génériques de ne pas être retenu au moment de l'exécution sûr, il est plus difficile de saisir le concept au premier abord.
De toute façon, il y a des raisons new ArrayList<String>().getClass() retourne Class<?> et pas Class<String> et bien sûr de le jeter aux Class<? extends String> vous devriez vous rappeler que les génériques sont là juste pour le type de compilation des contrôles (un peu comme implicite de validation, si vous voulez).

Donc, si vous voulez utiliser Guice à injecter MyRepository (avec n'importe quel type) de la mise en œuvre chaque fois que vous avez besoin d'une nouvelle instance de Repository (avec n'importe quel type), alors vous n'avez pas à réfléchir sur les génériques à tous, mais vous êtes sur votre propre pour assurer la sécurité de type (c'est pourquoi vous obtenez ces satanés "unchecked" avertissement).

Voici un exemple de code fonctionne très bien:

public class GuiceTest extends AbstractModule {

    @Inject
    List collection;

    public static void main(String[] args) {
        GuiceTest app = new GuiceTest();
        app.test();
    }

    public void test(){
        Injector injector = Guice.createInjector(new GuiceTest());
        injector.injectMembers(this);

        List<String> strCollection = collection;
        strCollection.add("I'm a String");
        System.out.println(collection.get(0));

        List<Integer> intCollection = collection;
        intCollection.add(new Integer(33));
        System.out.println(collection.get(1));
    }

    @Override
    protected void configure() {
        bind(List.class).to(LinkedList.class);
    }
}

Cette affiche:

I'm a String
33

Mais cette liste est mis en œuvre par un LinkedList. Bien que dans cet exemple, si vous avez essayé d'assigner un int quelque chose qui est Chaîne vous obtenez une exception.

int i = collection.get(0)

Mais si vous voulez obtenir un produit injectable objet déjà de type "castés" et dandy, vous pouvez demander de List<String> au lieu de simplement la Liste, mais alors Guice permettra de traiter ce Type de variable dans le cadre de la liaison de clé (similaire à un qualificatif comme @Nommé). Ce que cela signifie est que si vous voulez injection spécifiquement List<String> de ArrayList<String> la mise en œuvre et List<Integer> de LinkedList<Integer>, Guice vous permet de le faire (pas testé, supposition).

Mais il y a un hic:

    @Override
    protected void configure() {
        bind(List<String>.class).to(LinkedList<String>.class); <-- *Not Happening*
    }

Comme vous pouvez le remarquer classe littéraux ne sont pas génériques. C'est là que vous utilisez Guice est TypeLiterals.

    @Override
    protected void configure() {
        bind(new TypeLiteral<List<String>>(){}).to(new TypeLiteral<LinkedList<String>>(){});
    }

TypeLiterals conserver le type générique de la variable dans le cadre de la méta-information à la carte à la mise en œuvre. Espérons que cette aide.

Liée en quelque sorte, j'espère que quelqu'un va trouver cela utile. Dans certains cas, surtout si vous avez de la java.lang.Class instance du type que vous voulez faire de généralité, il est possible de forcer une injection dans l'exécution, par l'extension de la ParameterizedType classe.

Dans la solution ci-dessous, une méthode de fabrique, crée un générique Collection< ? s'étend Nombre> et Map < K,V > donnée une instance de la classe de l'objet

Example.java:

@SuppressWarnings("unchecked")
public class Example<K extends Number> {

  Injector injector = ...

  public Set<K> foo(Class<K> klass) {
    CompositeType typeLiteral = new CompositeType(Set.class, klass);
    Set<K> set = (Set<K>) injector.getInstance(Key.get(typeLiteral));
    return set;
  }

  public <V> Map<K,V> bar(Class<K> keyClass, Class<V> valueClass) {
    CompositeType typeLiteral = new CompositeType(Map.class, keyClass, valueClass);
    Map<K,V> collection = (Map<K,V>) injector.getInstance(Key.get(typeLiteral));
    return collection;
  }
}

CompositeType.java:

import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

import org.apache.commons.lang.StringUtils;

public class CompositeType implements ParameterizedType {

  private final String typeName;
  private final Class<?> baseClass;
  private final Type[] genericClass;

  public CompositeType(Class<?> baseClass, Class<?>... genericClasses) {
    this.baseClass = baseClass;
    this.genericClass = genericClasses;
    List<String> generics = ((List<Class<?>>)Arrays.asList(genericClasses))
            .stream()
            .map(Class::getName)
            .collect(Collectors.toList());
    String genericTypeString = StringUtils.join(generics, ",");
    this.typeName = baseClass.getName() + "<" + genericTypeString + ">";
  }

  @Override
  public String getTypeName() {
    return typeName;
  }

  @Override
  public Type[] getActualTypeArguments() {
    return genericClass;
  }

  @Override
  public Type getRawType() {
    return baseClass;
  }

  @Override
  public Type getOwnerType() {
    return null;
  }
}