Top-Fragen
Zeitleiste
Chat
Kontext

Annotation (Java)

Sprachelement von Java, das die Einbindung von Metadaten in den Quelltext erlaubt Aus Wikipedia, der freien Enzyklopädie

Remove ads
Remove ads

Als Annotation wird im Zusammenhang mit der Programmiersprache Java ein Sprachelement bezeichnet, das die Einbindung von Metadaten in den Quelltext erlaubt. Dieses Element wurde im JSR 175 festgelegt und mit der Version Java 5.0 eingeführt.

Annotationen beginnen mit einem @-Zeichen. Daran schließt sich ihr Name an. Optional kann eine kommagetrennte Parameterliste folgen, die in runden Klammern eingefasst wird. Beispielsweise markiert die Annotation im folgenden Quelltextausschnitt die Klasse A als überholt (deprecated):

@Deprecated
public class A {}

Ein Annotation Processor ist ein Compiler-Plugin, das Annotationen beim Kompilieren auswerten kann, um damit Warnungen und Fehlermeldungen zu unterdrücken oder auszulösen oder weiteren Quellcode oder andere Dateien zu generieren. Mit Annotationen versehenen Code kann er jedoch nicht ändern. Annotationen, bei denen das vorgesehen ist, können auch zur Laufzeit mittels Reflection ausgewertet werden.

Eingesetzt werden Annotationen unter anderem im Jakarta-EE-Umfeld, um Klassen um Informationen zu erweitern, die vor Java 5 in separaten Dateien hinterlegt werden mussten. Prominente Beispiele sind Home- und Local-Interfaces sowie Deployment-Deskriptoren.

Eine Vorgängertechnik zur Einbettung von Metadaten in Java-Quelltexten ist die Verwendung spezieller Javadoc-Kommentare. Diese wurden mit Hilfe sogenannter Doclets ausgewertet. Ein vielfach eingesetztes Werkzeug für diese Methode ist XDoclet. Diese Technik kann auch nach Einführung der Annotationen weiterhin verwendet werden.

Remove ads

Vordefinierte Annotationstypen

Zusammenfassung
Kontext

In Java SE 5.0 stehen sieben vordefinierte Annotationstypen zur Verfügung, die in den Paketen (Package) java.lang oder java.lang.annotation liegen. Sie werden alle (im Gegensatz zu den meisten Annotationen) vom Compiler ausgewertet. Weitere können von Programmierern erstellt werden.

Weitere Informationen Beschreibung ...
Remove ads

Definition eigener Annotationen

Zusammenfassung
Kontext

Annotationen sind spezielle Schnittstellen; ihre Namen werden daher konventionsgemäß mit großem Anfangsbuchstaben geschrieben. In ihrer Vereinbarung steht vor interface das Zeichen @. Sie erweitern implizit die Schnittstelle java.lang.annotation.Annotation. Sie dürfen keine andere Schnittstellen erweitern (d. h. extends ist verboten) und sind nicht generisch. Ihre Methoden sind parameterlos und nicht-generisch. Als Ergebnistypen (return type) sind nur folgende Typen erlaubt:

  • primitive Typen
  • Aufzählungstypen (enum)
  • Annotationstypen
  • String
  • Class
  • Felder (arrays) aus diesen Typen

Sie werfen auch keine Ausnahmen und dürfen keine Rekursion verwenden.

Viele Annotationen enthalten keine Methoden. Ein Beispiel wäre:

@interface Vorlaeufig { }

Andere Annotationen enthalten (wie für Schnittstellen üblich) Methoden, allerdings nur mit den oben aufgeführten Ergebnistypen. Wenn eine Annotation nur eine Methode enthält, ist ihr Name konventionsgemäß value:

@interface Test {
	boolean value(); // true solange nicht freigegeben
}

oder

@interface Autoren {
	String[] value(); // Namen der Autoren
}

oder

@interface Kunden {
	Person[] value();
}

wobei Person als Aufzählungstyp (enum) oder Annotation definiert werden muss, z. B.:

@interface Person {
	String name();
	int alter();
}

Bei der Vereinbarung von Annotationen werden häufig die Standard-Annotationen aus dem Paket java.lang.annotation verwendet. Insbesondere soll mit @Retention angegeben werden, wie lange die Annotation aufbewahrt werden soll: nur im Quelltext (SOURCE), in der gespeicherten class-Datei (CLASS) oder auch in der geladenen Klasse (RUNTIME). @Target beschreibt, für welche Programmelemente die Annotation verwendet werden darf. Beispielsweise sind alle Annotationsvereinbarungen im Paket java.lang.annotation mit den Annotationen

@Documented
@Retention(value=RUNTIME)
@Target(value=ANNOTATION_TYPE)

versehen. Hierdurch werden sie alle von javadoc ausgewertet, im Bytecode mit geladen und können so zur Laufzeit ausgewertet werden; außerdem dürfen sie nur für Annotationstypen verwendet werden.

Remove ads

Verwendung eigener Annotationen

Zusammenfassung
Kontext

Eine Annotation ohne Methoden, wie @Vorlaeufig, kann z. B. einer Klasse vorangestellt werden:

@Vorlaeufig
class Klasse {
	void methode();
}

Einer Annotation mit nur einer Methode mit dem Namen value muss in Klammern ein konstanter Wert vom Ergebnistyp dieser Methode mit angegeben werden:

@Test(true)
public void methode() { ... }

Wenn der Ergebnistyp ein Array ist, soll ein Arrayliteral verwendet werden:

@Autoren({"Solymosi", "Grude"})
String buch = "Algorithmen und Datenstrukturen mit Java"

Wenn das Array keine Elemente enthält, muss ({}) mit angegeben werden. Wenn das Array jedoch nur ein Element enthält, können die geschweiften Klammern weggelassen werden:

@Autoren("Solymosi")
String anderesBuch = "Programmieren in Scala"

Einer Annotation mit mehreren Methoden muss jeder ihrer Methoden in Klammern ein konstanter Wert zugewiesen werden:

@Person(name = "Andreas Solymosi", alter = 56)
Konto konto = new Konto();

Die Möglichkeit, den Wert mit dem Namen anzugeben, besteht auch für Annotationen mit einer Methode (ist allerdings überflüssig, dient höchstens der Lesbarkeit):

@Test(value = true)

Eine komplexe (geschachtelte) Annotation muss geschachtelt angewendet werden:

@Kunden(@Person(name = "Andreas Solymosi", alter = 56))
class Unternehmen {  }

In der Vereinbarung der Annotation können für die Methoden Standardwerte definiert werden; dann kann der entsprechende Wert bei der Verwendung weggelassen werden. Da Annotationen Schnittstellen sind, können sie selber mit Annotationen markiert werden:

@Autoren("Solymosi")
public @interface Test {
	boolean wert() default false; // muss nicht unbedingt wert heißen
}

Auswertung von Annotationen

Wenn die Annotationen mit dem Bytecode der Klasse geladen werden, können sie mit Hilfe von Reflexion ausgewertet werden. Beispielsweise kann man feststellen, ob eine Annotation angegeben wurde oder nicht:

boolean istVorlaeufig = Klasse.class.isAnnotationPresent(Vorlaeufig.class);

Wenn man festgestellt hat, dass die Annotation vorhanden ist, dann kann man auch ihren Wert lesen, z. B. ob die Methode noch im Testzustand ist oder nicht:

Test test = Klasse.class.getMethod("methode", new Class[]{}).getAnnotation(Test.class).value();

Wenn hierbei die Annotation nicht vorhanden ist, wird von getAnnotation() die Ausnahme NullPointerException ausgelöst. Aus einer komplexen Annotation müssen ihre Elemente einzeln selektiert werden:

Person kunden = Unternehmen.class.getAnnotation(Kunden.class).value()[0];

Remove ads

Annotation von Paketen

Die Java Language Specification erlaubt auch die Annotation von Paketen, beispielsweise um Dokumentation zu einem Paket bereitzustellen. Pro Paket darf maximal eine package-Deklaration mit Annotationen versehen sein. Falls ein Paket Annotationen erhalten soll, empfiehlt die Java Language Specification, eine gesonderte Datei namens package-info.java im Verzeichnis dieses Pakets anzulegen. Diese Datei beinhaltet dann die package-Deklaration mit den Annotationen.

Remove ads
Loading related searches...

Wikiwand - on

Seamless Wikipedia browsing. On steroids.

Remove ads