Più annotazioni dello stesso tipo su un elemento?

Question

Sto tentando di eseguire lo slap di due o più annotazioni dello stesso tipo su un singolo elemento, in questo caso, un metodo. Ecco il codice approssimativo che sto lavorando con:

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

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

Quando si compila quanto sopra, javac lamenta un'annotazione duplicato:

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

non è semplicemente possibile ripetere le annotazioni come questo? Pedanticamente parlando, le due istanze di @Foo non sono diverse a causa del fatto che i loro contenuti sono diversi?

Se quanto sopra non è possibile, quali sono alcuni possibili soluzioni?

AGGIORNAMENTO: Mi è stato chiesto di descrivere il mio caso d'uso. Ecco qui.

Sto costruendo un meccanismo sbrigativo di sintassi per "mappare" POJO per documentare negozi come MongoDB. Voglio consentire che gli indici siano specificati come annotazioni sui getter o setter. Ecco un esempio inventato:

public class Employee { 
    private List<Project> projects; 

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

Ovviamente, voglio essere in grado di trovare rapidamente le istanze di dipendenti da varie proprietà del progetto. Posso specificare @Index due volte con valori diversi di expr() o adottare l'approccio specificato nella risposta accettata. Anche se Hibernate fa questo e non è considerato un hack, penso che abbia ancora senso permettere almeno di avere più annotazioni dello stesso tipo su un singolo elemento.

Answer 1

Due o più annotazioni dello stesso tipo non sono consentite. Tuttavia, si potrebbe fare qualcosa di simile:

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

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

avrete bisogno di gestione dedicata di Foos annotazioni nel codice però.

btw, ho appena usato questa 2 ore fa per risolvere lo stesso problema :)

Answer 2

Come detto da sfussenegger, questo non è possibile.

La solita soluzione è per creare un'annotazione "multipla", che gestisce un array della precedente annotazione. In genere viene chiamato lo stesso, con un suffisso "s".

A proposito, questo è molto usato in grandi progetti pubblici (Hibernate per esempio), quindi non dovrebbe essere considerato come un hack, ma piuttosto una soluzione corretta per questa esigenza.

---

A seconda delle esigenze, potrebbe essere meglio per permettere che la tua annotazione in precedenza per gestire più valori.

Esempio:

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

Answer 3

Se avete solo 1 parametro "bar" è possibile il nome come "valore". In questo caso non dovrete scrivere il nome del parametro a tutti quando si utilizza in questo modo:

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

un po 'più corto e più ordinato, imho ..

Answer 4

In Java 8 (rilasciato a marzo 2014), è possibile scrivere annotazioni ripetute/duplicate. Vedi http://docs.oracle.com/javase/tutorial/java/annotations/repeating.html.

Answer 5

combinando le altre risposte nella forma più semplice ... un'annotazione con un semplice elenco di valori ...

Answer 6

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

Partendo da Java8 si può descrivere le annotazioni ripetibili:

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

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

Nota, value è un campo obbligatorio per la lista valori.

Ora è possibile utilizzare le annotazioni ripeterli invece di riempire la matrice:

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

Answer 7

parte gli altri modi citati, v'è un altro modo meno dettagliato in 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{ 

} 

Esempio da predefinito ottiene, FooContainer come annotazione

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

Sia la sopra di stampa:

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

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