Introduzione a Java Annotations

Possiamo definire un'annotation come un appunto che mettiamo per specificare qualcosa relativo al codice che stiamo scrivendo, un attributo particolare, un metodo o una classe che hanno delle peculiarità. Attraverso questo meccanismo siamo capaci di dare espressività al codice, di renderlo più leggibile agli occhi di altri sviluppatori ma soprattutto agli occhi del compilatore.

Le annotations, infatti, sono delle annotazioni per il compilatore (o per chi si occupa del deploy dell'applicazione) che, attraverso di esse avrà la possibilità di effettuare determinate operazioni.

Questo paradigma, oltre a rendere più espressivo il codice sorgente, permette una migliore manutenzione dello stesso. Utilizzando le opportune annotations, infatti, riusciremo ad evitare possibili errori di compilazione, oppure, meglio ancora, potremo delegare a strumenti esterni la configurazione dell'applicazione che stiamo scrivendo (nell'ultima parte dell'articolo vedremo le annotations in ambiente enterprise).

La stessa Sun definisce gli usi delle annotazioni come di seguito:

Per informare il compilatore
Per processare a tempo di compilazione (o di deploy)
Per processare a run time
Le ultime due caratteristiche sono tipiche degli ambienti enterprise, che le possono utilizzare mediante reflection.

Annotazioni previste da JDK 1.5
Un'annotazione si presenta nella seguente forma:

Listato 4.1. Esempio di un'annotazione
@Autore(
name = "Pasquale Congiustì",
company = "HTML.it"
)
class ClasseAnnotata() {
...
}
Ogni annotazione si presenta con il simbolo @ seguito dal nome dell'annotazione. Eventualmente può essere valorizzata con dei valori, tra parentesi tonde come coppia nome-valore. Essa precede la classe, il metodo o l'attributo che vogliamo annotare.

In questo esempio abbiamo annotato la classe con l'annotation Autore ed i due attributi name e company.

Nella prossima lezione vediamo le Annotations di default, fornite a partire dalla distribuzione J2SE 1.5. Si tratta di tre semplici annotazioni utili al compilatore.

Attenzione: utilizzare le annotazioni significherà che il codice non può essere compilato (e spesso anche eseguito) con versioni Java precedenti.

Tipi di Annotations

@Deprecated
L'annotazione @Deprecated viene utilizzata per specificare che l'elemento indicato è un elemento deprecato, cioè, attivo (per mantenere retrocompatibilità) ma non consigliato perché rimpiazzato da uno nuovo e supportato.

Listato 5.1. Esempio con un annotazione @Deprecated
public class TestDeprecated {
@Deprecated
public void metodoA() {
System.out.println("Questo metodo è DEPRECATO, usa metodoB().");
}

public void metodoB() {
System.out.println("Questo metodo è SUPPORTATO.");
}
}
La compilazione di questa classe non darà alcun segnale, procederà tutto normalmente. Sarà la compilazione della classe che userà TestDeprecated a ricevere segnalazioni di warning dal compilatore quando viene utilizzato il metodo metodoA().

TestDeprecated td=new TestDeprecated();
Td.metodoA();
@Override
L'annotation @Override è probabilmente la più utile in quanto consente di evitare degli errori, che in fase di codifica spesso accadono. L'annotazione dice che l'elemento indicato è un elemento che fa l'override (sovrascrive) del relativo elemento, del genitore da cui eredita.

L'esempio ci permetterà di capire meglio.

Listato 5.2. Esempio di Override
class A{
void metodo1(){
System.out.println("Metodo 1");
}
}

class B extends A{
@Override
void metodoo1(){
System.out.println("Override A.metodo1()");
}
}
Abbiamo la classe genitore A, che presenta un metodo, metodo1(). Creiamo una classe B, erede di A. Vogliamo fare l'override di metodo1(), quindi annotiamo il metodo presente nella classe B con l'annotazione @Override, indicando che il metodo annotato è un metodo che sovrascrive un metodo del genitore.

Se provate a compilare il codice, il compilatore vi restituirà un errore. Se notate, infatti, ho inserito un errore di battitura nel nome del metodo. Senza l'annotazione @Override la compilazione sarebbe andata a buon fine e non ci saremmo accorti dell'errore.

@SuppressWarning
L'annotazione @SuppressWarning è utile quando vogliamo sopprimere le indicazioni di warning da parte del compilatore, ad esempio, perché stiamo usando dei metodi deprecati.

Listato 5.3. Esempio di SuppressWarning
@SuppressWarnings({"deprecation"})
public void usaMetodoDeprecato() {
TestDeprecated t = new TestDeprecated();
t.metodoA();
}
Pur usando dei metodi deprecated, al compilatore abbiamo segnalato di sopprimere i warning.

Creare e utilizzare nuove annotazioni

Le annotazioni di default sono di sicuro interesse, in quanto permettono di migliorare alcuni aspetti nelle fasi di compilazione, facendo sì che lo sviluppatore possa fare a meno di preoccuparsi di alcuni potenziali errori di codifica.

JDK 5 permette allo sviluppatore di definire delle proprie annotazioni totalmente customizzabili. Si tratta semplicemente di definire il nome dell'annotazione e di alcune proprietà che la contraddistinguono.

La cosa che rende le annotations uno strumento davvero importante, tanto da alterare il tipico paradigma di programmazione, è la possibilità di effettuare introspezione del codice.

Con la reflection è possibile valutare a runtime quali annotations sono presenti (e quali valori hanno in esse) e quindi effettuare determinate operazioni. Possiamo pensare ad un framework che gestica la persistenza con un database, dove all'interno del codice sono presenti delle annotations che indicano come mappare attributi di classe su colonne di database. Oppure utilizzare uno strumento personalizzato per team di sviluppo per commentare opportunamente il codice, chi ne modifica i metodi, chi li crea e quando e così via, per mantenere traccia del lavoro svolto.

Per un esempio pratico sulla creazione delle Java Annotations, rimandiamo all'articolo dedicato, che sicuramente tratta meglio della guida l'argomento.

Dove usare le annotazioni

È chiaro come l'utilizzo opportuno di annotation sia capace di dare tanta espressività in più al codice prodotto. Il reale vantaggio che si ha è quando tale strumento viene affiancato da altri strumenti che fanno introspezione del codice e, in base ad esso, creano delle configurazioni per framework.

È proprio in queste situazioni, infatti, che le annotations hanno un notevole vantaggio. Prima citavamo il framework per la persistenza automatizzata, è il caso di Hibernate, che permette di mappare classi e tabelle attraverso descrittori XML. Ora, attraverso l'uso di annotation, non sarà più necessario creare dei descrittori di configurazione, bensì, adottare delle annotazioni che suggeriscano l'associazione direttamente all'interno del codice.

Mantenere descrittori di configurazione opportunamente allineati può essere un problema, in quanto si tratta di file esterni (generalmente XML), difficilmente leggibili dall'occhio umano.

È il caso anche degli EJB 3.0 che, dalle annotazioni, traggono un notevole vantaggio, rendendo più veloce e meno incline ad errori la produzioni di logica applicativa enterprise.

0 replies since 17/5/2010, 10:14 74 views