Um Annotationen eingehend zu erlernen, müssen wir in der Lage sein, unsere eigenen Annotationen zu definieren und zu verwenden. Bevor wir unsere eigenen Annotationen definieren, müssen wir die Syntax von Metaannotationen und zugehörigen Definitionsannotationen verstehen, die von Java bereitgestellt werden.
-------------------------------------------------- ----------------------------------
Meta-Anmerkung:
Die Rolle von Metaanmerkungen besteht darin, andere Anmerkungen zu kommentieren. Java5.0 definiert vier Standard-Meta-Annotationstypen, die zur Beschreibung anderer Annotationstypen verwendet werden. Von Java5.0 definierte Meta-Anmerkungen:
1.@Ziel,
2.@Aufbewahrung,
3.@Dokumentiert,
4.@Geerbt
Diese Typen und die von ihnen unterstützten Klassen finden Sie im Paket java.lang.annotation. Werfen wir einen Blick auf die Rolle jeder Meta-Annotation und die Anweisungen zur Verwendung der entsprechenden Unterparameter.
-------------------------------------------------- ----------------------------------
@Ziel:
@Target erklärt den Umfang der durch Annotation geänderten Objekte: Annotation kann für Pakete, Typen (Klassen, Schnittstellen, Aufzählungen, Annotationstypen), Typmitglieder (Methoden, Konstruktoren, Mitgliedsvariablen, Aufzählungswerte), Methodenparameter und lokale Variablen verwendet werden ( wie Schleifenvariablen, Catch-Parameter). Die Verwendung von target in der Deklaration des Annotation-Typs kann das geänderte Ziel klarer machen.
Funktion: Wird verwendet, um den Anwendungsbereich von Annotationen zu beschreiben (d. h.: wo die beschriebenen Annotationen verwendet werden können)
Die Werte (ElementType) sind:
1.CONSTRUCTOR: wird verwendet, um den Konstruktor zu beschreiben. 2.FIELD: wird verwendet, um die Domäne zu beschreiben. 3.LOCAL_VARIABLE: wird verwendet, um lokale Variablen zu beschreiben. 4.METHOD: wird verwendet, um die Methode zu beschreiben. 5.PACKAGE: wird verwendet, um das Paket zu beschreiben. 6.PARAMETER: wird verwendet zur Beschreibung der Parameter 7.TYPE: wird zur Beschreibung von Klassen, Schnittstellen (einschließlich Annotationstypen) oder Enum-Deklarationen verwendet
Anwendungsbeispiele:
@Target(ElementType.FIELD)
public @interface NoDBColumn {
}
-------------------------------------------------- ----------------------------------
@Zurückbehaltung:
@Retention definiert die Aufbewahrungsdauer der Annotation: Einige Annotationen erscheinen nur im Quellcode und werden vom Compiler verworfen, während andere in der Klassendatei kompiliert werden. Die Maschine ignoriert sie. während andere beim Laden der Klasse gelesen werden (bitte beachten Sie, dass dies keinen Einfluss auf die Ausführung der Klasse hat, da Annotation und Klasse separat verwendet werden). Verwenden Sie diese Meta-Annotation, um den „Lebenszyklus“ der Annotation zu begrenzen.
Funktion: Gibt an, auf welcher Ebene die Anmerkungsinformationen gespeichert werden müssen, und wird zur Beschreibung des Lebenszyklus der Anmerkung verwendet (d. h.: innerhalb welchem Bereich die beschriebene Anmerkung gültig ist).
Die Werte (RetentionPoicy) sind:
1.QUELLE: Gültig in der Quelldatei (d. h. die Quelldatei bleibt erhalten)
2.KLASSE: Gültig in Klassendateien (d. h. Klasse reserviert)
3.RUNTIME: zur Laufzeit gültig (d. h. zur Laufzeit beibehalten)
Der Retention-Meta-Annotationstyp hat als Mitglied einen eindeutigen Wert und sein Wert stammt aus dem Aufzählungstypwert von java.lang.annotation.RetentionPolicy. Konkrete Beispiele sind wie folgt:
-------------------------------------------------- ----------------------------------
@Dokumentiert:
@Documented wird verwendet, um andere Annotationstypen zu beschreiben, die als öffentliche API der annotierten Programmmitglieder verwendet werden sollten und daher von Tools wie Javadoc dokumentiert werden können. Dokumentiert ist eine Markup-Anmerkung und hat keine Mitglieder.
Die @Inherited-Meta-Annotation ist eine Markup-Annotation, die besagt, dass ein bestimmter annotierter Typ vererbt wird. Wenn für eine Klasse ein mit @Inherited geänderter Annotationstyp verwendet wird, wird diese Annotation für Unterklassen dieser Klasse verwendet.
Hinweis: @Inherited-Annotationstypen werden von Unterklassen der annotierten Klasse geerbt. Eine Klasse erbt keine Annotationen von der Schnittstelle, die sie implementiert, und eine Methode erbt keine Annotationen von der Methode, die sie überlädt.
Wenn die Retention der mit dem Annotationstyp @Inherited annotierten Annotation RetentionPolicy.RUNTIME ist, erweitert die Reflection-API diese Vererbung. Wenn wir java.lang.reflect verwenden, um Annotationen eines @Inherited-Annotationstyps abzufragen, beginnt die reflektierende Codeinspektion zu arbeiten: Sie überprüft die Klasse und ihre übergeordnete Klasse, bis der angegebene Annotationstyp oder die oberste Ebene der Klassenvererbungsstruktur gefunden wird erreicht ist.
Beispielcode:
-------------------------------------------------- ----------------------------------
Benutzerdefinierte Anmerkung:
Wenn Sie @interface zum Anpassen von Anmerkungen verwenden, wird die java.lang.annotation.Annotation-Schnittstelle automatisch geerbt und andere Details werden vom Compiler automatisch vervollständigt. Beim Definieren von Anmerkungen können Sie keine anderen Anmerkungen oder Schnittstellen erben. @interface wird zum Deklarieren einer Annotation verwendet, und jede Methode deklariert tatsächlich einen Konfigurationsparameter. Der Name der Methode ist der Name des Parameters und der Rückgabewerttyp ist der Typ des Parameters (der Rückgabewerttyp kann nur ein Basistyp, eine Klasse, ein String oder eine Aufzählung sein). Sie können den Standardwert eines Parameters über den Standardwert deklarieren.
Anmerkungsformat definieren:
öffentlicher @interface-Annotationsname {Definitionskörper}
Unterstützte Datentypen von Anmerkungsparametern:
1. Alle grundlegenden Datentypen (int, float, boolean, byte, double, char, long, short)
2. String-Typ 3. Klassentyp 4. Enum-Typ 5. Annotationstyp 6. Arrays aller oben genannten Typen
So legen Sie die Parameter im Annotation-Typ fest:
Erstens kann es nur mit den beiden Zugriffsrechten public oder default geändert werden. Beispielsweise ist String value(); hier ist die Methode auf den Standardtyp eingestellt;
Zweitens können Parametermitglieder nur die acht grundlegenden Datentypen Byte, Short, Char, Int, Long, Float, Double, Boolean und Datentypen wie String, Enum, Class, Anmerkungen und Arrays dieser Typen verwenden. String value(); Das Parametermitglied hier ist String;
Drittens: Wenn nur ein Parametermitglied vorhanden ist, ist es am besten, den Parameternamen auf „Wert“ gefolgt von Klammern zu setzen. Beispiel: Die FruitName-Annotation im folgenden Beispiel hat nur ein Parametermitglied.
Einfache benutzerdefinierte Anmerkungen und Beispiele für die Verwendung von Anmerkungen:
import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* Hinweise zu Fruchtnamen
* @author peida
*
*/
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@Dokumentiert
public @interface FruitName {
String value() default „“;
}
import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* Anmerkung zur Fruchtfarbe
* @author peida
*
*/
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@Dokumentiert
public @interface FruitColor {
/**
* Farbaufzählung
* @author peida
*
*/
öffentliche Aufzählung Color{BULE,RED,GREEN};
/**
* Farbattribute
* @zurückkehren
*/
Farbe FruitColor() Standard Color.GREEN;
}
annotation.FruitColor.Color importieren;
öffentliche Klasse Apple {
@FruitName("Apple")
privater String appleName;
@FruitColor(fruitColor=Color.RED)
private String appleColor;
public void setAppleColor(String appleColor) {
this.appleColor = appleColor;
}
öffentlicher String getAppleColor() {
return appleColor;
}
public void setAppleName(String appleName) {
this.appleName = appleName;
}
öffentlicher String getAppleName() {
return appleName;
}
public void displayName(){
System.out.println("Der Name der Frucht ist: Apple");
}
}