Riflessione Java - impatto di setAccessible (true)

Sto usando alcune annotazioni per impostare dinamicamente i valori dei campi nelle classi. Poiché desidero farlo indipendentemente dal fatto che sia pubblico, protetto o privato, sto chiamando setAccessible(true)l'oggetto Field ogni volta prima di chiamare il set()metodo. La mia domanda è che tipo di impatto ha la setAccessible()chiamata sul campo stesso?

Più specificamente, diciamo che è un campo privato e questo insieme di chiamate in codice setAccessible(true). Se un altro punto nel codice dovesse poi recuperare lo stesso campo attraverso la riflessione, il campo sarebbe già accessibile? Oppure i metodi getDeclaredFields()e getDeclaredField()restituiscono ogni volta nuove istanze di un oggetto Field?

Immagino che un altro modo per affermare la domanda sia se chiamo setAccessible(true), quanto è importante riportarlo al valore originale dopo aver finito?

Con setAccessible()si modifica il comportamento di AccessibleObject, cioè l' Fieldistanza, ma non il campo effettivo della classe. Ecco la documentazione (estratto):

Un valore di trueindica che l'oggetto riflesso deve sopprimere i controlli per il controllo dell'accesso al linguaggio Java quando viene utilizzato

E un esempio eseguibile:

public class FieldAccessible {
    public static class MyClass {
        private String theField;
    }

    public static void main(String[] args) throws Exception {
        MyClass myClass = new MyClass();
        Field field1 = myClass.getClass().getDeclaredField("theField");
        field1.setAccessible(true);
        System.out.println(field1.get(myClass)); // no exception
        Field field2 = myClass.getClass().getDeclaredField("theField");
        System.out.println(field2.get(myClass)); // IllegalAccessException
    }

}

Il getDeclaredFieldmetodo deve restituire ogni volta un nuovo oggetto, esattamente perché questo oggetto ha il accessibleflag mutabile . Quindi non è necessario reimpostare il flag. Puoi trovare tutti i dettagli in questo post del blog .

Come altri poster hanno indicato, setAccessibleè applicabile solo a quell'istanza del tuo java.lang.reflect.Field, quindi non è necessario riportare l'accessibilità al suo stato originale.

Però...

Se vuoi che le tue chiamate field.setAccessible(true)siano persistenti devi usare i metodi sottostanti in java.lang.Classe java.lang.reflect.Field. Il pubblico di fronte a metodi che inviare copie del Fieldcaso, in modo che "dimentica" dopo ogni volta che si fa qualcosa di simileclass.getField(name)

import java.lang.reflect.*;
import sun.reflect.FieldAccessor;

public class Reflect {
    private static Method privateGetDeclaredFields;
    private static Method getFieldAccessor;

    public static Field[] fields(Class<?> clazz) throws Exception {
        return (Field[]) privateGetDeclaredFields.invoke(clazz, false);
    }

    public static <T> T get(Object instance, Field field) throws Exception {
        return ((FieldAccessor) getFieldAccessor.invoke(field, instance)).get(instance);
    }

    public static void set(Object instance, Field field, Object value) throws Exception {
        ((FieldAccessor) getFieldAccessor.invoke(field, instance)).set(instance, value);
    }

    static {
        try {
            // These are used to access the direct Field instances instead of the copies you normally get through #getDeclaredFields.
            privateGetDeclaredFields = Class.class.getDeclaredMethod("privateGetDeclaredFields", boolean.class);
            privateGetDeclaredFields.setAccessible(true);
            getFieldAccessor = Field.class.getDeclaredMethod("getFieldAccessor", Object.class);
            getFieldAccessor.setAccessible(true);
        } catch (Exception e) {
            // Should only occur if the internals change.
            e.printStackTrace();
        }
    }
}

Aggiornamento : questa implementazione è per Java 8, le versioni future cambiano il back-end che lo interrompe. Lo stesso concetto si applica comunque se si desidera davvero continuare questa strategia.

import java.lang.reflect.Field;
import java.lang.reflect.Method;

public class PrivateVariableAcc {

    public static void main(String[] args) throws Exception {
        PrivateVarTest myClass = new PrivateVarTest();
        Field field1 = myClass.getClass().getDeclaredField("a");
        field1.setAccessible(true);
        System.out.println("This is access the private field-"
            + field1.get(myClass));
        Method mm = myClass.getClass().getDeclaredMethod("getA");
        mm.setAccessible(true);
        System.out.println("This is calling the private method-"
            + mm.invoke(myClass, null));
    }

}