¿Cómo leer el valor de un campo privado de una clase diferente en Java?

Tengo una clase mal diseñada en un tercero JARy necesito acceder a uno de sus campos privados . Por ejemplo, ¿por qué debería elegir un campo privado si es necesario?

class IWasDesignedPoorly {
    private Hashtable stuffIWant;
}

IWasDesignedPoorly obj = ...;

¿Cómo puedo usar la reflexión para obtener el valor de stuffIWant?

Para acceder a los campos privados, debe obtenerlos de los campos declarados de la clase y luego hacerlos accesibles:

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

EDITAR : como ha comentado aperkins , tanto acceder al campo, configurarlo como accesible y recuperar el valor puede arrojar Exceptions, aunque las únicas excepciones marcadas de las que debe tener en cuenta se comentaron anteriormente.

Se NoSuchFieldExceptiongeneraría si solicitara un campo con un nombre que no correspondiera a un campo declarado.

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

Se IllegalAccessExceptiongeneraría si el campo no fuera accesible (por ejemplo, si es privado y no se ha hecho accesible al perder la f.setAccessible(true)línea).

Los RuntimeExceptions que se pueden lanzar son SecurityExceptions (si las JVM SecurityManagerno le permitirán cambiar la accesibilidad de un campo), o IllegalArgumentExceptions, si intenta acceder al campo en un objeto que no es del tipo de clase del campo:

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

Pruebe FieldUtilsdesde apache commons-lang3:

FieldUtils.readField(object, fieldName, true);

La reflexión no es la única forma de resolver su problema (que es acceder a la funcionalidad / comportamiento privado de una clase / componente)

Una solución alternativa es extraer la clase del .jar, descompilarla usando (por ejemplo) Jode o Jad , cambiar el campo (o agregar un descriptor de acceso) y recompilarlo contra el .jar original. Luego coloque el nuevo .class delante del .jaren el classpath, o vuelva a insertarlo en el .jar. (la utilidad jar le permite extraer y reinsertar en un .jar existente)

Como se señala a continuación, esto resuelve el problema más amplio de acceder / cambiar el estado privado en lugar de simplemente acceder / cambiar un campo.

Esto requiere que .jarno se firme, por supuesto.

Otra opción que aún no se ha mencionado: usar Groovy . Groovy le permite acceder a variables de instancia privadas como efecto secundario del diseño del lenguaje. Ya sea que tenga o no un captador para el campo, simplemente puede usar

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

Usando Reflection in Java puede acceder a todos los private/publiccampos y métodos de una clase a otra. Pero según la documentación de Oracle en los inconvenientes de la sección , recomendaron que:

"Dado que la reflexión permite que el código realice operaciones que serían ilegales en el código no reflectante, como acceder a campos y métodos privados, el uso de la reflexión puede provocar efectos secundarios inesperados, que pueden hacer que el código sea disfuncional y destruir la portabilidad. Código reflectante rompe las abstracciones y, por lo tanto, puede cambiar el comportamiento con las actualizaciones de la plataforma "

a continuación se muestran los ajustes de código para demostrar los conceptos básicos de Reflection

Reflexión1.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()));
        }
    }

}

Espero que ayude.

Como menciona oxbow_lakes, puede usar la reflexión para sortear las restricciones de acceso (suponiendo que su SecurityManager lo permita).

Dicho esto, si esta clase está tan mal diseñada que te hace recurrir a tal piratería informática, tal vez deberías buscar una alternativa. Seguro que este pequeño truco podría ahorrarte unas horas ahora, pero ¿cuánto te costará en el futuro?

Utilice el marco de optimización Soot Java para modificar directamente el código de bytes. http://www.sable.mcgill.ca/soot/

Soot está completamente escrito en Java y funciona con nuevas versiones de Java.

Debes hacer lo siguiente:

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

Si usa Spring, ReflectionTestUtils proporciona algunas herramientas útiles que ayudan aquí con un mínimo esfuerzo. Se describe como "para uso en escenarios de prueba de unidad e integración" . También hay una clase similar llamada ReflectionUtils, pero se describe como "Solo para uso interno" . Consulte esta respuesta para obtener una interpretación de lo que esto significa.

Para abordar el ejemplo publicado:

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

Solo una nota adicional sobre la reflexión: he observado en algunos casos especiales, cuando existen varias clases con el mismo nombre en diferentes paquetes, esa reflexión tal como se usa en la respuesta superior puede fallar al elegir la clase correcta del objeto. Entonces, si sabe cuál es el paquete.clase del objeto, entonces es mejor acceder a sus valores de campo privado de la siguiente manera:

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

(Esta es la clase de ejemplo que no funcionaba para mí)

Puede usar Manifold's @JailBreak para una reflexión directa y segura de Java:

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

public class Foo {
    private String stuffIWant;
}

@JailBreakdesbloquea la foovariable local en el compilador para acceder directamente a todos los miembros de Foola jerarquía.

Del mismo modo, puede usar el método de extensión jailbreak () para un uso único:

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

A través del jailbreak()método, puede acceder a cualquier miembro de Foola jerarquía.

En ambos casos, el compilador resuelve el acceso de campo para que escriba de forma segura, como si fuera un campo público, mientras que Manifold genera un código de reflexión eficiente para usted bajo el capó.

Descubre más sobre Colector .

Es bastante fácil con la herramienta XrayInterface . Simplemente defina los captadores / establecedores que faltan, por ejemplo

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

y haz una radiografía de tu pobre proyecto diseñado:

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

Internamente esto se basa en la reflexión.

Intente solucionar el problema para el caso, la clase de la que desea establecer / obtener datos es una de sus propias clases.

Solo crea un public setter(Field f, Object value)y public Object getter(Field f)para eso. Incluso puede hacer algunas comprobaciones de seguridad por su cuenta dentro de estas funciones miembro. Por ejemplo, para el 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);
    }
}

Por supuesto, ahora usted tiene que averiguar la java.lang.reflect.Fieldde sStringantes del fraguado del valor del campo.

Utilizo esta técnica en un ResultSet-to-and-from-model-mapper genérico.