Guice et de l'interface qui a de multiples implémentations

Si j'ai de l'interface du programme de validation et de multiples implémentations de cette interface. Comment peut-on injecter une ou de plusieurs implémentations avec Guice? Maintenant, je sais que je peux utiliser le code suivant pour injecter un, mais il ne permet qu'une seule mise en œuvre:

public class MyModule extends AbstractModule {
  @Override 
  protected void configure() {
    bind(Validator.class).to(OneOfMyValidators.class);
  }
}

Ce que je voudrais faire c'est:

Validator v1 = injector.getInstance(Validator1.class);
Validator v2 = injector.getInstance(Validator2.class);

Est-il possible?

Votre exemple ne pas injecter le validateur, il crée simplement. Comment voulez-vous vous distinguer de vos 1456 implémentations dans le code réel?
Vrai. Je voulais dire que la demande peut avoir un nombre x de validateurs. Et peut-être validateur créateur veut injecter certains avec des dépendances pour les validateurs. Alors validateur créateur pourrait ajouter @inject pour validateur constructeur et obtenir les dépendances nécessaires.

OriginalL'auteur newbie | 2011-11-08

  1. 22

    Réponse courte: la liaison des annotations. Ils sont essentiellement un moyen de laisser le depender donner un indice qui pointe vers une instance particulière de la mise en œuvre sans nécessiter une dépendance sur la pleine mise en œuvre concrète de la classe.

    Voir:
    https://github.com/google/guice/wiki/BindingAnnotations

    Par exemple, dans le module, vous pourriez faire:

    bind(Validator.class).annotatedWith(ValidatorOne.class).to(OneOfMyValidators.class);
bind(Validator.class).annotatedWith(ValidatorTwo.class).to(SomeOtherValidator.class);

    Et dans votre constructeur, vous feriez:

    @Inject
MyClass(@ValidatorOne Validator someValidator,
    @ValidatorTwo Validator otherValidator) {
  ...
}

    Pour obtenir une annoté de la valeur directement à partir d'une Injector, vous devrez utiliser le Guice Key classe, comme:

    Validator v1 = injector.getInstance(Key.get(Validator.class, ValidatorOne.class));

    Sur une note de côté, contraignant les annotations sont très utiles pour l'injection des constantes d'exécution. Voir les commentaires de l'bindConstant:

    https://google.github.io/guice/api-docs/latest/javadoc/index.html?com/google/inject/Binder.html

    Merci pour la réponse, mais je ne sais pas si c'est la solution adaptée à ma situation, ce que si il y a 1456 validateurs? Alors j'aurais besoin de 1456 annotations, un pour chaque validateur, et j'ai déjà le générique d'annotation pour les validateurs.
    Permettez-moi de prendre un peu de recul et se demander: "Comment vous voulez que votre validation dépendant de classes de demander à ces validateurs?" Ou, dans un monde idéal, ce serait de leur @Inject constructeurs? Voulez-vous un code de poser pour des cas précis? (par exemple,@ValidatorOne Validator someValidator). Ou, serait-classes peut-être souhaitez dépendent d'un Set<Validator>? (si oui, Multibindings sont à portée de main). Ou doit-code peut-être dépendent d'un seul Validator c'est en interne composé de nombreux Validators? La réponse qui va certainement influencer la solution optimale.
    Vous pouvez utiliser les Clés nommées au lieu de les annotations @Nommé("validator1")

    OriginalL'auteur Andrew McNamee

  2. 6

    J'ai trouvé ce fil de discussion lors de la recherche d'une solution dynamique de la liaison de plusieurs implémentations de l'interface, similaire à ServiceLoader en Java. La réponse couvre un cas plus général, mais il peut également être utilisé pour obtenir une mise en oeuvre particulière de l'ensemble. Multibinder permet de lier plusieurs implémentations de type:

    public class ValidatorsModule extends AbstractModule {
  protected void configure() {
      Multibinder<Validator> multibinder
          = Multibinder.newSetBinder(binder(), Validator.class);
      multibinder.addBinding().toInstance(new ValidatorOne());
      multibinder.addBinding().toInstance(new ValidatorTwo());
  }
}

//Usage
@Inject Set<Validator> validators;
    Je n'ai pas Multibinder dans com.google.injecter de l'espace de noms. Je suppose que sa dans une autre version.....la version de jus de soutient?
    Multibinder a été introduit dans Guice 2.0. Quelle version utilisez-vous?
    4.1.0 par mon pom fichier: <dépendance> <groupId>com.google.injecter</groupId> <artifactId>guice</artifactId> <version>4.1.0< version> </dépendance>
    Vous avez besoin de guice-multibindings module en plus de guice. Voir stackoverflow.com/questions/8688538/...

    OriginalL'auteur ejboy

  3. 5

    Très similaire à ejboy de la proposition, mais puisque vous possédez de différents Validateur de classes, vous pouvez lier à la classe elle-même, et non pas la création d'instances manuellement.

    protected void configure() {
   ...
   Multibinder<Validator> mb = Multibinder.newSetBinder(binder(), Validator.class);
   mb.addBinding().to(Validator1.class);
   mb.addBinding().to(Validator2.class);
   mb.addBinding().to(Validator3.class);
   ...
}

    Puis du point de vue de l'utilisation, par exemple par le Constructeur de l'Injection:

    class UseCase {
    private Set<Validator> allOfThem;

    @Inject
    public UseCase(Set<Validator> allOfThem) {
        this.allOfThem = allOfThem;
        //e.g. iteratation
        for (Validator oneOfThem : allOfThem) {
            ...
        }
    }
}

    OriginalL'auteur Hartmut P.