Java Annotations

Le annotazioni Java forniscono informazioni sul codice. Le annotazioni Java non hanno alcun effetto diretto sul codice che annotano. Nel tutorial sulle annotazioni Java, esamineremo quanto segue;

1. Annotazioni Java integrate
2. Come scrivere un’annotazione personalizzata
3. Utilizzo delle annotazioni e come analizzarle utilizzando API di riflessione.

Annotazioni Java

Java 1.5 ha introdotto le annotazioni ed ora è ampiamente utilizzato nei framework Java EE come Hibernate, Jersey, e Spring. L’annotazione Java è un metadato incorporato nel programma stesso. Può essere analizzato dall’analizzatore di annotazioni o dal compilatore. Possiamo anche specificare la disponibilità delle annotazioni solo al momento della compilazione o fino al runtime. Prima delle annotazioni Java, i metadati del programma erano disponibili attraverso i commenti Java o tramite Javadoc, ma le annotazioni offrono più di questo. I metadati delle annotazioni possono essere disponibili anche a runtime e gli analizzatori di annotazioni possono utilizzarli per determinare il flusso di esecuzione. Ad esempio, in Jersey webservice aggiungiamo un’annotazione PATH con una stringa URI a un metodo e, durante l’esecuzione, Jersey la analizza per determinare il metodo da invocare per il dato modello URI.

Java Custom Annotation

Creare un’annotazione personalizzata è simile a scrivere un’interfaccia, tranne che la parola chiave dell’interfaccia è preceduta dal simbolo _@_. Possiamo dichiarare metodi nell’annotazione. Vediamo un esempio di annotazione personalizzata in Java e poi discuteremo delle sue caratteristiche e dei punti importanti.

package com.journaldev.annotations;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Documented
@Target(ElementType.METHOD)
@Inherited
@Retention(RetentionPolicy.RUNTIME)
public @interface MethodInfo{
	String author() default "Pankaj";
	String date();
	int revision() default 1;
	String comments();
}

Alcuni punti importanti sulle annotazioni Java sono:

1. I metodi di annotazione non possono avere parametri.
2. I tipi di ritorno dei metodi di annotazione sono limitati a tipi primitivi, String, Enums, Annotation o array di questi.
3. I metodi di annotazione in Java possono avere valori predefiniti.
4. Le annotazioni possono avere meta annotazioni ad esse collegate. Le meta annotazioni sono utilizzate per fornire informazioni sull’annotazione stessa.

Meta annotazioni in Java

Esistono cinque tipi di meta annotazioni:

1. @Documented – indica che gli elementi che utilizzano questa annotazione dovrebbero essere documentati da Javadoc e strumenti simili. Questo tipo dovrebbe essere utilizzato per annotare le dichiarazioni di tipi le cui annotazioni influenzano l’uso degli elementi annotati da parte dei loro clienti. Se una dichiarazione di tipo è annotata con Documented, le sue annotazioni diventano parte dell’API pubblica degli elementi annotati.
2. @Target – indica i tipi di elemento del programma a cui è applicabile un tipo di annotazione. Alcuni valori possibili sono TIPO, METODO, COSTRUTTORE, CAMPO, ecc. Se la meta-annotazione Target non è presente, allora l’annotazione può essere utilizzata su qualsiasi elemento del programma.
3. @Inherited – indica che un tipo di annotazione viene ereditato automaticamente. Se l’utente richiede il tipo di annotazione su una dichiarazione di classe e la dichiarazione di classe non ha alcuna annotazione per questo tipo, allora la superclasse della classe verrà automaticamente interrogata per il tipo di annotazione. Questo processo verrà ripetuto fino a quando non viene trovata un’annotazione per questo tipo o fino alla cima della gerarchia delle classi (Object).
4. @Retention – indica per quanto tempo le annotazioni con il tipo annotato devono essere mantenute. Prende un argomento RetentionPolicy i cui valori possibili sono SOURCE, CLASS e RUNTIME
5. @Repeatable – utilizzato per indicare che il tipo di annotazione il cui riferimento annota è ripetibile.

Annotationi integrate in Java

Java fornisce cinque annotazioni integrate.

1. @Override – Quando vogliamo sovrascrivere un metodo della superclasse, dovremmo usare questa annotazione per informare il compilatore che stiamo sovrascrivendo un metodo. Quindi, quando il metodo della superclasse viene rimosso o modificato, il compilatore mostrerà un messaggio di errore. Scopri perché dovremmo sempre usare l’annotazione di override in Java durante la sovrascrittura di un metodo.
2. @Deprecated – Quando vogliamo far sapere al compilatore che un metodo è deprecato, dovremmo usare questa annotazione. Java consiglia che nel javadoc dovremmo fornire informazioni su perché questo metodo è deprecato e qual è l’alternativa da utilizzare.
3. @SuppressWarnings – Questo serve solo per dire al compilatore di ignorare avvertimenti specifici che produce, ad esempio l’uso di tipi grezzi nei generici di Java. La sua politica di ritenzione è SOURCE e viene scartata dal compilatore.
4. @FunctionalInterface – Questa annotazione è stata introdotta in Java 8 per indicare che l’interfaccia è destinata a essere un’interfaccia funzionale.
5. @SafeVarargs – Un’asserzione del programmatore che il corpo del metodo o costruttore annotato non esegue operazioni potenzialmente non sicure sul suo parametro varargs.

Esempio di annotazioni Java

Vediamo un esempio di Java che mostra l’uso delle annotazioni integrate in Java così come l’uso di un’annotazione personalizzata creata da noi nell’esempio precedente.

package com.journaldev.annotations;

import java.io.FileNotFoundException;
import java.util.ArrayList;
import java.util.List;

public class AnnotationExample {

	public static void main(String[] args) {
	}

	@Override
	@MethodInfo(author = "Pankaj", comments = "Main method", date = "Nov 17 2012", revision = 1)
	public String toString() {
		return "Overriden toString method";
	}

	@Deprecated
	@MethodInfo(comments = "deprecated method", date = "Nov 17 2012")
	public static void oldMethod() {
		System.out.println("old method, don't use it.");
	}

	@SuppressWarnings({ "unchecked", "deprecation" })
	@MethodInfo(author = "Pankaj", comments = "Main method", date = "Nov 17 2012", revision = 10)
	public static void genericsTest() throws FileNotFoundException {
		List l = new ArrayList();
		l.add("abc");
		oldMethod();
	}

}

I believe above java annotation example is self-explanatory and showing the use of annotations in different cases.

Analisi delle annotazioni Java

Utilizzeremo la riflessione per analizzare le annotazioni Java da una classe. Si prega di notare che la politica di conservazione delle annotazioni dovrebbe essere RUNTIME altrimenti le sue informazioni non saranno disponibili a runtime e non saremo in grado di recuperare alcun dato da essa.

package com.journaldev.annotations;

import java.lang.annotation.Annotation;
import java.lang.reflect.Method;

public class AnnotationParsing {

	public static void main(String[] args) {
		try {
			for (Method method : AnnotationParsing.class.getClassLoader()
					.loadClass(("com.journaldev.annotations.AnnotationExample")).getMethods()) {
				// verifica se l'annotazione MethodInfo è presente per il metodo
				if (method.isAnnotationPresent(com.journaldev.annotations.MethodInfo.class)) {
					try {
						// itera tutte le annotazioni disponibili nel metodo
						for (Annotation anno : method.getDeclaredAnnotations()) {
							System.out.println("Annotation in Method '" + method + "' : " + anno);
						}
						MethodInfo methodAnno = method.getAnnotation(MethodInfo.class);
						if (methodAnno.revision() == 1) {
							System.out.println("Method with revision no 1 = " + method);
						}

					} catch (Throwable ex) {
						ex.printStackTrace();
					}
				}
			}
		} catch (SecurityException | ClassNotFoundException e) {
			e.printStackTrace();
		}
	}

}

Il risultato del programma precedente è:

Annotation in Method 'public java.lang.String com.journaldev.annotations.AnnotationExample.toString()' : @com.journaldev.annotations.MethodInfo(author=Pankaj, revision=1, comments=Main method, date=Nov 17 2012)
Method with revision no 1 = public java.lang.String com.journaldev.annotations.AnnotationExample.toString()
Annotation in Method 'public static void com.journaldev.annotations.AnnotationExample.oldMethod()' : @java.lang.Deprecated()
Annotation in Method 'public static void com.journaldev.annotations.AnnotationExample.oldMethod()' : @com.journaldev.annotations.MethodInfo(author=Pankaj, revision=1, comments=deprecated method, date=Nov 17 2012)
Method with revision no 1 = public static void com.journaldev.annotations.AnnotationExample.oldMethod()
Annotation in Method 'public static void com.journaldev.annotations.AnnotationExample.genericsTest() throws java.io.FileNotFoundException' : @com.journaldev.annotations.MethodInfo(author=Pankaj, revision=10, comments=Main method, date=Nov 17 2012)

La Reflection API è molto potente e ampiamente utilizzata in Java, nei framework J2EE come Spring, Hibernate, JUnit, controlla Riflessione in Java. Questo è tutto per il tutorial sull’esempio di annotazioni Java, spero tu abbia imparato qualcosa da esso. Aggiornamenti delle annotazioni Java:

1. Specifiche del Servlet 3.0 hanno introdotto l’uso delle annotazioni per la configurazione del Servlet e i parametri di inizializzazione, leggi di più su Java Servlet Tutorial.
2. Possiamo utilizzare le annotazioni in Struts 2 per configurare le sue classi di azioni e le pagine di risultato, controlla l’esempio funzionante su Struts 2 Hello World Annotation Example.

Riferimento: sito Oracle