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

Ho una classe mal progettata in una terza parte JARe devo accedere a uno dei suoi campi privati . Ad esempio, perché dovrei scegliere il campo privato è necessario?

class IWasDesignedPoorly {
    private Hashtable stuffIWant;
}

IWasDesignedPoorly obj = ...;

Come posso usare la riflessione per ottenere il valore di stuffIWant?

Per accedere ai campi privati, devi ottenerli dai campi dichiarati della classe e renderli accessibili:

Field f = obj.getClass().getDeclaredField("stuffIWant"); //NoSuchFieldException
f.setAccessible(true);
Hashtable iWantThis = (Hashtable) f.get(obj); //IllegalAccessException

EDIT : come è stato commentato da aperkins , sia accedere al campo, impostarlo come accessibile e recuperare il valore può generare Exceptions, anche se le uniche eccezioni verificate che è necessario tenere presente sono commentate sopra.

Verrà NoSuchFieldExceptiongenerato se si richiedesse un campo con un nome che non corrispondesse a un campo dichiarato.

obj.getClass().getDeclaredField("misspelled"); //will throw NoSuchFieldException

Verrà IllegalAccessExceptiongenerato se il campo non fosse accessibile (ad esempio, se è privato e non è stato reso accessibile perdendo la f.setAccessible(true)linea.

Le RuntimeExceptions che possono essere lanciate sono SecurityExceptions (se le JVM SecurityManagernon ti consentono di modificare l'accessibilità di un campo), oppure IllegalArgumentExceptions, se provi ad accedere al campo su un oggetto non del tipo di classe del campo:

f.get("BOB"); //will throw IllegalArgumentException, as String is of the wrong type

Prova FieldUtilsda apache commons-lang3:

FieldUtils.readField(object, fieldName, true);

Reflection non è l'unico modo per risolvere il problema (ovvero accedere alla funzionalità / comportamento privato di una classe / componente)

Una soluzione alternativa è quella di estrarre la classe dal .jar, decompilarla usando (diciamo) Jode o Jad , cambiare il campo (o aggiungere un accessorio) e ricompilarla con il .jar originale. Quindi metti il ​​nuovo .class davanti al .jarnel percorso di classe o reinseriscilo nel file .jar. (l'utilità jar consente di estrarre e reinserire un file .jar esistente)

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

Ciò richiede .jarovviamente di non essere firmato.

Un'altra opzione che non è stata ancora menzionata: usa Groovy . Groovy ti 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 Reflection in Java è possibile accedere a tutti i private/publiccampi e i metodi di una classe per un'altra. Ma come da documentazione Oracle nella sezione svantaggi hanno raccomandato che:

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

ecco i seguenti codici per dimostrare i concetti di base di Reflection

Reflection1.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");
    }

}

Reflection2.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 la riflessione per aggirare le restrizioni di accesso (supponendo che il tuo SecurityManager ti consenta).

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

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

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

Devi fare quanto segue:

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

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

Per affrontare l'esempio pubblicato:

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

Solo una nota aggiuntiva sulla riflessione: ho osservato in alcuni casi speciali, quando esistono diverse classi con lo stesso nome in pacchetti diversi, quella riflessione usata nella risposta superiore potrebbe non riuscire a scegliere la classe corretta dall'oggetto. Quindi, se sai qual è il pacchetto.class dell'oggetto, allora è meglio accedere ai suoi valori del 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)

È possibile utilizzare @JailBreak di Manifold per una riflessione Java diretta e sicura:

@JailBreak Foo foo = new Foo();
foo.stuffIWant = "123;

public class Foo {
    private String stuffIWant;
}

@JailBreaksblocca la foovariabile locale nel compilatore per l'accesso diretto a tutti i membri nella Foogerarchia di.

Allo stesso modo è possibile utilizzare il metodo di estensione jailbreak () per un utilizzo una tantum:

foo.jailbreak().stuffIWant = "123";

Attraverso il jailbreak()metodo è possibile accedere a qualsiasi membro nella Foogerarchia.

In entrambi i casi il compilatore risolve l'accesso al campo per te in modo sicuro, come se fosse un campo pubblico, mentre Manifold genera un codice di riflessione efficiente per te sotto il cofano.

Scopri di più sul collettore .

È abbastanza facile con lo strumento XrayInterface . Basta definire i getter / setter mancanti, ad es

interface BetterDesigned {
  Hashtable getStuffIWant(); //is mapped by convention to stuffIWant
}

e xray il tuo progetto povero progettato:

IWasDesignedPoorly obj = new IWasDesignedPoorly();
BetterDesigned better = ...;
System.out.println(better.getStuffIWant());

Internamente questo si basa sulla riflessione.

Prova ad aggirare il problema per il caso, il cui livello si desidera impostare / ottenere dati è una delle tue classi.

Basta creare un public setter(Field f, Object value)e public Object getter(Field f)per quello. Puoi anche fare un controllo sicuro delle tue funzioni membro. Ad esempio per il setter:

class myClassName {
    private String aString;

    public set(Field field, Object value) {
        // (A) do some checkings here  for security

        // (B) set the value
        field.set(this, value);
    }
}

Certo, ora devi scoprire il java.lang.reflect.Fieldfor sStringprima di impostare il valore del campo.

Uso questa tecnica in un generico ResultSet-to-and-from-model-mapper.