Java -benutzerdefinierte Anmerkungen
Java -Anmerkungen sind einige Meta -Informationen, die dem Code angehängt sind, der zum Parsen und zur Verwendung einiger Tools während der Zusammenstellung und Laufzeit verwendet wird und als Erklärung und Konfigurationsfunktionen dienen.
Anmerkungen werden die tatsächliche Logik des Codes nicht beeinflussen und nur eine Hilfsrolle spielen. Im java.lang.Annotationspaket enthalten.
1. Meta Note
Meta-Annotation bezieht sich auf die Annotation der Annotation. Einschließlich vier Typen: @retention @target @Document @inherited.
1.1. @Retention: Definieren Sie die Aufbewahrungsstrategie von Anmerkungen
@Retention (retentionPolicy.source) // Die Annotation ist nur im Quellcode vorhanden und enthält nicht @Retention (retentionPolicy.class) // Die Standard -Aufbewahrungsrichtlinie wird verwendet. Die Annotation wird in der Klassen -Bytecode -Datei vorhanden, sie kann jedoch nicht zur Laufzeit erhalten werden. @Retention (RetentionPolicy.Runtime) // Die Annotation wird in der Klassen -Bytecode -Datei vorhanden und können zur Laufzeit durch Reflexion erhalten werden.
Annotationsklasse:
@Retention (retentionPolicy.runtime) // Die Annotation wird in der Klassen -Bytecode -Datei vorhanden. @Target ({Elementtype.field, elementtype.method} kann durch Reflexion zur Laufzeit erhalten werden // das Ziel der Annotation ** Der Bereich des Feldes und die Aufzählungskonstante/Methode @dokumentiert // geben an, dass die Annotation in der Javadoc public @Interface {** ** ** ** ** ** ** ** ** ** ***is is it is is is is is is is is is is is is is is is is is is is is is is is is is is is is is is is is is is is is is is is is is is is is is is is is is is is is enthalten ist* false;/*** Feldname* @return*/String name () default "";/*** Ist es bearbeitet* @return*/boolean editable () Standard true;/*** Ob in der Liste angezeigt werden 0;} Entitätsklasse:
public class Anno {@FieldMeta(id=true,name="serial number",order=1)private int id;@FieldMeta(name="name",order=3)private String name;@FieldMeta(name="age",order=2)private int age;@FieldMeta(description="Description",order=4)public String desc(){return "test of java reflection to obtain annotation";}public int getId() {return id;} public void setId (int id) {this.id = id;} public String getName () {return name;} public void setName (String name) {this.name = name;} public int getageage () {return ay;} öffentliche Void -Setage (Int AGE) {this.age = älter;}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}} Holen Sie sich den Help -Kurs für Annotation:
public class SortableField {public SortableField(){}public SortableField(FieldMeta meta, Field field) {super();this.meta = meta;this.field = field;this.name=field.getName();this.type=field.getType();}public SortableField(FieldMeta meta, String name, Class<?> type) {super();this.meta = meta; name getName () {return name;} public void setName (String name) {this.name = name;} public class <?> GetType () {return type;} public void setType (Klasse <?> Typ) {this.type = type;}} Um Anmerkungen zur Laufzeit zu erhalten, erstellen Sie zunächst eine Basisklasse:
öffentliche Klasse Eltern <T> {private Klasse <T> Entität; public parent () {init ();}@unterdrückungwarnings ("Unbekämpft") öffentliche Liste <sortableField> init () {list <sortableField> list = new ArrayList <SortableField> ();/** GetClass (). (Klasse, Schnittstelle, primitiver Typ oder Leere) *und konvertiert ihn dann in parameterizedtype. . * getactualtTypeargumente () gibt ein Array von Typobjekten zurück, die die tatsächlichen Typparameter dieses Typs darstellen. * [0] ist der erste in diesem Array. . * Kurz gesagt, es soll die tatsächliche Art der generischen Parameter der Superklasse erhalten. . */entity = (class <t>) ((parameterizedtype) this.getClass (). Felder, enthalten jedoch keine ererbten Felder* Entity.getfields (); Gibt nur alle zugänglichen öffentlichen Felder der Klasse oder Schnittstelle zurück, die durch das Objekt*in der Klasse getDeclared ** () Methoden zurückgeben, Felder, Methoden usw. mit allen Zugriffsberechtigungen; * Siehe api * */field [] fields = entity.getDeclaredfields (); // für (field f: fields) {// Die Annotation enthält Fieldmeta fieldmeta meta = f.getAnnotation (fieldmeta.class); if (meta! Alle zugänglichen öffentlichen Methoden der Klasse oder Schnittstelle, die durch die Objektmethode [] methoden = entity.getMethods () dargestellt werden; Für (Methode M: Methoden) {Fieldmeta meta = M.Getannotation (fieldmeta.class); if (meta! Sortierung // Collections.sort (Liste, neue Fieldsortcom ()); Collections.sort (Liste, neuer Komparator <sortableField> () {@Overridepublic int Compare (sortableField S1, sortableField s2) {return s1.getmeta (). Order ()-S2GetMeta (). Order (); // // // // // // // // // // // zurücksend (); // // // ///// // // // // // // // ///// zurücksend (). s1.getName (). vergleicheto (s2.getName ()); // Sie können auch Compare für Vergleiche verwenden}});} returnlist;}} Erstellen Sie eine Unterklasse, um die Basisklasse zu erben:
Das Kind der öffentlichen Klasse erweitert Eltern <Anno> {} Testklasse:
public class testannotation {@Suppresswarnings ({"Unerreger", "rawttypes"}) public static void main (String [] args) {parent c = new Child (); liste <sortableField> list = C.init (); // Die Annotation in der Klasse in der Generik im Generik // Outputl -Ergebnis (Sortefield L: Liste) {-Println (-Pouting -Ergebnis): Sortable Field L:: Sortefield L:: Sortefield l:: sortable l. "+l.getName ()+"/t Feldtyp: "+l.gettype ()+"/t Annotationsname: "+l.getmeta (). name ()+"/t Annotation Beschreibung: "+l.getmeta (). Beschreibung ());}}}/////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////
1. Das Arbeitsprinzip der Annotation:
JDK5.0 bietet Annotationsfunktionen, mit der Entwickler ihre eigenen Annotationstypen definieren und verwenden können. Diese Funktion besteht aus einer Syntax, die Annotyp und eine Syntax definiert, die die Annotierungserklärung beschreibt, eine API mit der Annotation, eine Klassendatei, die Annotation verwendet, um zu ändern, und Annotationsverarbeitungstool.
Annotation wirkt sich nicht direkt auf die Semantik des Codes aus, kann jedoch als Tool oder Klassenbibliothek eines Programms angesehen werden. Es wird sich wiederum auf die Laufprogrammsemantik auswirken.
Annotation kann während der Laufzeit auf verschiedene Weise durch einen Reflexionsmechanismus gelesen werden.
2. @Override Annotation:
Java.lang
Kommentar Typ Override
@Target (value = Methode)
@Retention (value = Quelle)
public @Interface Override bedeutet, dass eine Methodenerklärung beabsichtigt, eine andere Methodeerklärung in der Superklasse zu überschreiben. Wenn die Methode mit diesem Annotationstyp kommentiert, die Superklasse -Methode jedoch nicht überschreibt, generiert der Compiler eine Fehlermeldung.
Die @Override -Annotation bedeutet, dass die Unterklasse die entsprechende Methode der übergeordneten Klasse überschreiben muss.
Override ist eine Markierungsannotation, die zur Identifizierung der Annotation verwendet wird. Der Annotationsname selbst repräsentiert die Informationen, die dem Tool -Programm übergeben werden sollen.
Hier ist ein Beispiel mit @Override Annotation:
Klasse A {private String -ID; A (String id) {this.id = id; } @Override public String toString () {return id; }}3.. @Deprecated Annotation:
Java.lang
Kommentar Typ veraltet
@Documented
@Retention (value = runtime)
Public @Interface veraltete Programmelemente, die mit @deprecated kommentiert sind, sind von Programmierern davon abgehalten, solche Elemente zu verwenden, normalerweise weil es gefährlich ist oder es bessere Optionen gibt. Der Compiler warnt, wenn sie nicht genehmigte Programmelemente verwenden oder um Neuschreibungen in nicht genehmigten Code durchführen.
@Deprecated Annotation Repräsentationsmethode wird nicht empfohlen.
Veraltet ist eine Markierungsannotation.
Hier ist ein Beispiel mit @Deprecated Annotation:
Klasse A {private String -ID; A (String id) {this.id = id; } @Deprecated public void execute () {System.out.println (id); } public static void main (String [] args) {a a = new a ("a123"); A.execute (); }}4. @Suppresswarnings Annotation:
Java.lang
Kommentieren typeSuppresswarnings
@Target (value = {Type, Feld, Methode, Parameter, Konstruktor, local_variable})
@Retention (value = Quelle)
public @Interface SuppressWarnings gibt an, dass die angegebene Compiler -Warnung im Kommentarelement (und alle in diesem Kommentarelement enthaltenen Programmelemente) nicht issplayed sein sollte. Beachten Sie, dass die in einem bestimmten Element nicht nicht isorierende Warnungen ein Supersatz aller Warnungen ist, die im Element nicht isoriert sind. Wenn Sie beispielsweise eine Klasse kommentieren, um eine Warnung zu entfernen und eine Methode zu kommentieren, um eine weitere Warnung zu entfernen, werden beide Warnungen in dieser Methode nicht geschlossen.
Abhängig vom Stil sollten Programmierer diese Annotation immer für die innersten verschachtelten Elemente verwenden, und sie funktioniert nur, wenn sie dort verwendet wird. Wenn Sie eine Warnung in einer bestimmten Methode entfernen möchten, sollten Sie die Methode anstelle ihrer Klasse kommentieren.
@SuppressWarnings Annotation zeigt die Unterdrückungswarnung an.
Hier ist ein Beispiel mit @Suppresswarnings Annotation:
@SuppressWarnings ("Deaktiviert") public static void main (string [] args) {listlist = new ArrayList (); list.add ("ABC");}5. benutzerdefinierte Anmerkungen:
Wenn @Interface zu benutzerdefinierten Anmerkungen verwendet wird, wird die Schnittstelle von Java.lang.Annotation.annotation automatisch geerbt und andere Details vom Compiler automatisch ausgeführt. Bei der Definition von Anmerkungen können andere Anmerkungen oder Schnittstellen nicht vererbt werden.
Passen Sie den einfachsten Kommentar an:
public @Interface Myannotation {} Verwenden Sie benutzerdefinierte Annotation: public class AnnotationTest2 {@myannotation public void execute () {System.out.println ("methode"); }} 5.1. Variablen hinzufügen:
public @Interface Myannotation {String value1 ();} Verwenden Sie benutzerdefinierte Annotationen: public class AnnotationTest2 {@myannotation (value1 = "abc") public void execute () {System.out.println ("Methode"); }}Wenn der in der Annotation verwendete Attributname Wert ist, kann die Attributwert -Schnittstelle direkt geschrieben werden, ohne den Namen des Attributs beim Zuweisen anzugeben. Mit Ausnahme der unerwarteten Variablennamen des Wertes müssen alle Variablennamen mit name = value zugewiesen werden.
5.2. Standardwerte hinzufügen:
public @Interface Myannotation {String value1 () Standard "ABC";}5.3. Multivariate Nutzung Aufzählung:
public @Interface Myannotation {String value1 () Standard "ABC"; Myenum value2 () Standard myenum.sunny;} enum myenum {sonnig, regnerisch} Verwenden Sie benutzerdefinierte Anmerkungen:
public class AnnotationTest2 {@myannotation (value1 = "a", value2 = myenum.sunny) public void execute () {System.out.println ("Methode"); }} 5.4. Array -Variablen:
public @Interface Myannotation {String [] value1 () Standard "ABC";} Verwenden Sie benutzerdefinierte Anmerkungen:
public class AnnotationTest2 {@myannotation (value1 = {"a", "b"}) public void execute () {System.out.println ("Methode"); }}6. Stellen Sie den Umfang der Annotation fest:
@Documented
@Retention (value = runtime)
@Target (value = Annotation_type)
Die öffentliche @Interface -Aufbewahrung gibt an, wie lange die Annotation des Annotationstyps beibehalten werden sollte. Wenn in der Deklaration vom Kommentarstyp keine Aufbewahrungsanträge vorhanden sind, stellt die Aufbewahrungsrichtlinie bei RetentionPolicy.Class aus.
Ziel -Meta -Kommentare sind nur gültig, wenn der Meta -Kommentar -Typ direkt für Kommentare verwendet wird. Wenn der Meta -Kommentar -Typ als Mitglied eines anderen Kommentararts verwendet wird, ist er ungültig.
öffentliche Aufbewahrungspolitik
Erweitert Enum <StentionPolicy> Kommentare Retentionspolitik. Konstanten für diesen Enum -Typ beschreiben verschiedene Strategien, um Kommentare zu behalten. Sie werden mit Retention -Meta -Kommentaren verwendet, um anzugeben, wie lange Anmerkungen erhalten bleiben.
KLASSE
Der Compiler protokolliert Kommentare in der Klassendatei, die VM muss jedoch keine Kommentare zur Laufzeit aufbewahren.
LAUFZEIT
Der Compiler erfasst die Kommentare in der Klassendatei und die VM behält die Kommentare zur Laufzeit bei, sodass sie reflektierend gelesen werden kann.
QUELLE
Kommentare, um den Compiler zu verwerfen. @Retention Annotation kann Compilern bei der Definition von Anmerkungen Annotationspolitik liefern.
Die Annotation der Klassenrichtungsrichtlinie ist @Suppresswarnings, die nicht in der .Class -Datei gespeichert wird.
6.1. Beispiele für die Verwendung in benutzerdefinierten Anmerkungen:
@Retention (retentionPolicy.class) public @Interface Myannotation {String [] value1 () Standard "ABC";}7. Beispiel für die Verwendung von Reflexionen zum Lesen von Annotationsinformationen der Richtlinien zur Laufzeitaufbewahrung:
java.lang.reflect
Schnittstellenanmerkungen
Alle bekannten Implementierungsklassen:
AccessibleObject, Klasse, Konstruktor, Feld, Methode, Paket repräsentiert ein kommentiertes Element des Programms, das derzeit in dieser VM ausgeführt wird. Diese Schnittstelle ermöglicht eine reflexive Lektüre von Kommentaren. Alle Kommentare, die mit Methoden in dieser Schnittstelle zurückgegeben werden, sind unveränderlich und serialisierbar. Der Anrufer kann das vom Accessor des zugewiesene Array aufzählende Mitglieds zurückgegebene Array ändern. Dies hat keinen Einfluss auf das von andere Anrufer zurückgegebene Array.
Wenn eine Methode in dieser Schnittstelle einen Kommentar zurückgibt (direkt oder indirekt), der ein zugewiesenes Klassenmitglied enthält, das auf eine Klasse verweist, auf die in dieser VM nicht zugegriffen werden kann, führt der Versuch, die Klasse zu lesen, indem die Methode aufgerufen wird, die von der relevanten Klasse auf dem zurückgegebenen Kommentar zurückgegeben wird.
INAntationPresent
boolean innotationPresent (Klasse <? Erweitert Annotation> AnnotationClass) Gibt true zurück, wenn der Kommentar des angegebenen Typs in diesem Element vorhanden ist, ansonsten false zurückgibt. Diese Methode wurde hauptsächlich entwickelt, um den Zugriff auf Tag -Kommentare zu erleichtern.
Parameter:
AnnotationClass - Klassenobjekt, die dem Annotationstyp entspricht
zurückkehren:
Geben Sie True zurück, wenn der Kommentar des angegebenen Kommentaryps in diesem Objekt vorhanden ist, ansonsten falsch
Werfen:
NullPointerexception - Wenn die angegebene Annotationsklasse null ist
Beginnen Sie mit der folgenden Version:
1.5
Getannotation
<T erweitert Annotation> T getAnnotation (Klasse <T> AnnotationClass) gibt diese Kommentare zurück, wenn Kommentare des angegebenen Typs dieses Elements vorliegen, ansonsten wird Null zurückgegeben.
Parameter:
AnnotationClass - Klassenobjekt, die dem Annotationstyp entspricht
zurückkehren:
Wenn die Kommentare des angegebenen Kommentaryps des Elements in diesem Objekt vorhanden sind, werden diese Kommentare zurückgegeben, ansonsten NULL
Werfen:
NullPointerexception - Wenn die angegebene Annotationsklasse null ist
Beginnen Sie mit der folgenden Version:
1.5
Getannotationen
Annotation [] getAnnotations () gibt alle Kommentare zurück, die in diesem Element vorhanden sind. (Wenn dieses Element nicht kommentiert wird, wird ein Array von Länge Null zurückgegeben.) Der Anrufer der Methode kann das zurückgegebene Array nach Belieben ändern. Dies hat keinen Einfluss auf das von andere Anrufer zurückgegebene Array.
zurückkehren:
Alle Kommentare, die in diesem Element existieren
Beginnen Sie mit der folgenden Version:
1.5
getDeclaredannotations
Annotation [] getDeclaredAnnotations () gibt alle Kommentare zurück, die direkt zu diesem Element existieren. Im Gegensatz zu anderen Methoden in dieser Schnittstelle ignoriert diese Methode vererbte Annotationen. (Wenn kein Kommentar direkt zu diesem Element vorliegt, wird ein Array mit Länge Null zurückgegeben.) Der Anrufer der Methode kann das zurückgegebene Array nach Belieben ändern. Dies hat keinen Einfluss auf das von andere Anrufer zurückgegebene Array.
zurückkehren:
Alle Kommentare, die direkt zu diesem Element existieren
Beginnen Sie mit der folgenden Version:
1.5
Hier ist ein Beispiel für die Verwendung von Reflexion zum Lesen von Annotationsinformationen der Richtlinien für Laufzeitaufbewahrung:
Benutzerdefinierte Anmerkungen:
@Retention (retentionPolicy.Runtime) public @Interface Myannotation {String [] value1 () Standard "ABC";} Verwenden Sie benutzerdefinierte Anmerkungen:
public class AnnotationTest2 {@myannotation (value1 = {"a", "b"}) @Deprecated public void execute () {System.out.println ("Methode"); }} Informationen in der Annotation lesen:
public static void main (String [] args) löst SicherheitException, NoSuchMethodException, illegalArgumentException, illegale Accessexception, InvocationTargetException {AnnotationTest2 AnnotationTest2 = new AnnotationTest2 () aus. // GetClass -Instanz von AnnotationTest2Class <AnnotationTest2> c = AnnotationTest2.Class; // GetMethodinStance -Methode Methode Methode = C.GetMethod ("Execute", New Class [] {}); // Bestimmen Sie, ob die Methode Myannotation Annotation enthält, wenn (method.InannotationPresent (myannotation.class)) {// die Annotationsinstanz dieser Methode myannotation myannotation = methode.getannotation (myannotation.class) abrufen; // Die Methode methody.invoke (AnnotationTest2, neues Objekt [] {}) ausführen; // Myannotation String [] value1 = myannotation.Value1 (); System.out.println (value1 [0]); } // Alle Anmerkungen zur Methode Annotation [] Annotationen = method.getAnnotations () erhalten; für (Annotation Annotation: Annotationen) {System.out.println (Annotation); }}8. Verwendung begrenzter Anmerkungen:
Begrenzte Anmerkungen verwenden @Target.
@Documented
@Retention (value = runtime)
@Target (value = Annotation_type)
public @Interface Ziel gibt den Typ der Programmelemente an, für den der Annotationstyp gilt. Wenn in der Deklaration von Kommentaren nicht ein Ziel -Meta -Kommentar vorliegt, kann der deklarierte Typ in jedem Programmelement verwendet werden. Wenn ein solcher Meta -Kommentar besteht, erzwingt der Compiler die angegebene Nutzungsgrenze. Beispielsweise zeigt dieser Meta -Kommentar an, dass der Deklarationstyp selbst ist, d. H. Der Meta -Kommentar -Typ. Es kann nur bei Deklarationen vom Kommentarstyp verwendet werden:
@Target (elementtype.annotation_type) public @Interface metaannotationType {...} Dieser Meta -Kommentar zeigt an, dass der Deklarationstyp nur als Mitgliedstypen in komplexen Annotyp -Deklarationen verwendet werden kann. Es kann nicht direkt für Kommentare verwendet werden:
@Target ({}) public @Interface membertype {...} Dies ist ein Kompilierungszeitfehler, der angibt, dass eine Elementtyp-Konstante im Zielkommentar mehr als einmal erscheint. Beispielsweise sind die folgenden Meta -Kommentare illegal:
@Target ({Elementtype.field, elementtype.method, elementtype.field}) public @Interface Bogus {...} public enum elementtypeErweitert Enum <Elementtype> Programmelementtyp. Konstanten dieses Enum -Typs bieten eine einfache Klassifizierung von Elementen, die in einem Java -Programm deklariert sind.
Diese Konstanten werden mit dem Target -Meta -Kommentar -Typ verwendet, um festzustellen, unter welchen Umständen die Verwendung des Kommentartyps legal ist.
Annotation_Type
Kommentartyp Deklaration
Konstruktor
Erklärung zur Konstruktormethode
FELD
Felderklärung (einschließlich Aufzählungskonstanten)
Local_variable
Lokale variable Deklaration
VERFAHREN
Methodenanweisung
PAKET
Paketanweisung
PARAMETER
Parameterdeklaration
TYP
Klasse, Schnittstelle (einschließlich Kommentierungstypen) oder Aufzählungserklärung
Beispiele für Einschränkungen bei der Verwendung von Anmerkungen:
@Target (elementtype.method) public @Interface Myannotation {string [] value1 () Standard "ABC";}9. Notizen zum Hilfdokument hinzufügen:
Um die API -Datei beim Erstellen einer Javadoc -Datei Annotationsinformationen hinzuzufügen, können Sie java.lang.annotation.documented verwenden.
Deklarieren Sie das Build -Annotationsdokument in einer benutzerdefinierten Annotation:
@DocumentedPublic @Interface Myannotation {String [] value1 () Standard "ABC";} Verwenden Sie benutzerdefinierte Anmerkungen:
public class AnnotationTest2 {@myannotation (value1 = {"a", "b"}) public void execute () {System.out.println ("Methode"); }}10. Vererbung in Anmerkungen verwenden:
Standardmäßig werden Anmerkungen nicht in Unterklassen geerbt. Sie können java.lang.Annotation.inherited Annotation Deklaration Wenn benutzerdefinierte Annotationen verwendet werden.
@Documented
@Retention (value = runtime)
@Target (value = Annotation_type)
public @Interface erbelt zeigt an, dass der Annotationstyp automatisch vererbt wird. Wenn in der Deklaration vom Kommentarstyp eine ererbte Meta -Annotation vorhanden ist und der Benutzer den Kommentartyp in einer Klassenerklärung abfragt, wird in der Klassenerklärung kein Kommentar dieses Typs vorhanden, wird der Kommentartyp automatisch in der Superklasse der Klasse abfragt. Dieser Vorgang wird wiederholt, bis diese Art von Kommentar gefunden oder die oberste Ebene der Klassenhierarchie erreicht ist. Wenn keine Superklasse eine Annotation dieser Art hat, zeigt die Abfrage an, dass die aktuelle Klasse keine solche Annotation hat.
Beachten Sie, dass dieser Meta -Kommentar -Typ ungültig ist, wenn Sie einen Anmerkungsart Typ verwenden, um etwas anderes als die Klasse zu kommentieren. Beachten Sie auch, dass dieser Meta -Kommentar nur die Erbschaft von Kommentaren aus Superklassen erleichtert; Für Kommentare zu implementierten Schnittstellen ist es ungültig.
In dem obigen Artikel handelt es sich kurz um Java -benutzerdefinierte Anmerkungen, und die Verwendung von Reflexion, um Anmerkungen während der Laufzeit zu erhalten, ist der gesamte Inhalt, den ich mit Ihnen teile. Ich hoffe, es kann Ihnen eine Referenz geben und ich hoffe, Sie können Wulin.com mehr unterstützen.