Mehrere Anmerkungen desselben Typs zu einem Element?

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

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

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

Beim Kompilieren der obigen Informationen beschwert sich javac über eine doppelte Anmerkung:

max @ upsight: ~ / work / daybreak $ javac Dupe.java 
Dupe.java:5: doppelte Anmerkung

Ist es einfach nicht möglich, solche Anmerkungen zu wiederholen? Sind die beiden oben genannten Instanzen von @Foo pedantisch gesehen nicht unterschiedlich, da ihre Inhalte unterschiedlich sind?

Wenn dies nicht möglich ist, welche möglichen Problemumgehungen gibt es?

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

Ich baue einen zuckerhaltigen Syntaxmechanismus auf, um POJOs Dokumentenspeichern wie MongoDB zuzuordnen. Ich möchte zulassen, dass Indizes als Anmerkungen zu den Gettern oder Setzern angegeben werden. Hier ist ein erfundenes Beispiel:

public class Employee {
    private List<Project> projects;

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

Natürlich möchte ich in der Lage sein, Instanzen von Mitarbeitern anhand verschiedener Eigenschaften von Project schnell zu finden. Ich kann entweder @Index zweimal mit unterschiedlichen expr () -Werten angeben oder den in der akzeptierten Antwort angegebenen Ansatz wählen. Obwohl Hibernate dies tut und es nicht als Hack betrachtet wird, halte ich es dennoch für sinnvoll, zumindest mehrere Annotationen desselben Typs für ein einzelnes Element zuzulassen.

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

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

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

Sie benötigen jedoch eine spezielle Behandlung der Foos-Annotation im Code.

Übrigens habe ich das gerade vor 2 Stunden benutzt, um das gleiche Problem zu umgehen :)

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

Abgesehen von den anderen genannten Möglichkeiten gibt es in Java8 noch eine weniger ausführliche Möglichkeit:

@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 wird standardmäßig FooContainerals Anmerkung abgerufen

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

Sowohl der obige 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)])

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

Ab Java8 können Sie wiederholbare Anmerkungen beschreiben:

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

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

Hinweis: valueErforderliches Feld für die Werteliste.

Jetzt können Sie Anmerkungen verwenden, die sie wiederholen, anstatt das Array zu füllen:

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

Wie von sfussenegger gesagt, ist dies nicht möglich.

Die übliche Lösung besteht darin , eine "mehrfache" Annotation zu erstellen , die ein Array der vorherigen Annotation verarbeitet. Es wird normalerweise mit dem Suffix 's' gleich benannt.

Dies wird übrigens sehr häufig in großen öffentlichen Projekten verwendet (z. B. im Ruhezustand), daher sollte es nicht als Hack betrachtet werden, sondern als richtige Lösung für diesen Bedarf.

Abhängig von Ihren Anforderungen ist es möglicherweise besser, Ihre frühere Anmerkung mehrere Werte verarbeiten zu lassen .

Beispiel:

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

Kombinieren Sie die anderen Antworten in der einfachsten Form ... eine Anmerkung mit einer einfachen Liste von Werten ...

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

//...

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

Wenn Sie nur 1 Parameter "bar" haben, können Sie ihn als "Wert" bezeichnen. In diesem Fall müssen Sie den Parameternamen überhaupt nicht schreiben, wenn Sie ihn wie folgt verwenden:

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

ein bisschen kürzer und ordentlicher, imho ..

In der aktuellen Java-Version konnte ich dieses Problem mit der folgenden Anmerkung beheben:

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