Analisi dell'annotazione Java

Panoramica

　　　　　　 Java ha introdotto le annotazioni Annotation nella versione 1.5, anche conosciute come Java Annotation, le annotazioni sono un tipo di metadati grammaticali che possono essere utilizzati direttamente nel codice sorgente, come classi, metodi, variabili, parametri, nomi di pacchetti, ecc. Diversamente dai tag Javadoc, il compilatore può conservare il codice delle annotazioni durante la generazione del file class, e per utilizzare le annotazioni durante l'esecuzione del programma (run-time), la macchina virtuale Java le conserva, in modo che possano essere recuperate le informazioni relative alle annotazioni Annotation attraverso la reflection.

Annotazioni integrate

In realtà, nella nostra vita quotidiana, incontriamo spesso i commenti, come @Override, @Deprecated, ecc., che sono annotazioni integrate nel JDK. Vediamo prima quali sono le annotazioni integrate in Java.
　•Le annotazioni agiscono sul codice Java
◦@Override verifica se un metodo è un metodo sovrascritto, se questo metodo non viene trovato nel padre o nell'interfaccia implementata, il processo di compilazione genererà un errore.
　◦@Deprecated etichetta un metodo o una classe come obsoleti, se si utilizza tale classe o metodo, il processo di compilazione genererà un avviso
　◦@SuppressWarnings notifica al compilatore di ignorare gli avvisi riguardanti i parametri etichettati
　◦@SafeVarargs ignora gli avvisi riguardanti la chiamata a metodi o costruttori con parametri generici, annotazione aggiunta nel 1.7
　◦@FunctionalInterface indica che un'interfaccia dichiarata verrà utilizzata come interfaccia funzionale, annotazione aggiunta nel 1.8

•Le annotazioni che si applicano ad altre annotazioni sono chiamate meta-annotazioni (Meta Annotation)
◦@Retention indica quando utilizzare l'annotazione etichettata (ovvero quando l'annotazione verrà conservata)
■Viene mantenuto solo nel codice sorgente e viene eliminato durante il processo di compilazione (RetentionPolicy.RUNTIME)
　■Le annotazioni vengono salvate durante il processo di compilazione nel file class e vengono ignorate al momento del caricamento del file class (RetentionPolicy.CLASS)
　■Le annotazioni vengono lette al momento del caricamento del file class, ovvero sono disponibili durante l'esecuzione e possono essere ottenute informazioni sulle annotazioni tramite reflection (RetentionPolicy.RUNTIME)

　◦@Documented indica che l'annotazione etichettata verrà scritta nel documento Javadoc durante la generazione
　◦@Target indica l'intervallo di applicazione dell'annotazione etichettata
■ElementType.TYPE: utilizzato per descrivere la classe, l'interfaccia (incluso il tipo di annotazione) o la dichiarazione enum
　■ElementType.FIELD: utilizzato per descrivere il campo
　■ElementType.METHOD: utilizzato per descrivere il metodo
　■ElementType.PARAMETER: utilizzato per descrivere il parametro
　■ElementType.CONSTRUCTOR: utilizzato per descrivere il costruttore
　■ElementType.LOCAL_VARIABLE: utilizzato per descrivere la variabile locale
　■ElementType.ANNOTATION_TYPE: utilizzato per descrivere l'annotazione
　■ElementType.PACKAGE: utilizzato per descrivere il pacchetto

　◦@Inherited indica che l'annotazione etichettata è ereditabile, ovvero se un'annotazione modificata con @Inherited viene utilizzata per una classe, l'annotazione verrà applicata anche alla classe figlia.
　◦@Repeatable indica che l'annotazione etichettata può essere applicata più volte allo stesso oggetto, nuova annotazione aggiunta nella versione 1.9

　Annotazione personalizzata

È stato detto così tanto sugli annotazioni, si concentra su meta-annotazioni, quando definiamo annotazioni personalizzate, di solito utilizziamo meta-annotazioni per aiutarci. La forma dell'annotazione personalizzata è public @interface nome_annotazione {corpo}, l'uso di @interface per definire un'annotazione eredita automaticamente l'interfaccia java.lang.annotation.Annotation. Quando si definisce un'annotazione personalizzata, non si può ereditare altre annotazioni o interfacce. I metodi dichiarati nell'annotazione sono in realtà dichiarati come parametri di annotazione, il nome del metodo è il nome del parametro, il tipo di ritorno è il tipo del parametro, è possibile dichiarare il valore predefinito del parametro con default.

Creare un'annotazione personalizzata è molto semplice, utilizzare @interface per definire un'annotazione, come segue.

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Documented
public @interface ClassInfo {
 String author() default "Wang";
 String date();
 String comments();
}

È stata definita un'annotazione personalizzata chiamata ClassInfo, in base a @Retention, questa annotazione esisterà sempre, ossia esisterà durante l'esecuzione del programma, questa annotazione rimarrà valida; @Target(ElementType.TYPE) indica che l'annotazione ClassInfo è applicata ai dichiarativi di classe, interfaccia o enum; @Documented
L'informazione ClassInfo può essere scritta nel documento Javadoc.

Ecco alcuni parametri di annotazione nella annotazione personalizzata, ci sono tre parametri di annotazione, i parametri di annotazione possono essere impostati con valori predefiniti, ad esempio il parametro di annotazione author, il valore predefinito è Wang, gli altri due parametri non hanno valori predefiniti.

Ecco un'altra annotazione personalizzata.

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface MethodInfo {
 String description() default "No Description";
 String date();
}

Questa annotazione personalizzata MethodInfo è applicata ai metodi, durante l'esecuzione del programma, questa annotazione esiste anche; contiene due parametri di annotazione.

La definizione dei parametri di annotazione (definizione del metodo), può solo utilizzare i modificatori di accesso public o default, il tipo dei parametri supporta le seguenti tipologie.
　•Ogni tipo di dati di base (byte, int, short, long, float, double, char, boolean)
　• Tipo String
　• Tipo Class
　• Tipo enum
　• Tipo Annotation
　• Tutti i tipi di array

Utilizzo delle annotazioni

Oltre alle due annotazioni menzionate sopra, è stata aggiunta un'annotazione di ambito Field.

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface FieldInfo {
 String type();
 String name();
}

Se i parametri delle annotazioni personalizzate non sono dichiarati con un valore predefinito, è necessario assegnare questi parametri durante l'uso dell'annotazione personalizzata, altrimenti il compilatore genererà un errore.

Guarda il codice di utilizzo delle annotazioni:

@ClassInfo(author = "wang",
  date = "2016/9/13",
  comments = "annotation demo")
public class AnnotationDemo {
 @FieldInfo(type = "public", name = "firstField")
 public int firstField;
 @FieldInfo(type = "private", name = "secondField")
 private String secondField;
 @MethodInfo(description = "method in AnnotationDemo", name = "firstMethod")
 public void firstMethod(String value) {
  System.out.printf("first method involved");
 }
 @MethodInfo(description = "method in AnnotationDemo", name="secondMethod")
 private void secondMethod() {
  System.out.printf("first method involved");
 }
}

Ottieni informazioni sugli annotazioni

Per ottenere informazioni sugli annotazioni, è necessario garantire che queste siano presenti durante l'esecuzione del programma, quindi generalmente si aggiunge l'annotazione meta @Retention(RetentionPolicy.RUNTIME) alle annotazioni personalizzate, in modo che durante l'esecuzione del programma possiamo ottenere alcune informazioni sugli annotazioni tramite reflection. Per ulteriori spiegazioni sulla reflection, si può consultare questo articolo.

public class AnnotationTest {
 public static void main(String[] args) {
  resolveClassAnnotationInfo(AnnotationDemo.class);
  resolveFieldAnnotationInfo(AnnotationDemo.class);
  resolveMethodAnnotationInfo(AnnotationDemo.class);
 }
 private static void resolveClassAnnotationInfo(Class<?> clz) {
  // Giudicare se la classe ha l'annotazione ClassInfo
  if(clz.isAnnotationPresent(ClassInfo.class)) {
   ClassInfo classInfo = (ClassInfo) clz.getAnnotation(ClassInfo.class);
   System.out.println(classInfo.author() + " " + classInfo.comments() + " " + classInfo.date());
  }
 }
 private static void resolveFieldAnnotationInfo(Class<?> clz) {
  Field[] fields = clz.getDeclaredFields();
  per (Field field : fields) {
   if(field.isAnnotationPresent(FieldInfo.class)) {
    FieldInfo fieldInfo = (FieldInfo) field.getAnnotation(FieldInfo.class);
    System.out.println(fieldInfo.type() + " " + fieldInfo.name());
   }
  }
 }
 private static void resolveMethodAnnotationInfo(Class<?> clz) {
  Method[] methods = clz.getDeclaredMethods();
  per (Method method : methods) {
   if(method.isAnnotationPresent(MethodInfo.class)) {}}
    MethodInfo methodInfo = (MethodInfo) method.getAnnotation(MethodInfo.class);
    System.out.println(methodInfo.name() + " " + methodInfo.description());
   }
  }
 }
}

Ottieni Field/Method e altri dalla classe tramite reflection, ottieni le annotazioni correlate tramite getAnnotation() o getAnnotations(), e puoi ottenere informazioni specifiche delle annotazioni una volta ottenute le annotazioni specifiche.

L'output del risultato dell'esecuzione è il seguente:

Figura-1 Immagine del risultato di esecuzione

Sommario

Per i principianti di Java o per i programmatori Java con un po' di esperienza, l'interazione con gli annotazioni di Java potrebbe essere limitata, e in pratica, vengono utilizzate raramente, ma sono spesso visibili nel codice. Questo articolo fornisce una breve introduzione alle annotazioni, almeno a livello di lettura del codice non dovrebbe esserci alcun problema.

Questo è tutto il contenuto dell'articolo. Spero che sia utile per il vostro studio e vi prego di sostenere il nostro manuale di urla.

Dichiarazione: Il contenuto di questo articolo è stato tratto da Internet, di proprietà del rispettivo autore. Il contenuto è stato contribuito volontariamente dagli utenti di Internet e caricato autonomamente. Questo sito non detiene i diritti di proprietà e non ha effettuato alcuna modifica manuale. Non si assume alcuna responsabilità legale. Se si rileva contenuto sospetto di violazione del copyright, si prega di inviare una email a notice#oldtoolbag.com (sostituire # con @) per segnalare il problema e fornire prove pertinenti. Una volta verificata la violazione, il sito rimuoverà immediatamente il contenuto sospetto.