WissensdatenbankPrüfungszentrum
DEDeutsch
Sprache wählen13

CKTIS / Java

Klassenannotationen per Reflection auslesen

Lies wiederholbare Annotationen als Array aus und prüfe auf Markerannotationen. Unterscheide die Suche in Oberklassen von der Suche nur in der untersuchten Klasse.

Version: Java SE 21

Syntax

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)

Das Klassenliteral Child.class liefert das zu untersuchende Class<Child>-Objekt; Tag.class liefert das Class<Tag>-Objekt für den gesuchten Annotationstyp. Es handelt sich um Instanzmethoden von Class: Ein Child-Objekt ist nicht nötig. Damit Reflection Annotationen an Klassendeklarationen lesen kann, versieh den Annotationstyp mit @Retention(RetentionPolicy.RUNTIME).

getAnnotationsByType(Tag.class) liefert ein Tag[], bei keinem Treffer ein leeres Array statt null. Die Methode entpackt den mit @Repeatable angegebenen Container in der Reihenfolge seiner Einträge. Hat der gesuchte Typ @Inherited und findet sich in der Klasse weder direkt noch im Container ein Treffer, sucht die Methode in Oberklassen, nicht in Schnittstellen. Treffer aus verschiedenen Ebenen werden nicht zusammengeführt. getDeclaredAnnotationsByType entpackt den Container ebenfalls, prüft aber nur die untersuchte Klasse.

isAnnotationPresent(A.class) liefert einen boolean und entspricht getAnnotation(A.class) != null. Das eignet sich für Markerannotationen, die keine Elemente haben. Gibt es keinen direkten Treffer und hat der gesuchte Typ @Inherited, prüft die Methode Oberklassen, nicht Schnittstellen. Sie schaut nicht in den Container: Wiederholungen, die nur darin stehen, führen für den wiederholbaren Typ nicht zu true. getDeclaredAnnotation prüft nur auf einen direkten Treffer an der Klasse und liefert sonst null.

Alle genannten Methoden, die einen Annotationstyp erwarten, werfen bei einem null-Argument eine NullPointerException. Um auch Einträge im Container zu berücksichtigen, prüfe auf mindestens einen Treffer mit getAnnotationsByType(Tag.class).length > 0.

Beispiele

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();
    }
}

Ergebnis

Child tags: [alpha, beta]
Child declared tags: 0
Child flag: true
Child declared flag: false
Base Tag present: false
Local tags: [local]

`Child` erbt `@Flag` und beide `@Tag`-Instanzen, deklariert aber keine davon. Die beiden `@Tag`-Instanzen an `Base` stecken im Container `@Tags`; die Anwesenheitsprüfung für `Tag.class` an `Base` ergibt daher `false`. Das eigene `@Tag` an `Local` hat Vorrang vor den geerbten Instanzen, statt sie zu ergänzen.

Zugehörige Lektionen

  • Java · Lektion 58 · Fortgeschritten · Version: 2

Quellen