WissensdatenbankPrüfungszentrum
DEDeutsch
Sprache wählen13

CKTIS / Java

Java-Reflection: Zugriff auf Felder und Methoden

In Java SE 21 lassen sich mit `Field` und `Method` Metadaten und Annotationen abfragen, Feldwerte ändern und Methoden aufrufen. Das Auffinden eines privaten Members gewährt noch keinen Zugriff; für `setAccessible(true)` gelten Modulregeln.

Version: Java SE 21

Syntax

Java SE 21 — java.lang.reflect
Field f = Owner.class.getDeclaredField("count");
Method m = Owner.class.getDeclaredMethod("add", int.class);
f.setAccessible(true);
m.setAccessible(true);

// Field instance methods
void setAccessible(boolean flag)
void set(Object receiver, Object value)
Object get(Object receiver)
String getName()
Class<?> getType()
void setInt(Object receiver, int value)
int getInt(Object receiver)
<T extends Annotation> T getAnnotation(Class<T> annotationType)

// Method instance methods
void setAccessible(boolean flag)
Object invoke(Object receiver, Object... args) throws IllegalAccessException, InvocationTargetException
boolean isAnnotationPresent(Class<? extends Annotation> annotationType)
String getName()

Field und Method aus java.lang.reflect repräsentieren Klassenmember. getDeclaredField(name) sucht nach dem exakten Feldnamen; getDeclaredMethod(name, parameterTypes...) wählt nach dem exakten Methodennamen und den deklarierten Parametertypen in ihrer Reihenfolge aus. int.class und Integer.class wählen unterschiedliche Überladungen. Die JVM erlaubt in derselben Klasse Methoden mit identischem Namen und identischen Parametertypen, aber unterschiedlichen Rückgabetypen. Ist der Rückgabetyp einer passenden Methode spezifischer als alle anderen passenden Rückgabetypen, wählt getDeclaredMethod diese Methode; andernfalls wählt es eine der passenden Methoden beliebig aus. Die Suche berücksichtigt private, aber keine geerbten Member. Fehlt ein Treffer, folgt NoSuchFieldException beziehungsweise NoSuchMethodException. Das Auffinden allein gewährt keinen Zugriff.

Ein erfolgreiches setAccessible(true) unterdrückt auf einem Field oder Method die Zugriffskontrollen der Java-Sprache für dieses Reflexionsobjekt, ohne den Modifizierer des Members zu ändern. setAccessible(false) aktiviert die Kontrollen wieder. Für private Member ist die Unterdrückung im selben Modul möglich. Modulübergreifend muss das deklarierende Paket für das aufrufende Modul geöffnet sein (opens); exports allein genügt nicht. Verhindert das Modul den Zugriff, wirft setAccessible(true) eine InaccessibleObjectException, während trySetAccessible() false liefert. Lehnt ein installierter Sicherheitsmanager die Anfrage ab, können beide Methoden SecurityException werfen.

Field.getName() liefert den einfachen Feldnamen, getType() den deklarierten Typ als Class<?>, etwa int.class. get(receiver) verpackt primitive Werte, und set(receiver, value) entpackt für ein primitives Feld einen kompatiblen Wert. getInt(receiver) liest einen int aus einem int-Feld oder einem primitiven Feld, dessen Typ sich zu int erweitern lässt. setInt(receiver, value) schreibt einen int in ein Feld vom Typ int oder von einem breiteren primitiven Typ. Verengende Konvertierungen finden nicht statt. Die Unterdrückung erlaubt keine Schreibzugriffe auf static final-Felder oder auf final-Felder in Records oder versteckten Klassen.

Method.getName() liefert den einfachen Methodennamen. invoke(receiver, args...) ruft die bereits ausgewählte Methode auf, entpackt dabei bei Bedarf primitive Argumente und kann deren Typ erweitern. Ein primitives Ergebnis wird verpackt; für void kommt null zurück. Beim Lesen, Schreiben und Aufrufen ist eine kompatible Instanz nötig; bei static-Membern wird der Empfänger ignoriert und darf null sein. null statt einer benötigten Instanz führt zu NullPointerException; ein inkompatibler Empfänger, Wert oder eine unpassende Argumentliste führt zu IllegalArgumentException. Wird der Zugriff bei der Operation verweigert, folgt IllegalAccessException. Ausnahmen der Zielmethode werden in InvocationTargetException verpackt; getCause() liefert die Ursache.

Field.getAnnotation(Label.class) liefert die Deklarationsannotation des Feldes oder null. Method.isAnnotationPresent(Label.class) prüft, ob die Deklarationsannotation der Methode vorhanden ist, ohne sie zurückzugeben. Deklariere den Annotationstyp mit @Retention(RetentionPolicy.RUNTIME), damit er per Reflection sichtbar ist. Für diese Metadatenabfragen müssen Zugriffskontrollen nicht unterdrückt werden.

Beispiele

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

@Retention(RetentionPolicy.RUNTIME)
@interface Label {
    String value();
}

final class Owner {
    @Label("items")
    private int count = 1;

    @Label("operation")
    private int add(int delta) {
        return count + delta;
    }
}

public class ReflectionMembersDemo {
    public static void main(String[] args) throws ReflectiveOperationException {
        Owner owner = new Owner();
        Field field = Owner.class.getDeclaredField("count");
        Method method = Owner.class.getDeclaredMethod("add", int.class);

        try {
            field.get(owner);
            throw new AssertionError("Private field was readable before override");
        } catch (IllegalAccessException expected) {
            System.out.println("field access denied");
        }
        try {
            method.invoke(owner, 5);
            throw new AssertionError("Private method was callable before override");
        } catch (IllegalAccessException expected) {
            System.out.println("method access denied");
        }

        field.setAccessible(true);
        method.setAccessible(true);

        System.out.println(field.getName() + ":" + field.getType().getName()
                + " label=" + field.getAnnotation(Label.class).value());
        field.set(owner, Integer.valueOf(7));
        System.out.println("get=" + field.get(owner));
        field.setInt(owner, 11);
        System.out.println("getInt=" + field.getInt(owner));
        System.out.println(method.getName() + " annotated="
                + method.isAnnotationPresent(Label.class));
        System.out.println("invoke=" + method.invoke(owner, 5));
    }
}

Ergebnis

field access denied
method access denied
count:int label=items
get=7
getInt=11
add annotated=true
invoke=16

`Owner` und `ReflectionMembersDemo` sind getrennte Top-Level-Klassen im selben Modul. Der erste Lesezugriff und Aufruf werden verweigert. Nach Unterdrückung der Kontrollen schreibt das Beispiel `7` und `11`; `add(5)` liefert `16`, ohne `count` zu ändern.

Zugehörige Lektionen

  • Java · Lektion 54 · Fortgeschritten · Version: 2

Quellen