Come leggere il valore di un campo privato da una classe diversa in Java?

Prova FieldUtils da apache commons-lang3:

FieldUtils.readField(object, fieldName, true);

La riflessione non è l'unico modo per risolvere il problema (che consiste nell'accedere alla funzionalità/comportamento privato di una classe/componente)

Una soluzione alternativa è estrarre la classe dal .jar, decompilarlo usando (diciamo) Jode o Jad , cambiare il campo (o aggiungere un accessor) e ricompilarlo rispetto all'originale .vaso. Quindi metti il nuovo .classe prima del .jar nel classpath, o reinserirlo nel .jar. (l'utilità jar consente di estrarre e reinserire in un esistente .vaso)

Come indicato di seguito, questo risolve il problema più ampio dell'accesso/modifica dello stato privato piuttosto che semplicemente accedere/modificare un campo.

Ciò richiede che .jar non sia firmato, ovviamente.

Un'altra opzione che non è stata ancora menzionata: usa Groovy. Groovy consente di accedere a variabili di istanza private come effetto collaterale del design della lingua. Che tu abbia o meno un getter per il campo, puoi semplicemente usare

def obj = new IWasDesignedPoorly()
def hashTable = obj.getStuffIWant()

Utilizzando il Riflessione in Java è possibile accedere a tutti i private/public campi e metodi di una classe a un'altra .Ma secondo l'Oracolo documentazione {[9] } nella sezione svantaggi hanno raccomandato che:

"Poiché reflection consente al codice di eseguire operazioni illegali nel codice non riflettente, come l'accesso a campi e metodi privati, l'uso di reflection può causare effetti collaterali imprevisti, che possono rendere il codice disfunzionale e può distruggere la portabilità. Il codice riflettente interrompe le astrazioni e quindi può cambiare il comportamento con gli aggiornamenti della piattaforma "

Ecco i seguenti snapt di codice per dimostrare i concetti di base di Reflection

Riflettenza1.java

public class Reflection1{

    private int i = 10;

    public void methoda()
    {

        System.out.println("method1");
    }
    public void methodb()
    {

        System.out.println("method2");
    }
    public void methodc()
    {

        System.out.println("method3");
    }

}

Riflettenza2.java

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


public class Reflection2{

    public static void main(String ar[]) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException
    {
        Method[] mthd = Reflection1.class.getMethods(); // for axis the methods 

        Field[] fld = Reflection1.class.getDeclaredFields();  // for axis the fields  

        // Loop for get all the methods in class
        for(Method mthd1:mthd)
        {

            System.out.println("method :"+mthd1.getName());
            System.out.println("parametes :"+mthd1.getReturnType());
        }

        // Loop for get all the Field in class
        for(Field fld1:fld)
        {
            fld1.setAccessible(true);
            System.out.println("field :"+fld1.getName());
            System.out.println("type :"+fld1.getType());
            System.out.println("value :"+fld1.getInt(new Reflaction1()));
        }
    }

}

Spero che possa aiutare.

Come menziona oxbow_lakes, puoi usare reflection per aggirare le restrizioni di accesso (supponendo che SecurityManager ti consenta).

Detto questo, se questa classe è così mal progettata che ti fa ricorrere a tale hackery, forse dovresti cercare un'alternativa. Certo, questo piccolo trucco potrebbe farti risparmiare qualche ora, ma quanto ti costerà lungo la strada?

Utilizzare il framework di ottimizzazione Java Fuliggine per modificare direttamente il bytecode. http://www.sable.mcgill.ca/soot /

Fuliggine è completamente scritto in Java e funziona con le nuove versioni di Java.

È necessario effettuare le seguenti operazioni:

private static Field getField(Class<?> cls, String fieldName) {
    for (Class<?> c = cls; c != null; c = c.getSuperclass()) {
        try {
            final Field field = c.getDeclaredField(fieldName);
            field.setAccessible(true);
            return field;
        } catch (final NoSuchFieldException e) {
            // Try parent
        } catch (Exception e) {
            throw new IllegalArgumentException(
                    "Cannot access field " + cls.getName() + "." + fieldName, e);
        }
    }
    throw new IllegalArgumentException(
            "Cannot find field " + cls.getName() + "." + fieldName);
}

Solo una nota aggiuntiva su reflection: ho osservato in alcuni casi speciali, quando diverse classi con lo stesso nome esistono in pacchetti diversi, che reflection come usato nella risposta principale potrebbe non riuscire a scegliere la classe corretta dall'oggetto. Quindi, se si sa che cosa è il pacchetto.classe dell'oggetto, quindi è meglio accedere ai suoi valori di campo privato come segue:

org.deeplearning4j.nn.layers.BaseOutputLayer ll = (org.deeplearning4j.nn.layers.BaseOutputLayer) model.getLayer(0);
Field f = Class.forName("org.deeplearning4j.nn.layers.BaseOutputLayer").getDeclaredField("solver");
f.setAccessible(true);
Solver s = (Solver) f.get(ll);

(Questa è la classe di esempio che non funzionava per me)

Se si utilizza Spring, ReflectionTestUtils fornisce alcuni strumenti utili che aiutano qui con il minimo sforzo. È descritto come "per l'uso in scenari di test di unità e integrazione". Esiste anche una classe simile denominata ReflectionUtils ma questa è descritta come "Solo per uso interno" - vedi questa risposta per un'interpretazione di ciò che significa.

Per risolvere l'esempio pubblicato:

Hashtable iWantThis = (Hashtable)ReflectionTestUtils.getField(obj, "stuffIWant");