CKTIS / Java
Leggere le annotazioni di classe tramite reflection
Leggi le annotazioni ripetibili in un array e verifica la presenza di un’annotazione marcatore. Distingui la ricerca con ereditarietà da quella limitata alla dichiarazione della classe.
Versione: Java SE 21
Sintassi
On java.lang.Class<T> (instance methods; Annotation is java.lang.annotation.Annotation):
<A extends Annotation> A[] getAnnotationsByType(Class<A> annotationClass)
boolean isAnnotationPresent(Class<? extends Annotation> annotationClass)
<A extends Annotation> A[] getDeclaredAnnotationsByType(Class<A> annotationClass)
<A extends Annotation> A getDeclaredAnnotation(Class<A> annotationClass)
Class literals: Child.class has type Class<Child>; Tag.class has type Class<Tag>.
Example call: Child.class.getAnnotationsByType(Tag.class)Il letterale di classe Child.class fornisce l’oggetto Class<Child> da esaminare; Tag.class fornisce l’oggetto Class<Tag> che identifica il tipo di annotazione cercato. Sono metodi di istanza di Class: non serve creare un oggetto Child. Per leggere tramite reflection le annotazioni di una dichiarazione di classe, applica @Retention(RetentionPolicy.RUNTIME) al tipo di annotazione.
getAnnotationsByType(Tag.class) restituisce un Tag[]; se non ci sono corrispondenze, restituisce un array vuoto, non null. Estrae le annotazioni dal contenitore indicato da @Repeatable, mantenendo l’ordine dei suoi elementi. Se il tipo cercato ha @Inherited e nella classe non ci sono corrispondenze, né dirette né nel contenitore, la ricerca risale le superclassi, non le interfacce. Non unisce i risultati di livelli diversi. getDeclaredAnnotationsByType estrae anch’esso le annotazioni dal contenitore, ma controlla solo la classe esaminata.
isAnnotationPresent(A.class) restituisce un boolean ed equivale a getAnnotation(A.class) != null. È utile per le annotazioni marcatore, che non hanno elementi. Se manca una corrispondenza diretta e il tipo cercato ha @Inherited, controlla le superclassi, non le interfacce. Non guarda dentro il contenitore: le ripetizioni presenti solo lì non fanno restituire true per il tipo ripetibile. getDeclaredAnnotation verifica solo se c’è una corrispondenza diretta sulla classe e restituisce null in caso contrario.
Tutti i metodi citati che accettano un tipo di annotazione lanciano NullPointerException se l’argomento è null. Per verificare se esiste almeno una corrispondenza, comprese quelle nel contenitore, usa getAnnotationsByType(Tag.class).length > 0.
Esempi
import java.lang.annotation.*;
import java.util.Arrays;
public class AnnotationDemo {
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Inherited
@interface Flag {}
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Inherited
@Repeatable(Tags.class)
@interface Tag { String value(); }
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Inherited
@interface Tags { Tag[] value(); }
@Flag
@Tag("alpha")
@Tag("beta")
static class Base {}
static class Child extends Base {}
@Tag("local")
static class Local extends Child {}
public static void main(String[] args) {
System.out.println("Child tags: " + values(Child.class.getAnnotationsByType(Tag.class)));
System.out.println("Child declared tags: " + Child.class.getDeclaredAnnotationsByType(Tag.class).length);
System.out.println("Child flag: " + Child.class.isAnnotationPresent(Flag.class));
System.out.println("Child declared flag: " + (Child.class.getDeclaredAnnotation(Flag.class) != null));
System.out.println("Base Tag present: " + Base.class.isAnnotationPresent(Tag.class));
System.out.println("Local tags: " + values(Local.class.getAnnotationsByType(Tag.class)));
}
private static String values(Tag[] tags) {
return Arrays.stream(tags).map(Tag::value).toList().toString();
}
}Risultato
Child tags: [alpha, beta] Child declared tags: 0 Child flag: true Child declared flag: false Base Tag present: false Local tags: [local]
`Child` eredita `@Flag` ed entrambe le occorrenze di `@Tag`, ma non ne dichiara nessuna. Le due occorrenze di `@Tag` su `Base` sono nel contenitore `@Tags`, quindi il test di presenza di `Tag.class` su `Base` restituisce `false`. L’annotazione `@Tag` di `Local` prende il posto delle occorrenze ereditate nel risultato, senza aggiungersi a esse.
Lezioni correlate
- Java · Lezione 58 · Avanzato · Versione: 2
Fonti
- Java SE 21 API — Class.getAnnotationsByType
- Java SE 21 API — Class.isAnnotationPresent
- Java SE 21 API — Class.getDeclaredAnnotationsByType
- Java SE 21 API — Class.getDeclaredAnnotation
- Java SE 21 API — AnnotatedElement: kinds of annotation presence
- Java SE 21 API — Inherited
- Java SE 21 API — RetentionPolicy.RUNTIME
- Java Language Specification, Java SE 21 — §9.6.3 Repeatable Annotation Interfaces
- Java Language Specification, Java SE 21 — §9.7.5 Multiple Annotations of the Same Interface
- Java Language Specification, Java SE 21 — §15.8.2 Class Literals