Plusieurs annotations du même type sur un élément?

Je suis tenter de la gifler deux ou plusieurs annotations du même type sur un seul élément, dans ce cas, une méthode. Ici l'approximative de code que je travaille avec:

public class Dupe {
    public @interface Foo {
      String bar();
    }

    @Foo(bar="one")
    @Foo(bar="two")
    public void haha() {}
}

Lors de la compilation ci-dessus, javac se plaint d'une double annotation:

max@upsight:~/work/aube$ javac Dupe.java 
Dupe.java:5: double annotation

Est-il tout simplement pas possible de répéter les annotations de ce genre? Manière affectée de parler, ne sont pas les deux instances de @Foo ci-dessus différents, en raison de leur contenu différent?

Si ce qui précède n'est pas possible, quelles sont les solutions potentielles?

Mise à JOUR: j'ai été demandé de décrire mon cas d'utilisation. Va ici.

Je suis en train de construire une syntaxe sugarish mécanisme de "carte" Pojo du document dans les magasins comme MongoDB. Je veux permettre à des index spécifié que les annotations sur les getters ou organismes de normalisation. Voici un exemple artificiel:

public class Employee {
    private List<Project> projects;

    @Index(expr = "project.client_id")
    @Index(expr = "project.start_date")
    public List<Project> getProjects() { return projects; }
}

Évidemment, je veux être en mesure de trouver rapidement les instances de l'Employé par diverses propriétés de Projet. Je peux spécifier @Index à deux reprises avec différents expr() les valeurs, ou de prendre l'approche spécifié dans la accepté de répondre. Même si Hibernate fait cela, et il n'est pas considéré comme un hack, je pense qu'il a encore un sens pour au moins permettre d'avoir plusieurs annotations du même type sur un seul élément.

  • Il y a un effort pour avoir cette double règle de se détendre pour permettre à votre programme en Java 7. Pouvez-vous décrire votre cas d'utilisation, s'il vous plaît?
  • J'ai édité ma question avec une description de pourquoi je veux faire ce. Merci.
  • Il pourrait être utile en CDI pour permettre à un haricot d'être fourni pour plusieurs qualificatifs. Par exemple, j'ai juste essayé de réutiliser un haricot dans deux endroits en le qualifiant de "@Produit @PackageName("test1") @PackageName("test2")"
  • Plus loin: La réponse ci-dessous ne permet pas de résoudre ce problème parce que le CDI serait de voir les composites comme un Qualificatif.
InformationsquelleAutor Max A. | 2009-10-12
  1. 133

    Deux ou plusieurs annotations de même type ne sont pas autorisés. Cependant, vous pourriez faire quelque chose comme ceci:

    public @interface Foos {
    Foo[] value();
}

@Foos({@Foo(bar="one"), @Foo(bar="two")})
public void haha() {}

    Vous aurez besoin d'un traitement de Foos annotation dans le code si.

    btw, j'ai simplement utilisé cette 2 heures pour contourner le même problème 🙂

    • Vous pouvez aussi faire cela dans Groovy?
    • Oui. Vous auriez à utiliser des crochets si, par exemple,@Foos([@Foo(bar="one"), @Foo(bar="two")]). Voir groovy.codehaus.org/Annotations+avec+Groovy
    • Un peu plus tard dans la journée, mais attention à point pour les conseils que peut traiter la liste des Foo Foos intérieur? Pour le moment, je suis en train de prcess le résultat d'une méthode, mais bien que les Foos est intercepté les Foo conseil n'est jamais entré
    InformationsquelleAutor sfussenegger
  2. 58

    Dans Java 8 (publié en Mars 2014), il est possible d'écrire répétée/dupliquer des annotations. Voir http://docs.oracle.com/javase/tutorial/java/annotations/repeating.html.

    InformationsquelleAutor mernst
  3. 14

    http://docs.oracle.com/javase/tutorial/java/annotations/repeating.html

    À partir de Java8 vous pouvez décrire reproductible annotations:

    @Repeatable(FooValues.class)
public @interface Foo {
    String bar();
}

public @interface FooValues {
    Foo[] value();
}

    Note, value est un champ obligatoire pour les valeurs de la liste.

    Maintenant, vous pouvez utiliser les annotations répétant, au lieu de remplir le tableau:

    @Foo(bar="one")
@Foo(bar="two")
public void haha() {}
    InformationsquelleAutor Sergei Pikalev
  4. 13

    Outre les autres moyens mentionnés, il y a un plus moins verbeux dans Java8:

    @Target(ElementType.TYPE)
@Repeatable(FooContainer.class)
@Retention(RetentionPolicy.RUNTIME)
@interface Foo {
    String value();

}

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface FooContainer {
        Foo[] value();
        }

@Foo("1") @Foo("2") @Foo("3")
class Example{

}

    Exemple, par défaut, obtient, FooContainer comme une Annotation

        Arrays.stream(Example.class.getDeclaredAnnotations()).forEach(System.out::println);
    System.out.println(Example.class.getAnnotation(FooContainer.class));

    Les deux ci-dessus d'impression:

    @com.FooContainer(valeur=[@com.Foo(valeur=1), @com.Foo(valeur=2),
    @com.Foo(valeur=3)])

    @com.FooContainer(valeur=[@com.Foo(valeur=1), @com.Foo(valeur=2), @com.Foo(valeur=3)])

    • Il est intéressant de souligner que la méthode/nom du champ dans FooContainer doit être stricte nommé "valeur()". Sinon Toto ne compilera pas.
    • ...contenant également du type d'annotation (FooContainer) ne peut être applicable à d'autres types de reproductibles type d'annotation (Foo).
    InformationsquelleAutor Jatin
  5. 12

    Comme dit par sfussenegger, ce n'est pas possible.

    La solution habituelle est de construire un "multiple" annotation, qui gère un tableau de la précédente annotation. Il est généralement le même nom, avec un 's' suffixe.

    Par la voie, c'est très utilisée dans de grands projets publics (Hibernate par exemple), donc il ne devrait pas être considéré comme un hack, mais plutôt une solution correcte pour ce besoin.

    En fonction de vos besoins, il pourrait être préférable de permettre à votre annotation antérieure à gérer de multiples valeurs.

    Exemple:

        public @interface Foo {
      String[] bars();
    }
    • Je savais que c'était étrangement familier. Merci pour rafraîchir ma mémoire.
    • C'est maintenant possible avec Java 8.
    InformationsquelleAutor KLE
  6. 4

    combinant les autres réponses dans la forme la plus simple ... une annotation avec une simple liste de valeurs ...

    @Foos({"one","two"})
private String awk;

//...

public @interface Foos{
    String[] value();
}
    InformationsquelleAutor matt1616
  7. 3

    Si vous avez seulement 1 paramètre "bar", vous pouvez lui donner un nom en tant que "valeur". Dans ce cas, vous n'avez pas à écrire le nom du paramètre lorsque vous utilisez la comme ceci:

    @Foos({@Foo("one"), @Foo("two")})
public void haha() {}

    un peu plus court et plus lisible, à mon humble avis..

    • Point Correct, mais comment cette tentative de répondre à l'OP de la question?
    • vous avez raison, je pense qu'il était plus d'une amélioration de la réponse sommet de sfussenegger et appartient donc plus dans les commentaires là-haut. Mais la réponse est obsolète toute façon reproductible des annotations...
    InformationsquelleAutor mihahh
  8. 0

    Dans la version actuelle de Java, j'ai été en mesure de résoudre ce problème avec l'annotation suivante:

    @Foo({"one", "two"})
    • quelle version? jdk 8,9,10,11?
    InformationsquelleAutor Eduardo Alexandre de Souza