Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / Java

Reflection in Java: accesso a campi e metodi

In Java SE 21, `Field` e `Method` permettono di consultare metadati e annotazioni, modificare campi e invocare metodi. Trovare un membro privato non concede l’accesso e `setAccessible(true)` è soggetto alle regole dei moduli.

Versione: Java SE 21

Sintassi

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 e Method, nel pacchetto java.lang.reflect, rappresentano membri di una classe. getDeclaredField(name) cerca il nome esatto del campo; getDeclaredMethod(name, parameterTypes...) seleziona il metodo in base al nome esatto e, nell’ordine, ai tipi dichiarati dei parametri. int.class e Integer.class selezionano overload diversi. La JVM ammette nella stessa classe metodi con lo stesso nome e gli stessi tipi dei parametri, ma con tipi di ritorno diversi. Se il tipo di ritorno di uno dei metodi corrispondenti è più specifico di tutti gli altri, getDeclaredMethod sceglie quel metodo; altrimenti ne sceglie uno arbitrariamente tra quelli corrispondenti. Entrambe le ricerche includono i membri privati ma non quelli ereditati. Se non c’è corrispondenza, lanciano rispettivamente NoSuchFieldException e NoSuchMethodException. Trovare un membro non concede l’accesso.

Se setAccessible(true) riesce su un Field o Method, disattiva i controlli di accesso del linguaggio Java per quell’oggetto di reflection, senza modificare il modificatore del membro. setAccessible(false) ripristina i controlli. Per un membro privato è possibile disattivarli nello stesso modulo. Tra moduli, il package che dichiara il membro deve essere aperto al modulo chiamante (opens); non basta esportarlo (exports). Se il modulo impedisce l’operazione, setAccessible(true) lancia InaccessibleObjectException, mentre trySetAccessible() restituisce false. Se un security manager installato nega la richiesta, entrambi i metodi possono lanciare SecurityException.

Field.getName() restituisce il nome semplice del campo e getType() il tipo dichiarato come Class<?>, per esempio int.class. get(receiver) esegue il boxing di un valore primitivo; set(receiver, value) esegue l’unboxing di un valore compatibile per un campo primitivo. getInt(receiver) legge un int da un campo int o da un campo di un tipo primitivo convertibile a int per ampliamento. setInt(receiver, value) scrive un int in un campo int o di un tipo primitivo più ampio. Queste operazioni non eseguono conversioni per restringimento. Disattivare i controlli non consente di scrivere nei campi static final né nei campi final di record o classi nascoste.

Method.getName() restituisce il nome semplice del metodo. invoke(receiver, args...) chiama il metodo già selezionato: all’occorrenza esegue l’unboxing degli argomenti primitivi e può ampliarne il tipo. Esegue il boxing di un risultato primitivo e restituisce null per void. Per letture, scritture e chiamate si passa un’istanza compatibile; per un membro static, il ricevente viene ignorato e può essere null. Un ricevente null per un membro di istanza causa NullPointerException. Un ricevente, un valore o una lista di argomenti incompatibili causano IllegalArgumentException. Un accesso negato durante l’operazione causa IllegalAccessException. Un’eccezione lanciata dal metodo chiamato è avvolta in InvocationTargetException; recuperala con getCause().

Field.getAnnotation(Label.class) restituisce l’annotazione sulla dichiarazione del campo o null. Method.isAnnotationPresent(Label.class) verifica se l’annotazione è presente sulla dichiarazione del metodo senza restituirla. Definisci il tipo di annotazione con @Retention(RetentionPolicy.RUNTIME) affinché sia visibile tramite reflection. La lettura di questi metadati non richiede di disattivare i controlli di accesso.

Esempi

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

Risultato

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

`Owner` e `ReflectionMembersDemo` sono classi distinte di primo livello nello stesso modulo. La prima lettura e la prima chiamata vengono negate. Dopo aver disattivato i controlli, l’esempio scrive `7` e `11`; `add(5)` restituisce `16` senza modificare `count`.

Lezioni correlate

  • Java · Lezione 54 · Avanzato · Versione: 2

Fonti