Comment lire la valeur d'un champ privé d'une classe différente en Java?

J'ai une classe mal conçue dans une tierce partie JARet j'ai besoin d'accéder à l'un de ses champs privés . Par exemple, pourquoi devrais-je avoir besoin de choisir un domaine privé est-ce nécessaire?

class IWasDesignedPoorly {
    private Hashtable stuffIWant;
}

IWasDesignedPoorly obj = ...;

Comment puis-je utiliser la réflexion pour obtenir la valeur de stuffIWant?

Pour accéder aux champs privés, vous devez les obtenir à partir des champs déclarés de la classe, puis les rendre accessibles:

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

EDIT : comme l'a commenté aperkins , à la fois accéder au champ, le définir comme accessible et récupérer la valeur peut lancer Exceptions, bien que les seules exceptions vérifiées dont vous devez être conscient soient commentées ci-dessus.

Le NoSuchFieldExceptionserait levé si vous demandiez un champ par un nom qui ne correspondait pas à un champ déclaré.

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

Le IllegalAccessExceptionserait jeté si le champ n'était pas accessible (par exemple, s'il est privé et n'a pas été rendu accessible en manquant la f.setAccessible(true)ligne.

Les RuntimeExceptions qui peuvent être levés sont soit SecurityExceptions (si la machine virtuelle Java SecurityManagerne vous permet pas de modifier l'accessibilité d'un champ), soit IllegalArgumentExceptions, si vous essayez d'accéder au champ sur un objet qui n'est pas du type de la classe du champ:

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

Essayez FieldUtilsavec apache commons-lang3:

FieldUtils.readField(object, fieldName, true);

La réflexion n'est pas le seul moyen de résoudre votre problème (qui consiste à accéder aux fonctionnalités / comportements privés d'une classe / d'un composant)

Une autre solution consiste à extraire la classe du .jar, à la décompiler en utilisant (disons) Jode ou Jad , à modifier le champ (ou à ajouter un accesseur) et à le recompiler avec le .jar d'origine. Mettez ensuite la nouvelle .class devant le .jardans le chemin de classe, ou réinsérez-la dans le .jar. (l'utilitaire jar vous permet d'extraire et de réinsérer dans un .jar existant)

Comme indiqué ci-dessous, cela résout le problème plus large de l'accès / la modification de l'état privé plutôt que l'accès / la modification d'un champ.

Il faut pour cela de .jarne pas être signé, bien sûr.

Une autre option qui n'a pas encore été mentionnée: utilisez Groovy . Groovy vous permet d'accéder à des variables d'instance privées comme effet secondaire de la conception du langage. Que vous ayez ou non un getter pour le terrain, vous pouvez simplement utiliser

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

En utilisant la réflexion en Java, vous pouvez accéder à tous les private/publicchamps et méthodes d'une classe à une autre. Mais selon la documentation Oracle dans la section inconvénients, ils ont recommandé que:

"Étant donné que la réflexion permet au code d'effectuer des opérations qui seraient illégales dans un code non réfléchissant, telles que l'accès à des champs et des méthodes privés, l'utilisation de la réflexion peut entraîner des effets secondaires inattendus, qui peuvent rendre le code dysfonctionnel et détruire la portabilité. Code réfléchissant brise les abstractions et peut donc changer de comportement avec les mises à niveau de la plate-forme "

voici des extraits de code pour illustrer les concepts de base de la réflexion

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

}

J'espère que cela vous aidera.

Comme le mentionne oxbow_lakes, vous pouvez utiliser la réflexion pour contourner les restrictions d'accès (en supposant que votre SecurityManager vous le permette).

Cela dit, si cette classe est si mal conçue qu'elle vous fait recourir à un tel piratage, vous devriez peut-être chercher une alternative. Bien sûr, ce petit hack pourrait vous faire économiser quelques heures maintenant, mais combien cela vous coûtera-t-il sur la route?

Utilisez le framework Soot Java Optimization pour modifier directement le bytecode. http://www.sable.mcgill.ca/soot/

Soot est entièrement écrit en Java et fonctionne avec les nouvelles versions de Java.

Vous devez effectuer les opérations suivantes:

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 vous utilisez Spring, ReflectionTestUtils fournit des outils pratiques qui vous aident ici avec un minimum d'effort. Il est décrit comme "destiné à être utilisé dans des scénarios de tests unitaires et d'intégration" . Il existe également une classe similaire nommée ReflectionUtils, mais celle-ci est décrite comme "destinée uniquement à un usage interne" - voir cette réponse pour une interprétation de ce que cela signifie.

Pour traiter l'exemple publié:

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

Juste une note supplémentaire sur la réflexion: j'ai observé dans certains cas spéciaux, lorsque plusieurs classes du même nom existent dans des packages différents, que la réflexion telle qu'utilisée dans la première réponse peut ne pas sélectionner la classe correcte dans l'objet. Donc, si vous savez quelle est la package.class de l'objet, il est préférable d'accéder à ses valeurs de champ privé comme suit:

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

(Ceci est l'exemple de classe qui ne fonctionnait pas pour moi)

Vous pouvez utiliser @JailBreak de Manifold pour une réflexion Java directe et sécurisée:

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

public class Foo {
    private String stuffIWant;
}

@JailBreakdéverrouille la foovariable locale dans le compilateur pour un accès direct à tous les membres de Foola hiérarchie.

De même, vous pouvez utiliser la méthode d'extension jailbreak () pour une utilisation ponctuelle:

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

Grâce à la jailbreak()méthode, vous pouvez accéder à n'importe quel membre de Foola hiérarchie.

Dans les deux cas, le compilateur résout l'accès au champ pour vous en toute sécurité, comme s'il s'agissait d'un champ public, tandis que Manifold génère un code de réflexion efficace pour vous sous le capot.

En savoir plus sur le collecteur .

C'est assez simple avec l'outil XrayInterface . Il suffit de définir les getters / setters manquants, par exemple

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

et xray votre pauvre projet conçu:

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

En interne, cela repose sur la réflexion.

Essayez de contourner le problème pour le cas, le type dont vous voulez définir / obtenir des données est l'une de vos propres classes.

Créez simplement un public setter(Field f, Object value)et public Object getter(Field f)pour cela. Vous pouvez même faire quelques vérifications de sécurité par vous-même à l'intérieur de ces fonctions membres. Par exemple pour le passeur:

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

Bien sûr, vous devez maintenant trouver le java.lang.reflect.Fieldfor sStringavant de définir la valeur du champ.

J'utilise cette technique dans un mappeur générique ResultSet-to-and-from-model.