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

J'essaie de gifler deux ou plusieurs annotations du même type sur un seul élément, dans ce cas, une méthode. Voici le code approximatif avec lequel je travaille:

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

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

Lors de la compilation de ce qui précède, javac se plaint d'une annotation en double:

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

N'est-il tout simplement pas possible de répéter des annotations comme celle-ci? Pédantiquement parlant, les deux instances de @Foo ci-dessus ne sont-elles pas différentes en raison de leur contenu différent?

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

MISE À JOUR: on m'a demandé de décrire mon cas d'utilisation. Voici.

Je construis un mécanisme de syntaxe sucré pour "mapper" les POJO aux magasins de documents tels que MongoDB. Je veux permettre aux index d'être spécifiés comme annotations sur les getters ou les setters. 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 pouvoir trouver rapidement des instances de Employee par différentes propriétés de Project. Je peux soit spécifier @Index deux fois avec des valeurs expr () différentes, soit adopter l'approche spécifiée dans la réponse acceptée. Même si Hibernate fait cela et que ce n'est pas considéré comme un hack, je pense qu'il est toujours logique de permettre au moins d'avoir plusieurs annotations du même type sur un seul élément.

Deux annotations ou plus du même type ne sont pas autorisées. Cependant, vous pouvez faire quelque chose comme ceci:

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

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

Vous aurez cependant besoin d'une gestion dédiée de l'annotation Foos dans le code.

btw, je viens de l'utiliser il y a 2 heures pour contourner le même problème :)

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

Outre les autres moyens mentionnés, il existe une autre manière moins verbeuse en 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, FooContainersous forme d'annotation

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

Les deux imprimés ci-dessus:

@ 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)])

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

À partir de Java8, vous pouvez décrire des annotations répétables:

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

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

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

Vous pouvez maintenant utiliser des annotations en les répétant au lieu de remplir le tableau:

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

Comme l'a dit sfussenegger, ce n'est pas possible.

La solution habituelle est de créer une annotation "multiple" , qui gère un tableau de l'annotation précédente. Il porte généralement le même nom, avec un suffixe «s».

D'ailleurs, cela est très utilisé dans les grands projets publics (Hibernate par exemple), donc cela ne doit pas être considéré comme un hack, mais plutôt comme une solution correcte à ce besoin.

En fonction de vos besoins, il peut être préférable d' autoriser votre annotation précédente à gérer plusieurs valeurs .

Exemple:

    public @interface Foo {
      String[] bars();
    }

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();
}

Si vous n'avez qu'un seul paramètre «barre», vous pouvez le nommer «valeur». Dans ce cas, vous n'aurez pas du tout à écrire le nom du paramètre lorsque vous l'utilisez comme ceci:

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

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

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

@Foo({"one", "two"})