Annotazioni Ripetute in Java

Annotazioni Ripetute

A partire da JDK 8, un'annotazione può essere ripetuta sullo stesso elemento.

Questo tipo di annotazione è chiamato annotazione ripetuta. Perché un'annotazione sia ripetibile, deve essere annotata con l'annotazione @Repeatable, definita in java.lang.annotation. Il suo campo value specifica il tipo contenitore per l'annotazione ripetibile. Il contenitore è specificato come un'annotazione per la quale il campo value è un array del tipo di annotazione ripetibile. Quindi, per creare un'annotazione ripetibile, dobbiamo creare un'annotazione contenitore e poi specificare quel tipo di annotazione come argomento dell'annotazione @Repeatable.

Per accedere alle annotazioni ripetute usando un metodo come getAnnotation(), utilizzeremo l'annotazione contenitore, non l'annotazione ripetibile. Il seguente programma mostra questo approccio. Converte la versione di LaMiaAnnotazione mostrata precedentemente in un'annotazione ripetibile e dimostra il suo uso.

// Dimostra un'annotazione ripetuta.

import java.lang.annotation.*;
import java.lang.reflect.*;

// Rende LaMiaAnnotazione ripetibile.
@Retention(RetentionPolicy.RUNTIME)
@Repeatable(LeMieAnnotazioniRipetute.class)
@interface LaMiaAnnotazione {
    String str() default "Testing";

    int val() default 9000;
}

// Questa è l'annotazione contenitore.
@Retention(RetentionPolicy.RUNTIME)
@interface LeMieAnnotazioniRipetute {
    LaMiaAnnotazione[] value();
}

class RipetiAnnotazione {

    // Ripete LaMiaAnnotazione su ilMioMetodo().
    @LaMiaAnnotazione(str = "Prima annotazione", val = -1)
    @LaMiaAnnotazione(str = "Seconda annotazione", val = 100)
    public static void ilMioMetodo(String str, int i) {
        RipetiAnnotazione ob = new RipetiAnnotazione();
        try {
            Class<?> c = ob.getClass();
            // Ottiene le annotazioni per ilMioMetodo().
            Method m = c.getMethod("ilMioMetodo", String.class, int.class);
            // Visualizza le annotazioni LaMiaAnnotazione ripetute.
            Annotation anno = m.getAnnotation(LeMieAnnotazioniRipetute.class);
            for (LaMiaAnnotazione a : ((LeMieAnnotazioniRipetute) anno).value()) {
                System.out.println(a);
            }
        } catch (NoSuchMethodException exc) {
            System.out.println("Metodo Non Trovato.");
        }
    }

    public static void main(String[] args) {
        ilMioMetodo("test", 10);
    }
}

L'output è mostrato qui:

@LaMiaAnnotazione(val=-1, str="Prima annotazione")
@LaMiaAnnotazione(val=100, str="Seconda annotazione")

Come spiegato, purché LaMiaAnnotazione sia ripetibile, deve essere annotata con l'annotazione @Repeatable, che specifica la sua annotazione contenitore. L'annotazione contenitore è chiamata LeMieAnnotazioniRipetute. Il programma accede alle annotazioni ripetute chiamando getAnnotation(), passando la classe dell'annotazione contenitore, non l'annotazione ripetibile stessa. Come mostra l'output, le annotazioni ripetute vengono restituite in un contenitore e nell'esempio abbiamo utilizzato un ciclo for-each per visualizzare ciascuna annotazione ripetuta.

Un altro modo per ottenere le annotazioni ripetute è usare uno dei metodi in AnnotatedElement che può operare direttamente su un'annotazione ripetuta. Questi sono getAnnotationsByType() e getDeclaredAnnotationsByType(). Qui, utilizzeremo il primo. È mostrato qui:

default <T extends Annotation> T[ ] getAnnotationsByType(Class<T> annoType)

Restituisce un array delle annotazioni di annoType associate all'oggetto chiamante. Se non sono presenti annotazioni, l'array sarà di lunghezza zero. Ecco un esempio. Assumendo il programma precedente, la seguente sequenza usa getAnnotationsByType() per ottenere le annotazioni LaMiaAnnotazione ripetute:

Annotation[] annos = m.getAnnotationsByType(LaMiaAnnotazione.class);
for(Annotation a : annos)
    System.out.println(a);

Qui, il tipo di annotazione ripetuta, che è LaMiaAnnotazione, è passato a getAnnotationsByType(). L'array restituito contiene tutte le istanze di LaMiaAnnotazione associate a ilMioMetodo(), che, in questo esempio, sono due. Ogni annotazione ripetuta può essere acceduta tramite il suo indice nell'array. In questo caso, ogni annotazione LaMiaAnnotazione è visualizzata tramite un ciclo for-each.