CKTIS / Java
Leer anotaciones de clase mediante reflexión
Recupera las anotaciones repetibles en un array y comprueba si hay una anotación marcadora. Distingue la búsqueda con herencia de la limitada a la declaración de la clase.
Versión: Java SE 21
Sintaxis
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)El literal de clase Child.class proporciona el objeto Class<Child> que se va a inspeccionar; Tag.class proporciona el objeto Class<Tag> que identifica el tipo de anotación buscado. Son métodos de instancia de Class: no hace falta crear un objeto Child. Para leer por reflexión anotaciones de una declaración de clase, aplica @Retention(RetentionPolicy.RUNTIME) al tipo de anotación.
getAnnotationsByType(Tag.class) devuelve un Tag[]; si no hay coincidencias, devuelve un array vacío, no null. Extrae las anotaciones del contenedor indicado por @Repeatable y conserva el orden de sus elementos. Si el tipo buscado lleva @Inherited y no hay coincidencias en la clase, ni directas ni dentro del contenedor, busca en las superclases, no en las interfaces. No combina resultados de distintos niveles. getDeclaredAnnotationsByType también examina el contenedor, pero solo consulta la clase inspeccionada.
isAnnotationPresent(A.class) devuelve un boolean y equivale a getAnnotation(A.class) != null. Es útil para anotaciones marcadoras, que no tienen elementos. Si no hay coincidencia directa y el tipo buscado lleva @Inherited, consulta las superclases, no las interfaces. No mira dentro del contenedor: las repeticiones que solo estén allí no hacen que la prueba devuelva true para el tipo repetible. getDeclaredAnnotation solo comprueba si hay una coincidencia directa en la clase y devuelve null si no la hay.
Todos los métodos anteriores que reciben un tipo de anotación lanzan NullPointerException si el argumento es null. Para comprobar si hay al menos una coincidencia, incluidas las del contenedor, usa getAnnotationsByType(Tag.class).length > 0.
Ejemplos
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();
}
}Resultado
Child tags: [alpha, beta] Child declared tags: 0 Child flag: true Child declared flag: false Base Tag present: false Local tags: [local]
`Child` hereda `@Flag` y las dos apariciones de `@Tag`, pero no declara ninguna. Las dos apariciones de `@Tag` en `Base` están en el contenedor `@Tags`, por lo que comprobar la presencia de `Tag.class` en `Base` devuelve `false`. La anotación `@Tag` de `Local` sustituye en el resultado a las heredadas, en vez de sumarse a ellas.
Lecciones relacionadas
- Java · Lección 58 · Avanzado · Versión: 2
Fuentes
- 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