Mehrere Annotationen des gleichen Typs auf einem Element?

Question

Ich versuche, zwei oder mehr Anmerkungen des gleichen Typs auf ein einzelnes Element, in diesem Fall eine Methode zu schlagen. Hier ist der ungefähre Code, ich arbeite mit:

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

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

Beim Kompilieren der oben Javac beschwert sich über eine doppelte Anmerkung:

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

Ist es einfach nicht möglich, Anmerkungen wie diese zu wiederholen? Sind die beiden Instanzen von @Foo nicht pedantisch unterschiedlich, weil ihre Inhalte unterschiedlich sind?

Wenn das obige nicht möglich ist, was sind einige mögliche Problemumgehungen?

UPDATE: Ich wurde gebeten, meinen Anwendungsfall zu beschreiben. Hier geht.

Ich bin ein Syntax Sugarish-Mechanismus zum "Mappen" POJOs zu Dokumenten speichert wie MongoDB. Ich möchte zulassen, dass Indizes als Anmerkungen auf den Gettern oder Sätzen angegeben werden. Hier ist ein konstruiertes Beispiel:

public class Employee { 
    private List<Project> projects; 

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

Offensichtlich möchte ich schnell in der Lage sein, um Fälle von Mitarbeiter durch verschiedene Eigenschaften des Projekts zu finden. Ich kann @Index entweder zweimal mit verschiedenen expr() - Werten angeben oder den in der akzeptierten Antwort angegebenen Ansatz wählen. Obwohl Hibernate dies tut und nicht als Hack betrachtet wird, halte ich es immer noch für sinnvoll, zumindest mehrere Annotationen desselben Typs auf einem einzelnen Element zuzulassen.

Answer 1

Zwei oder mehr Anmerkungen desselben Typs sind nicht zulässig. Sie könnten jedoch so etwas tun:

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

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

Sie benötigen dedizierte Behandlung von Foos Annotation in Code jedoch.

btw, ich habe das vor 2 Stunden nur verwendet um das gleiche Problem zu arbeiten :)

Answer 2

Wie sfussenegger sagt, ist dies nicht möglich.

Die übliche Lösung ist Erstellen Sie eine "multiple" Annotation, die ein Array der vorherigen Annotation behandelt. Es wird normalerweise mit dem Suffix "s" gleich benannt.

Übrigens wird dies in großen öffentlichen Projekten (Hibernate zum Beispiel) sehr häufig verwendet, so dass es nicht als Hack, sondern als richtige Lösung für diesen Bedarf betrachtet werden sollte.

---

Je nach Bedarf könnte es besser sein, lassen Sie Ihre früheren Anmerkung mehrere Werte zu handhaben.

Beispiel:

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

Answer 3

Wenn Sie nur 1 Parameter "bar" haben Sie es als "Wert" nennen kann. In diesem Fall müssen Sie nicht die Parameternamen überhaupt schreiben, wenn Sie es wie folgt verwendet werden:

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

etwas kürzer und übersichtliche, imho ..

Answer 4

In Java 8 (veröffentlicht im März 2014) ist es möglich, wiederholte/doppelte Annotationen zu schreiben. Siehe http://docs.oracle.com/javase/tutorial/java/annotations/repeating.html.

Answer 5

die anderen Antworten in die einfachste Form der Kombination von ... eine Anmerkung mit einer einfachen Liste von Werten ...

Answer 6

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

von Java8 starten können Sie beschreiben wiederholbar Anmerkungen:

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

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

Hinweis, value ist ein Pflichtfeld für die Werteliste.

Jetzt können Sie Anmerkungen verwenden sie zu wiederholen, anstatt die Anordnung der Füllung:

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

Answer 7

Neben den anderen Möglichkeiten erwähnt, gibt es noch eine weniger ausführliche Art und Weise 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{ 

} 

Beispiel durch Verzug, FooContainer als Annotation

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

Sowohl die oben Druck:

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

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