Base de conocimientosCentro de exámenes
ESEspañol
Elegir idioma13

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